amenbo 0.3.0 → 0.4.1

package/dist/extract/markdown.js

@@ -75,7 +75,9 @@ function collectQualityInput(document, geometry) {
             extractedTokenEstimate: 0,
         };
     }
-    // 元のDOMを変更しないよう、複製上でscript/style/noscriptを取り除いてから可視テキストを測る
+    // script/styleはこの時点で既にremoveStyleLeakElementsにより除去済み(ここでの除去は防御的で
+    // 実質no-op)。noscriptはReadability.parse()の画像復元(_unwrapNoscriptImages)のため意図的に
+    // 残してあるので、統計を歪めないよう複製上でのみ除去する(元のDOMは変更しない)。
     const clone = body.cloneNode(true);
     for (const el of Array.from(clone.querySelectorAll("script, style, noscript"))) {
         el.remove();
@@ -139,6 +141,11 @@ function extractByGeometry(document, geometry) {
 const ANCHOR_MAX_LENGTH = 80;
 const ANCHOR_MIN_PARAGRAPH_LENGTH = 30;
 const MAX_SPAN = 1000;
+const PROBE_MIN_LENGTH = 8;
+const PROBE_MAX_COUNT = 3;
+const PROBE_MAX_LENGTH = 60;
+// アンカー長(見出し用)とは別概念のため定数を分ける(片方の調整が他方へ波及しないように)。
+const PROBE_FALLBACK_MAX_LENGTH = 80;
 /** colspan/rowspan属性値を1以上MAX_SPAN以下の整数へ丸める(異常値ガード)。 */
 function clampSpan(value) {
     const n = Number.parseInt(value ?? "1", 10);
@@ -148,8 +155,18 @@ function clampSpan(value) {
 }
 /**
  * turndownのGFMテーブル変換はcolspan/rowspan・多段ヘッダを扱えず列ズレや空セルを生む。
- * グリッドを再構築してspanを実セルへ展開し、先頭の連続ヘッダ行は1行へ結合してから
- * 全行同一列数の単純表を返す。救出経路の表のみに適用する(影響を局所化)。
+ * グリッドを再構築してspanを「位置の占有」として展開し(内容の複製はしない)、先頭の連続ヘッダ行は
+ * 1行へ結合してから全行同一列数の単純表を返す。救出経路(collectDataTables)とReadability/アダプタ等が
+ * 本文に保持した複雑表(normalizeRetainedTables)の双方から呼ばれる。
+ * spanの無い単純表・既に正規化済みの表に対しては構造を変えず冪等に振る舞う。
+ * captionは再構築で失われないよう先頭へ復元する。
+ *
+ * 内容配置は行の役割で分岐する:
+ * - 列ヘッダ行(all-th ∧ 起点セル2つ以上): 占有読み。colspanグループラベルは配下の各列へ複製される
+ *   (多段ヘッダ結合「グループ 列名」の意味を保つための唯一の複製)
+ * - データ行: 起点位置にのみ内容、span継続位置は空セル(複製しない)
+ * - 全幅単一th行: 列ヘッダではなく表題/節ラベル。先頭の連続分はcaptionへ畳み(turndown-gfmが
+ *   ヘッダ行を見失って複雑表フォールバックへ落ちるのを防ぐ)、表中間の区切り行はデータ行として出力
  */
 export function normalizeTableHtml(tableHtml) {
     const { document } = parseHTML(`<!DOCTYPE html><html><body>${tableHtml}</body></html>`);
@@ -157,23 +174,27 @@ export function normalizeTableHtml(tableHtml) {
     if (!tableEl)
         return tableHtml;
     const table = tableEl;
+    // 自表直下のcaptionのみ拾う(入れ子表のcaptionを巻き込まない)。
+    const caption = Array.from(document.querySelectorAll("caption")).find((cap) => cap.closest("table") === tableEl);
     // 入れ子の表の行を巻き込まないよう、直接の行(closestが自表と一致)だけを対象にする。
     const rows = Array.from(table.querySelectorAll("tr")).filter((tr) => tr.closest("table") === tableEl);
     const rowCount = rows.length;
     if (rowCount === 0)
         return tableHtml;
     const grid = Array.from({ length: rowCount }, () => []);
-    const isHeaderRow = [];
+    const allTh = [];
+    const originCount = [];
     for (let r = 0; r < rowCount; r++) {
         const cells = Array.from(rows[r].children).filter((el) => el.tagName === "TD" || el.tagName === "TH");
-        isHeaderRow[r] = cells.length > 0 && cells.every((cell) => cell.tagName === "TH");
+        allTh[r] = cells.length > 0 && cells.every((cell) => cell.tagName === "TH");
+        originCount[r] = cells.length;
         let c = 0;
         for (const cell of cells) {
             while (grid[r][c] !== undefined)
                 c++;
             const colspan = clampSpan(cell.getAttribute("colspan"));
             const rowspan = clampSpan(cell.getAttribute("rowspan"));
-            const filled = { html: cell.innerHTML.trim() };
+            const filled = { html: cell.innerHTML.trim(), originRow: r, originCol: c };
             for (let i = 0; i < rowspan && r + i < rowCount; i++) {
                 for (let j = 0; j < colspan; j++) {
                     grid[r + i][c + j] = filled;
@@ -185,37 +206,93 @@ export function normalizeTableHtml(tableHtml) {
     const numCols = grid.reduce((max, row) => Math.max(max, row.length), 0);
     if (numCols === 0)
         return tableHtml;
+    const occupancyCell = (r, c) => grid[r]?.[c]?.html ?? "";
+    const originCellHtml = (r, c) => {
+        const g = grid[r]?.[c];
+        return g && g.originRow === r && g.originCol === c ? g.html : "";
+    };
+    // 列ヘッダ行: all-th ∧ 起点セル2つ以上。単一全幅th行(起点セル1つ)は列ヘッダではなくラベル行。
+    const isColumnHeaderRow = (r) => allTh[r] && originCount[r] >= 2;
+    const isFullWidthLabelRow = (r) => {
+        if (numCols < 2 || !allTh[r] || originCount[r] !== 1)
+            return false;
+        let covered = 0;
+        for (let c = 0; c < numCols; c++)
+            if (grid[r]?.[c]?.originRow === r)
+                covered++;
+        return covered === numCols;
+    };
+    const emitRow = (cells, tag) => `<tr>${cells.map((h) => `<${tag}>${h}</${tag}>`).join("")}</tr>`;
+    const emitOne = (r) => {
+        // thは列ヘッダ行にのみ与える。単一起点のラベル行をthのまま出力すると、空th兄弟を伴う
+        // 「all-th複数セル行」として実体化し、再パース時(救出挿入後のnormalizeRetainedTables)に
+        // 列ヘッダと誤認されて多段ヘッダ結合へ巻き込まれる=区切りラベルが消失するため。
+        const tag = isColumnHeaderRow(r) ? "th" : "td";
+        const read = isColumnHeaderRow(r) ? occupancyCell : originCellHtml;
+        return emitRow(Array.from({ length: numCols }, (_, c) => read(r, c)), tag);
+    };
+    // 先頭の連続する全幅単一thラベル行をcaptionへ畳む。全行がラベル行の退化ケースでは畳まない。
+    const foldedCaptions = [];
+    let start = 0;
+    while (start < rowCount && isFullWidthLabelRow(start)) {
+        const text = occupancyCell(start, 0);
+        if (text)
+            foldedCaptions.push(text);
+        start++;
+    }
+    if (start >= rowCount) {
+        start = 0;
+        foldedCaptions.length = 0;
+    }
     let headerCount = 0;
-    while (headerCount < rowCount && isHeaderRow[headerCount])
+    while (start + headerCount < rowCount && isColumnHeaderRow(start + headerCount))
         headerCount++;
-    const cellHtml = (r, c) => grid[r]?.[c]?.html ?? "";
-    const out = ["<table>"];
-    const emitRow = (cells, tag) => {
-        out.push(`<tr>${cells.map((h) => `<${tag}>${h}</${tag}>`).join("")}</tr>`);
-    };
-    if (headerCount >= 2) {
-        // 多段ヘッダ: 列ごとに上→下のセルを重複除去して連結し、1行のヘッダへ畳む。
+    const headerRows = [];
+    const bodyRows = [];
+    // 全行がヘッダ(start+headerCount === rowCount)の表を結合するとデータ行が消えるため、
+    // 結合はデータ行が1行以上残る場合に限る。全ヘッダ表はelse分岐で先頭行のみthead扱いにし、
+    // 残りは各行を保持する(スタイル目的でthを使う表の保護)。
+    if (headerCount >= 2 && start + headerCount < rowCount) {
+        // 多段ヘッダ: 列ごとに上→下のセルを占有読みし、重複除去して連結して1行のヘッダへ畳む。
         const merged = [];
         for (let c = 0; c < numCols; c++) {
             const parts = [];
-            for (let r = 0; r < headerCount; r++) {
-                const h = cellHtml(r, c);
+            for (let r = start; r < start + headerCount; r++) {
+                const h = occupancyCell(r, c);
                 if (h && parts[parts.length - 1] !== h)
                     parts.push(h);
             }
             merged.push(parts.join(" "));
         }
-        emitRow(merged, "th");
-        for (let r = headerCount; r < rowCount; r++) {
-            emitRow(Array.from({ length: numCols }, (_, c) => cellHtml(r, c)), "td");
-        }
+        headerRows.push(emitRow(merged, "th"));
+        for (let r = start + headerCount; r < rowCount; r++)
+            bodyRows.push(emitOne(r));
     }
     else {
-        // ヘッダ0/1行: spanの展開のみ行い、行のth/tdは元の判定を踏襲する。
-        for (let r = 0; r < rowCount; r++) {
-            emitRow(Array.from({ length: numCols }, (_, c) => cellHtml(r, c)), isHeaderRow[r] ? "th" : "td");
+        // ヘッダ0/1行(全ヘッダ表を含む): 先頭が列ヘッダ行ならthead、残りはtbodyへ。
+        for (let r = start; r < rowCount; r++) {
+            if (r === start && isColumnHeaderRow(r))
+                headerRows.push(emitOne(r));
+            else
+                bodyRows.push(emitOne(r));
         }
     }
+    // captionを内包したままでもヘッダ行を見失わないよう、ヘッダはthead・データはtbodyで囲う
+    // (turndown-gfmはtrがtableの先頭子でないとヘッダと認識せず、captionがあると降格するため)。
+    const captionParts = [];
+    if (caption) {
+        const capHtml = caption.innerHTML.trim();
+        if (capHtml)
+            captionParts.push(capHtml);
+    }
+    captionParts.push(...foldedCaptions);
+    const out = ["<table>"];
+    if (captionParts.length > 0)
+        out.push(`<caption>${captionParts.join(" ")}</caption>`);
+    if (headerRows.length > 0)
+        out.push(`<thead>${headerRows.join("")}</thead>`);
+    if (bodyRows.length > 0)
+        out.push(`<tbody>${bodyRows.join("")}</tbody>`);
     out.push("</table>");
     return out.join("");
 }
@@ -226,6 +303,7 @@ function normalizeForSignature(text) {
 /**
  * document順に並べた要素列から、tableIndexの表の直前アンカー(見出し優先・無ければ近傍段落)を求める。
  * 見出しは節の先頭に表を戻すのに最適。見出しが皆無なページ用に段落をフォールバックにする。
+ * 由来(heading/paragraph)を返し、照合方法(完全一致/包含)を呼び出し側で出し分けられるようにする。
  */
 function findTableAnchor(seq, tableIndex) {
     let paragraph = "";
@@ -236,13 +314,39 @@ function findTableAnchor(seq, tableIndex) {
         const text = normalizeForSignature(el.textContent);
         if (/^H[1-6]$/.test(el.tagName)) {
             if (text.length > 0)
-                return text.slice(0, ANCHOR_MAX_LENGTH); // 見出し優先。
+                return { text: text.slice(0, ANCHOR_MAX_LENGTH), kind: "heading" }; // 見出し優先。
         }
         else if (!paragraph && text.length >= ANCHOR_MIN_PARAGRAPH_LENGTH) {
             paragraph = text.slice(0, ANCHOR_MAX_LENGTH);
         }
     }
-    return paragraph;
+    return paragraph ? { text: paragraph, kind: "paragraph" } : { text: "", kind: "" };
+}
+/**
+ * 表内セル(th/td)から重複判定用の照合プローブを作る。入れ子表を内包するセルは、その内側の
+ * 表全体がinnerHTMLに入り込みノイズになる(かつ内側セルは個別に拾える)ため除外する。
+ * 長さ8字以上のセルテキストを重複除去し、長い順(安定ソート)に最大3本、各60字へ切り詰める。
+ * 対象セルが1つも無い表は、従来のouterHTML先頭を単一プローブとしてフォールバックする。
+ */
+function buildTableProbes(table) {
+    const cells = Array.from(table.querySelectorAll("th, td")).filter((cell) => cell.querySelectorAll("table").length === 0);
+    const seen = new Set();
+    const probes = [];
+    for (const cell of cells) {
+        const text = normalizeForSignature(cell.innerHTML);
+        if (text.length < PROBE_MIN_LENGTH || seen.has(text))
+            continue;
+        seen.add(text);
+        probes.push(text);
+    }
+    if (probes.length === 0) {
+        return [normalizeForSignature(table.outerHTML).slice(0, PROBE_FALLBACK_MAX_LENGTH)].filter((p) => p.length > 0);
+    }
+    return probes
+        .map((probe, index) => ({ probe, index }))
+        .sort((a, b) => b.probe.length - a.probe.length || a.index - b.index)
+        .slice(0, PROBE_MAX_COUNT)
+        .map(({ probe }) => probe.slice(0, PROBE_MAX_LENGTH));
 }
 /**
  * Readabilityが取りこぼしがちなデータ表を、救出候補としてHTML文字列＋位置アンカーで採取する。
@@ -271,26 +375,62 @@ export function collectDataTables(body) {
         }
         if (maxCells < 2)
             continue;
+        const anchor = findTableAnchor(seq, i);
         result.push({
             html: normalizeTableHtml(table.outerHTML),
-            // 重複判定は正規化前の元テキスト基準にする(Readability保持時の照合を安定させる)。
-            signature: normalizeForSignature(table.textContent).slice(0, ANCHOR_MAX_LENGTH),
-            anchor: findTableAnchor(seq, i),
+            probes: buildTableProbes(table),
+            anchor: anchor.text,
+            anchorKind: anchor.kind,
         });
     }
     return result;
 }
+/**
+ * 表のプローブの真の過半数(floor(n/2)+1)が本文に含まれていれば「既に本文にある」と判定する
+ * (プローブ0本は既存扱い)。ceil(n/2)だとn=2のとき1本一致(50%)で既存と判定され、本文の地の文と
+ * 偶然一致した1本のせいで本当に落ちた表が救出されない=サイレント欠落に倒れる。重複挿入(可視・
+ * 有界)よりデータ欠落(不可視)の方が害が大きいため、偶数本では厳しい側に倒す。
+ */
+function isTableAlreadyPresent(table, contentText) {
+    if (table.probes.length === 0)
+        return true;
+    let hits = 0;
+    for (const probe of table.probes) {
+        if (probe.length > 0 && contentText.includes(probe))
+            hits++;
+    }
+    return hits >= Math.floor(table.probes.length / 2) + 1;
+}
+/**
+ * 表アンカーの照合。heading由来は見出し要素(h1-h6)の正規化テキスト完全一致に限定する
+ * (「人口」等の短く非一意な見出しが段落の部分文字列へ吸着し、表が無関係な節へ誤挿入されるのを防ぐ。
+ *  実測: zh.wikipedia 广东省で人口統計表が航空節へ誤挿入)。anchorが80字で切り詰められている場合のみ
+ * 前方一致を許す。paragraph由来は従来どおり包含判定する。
+ */
+function matchesTableAnchor(node, table) {
+    if (table.anchor.length === 0)
+        return false;
+    const nodeText = normalizeForSignature(node.textContent);
+    if (table.anchorKind === "heading") {
+        if (!/^H[1-6]$/.test(node.tagName))
+            return false;
+        return nodeText === table.anchor || (table.anchor.length === ANCHOR_MAX_LENGTH && nodeText.startsWith(table.anchor));
+    }
+    return nodeText.includes(table.anchor);
+}
 /**
  * Readability出力に含まれない表だけを、可能なら元の位置(アンカー直後)へ、無理なら末尾へ再結合する。
  * アンカー(表の直前見出し/段落)がReadability出力に残っていれば、その要素の直後に挿入して
- * 「表が本来属していた節」へ戻す(記事構造=意味の保持)。残っていなければ末尾フォールバック。
+ * 「表が本来属していた節」へ戻す(記事構造=意味の保持)。残っていなければ末尾フォールバック
+ * (誤配置より末尾が安全)。
  */
 export function reinsertDroppedTables(contentHtml, tables) {
     if (tables.length === 0)
         return { html: contentHtml, appended: 0 };
-    // Readabilityが既に保持している表はシグネチャ(元テキスト先頭)で除外する。
+    // Readabilityが既に保持している表はプローブ多数決で除外する。Readabilityが一部セルを刈っても
+    // 過半数のプローブが本文に残っていれば「既にある」と判定する。
     const contentText = normalizeForSignature(contentHtml);
-    const missing = tables.filter((table) => table.signature.length > 0 && !contentText.includes(table.signature));
+    const missing = tables.filter((table) => !isTableAlreadyPresent(table, contentText));
     if (missing.length === 0)
         return { html: contentHtml, appended: 0 };
     const { document } = parseHTML(`<!DOCTYPE html><html><body>${contentHtml}</body></html>`);
@@ -298,9 +438,7 @@ export function reinsertDroppedTables(contentHtml, tables) {
     const anchorNodes = Array.from(host.body.querySelectorAll("h1, h2, h3, h4, h5, h6, p"));
     const tail = [];
     for (const table of missing) {
-        const anchorNode = table.anchor
-            ? anchorNodes.find((node) => normalizeForSignature(node.textContent).includes(table.anchor))
-            : undefined;
+        const anchorNode = anchorNodes.find((node) => matchesTableAnchor(node, table));
         if (anchorNode) {
             anchorNode.insertAdjacentHTML("afterend", table.html);
         }
@@ -312,9 +450,343 @@ export function reinsertDroppedTables(contentHtml, tables) {
     const html = tail.length > 0 ? `${inserted}\n${tail.join("\n")}` : inserted;
     return { html, appended: missing.length };
 }
+function isNestedInTable(el) {
+    // TABLE自身はclosestが自分を返すため祖先表は親から探す。他要素はel自身から探す。
+    const from = el.tagName === "TABLE" ? el.parentElement : el;
+    return from?.closest("table") != null;
+}
+/** 見出しレベル(H1-H6→1-6)を返す。見出しでなければ0。 */
+function headingLevel(tagName) {
+    const match = /^H([1-6])$/.exec(tagName);
+    return match ? Number(match[1]) : 0;
+}
+const HEADING_ANCHOR_SELECTOR = "h1, h2, h3, h4, h5, h6, p, table, ul, ol, dl";
+const HEADING_ANCHOR_CANDIDATE_MAX = 4;
+/**
+ * document順の要素列から、headingIndexの見出しの節スコープ内アンカーを求める。
+ * スコープは「自レベル以下(数値がlevel以下)の見出しに達するまで」。子見出し(数値が大きい)は
+ * 跨いで走査を続ける(親h2の直後に子h3が続く構造でも親の段落まで辿り着けるようにするため)。
+ * 段落(p)を最優先し、無ければ表/リスト等ブロックの先頭をフォールバックにする(表・リストのみの節用)。
+ * 表の内側の要素はanchorにしない(挿入先から除外されるため命中しても復元できない)。
+ * 由来(paragraph/block)を返し、照合方法を呼び出し側で出し分けられるようにする。無ければ空。
+ */
+function findHeadingAnchor(seq, headingIndex) {
+    const level = headingLevel(seq[headingIndex]?.tagName ?? "");
+    const candidates = [];
+    for (let i = headingIndex + 1; i < seq.length; i++) {
+        const el = seq[i];
+        if (!el)
+            continue;
+        const elLevel = headingLevel(el.tagName);
+        if (elLevel > 0) {
+            if (elLevel <= level)
+                break; // 同レベル/上位の見出し=節の終端。子見出しは跨いで継続。
+            continue;
+        }
+        if (isNestedInTable(el))
+            continue;
+        const text = normalizeForSignature(el.textContent);
+        if (text.length < ANCHOR_MIN_PARAGRAPH_LENGTH)
+            continue;
+        const kind = el.tagName === "P" ? "paragraph" : "block";
+        candidates.push({ text: text.slice(0, ANCHOR_MAX_LENGTH), kind });
+        // 段落は照合が安定しているため、最初の段落が候補に入ったら打ち切る(それが落ちている節は
+        // 本文ごと消えているとみなす)。ブロックだけが続く節は上限まで候補を積む。
+        if (kind === "paragraph" || candidates.length >= HEADING_ANCHOR_CANDIDATE_MAX)
+            break;
+    }
+    return candidates;
+}
+/**
+ * Readabilityは見出しがラッパー要素(編集リンク付きdiv等)に包まれていると本文整形時にh2-h6を
+ * 丸ごと落とし、outline/section機能が依存する節構造を全消失させる。parse前のdocumentからh2-h6を
+ * 採取し、節スコープ内の段落/ブロックをアンカーにして位置復元に備える。
+ * parseは渡したdocumentを破壊的に変更するため、必ずparse前に呼ぶこと。
+ * h1はReadabilityがtitleへ昇格させるため対象外(復元するとtitleと二重化する)。
+ * 見出し内リンク等のmarkupは持たない(outlineに要るのはテキストと階層のみ)。
+ */
+export function collectHeadings(body) {
+    const result = [];
+    const seq = Array.from(body.querySelectorAll(HEADING_ANCHOR_SELECTOR));
+    for (let i = 0; i < seq.length; i++) {
+        const el = seq[i];
+        if (!el)
+            continue;
+        const level = headingLevel(el.tagName);
+        if (level < 2)
+            continue; // h1(title二重化)と非見出し(p/表/リスト)を除外。
+        const text = normalizeForSignature(el.textContent);
+        if (text.length === 0)
+            continue; // 空見出しは捨てる。
+        result.push({ level, text, anchors: findHeadingAnchor(seq, i) });
+    }
+    return result;
+}
+const HEADING_INSERT_TARGET_SELECTOR = "p, blockquote, table, ul, ol, dl";
+/**
+ * 見出しアンカーの照合を由来で出し分ける。
+ * block(表/リスト)由来は両辺の全空白を除去して包含判定する。normalizeTableHtmlで再構築された表は
+ * セル間に空白が入らないため、生DOM textContent由来のanchorと空白がズレて通常の照合が外れる
+ * (実測: 表由来anchorが全滅)。CJKでは空白の意味が薄く除去による誤一致リスクは無視できるが、
+ * 欧文での偽陽性を避けるため段落由来には広げず、paragraph由来はnormalizeForSignatureベースの包含に留める。
+ */
+function matchesAnchorText(nodeText, anchor, kind) {
+    if (anchor.length === 0)
+        return false;
+    if (kind === "block") {
+        const needle = anchor.replace(/\s+/g, "");
+        return needle.length > 0 && nodeText.replace(/\s+/g, "").includes(needle);
+    }
+    return normalizeForSignature(nodeText).includes(anchor);
+}
+/**
+ * Readabilityが落とした見出しを、アンカー(直後段落)がReadability出力に残っている場合のみ、
+ * その段落の直前(beforebegin)へ`<hN>text</hN>`として戻す。
+ *
+ * 表救出(reinsertDroppedTables)との最重要差分は「アンカー不在の見出しは復元しない・末尾
+ * フォールバックもしない」こと。表=データそのもの(失うと情報欠落)だが、見出し=節のラベルであり、
+ * 節本文がReadability出力に残っていない見出しを戻してもノイズにしかならない。アンカーの生存確認が
+ * 「その節が本文として残っているか」の判定を兼ね、nav/フッター等Readabilityが正しく落とした節の
+ * 見出しを自然に除外する(サイト固有知識なしでnavbox見出しを拾わない)。
+ * 同一テキストの見出しは最初の1件のみ扱う(同名節の複数復元はアンカー取り違えリスクの方が大きい)。
+ * 挿入は「同テキストの見出しが本文に無い」場合のみのため、再適用しても増えない(冪等)。
+ */
+export function reinsertDroppedHeadings(contentHtml, headings) {
+    if (headings.length === 0)
+        return { html: contentHtml, restored: 0 };
+    const { document } = parseHTML(`<!DOCTYPE html><html><body>${contentHtml}</body></html>`);
+    const host = document;
+    const existing = new Set();
+    for (const el of Array.from(host.body.querySelectorAll("h1, h2, h3, h4, h5, h6"))) {
+        const text = normalizeForSignature(el.textContent);
+        if (text.length > 0)
+            existing.add(text);
+    }
+    // 表の内側の要素は挿入先から除外する(td内のpにマッチして見出しが表の中へ入り込むのを防ぐ)。
+    const anchorNodes = Array.from(host.body.querySelectorAll(HEADING_INSERT_TARGET_SELECTOR)).filter((node) => !isNestedInTable(node));
+    const handled = new Set();
+    let restored = 0;
+    for (const heading of headings) {
+        if (handled.has(heading.text))
+            continue; // 同一テキストは最初の1件のみ扱う。
+        handled.add(heading.text);
+        if (existing.has(heading.text))
+            continue; // 既に本文にある見出しは戻さない。
+        if (heading.anchors.length === 0)
+            continue; // アンカー不在=節本文が残っていないので復元しない。
+        // 候補を文書順に試し、最初に一致した要素の直前へ挿入する(節先頭のブロックが落ちていれば
+        // 後続のデータ表・段落へ吸着する)。
+        let anchorNode;
+        for (const candidate of heading.anchors) {
+            anchorNode = anchorNodes.find((node) => matchesAnchorText(node.textContent, candidate.text, candidate.kind));
+            if (anchorNode)
+                break;
+        }
+        if (!anchorNode)
+            continue; // 全候補が出力に無い=その節は落とされているので復元しない。
+        anchorNode.insertAdjacentHTML("beforebegin", `<h${heading.level}>${escapeHtml(heading.text)}</h${heading.level}>`);
+        restored++;
+    }
+    return restored > 0 ? { html: host.body.innerHTML, restored } : { html: contentHtml, restored: 0 };
+}
+/**
+ * 正規化が必要な「データ表」かを判定する。2行2列以上かつ、colspan/rowspanを持つか
+ * 「先頭に2行以上の連続ヘッダ行があり、かつその後にデータ行が残る(多段ヘッダ)」表のみtrue。
+ * 単純表・レイアウト表・全行がヘッダの表は、turndownに任せて差分と誤破壊を避けるため弾く
+ * (全ヘッダ表を多段ヘッダとして畳むとデータ行が消えるため対象外)。
+ * 連続ヘッダ行の数え方はnormalizeTableHtmlの列ヘッダ定義(all-th ∧ セル2つ以上)に揃える
+ * (全幅単一th行を列ヘッダに数えると単一セルラベルが誤って多段ヘッダ扱いされる)。
+ */
+function needsTableNormalization(table) {
+    const rows = Array.from(table.querySelectorAll("tr")).filter((tr) => tr.closest("table") === table);
+    if (rows.length < 2)
+        return false;
+    let maxCells = 0;
+    let hasSpan = false;
+    let leadingHeaderRows = 0;
+    let inLeadingHeaders = true;
+    for (const row of rows) {
+        const cells = Array.from(row.children).filter((el) => el.tagName === "TD" || el.tagName === "TH");
+        if (cells.length > maxCells)
+            maxCells = cells.length;
+        for (const cell of cells) {
+            if (clampSpan(cell.getAttribute("colspan")) > 1 || clampSpan(cell.getAttribute("rowspan")) > 1)
+                hasSpan = true;
+        }
+        const isColumnHeader = cells.length >= 2 && cells.every((cell) => cell.tagName === "TH");
+        if (inLeadingHeaders && isColumnHeader)
+            leadingHeaderRows++;
+        else
+            inLeadingHeaders = false;
+    }
+    if (maxCells < 2)
+        return false;
+    const hasMultiHeaderWithData = leadingHeaderRows >= 2 && leadingHeaderRows < rows.length;
+    return hasSpan || hasMultiHeaderWithData;
+}
+const CELL_BLOCK_SELECTOR = "ul, ol, h1, h2, h3, h4, h5, h6, hr, blockquote, pre";
+/** テキストをHTMLへ差し戻す際の最小エスケープ(pre→codeでtextContentを埋め込むため)。 */
+function escapeHtml(text) {
+    return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+/**
+ * 直前に非空白の内容があり、かつそれが<br>でない場合にtrue。インライン化した置換文字列が
+ * 先行テキストと無境界に連結される(例: 親liのテキストと入れ子リスト先頭項目が「親1子1」化する)
+ * のを防ぐため、置換文字列の先頭に<br>を足すべきかの判定に使う。
+ */
+function needsLeadingBreak(el) {
+    let prev = el.previousSibling;
+    while (prev) {
+        if (prev.nodeType === 1)
+            return prev.tagName !== "BR";
+        if (prev.nodeType === 3 && (prev.textContent ?? "").trim().length > 0)
+            return true;
+        prev = prev.previousSibling;
+    }
+    return false;
+}
+/** ブロック要素をGFM表セルに収まるインラインHTMLへ変換する。 */
+function inlineReplacement(el) {
+    const tag = el.tagName;
+    // hr(それ自体が区切り)とblockquote(ブロック子要素を保持したままのunwrap)以外は純インラインに
+    // なるため、先行内容との境界を<br>で明示する。
+    const lead = tag !== "HR" && tag !== "BLOCKQUOTE" && needsLeadingBreak(el) ? "<br>" : "";
+    if (tag === "UL" || tag === "OL") {
+        // マーカー無しで各liを<br>連結する(番号・入れ子構造は落とし、テキストとリンクを残す)。
+        const items = Array.from(el.children)
+            .filter((child) => child.tagName === "LI")
+            .map((li) => li.innerHTML.trim())
+            .filter((html) => html.length > 0)
+            .join("<br>");
+        return lead + items;
+    }
+    if (/^H[1-6]$/.test(tag))
+        return `${lead}<strong>${el.innerHTML.trim()}</strong><br>`;
+    if (tag === "HR")
+        return "<br>";
+    if (tag === "BLOCKQUOTE")
+        return el.innerHTML; // unwrap(子を保持)。
+    return `${lead}<code>${escapeHtml(el.textContent.replace(/\s*\n\s*/g, " ").trim())}</code>`; // PRE。
+}
+/** rootからの深さ(祖先数)を返す。入れ子リスト等を深い方から平坦化する順序付けに使う。 */
+function depthWithin(el, root) {
+    let depth = 0;
+    let cur = el.parentElement;
+    while (cur && cur !== root) {
+        depth++;
+        cur = cur.parentElement;
+    }
+    return depth;
+}
+/**
+ * 表のセル内ブロック要素(ul/ol/h1-6/hr/blockquote/pre)をインライン化する。
+ * turndown-gfmはこれらを含む表をtableShouldBeHtml判定でouterHTMLごとダンプする(joplin-table-wrapper
+ * のHTMLリーク)ため、プラグインを触らず入力側で発動条件を消す。入れ子表そのものは触らず、
+ * 入れ子表内の要素はその入れ子表を処理する呼び出しに委ねる(closestが自表と一致する要素のみ対象)。
+ * 入れ子リストは深い方から平坦化する。
+ */
+function inlineCellBlocks(table) {
+    const targets = Array.from(table.querySelectorAll(CELL_BLOCK_SELECTOR)).filter((el) => el.closest("table") === table);
+    if (targets.length === 0)
+        return false;
+    targets.sort((a, b) => depthWithin(b, table) - depthWithin(a, table));
+    for (const el of targets) {
+        el.insertAdjacentHTML("beforebegin", inlineReplacement(el));
+        el.remove();
+    }
+    return true;
+}
+/**
+ * 本文HTMLに保持された複雑表(colspan/rowspan・多段ヘッダ)をその場で正規化し、あわせて全表の
+ * セル内ブロック要素をインライン化する。
+ * 救出経路(reinsertDroppedTables)は「Readabilityが落とした表」しか正規化しないため、
+ * Readability/アダプタ/ジオメトリ/selector等が本文に保持した複雑表は未正規化のまま
+ * turndownへ渡ると列ズレ・空セルになる。turndown直前の全経路共通パスでこれを補う。
+ * (アダプタ経路(例: zenn等)はReadabilityを経由しないため、readability経路限定ではなく
+ *  全経路に適用する必要がある。)
+ * 正規化はspan/多段ヘッダを持つ最外データ表だけを対象にし、レイアウト表・単純表・
+ * 既に正規化済みの表(救出で挿入済みを含む)は触らないため冪等。
+ * インライン化はブロック要素を持つ全ての表が対象(セル内ul等によるturndown-gfmのouterHTML
+ * ダンプを防ぐため)。入れ子表もgfmからは単体の表として変換される(外表スキップ時に内表だけが
+ * GFM表になる)ので、最外表に限定せず各表を個別にインライン化する。正規化より先に全表を
+ * インライン化するのは、外表の正規化(remove+再挿入)後では旧サブツリー内の入れ子表への
+ * 変更が出力へ反映されないため。
+ */
+export function normalizeRetainedTables(contentHtml) {
+    if (!contentHtml.includes("<table"))
+        return contentHtml;
+    const { document } = parseHTML(`<!DOCTYPE html><html><body>${contentHtml}</body></html>`);
+    const host = document;
+    const tables = Array.from(host.body.querySelectorAll("table"));
+    let changed = false;
+    for (const table of tables) {
+        if (inlineCellBlocks(table))
+            changed = true;
+    }
+    for (const table of tables) {
+        if (table.parentElement?.closest("table"))
+            continue; // 入れ子表は最外表側で処理する。
+        if (!needsTableNormalization(table))
+            continue;
+        table.insertAdjacentHTML("afterend", normalizeTableHtml(table.outerHTML));
+        table.remove();
+        changed = true;
+    }
+    return changed ? host.body.innerHTML : contentHtml;
+}
+/**
+ * turndownにはstyle/scriptの内容を除外するルールが無く、DOM上に残っていると
+ * 地の文への吸収(defaultReplacementが子孫テキストをそのまま連結する)か、gfmプラグインの
+ * 複雑表フォールバック(node.outerHTMLをそのままダンプする)経由でMarkdownへ混入する。
+ * Readability自身は_prepDocumentで<style>を除去するが、それはparse()呼び出し時点の
+ * ドキュメントにしか効かない: 救出表(collectDataTables)はparse前のouterHTMLを採取するため
+ * 道連れにしてしまい、アダプタ/selector経路はReadabilityを経由すらしない。抽出方式に関わらず
+ * 確実に除去するため、全ての抽出処理より前にドキュメント全体から取り除く
+ * (removeConsentBannersより前: バナー判定のテキスト長ヒューリスティックが埋め込みCSSで
+ * 水増しされるのも防げる)。pre/code内は著者が意図的に置いたコード例とみなし対象外にする。
+ *
+ * noscriptは対象に含めない: Readability.parse()は内部の_unwrapNoscriptImages()で、遅延読み込み
+ * プレースホルダimgをnoscript内の実画像へ差し替えてからnoscriptを除去する(style/scriptには
+ * 無い復元ロジック)。ここで先回りして除去すると差し替え元のnoscriptが消え、劣化した
+ * プレースホルダ画像しか残らなくなる。noscript自体の除去はremoveResidualNoscriptElements
+ * (turndown直前の全経路共通パス、Readability実行後)に委ねる。
+ */
+export function removeStyleLeakElements(document) {
+    for (const el of Array.from(document.querySelectorAll("style, script"))) {
+        if (el.closest("pre, code"))
+            continue;
+        el.remove();
+    }
+}
+/**
+ * <noscript>の除去は、Readability.parse()内の_unwrapNoscriptImages()(遅延読み込み
+ * プレースホルダimgをnoscript内の実画像へ差し替える処理)より後に行う必要がある
+ * (removeStyleLeakElementsのコメント参照)。readability/geometry/body-fallback経路は
+ * Readability.parse()が常に呼ばれる(結果を使わない場合も含め、渡したdocumentへ破壊的に
+ * 適用される)ため、この時点で画像差し替え・noscript除去は既に完了しており本関数は素通りする。
+ * 一方adapter/selector経路はReadabilityを経由しないため<noscript>が残ったままで、
+ * 地の文へ混入する。turndown直前の全経路共通パスに置くことで、経由済みの経路には影響を
+ * 与えず(冪等)、未経由の経路だけを確実にカバーする。pre/code内は著者が意図的に置いた
+ * コード例とみなし対象外にする。
+ */
+export function removeResidualNoscriptElements(html) {
+    if (!/<noscript[\s>]/i.test(html))
+        return html;
+    const { document } = parseHTML(`<!DOCTYPE html><html><body>${html}</body></html>`);
+    const host = document;
+    let changed = false;
+    for (const el of Array.from(host.body.querySelectorAll("noscript"))) {
+        if (el.closest("pre, code"))
+            continue;
+        el.remove();
+        changed = true;
+    }
+    return changed ? host.body.innerHTML : html;
+}
 export function extractMarkdown(html, options = {}) {
     const url = options.url ?? "about:blank";
     const { document } = parseHTML(html);
+    removeStyleLeakElements(document);
     stripRubyAnnotations(document);
     removeConsentBanners(document);
     // レンダリング可視テキストに近い統計を、プルーニング/selector適用前の元ドキュメントから採取する
@@ -358,14 +830,22 @@ export function extractMarkdown(html, options = {}) {
             if (document.body) {
                 prunedBlockCount = pruneLowValueBlocks(document.body);
             }
-            // Readabilityはリンク密度の高いデータ表(各国人口ソート表等)を本文から丸ごと落とすことがある。
-            // parseは渡したdocumentを破壊的に変更するため、parse前に救出候補の表を位置アンカー付きで採取しておく。
+            // Readabilityはリンク密度の高いデータ表(各国人口ソート表等)を本文から丸ごと落とし、
+            // 見出しをラッパー要素ごと剥ぐこともある。parseは渡したdocumentを破壊的に変更するため、
+            // parse前に救出候補の表・見出しを位置アンカー付きで採取しておく。
             const dataTables = document.body ? collectDataTables(document.body) : [];
+            const droppedHeadings = document.body ? collectHeadings(document.body) : [];
             const article = new Readability(document).parse();
             const geometryHtml = options.geometry ? extractByGeometry(document, options.geometry) : null;
             if (article && article.content && (article.textContent ?? "").trim().length >= MIN_READABILITY_TEXT_LENGTH) {
-                // Readabilityが取りこぼしたデータ表を、可能なら元の位置へ戻して本文へ再結合する。
-                contentHtml = reinsertDroppedTables(article.content, dataTables).html;
+                // 見出し→表→見出しの順で戻す。1回目の見出し復元で表のアンカー(表直前の見出し優先)を
+                // 立ててから表を戻す。表が1つでも戻ったときだけ2回目を回し、Readabilityが落として救出で
+                // 本文へ戻った表をアンカーに持つ見出し(データ表のみの節)を拾う(1回目は表が本文に無く
+                // 復元できない)。表が戻らなければcontentは不変で2回目は必ずno-opなので、一般ページに
+                // 常時パースコストを乗せないよう分岐する。reinsertDroppedHeadingsは既存見出し集合で冪等。
+                const withHeadings = reinsertDroppedHeadings(article.content, droppedHeadings).html;
+                const tableStep = reinsertDroppedTables(withHeadings, dataTables);
+                contentHtml = tableStep.appended > 0 ? reinsertDroppedHeadings(tableStep.html, droppedHeadings).html : tableStep.html;
                 title = article.title || title;
                 extractionMethod = "readability";
             }
@@ -385,8 +865,13 @@ export function extractMarkdown(html, options = {}) {
             }
         }
     }
+    // turndownは複雑表(colspan/rowspan・多段ヘッダ)を列ズレ・空セルにするため、変換前に
+    // 全経路共通で最外データ表を正規化する(救出経路で正規化済みの表・単純表・レイアウト表は素通し)。
+    const normalizedHtml = normalizeRetainedTables(contentHtml);
+    // adapter/selector経路(Readability非経由)に残り得るnoscriptを最終段で除去する。詳細はコメント参照。
+    const sanitizedHtml = removeResidualNoscriptElements(normalizedHtml);
     const turndown = createTurndownService();
-    const rawMarkdown = turndown.turndown(contentHtml).trim();
+    const rawMarkdown = turndown.turndown(sanitizedHtml).trim();
     const markdown = normalizeCjkText(rawMarkdown);
     return {
         title,