@link-assistant/web-capture 1.7.11 → 1.7.12

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @link-assistant/web-capture
 
+## 1.7.12
+
+### Patch Changes
+
+- ed70bc8: Fix Google Docs browser-model markdown regressions around table separators,
+  blockquote continuation, nested inline markers, final newlines, and
+  public-export style preprocessing.
+
 ## 1.7.11
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/web-capture",
-  "version": "1.7.11",
+  "version": "1.7.12",
   "description": "CLI and microservice to render web pages as HTML, Markdown, or PNG",
   "main": "src/index.js",
   "bin": {

package/src/gdocs-preprocess.js

@@ -25,14 +25,15 @@ export function preprocessGoogleDocsExportHtml(html) {
   }
 
   const $ = cheerio.load(html, { decodeEntities: false });
+  const classStyles = parseCssClassStyles($);
   let hoisted = 0;
   let unwrappedLinks = 0;
 
-  $('span[style], p[style]').each(function () {
-    const style = String($(this).attr('style') || '');
-    const hasBold = /font-weight\s*:\s*(?:bold|[6-9]\d{2})/i.test(style);
-    const hasItalic = /font-style\s*:\s*italic/i.test(style);
-    const hasStrike = /text-decoration[^;]*\bline-through\b/i.test(style);
+  $('span, p').each(function () {
+    const style = combinedElementStyle($, this, classStyles);
+    const hasBold = hasBoldStyle(style);
+    const hasItalic = hasItalicStyle(style);
+    const hasStrike = hasStrikeStyle(style);
     if (!hasBold && !hasItalic && !hasStrike) {
       return;
     }
@@ -47,10 +48,31 @@ export function preprocessGoogleDocsExportHtml(html) {
     if (hasBold) {
       wrapped = `<strong>${wrapped}</strong>`;
     }
-    $(this).replaceWith(wrapped);
+    if (this.tagName === 'p') {
+      $(this).html(wrapped);
+    } else {
+      $(this).replaceWith(wrapped);
+    }
     hoisted += 1;
   });
 
+  $('p').each(function () {
+    const style = combinedElementStyle($, this, classStyles);
+    if (!isBlockquoteStyle(style)) {
+      return;
+    }
+    $(this).replaceWith(
+      `<blockquote><p>${$(this).html() || ''}</p></blockquote>`
+    );
+  });
+
+  $('a').each(function () {
+    const $a = $(this);
+    if (!$a.attr('href') && !$a.text().trim() && !$a.find('img').length) {
+      $a.remove();
+    }
+  });
+
   $('h1, h2, h3, h4, h5, h6').each(function () {
     const $h = $(this);
     $h.find('a').each(function () {
@@ -103,3 +125,63 @@ export function preprocessGoogleDocsExportHtml(html) {
 
   return { html: rewritten, hoisted, unwrappedLinks };
 }
+
+function parseCssClassStyles($) {
+  const classStyles = new Map();
+  $('style').each(function () {
+    const css = $(this).html() || '';
+    const classRule = /\.([A-Za-z0-9_-]+)\s*\{([^{}]*)\}/g;
+    let match;
+    while ((match = classRule.exec(css)) !== null) {
+      const [, className, style] = match;
+      classStyles.set(
+        className,
+        `${classStyles.get(className) || ''};${style}`
+      );
+    }
+  });
+  return classStyles;
+}
+
+function combinedElementStyle($, element, classStyles) {
+  const $el = $(element);
+  const styles = [String($el.attr('style') || '')];
+  const classes = String($el.attr('class') || '')
+    .split(/\s+/u)
+    .filter(Boolean);
+  for (const className of classes) {
+    if (classStyles.has(className)) {
+      styles.push(classStyles.get(className));
+    }
+  }
+  return styles.join(';');
+}
+
+function hasBoldStyle(style) {
+  return /font-weight\s*:\s*(?:bold|[6-9]\d{2})/i.test(style);
+}
+
+function hasItalicStyle(style) {
+  return /font-style\s*:\s*italic/i.test(style);
+}
+
+function hasStrikeStyle(style) {
+  return /text-decoration[^;]*\bline-through\b/i.test(style);
+}
+
+function isBlockquoteStyle(style) {
+  const marginLeft = numericCssPointValue(style, 'margin-left');
+  const marginRight = numericCssPointValue(style, 'margin-right');
+  return (
+    marginLeft > 0 &&
+    marginRight > 0 &&
+    Math.abs(marginLeft - marginRight) < 0.1
+  );
+}
+
+function numericCssPointValue(style, property) {
+  const match = style.match(
+    new RegExp(`${property}\\s*:\\s*(-?\\d+(?:\\.\\d+)?)pt`, 'i')
+  );
+  return match ? Number(match[1]) : 0;
+}

package/src/gdocs-render-markdown.js

@@ -0,0 +1,173 @@
+export function renderBlocksMarkdown(blocks) {
+  const counters = new Map();
+  const rendered = blocks.map((block) => {
+    if (block.type === 'table') {
+      counters.clear();
+      return { text: renderTableMarkdown(block), list: null, quote: false };
+    }
+    const counterKey = block.list
+      ? `${block.list.id || ''}\u0000${block.list.level || 0}`
+      : null;
+    if (block.list) {
+      for (const key of [...counters.keys()]) {
+        const level = Number(key.split('\u0000')[1]);
+        if (level > (block.list.level || 0)) {
+          counters.delete(key);
+        }
+      }
+      const next = (counters.get(counterKey) || 0) + 1;
+      counters.set(counterKey, next);
+      return {
+        text: renderParagraphMarkdown(block, { orderedIndex: next }),
+        list: block.list,
+        quote: Boolean(block.quote),
+      };
+    }
+    counters.clear();
+    return {
+      text: renderParagraphMarkdown(block),
+      list: null,
+      quote: Boolean(block.quote),
+    };
+  });
+
+  const joined = [];
+  for (let i = 0; i < rendered.length; i++) {
+    const cur = rendered[i];
+    if (!cur.text) {
+      continue;
+    }
+    if (joined.length > 0) {
+      const prev = rendered
+        .slice(0, i)
+        .reverse()
+        .find((entry) => entry.text);
+      const sameList =
+        cur.list && prev?.list && (cur.list.id || '') === (prev.list.id || '');
+      if (sameList) {
+        joined.push('\n');
+      } else if (cur.quote && prev?.quote) {
+        joined.push('\n>\n');
+      } else {
+        joined.push('\n\n');
+      }
+    }
+    joined.push(cur.text);
+  }
+  const markdown = joined.join('').trimEnd();
+  return markdown ? `${markdown}\n` : '';
+}
+
+function renderParagraphMarkdown(block, context = {}) {
+  const text = renderContentMarkdown(block.content).trim();
+  if (block.horizontalRule) {
+    return '---';
+  }
+  const style = block.style || '';
+  const headingMatch = style.match(/^HEADING_(\d)$/u);
+  if (headingMatch) {
+    return `${'#'.repeat(Number(headingMatch[1]))} ${text}`;
+  }
+  if (style === 'TITLE') {
+    return `# ${text}`;
+  }
+  if (style === 'SUBTITLE') {
+    return `## ${text}`;
+  }
+  if (block.list) {
+    const indent = '  '.repeat(Math.max(0, block.list.level || 0));
+    const orderedIndex = Math.max(1, Number(context.orderedIndex) || 1);
+    const marker = block.list.ordered ? `${orderedIndex}.` : '-';
+    return `${indent}${marker} ${text}`;
+  }
+  if (block.quote) {
+    return text
+      .split('\n')
+      .map((line) => (line ? `> ${line}` : '>'))
+      .join('\n');
+  }
+  return text;
+}
+
+function renderTableMarkdown(table) {
+  if (!table.rows.length) {
+    return '';
+  }
+  const width = Math.max(...table.rows.map((row) => row.cells.length), 1);
+  const rows = table.rows.map((row) =>
+    Array.from({ length: width }, (_, idx) =>
+      escapeMarkdownTableCell(
+        renderContentMarkdown(row.cells[idx]?.content || [])
+      )
+    )
+  );
+  const separator = Array.from({ length: width }, () => '---');
+  return [rows[0], separator, ...rows.slice(1)]
+    .map((row) => `| ${row.join(' | ')} |`)
+    .join('\n');
+}
+
+function renderContentMarkdown(content = []) {
+  const rendered = [];
+  for (let idx = 0; idx < content.length; idx++) {
+    const node = content[idx];
+    if (node.type === 'image') {
+      rendered.push(node.url ? `![${node.alt || 'image'}](${node.url})` : '');
+      continue;
+    }
+
+    const link = node.link || null;
+    const linkNodes = [node];
+    while (
+      content[idx + 1]?.type === 'text' &&
+      (content[idx + 1].link || null) === link
+    ) {
+      linkNodes.push(content[++idx]);
+    }
+    const label = renderTextRunsMarkdown(linkNodes);
+    rendered.push(link ? `[${label}](${link})` : label);
+  }
+  return rendered.join('');
+}
+
+function renderTextRunsMarkdown(nodes = []) {
+  const inactive = { bold: false, italic: false, strike: false };
+  let active = { ...inactive };
+  let output = '';
+  for (const node of nodes) {
+    const next = {
+      bold: Boolean(node.bold),
+      italic: Boolean(node.italic),
+      strike: Boolean(node.strike),
+    };
+    output += markdownStyleTransition(active, next);
+    output += node.text || '';
+    active = next;
+  }
+  output += markdownStyleTransition(active, inactive);
+  return output;
+}
+
+function markdownStyleTransition(active, next) {
+  const styles = [
+    ['bold', '**'],
+    ['italic', '*'],
+    ['strike', '~~'],
+  ];
+  let markers = '';
+  for (const [key, marker] of [...styles].reverse()) {
+    if (active[key] && !next[key]) {
+      markers += marker;
+    }
+  }
+  for (const [key, marker] of styles) {
+    if (!active[key] && next[key]) {
+      markers += marker;
+    }
+  }
+  return markers;
+}
+
+function escapeMarkdownTableCell(value) {
+  return String(value).replace(/\|/g, '\\|').replace(/\n/g, '<br>');
+}

package/src/gdocs.js

@@ -13,6 +13,7 @@ import { convertHtmlToMarkdown } from './lib.js';
 import { createBrowser as defaultCreateBrowser } from './browser.js';
 import { preprocessGoogleDocsExportHtml } from './gdocs-preprocess.js';
 import { localizeGoogleDocsModelImages } from './gdocs-images.js';
+import { renderBlocksMarkdown } from './gdocs-render-markdown.js';
 import {
   googleDocsBrowserModelUnavailableError,
   isGoogleDocsBrowserModelUnavailableError,
@@ -649,6 +650,7 @@ export function parseGoogleDocsModelChunks(
   let cell = null;
   const tableHistograms = [];
   let currentHistogram = null;
+  let previousTableControl = null;
 
   const bumpHistogram = (code) => {
     if (!currentHistogram) {
@@ -672,7 +674,7 @@ export function parseGoogleDocsModelChunks(
 
   const flushCell = ({ dropEmpty = false } = {}) => {
     if (cell && row) {
-      const isEmpty = cell.content.length === 0;
+      const isEmpty = cellIsEmpty(cell);
       if (!dropEmpty || !isEmpty) {
         row.cells.push(cell);
       }
@@ -695,7 +697,7 @@ export function parseGoogleDocsModelChunks(
       // last cell content (from `\n` just before the `0x11` close marker).
       while (
         table.rows.length > 1 &&
-        table.rows[table.rows.length - 1].cells.length === 0
+        rowIsEmpty(table.rows[table.rows.length - 1])
       ) {
         table.rows.pop();
       }
@@ -707,6 +709,7 @@ export function parseGoogleDocsModelChunks(
     }
     currentHistogram = null;
     table = null;
+    previousTableControl = null;
   };
 
   const targetContent = () => {
@@ -727,6 +730,7 @@ export function parseGoogleDocsModelChunks(
     if (code === 0x10) {
       flushParagraph(i + 1);
       table = { type: 'table', rows: [] };
+      previousTableControl = code;
       currentHistogram = {
         '0x0a': 0,
         '0x0b': 0,
@@ -746,6 +750,7 @@ export function parseGoogleDocsModelChunks(
       bumpHistogram(code);
       flushRow({ dropEmptyTrailingCell: true });
       row = { cells: [] };
+      previousTableControl = code;
       continue;
     }
     if (code === 0x1c) {
@@ -755,11 +760,19 @@ export function parseGoogleDocsModelChunks(
         row = { cells: [] };
       }
       cell = { content: [] };
+      previousTableControl = code;
       continue;
     }
     if (code === 0x0a) {
       bumpHistogram(code);
       if (table) {
+        if (
+          cellIsEmpty(cell) &&
+          (previousTableControl === 0x1c || previousTableControl === 0x12)
+        ) {
+          previousTableControl = code;
+          continue;
+        }
         // Inside a Google Docs table, `\n` (0x0a) separates CELLS, not rows.
         // Row boundaries are communicated via the explicit `0x12` marker and
         // the closing `0x11` marker. Earlier versions collapsed multi-column
@@ -769,6 +782,7 @@ export function parseGoogleDocsModelChunks(
           row = { cells: [] };
         }
         cell = { content: [] };
+        previousTableControl = code;
       } else {
         flushParagraph(i + 1);
       }
@@ -777,18 +791,21 @@ export function parseGoogleDocsModelChunks(
     if (code === 0x0b) {
       bumpHistogram(code);
       appendText(targetContent(), '\n');
+      previousTableControl = null;
       continue;
     }
 
     const image = imagesByPos.get(i);
     if (image) {
       targetContent().push(image);
+      previousTableControl = null;
       if (fullText[i] === '*') {
         continue;
       }
     }
 
     appendText(targetContent(), fullText[i], styleMaps.inlineStyles[i]);
+    previousTableControl = null;
   }
 
   if (table) {
@@ -817,6 +834,22 @@ export function parseGoogleDocsModelChunks(
   };
 }
 
+function cellIsEmpty(cell) {
+  if (!cell) {
+    return true;
+  }
+  return (cell.content || []).every((node) => {
+    if (node.type === 'image') {
+      return false;
+    }
+    return !String(node.text || '').trim();
+  });
+}
+
+function rowIsEmpty(row) {
+  return !row || row.cells.length === 0 || row.cells.every(cellIsEmpty);
+}
+
 function buildModelStyleMaps(items, textLength) {
   const inlineStyles = Array.from({ length: textLength }, () => ({
     bold: false,
@@ -868,11 +901,17 @@ function applyInlineTextStyle(inlineStyles, start, end, patch) {
 }
 
 function textStyleFromModel(item) {
-  return {
-    bold: Boolean(item.sm?.ts_bd),
-    italic: Boolean(item.sm?.ts_it),
-    strike: Boolean(item.sm?.ts_st),
-  };
+  const style = {};
+  if (item.sm?.ts_bd) {
+    style.bold = true;
+  }
+  if (item.sm?.ts_it) {
+    style.italic = true;
+  }
+  if (item.sm?.ts_st) {
+    style.strike = true;
+  }
+  return style;
 }
 
 function paragraphStyleFromModel(item) {
@@ -1105,152 +1144,6 @@ function sameTextStyle(a, b) {
   );
 }
 
-function renderBlocksMarkdown(blocks) {
-  const counters = new Map();
-  const rendered = blocks.map((block) => {
-    if (block.type === 'table') {
-      counters.clear();
-      return { text: renderTableMarkdown(block), list: null };
-    }
-    const counterKey = block.list
-      ? `${block.list.id || ''}\u0000${block.list.level || 0}`
-      : null;
-    if (block.list) {
-      // Reset deeper siblings when we re-enter a shallower level so
-      // nested lists restart from 1 on each new parent.
-      for (const key of [...counters.keys()]) {
-        const level = Number(key.split('\u0000')[1]);
-        if (level > (block.list.level || 0)) {
-          counters.delete(key);
-        }
-      }
-      const next = (counters.get(counterKey) || 0) + 1;
-      counters.set(counterKey, next);
-      return {
-        text: renderParagraphMarkdown(block, { orderedIndex: next }),
-        list: block.list,
-      };
-    }
-    counters.clear();
-    return { text: renderParagraphMarkdown(block), list: null };
-  });
-
-  const joined = [];
-  for (let i = 0; i < rendered.length; i++) {
-    const cur = rendered[i];
-    if (!cur.text) {
-      continue;
-    }
-    if (joined.length > 0) {
-      const prev = rendered
-        .slice(0, i)
-        .reverse()
-        .find((entry) => entry.text);
-      const sameList =
-        cur.list && prev?.list && (cur.list.id || '') === (prev.list.id || '');
-      joined.push(sameList ? '\n' : '\n\n');
-    }
-    joined.push(cur.text);
-  }
-  return joined.join('').replace(/\s+$/u, '');
-}
-
-function renderParagraphMarkdown(block, context = {}) {
-  const text = renderContentMarkdown(block.content).trim();
-  if (block.horizontalRule) {
-    return '---';
-  }
-  const style = block.style || '';
-  const headingMatch = style.match(/^HEADING_(\d)$/u);
-  if (headingMatch) {
-    return `${'#'.repeat(Number(headingMatch[1]))} ${text}`;
-  }
-  if (style === 'TITLE') {
-    return `# ${text}`;
-  }
-  if (style === 'SUBTITLE') {
-    return `## ${text}`;
-  }
-  if (block.list) {
-    const indent = '  '.repeat(Math.max(0, block.list.level || 0));
-    const orderedIndex = Math.max(1, Number(context.orderedIndex) || 1);
-    const marker = block.list.ordered ? `${orderedIndex}.` : '-';
-    return `${indent}${marker} ${text}`;
-  }
-  if (block.quote) {
-    return text
-      .split('\n')
-      .map((line) => (line ? `> ${line}` : '>'))
-      .join('\n');
-  }
-  return text;
-}
-
-function renderTableMarkdown(table) {
-  if (!table.rows.length) {
-    return '';
-  }
-  const width = Math.max(...table.rows.map((row) => row.cells.length), 1);
-  const rows = table.rows.map((row) =>
-    Array.from({ length: width }, (_, idx) =>
-      escapeMarkdownTableCell(
-        renderContentMarkdown(row.cells[idx]?.content || [])
-      )
-    )
-  );
-  const separator = Array.from({ length: width }, () => '---');
-  return [rows[0], separator, ...rows.slice(1)]
-    .map((row) => `| ${row.join(' | ')} |`)
-    .join('\n');
-}
-
-function renderContentMarkdown(content = []) {
-  const rendered = [];
-  for (let idx = 0; idx < content.length; idx++) {
-    const node = content[idx];
-    if (node.type === 'image') {
-      rendered.push(node.url ? `![${node.alt || 'image'}](${node.url})` : '');
-      continue;
-    }
-    if (!node.link) {
-      rendered.push(renderMarkedText(node.text || '', node));
-      continue;
-    }
-
-    const link = node.link;
-    const linkNodes = [node];
-    while (
-      content[idx + 1]?.type === 'text' &&
-      content[idx + 1].link === link
-    ) {
-      linkNodes.push(content[++idx]);
-    }
-    const label = linkNodes
-      .map((linkNode) => renderMarkedText(linkNode.text || '', linkNode))
-      .join('');
-    rendered.push(`[${label}](${link})`);
-  }
-  return rendered.join('');
-}
-
-function renderMarkedText(text, node = {}) {
-  let output = text;
-  if (!output) {
-    return output;
-  }
-  if (node.bold && node.italic) {
-    output = `***${output}***`;
-  } else if (node.bold) {
-    output = `**${output}**`;
-  } else if (node.italic) {
-    output = `*${output}*`;
-  }
-  if (node.strike) {
-    output = `~~${output}~~`;
-  }
-  return output;
-}
-
 function renderBlocksHtml(blocks) {
   return `<!doctype html><html><body>${blocks
     .map((block) => {
@@ -1383,10 +1276,6 @@ function escapeHtml(value) {
   });
 }
 
-function escapeMarkdownTableCell(value) {
-  return String(value).replace(/\|/g, '\\|').replace(/\n/g, '<br>');
-}
-
 /**
  * Extract base64 data URI images from HTML content.
  *

package/tests/unit/gdocs.test.js

@@ -285,6 +285,29 @@ describe('gdocs', () => {
       expect(markdown).toContain('| D | E | F |');
     });
 
+    it('does not create empty columns when Docs emits both 0x1c and 0x0a cell separators (issue #96)', () => {
+      const chunks = [
+        {
+          chunk: [
+            {
+              ty: 'is',
+              s: `${
+                String.fromCharCode(0x10) + String.fromCharCode(0x12)
+              }A${String.fromCharCode(0x1c)}\nB${String.fromCharCode(
+                0x1c
+              )}\nC\n${String.fromCharCode(0x11)}`,
+            },
+          ],
+        },
+      ];
+      const capture = parseGoogleDocsModelChunks(chunks);
+      const markdown = renderGoogleDocsCapture(capture, 'markdown');
+
+      expect(capture.tables[0].rows[0].cells).toHaveLength(3);
+      expect(markdown).toContain('| A | B | C |');
+      expect(markdown).not.toContain('| A |  | B |');
+    });
+
     it('numbers ordered list items sequentially (issue #92 R3)', () => {
       // Three list items sharing the same list id should render as 1. 2. 3.
       const text = 'First item\nSecond item\nThird item\n';
@@ -470,6 +493,108 @@ describe('gdocs', () => {
         '![Blue rectangle](https://docs.google.com/docs-images-rt/image-id)'
       );
     });
+
+    it('keeps nested bold and italic markers balanced (issue #96)', () => {
+      const text = 'Bold text with italic inside and back to bold\n';
+      const chunks = [
+        {
+          chunk: [
+            { ty: 'is', s: text },
+            {
+              ty: 'as',
+              st: 'text',
+              si: 1,
+              ei: text.length - 1,
+              sm: { ts_bd: true },
+            },
+            {
+              ty: 'as',
+              st: 'text',
+              si: text.indexOf('italic') + 1,
+              ei: text.indexOf('italic') + 'italic inside'.length,
+              sm: { ts_it: true },
+            },
+          ],
+        },
+      ];
+      const capture = parseGoogleDocsModelChunks(chunks);
+      const markdown = renderGoogleDocsCapture(capture, 'markdown');
+
+      expect(markdown).toBe(
+        '**Bold text with *italic inside* and back to bold**\n'
+      );
+    });
+
+    it('keeps styled same-target link segments in one link label (issue #96)', () => {
+      const text = 'Link with bold text\n';
+      const startOf = (needle) => text.indexOf(needle) + 1;
+      const endOf = (needle) => startOf(needle) + needle.length - 1;
+      const chunks = [
+        {
+          chunk: [
+            { ty: 'is', s: text },
+            {
+              ty: 'as',
+              st: 'link',
+              si: 1,
+              ei: text.length - 1,
+              sm: { lnks_link: { ulnk_url: 'https://example.com' } },
+            },
+            {
+              ty: 'as',
+              st: 'text',
+              si: startOf('bold'),
+              ei: endOf('bold'),
+              sm: { ts_bd: true },
+            },
+          ],
+        },
+      ];
+      const capture = parseGoogleDocsModelChunks(chunks);
+      const markdown = renderGoogleDocsCapture(capture, 'markdown');
+
+      expect(markdown).toBe('[Link with **bold** text](https://example.com)\n');
+    });
+
+    it('keeps consecutive blockquote paragraphs in the same quote block (issue #96)', () => {
+      const text = 'Quote paragraph one\nQuote paragraph two\n';
+      const lineEnd = (needle) => text.indexOf(needle) + needle.length + 1;
+      const chunks = [
+        {
+          chunk: [
+            { ty: 'is', s: text },
+            {
+              ty: 'as',
+              st: 'paragraph',
+              si: lineEnd('Quote paragraph one'),
+              ei: lineEnd('Quote paragraph one'),
+              sm: { ps_il: 24, ps_ifl: 24 },
+            },
+            {
+              ty: 'as',
+              st: 'paragraph',
+              si: lineEnd('Quote paragraph two'),
+              ei: lineEnd('Quote paragraph two'),
+              sm: { ps_il: 24, ps_ifl: 24 },
+            },
+          ],
+        },
+      ];
+      const capture = parseGoogleDocsModelChunks(chunks);
+      const markdown = renderGoogleDocsCapture(capture, 'markdown');
+
+      expect(markdown).toBe(
+        '> Quote paragraph one\n>\n> Quote paragraph two\n'
+      );
+    });
+
+    it('ends rendered markdown with a newline (issue #96)', () => {
+      const capture = parseGoogleDocsModelChunks([
+        { ty: 'is', s: 'Last line\n' },
+      ]);
+
+      expect(renderGoogleDocsCapture(capture, 'markdown')).toBe('Last line\n');
+    });
   });
 
   describe('renderDocsApiDocument (issue #72)', () => {
@@ -689,6 +814,18 @@ describe('gdocs', () => {
       expect(out).toContain('<del>');
     });
 
+    it('hoists Google Docs CSS class styles into semantic inline tags', () => {
+      const html =
+        '<style>.c7{font-weight:700}.c19{font-style:italic}.c21{text-decoration:line-through}</style>' +
+        '<p><span class="c7">Bold</span> <span class="c19">Italic</span> <span class="c21">Strike</span></p>';
+      const { html: out, hoisted } = preprocessGoogleDocsExportHtml(html);
+
+      expect(hoisted).toBe(3);
+      expect(out).toContain('<strong>Bold</strong>');
+      expect(out).toContain('<em>Italic</em>');
+      expect(out).toContain('<del>Strike</del>');
+    });
+
     it('combines multiple styles on a single span', () => {
       const html =
         '<p><span style="font-weight:700;font-style:italic;text-decoration:line-through">Mixed</span></p>';
@@ -718,6 +855,22 @@ describe('gdocs', () => {
       expect(out).not.toContain('<a id=');
     });
 
+    it('strips standalone empty anchors before headings', () => {
+      const html = '<a id="anchor-1"></a><h2>Headings</h2>';
+      const { html: out } = preprocessGoogleDocsExportHtml(html);
+
+      expect(out).toContain('<h2>Headings</h2>');
+      expect(out).not.toContain('<a id=');
+    });
+
+    it('turns class-indented Google Docs paragraphs into blockquotes', () => {
+      const html =
+        '<style>.c18{margin-left:24pt;margin-right:24pt}</style><p class="c18">Quote</p>';
+      const { html: out } = preprocessGoogleDocsExportHtml(html);
+
+      expect(out).toContain('<blockquote><p>Quote</p></blockquote>');
+    });
+
     it('replaces &nbsp; entity and U+00A0 with regular spaces', () => {
       const html = '<p>A\u00A0B&nbsp;C</p>';
       const { html: out } = preprocessGoogleDocsExportHtml(html);