asciidoctor-rhrev 1.3.0 → 1.5.1

package/antora-extension/antora-rhrev-asciidoc.js

@@ -2,16 +2,315 @@
 
 /**
  * Antora extension for revision history (rhrev) block macro.
- * 
+ *
  * Provides HTML5 backend support for revision history tables.
  * Auto-injects revision history at document start unless :rhrev: macro or manual mode.
- * 
+ *
  * Usage in antora-playbook.yml:
  *   antora:
  *     extensions:
  *       - require: ./antora-extension/antora-rhrev-asciidoc.js
  */
 
+// Mirrors Converter::ROLLUP_CONTEXTS on the Ruby gem's PDF side and
+// ROLLUP_CONTEXTS in rhrev_html.rb: block types with no revision-history row
+// of their own. A marked one rolls up as a bullet into its nearest
+// enclosing section's entry instead (or the document-level -all entry, if
+// it has no enclosing section, or its enclosing section has no id).
+const ROLLUP_CONTEXTS = ['paragraph', 'ulist', 'olist', 'dlist', 'admonition', 'open', 'quote', 'verse', 'sidebar']
+
+// Row-level: gets its own revision-history row when marked, requires an id.
+// Same six contexts collectAllEntries already scanned before this port.
+const ROW_LEVEL_CONTEXTS = ['section', 'floating_title', 'example', 'listing', 'table', 'image']
+
+// Walks up from node to its nearest enclosing section, or null if none
+// exists (the document preamble). Same shape as Converter#enclosing_section
+// on the Ruby side.
+function enclosingSection(node) {
+  let section = node.getParent ? node.getParent() : null
+  while (section && section.getContext && section.getContext() !== 'section') {
+    section = section.getParent ? section.getParent() : null
+  }
+  return section || null
+}
+
+// Finds anchorNode's existing entry for this revision on catalog and
+// appends another bullet onto its change text, or creates the entry if
+// anchorNode has none yet. Same shape as Converter#append_child_change_to_entry.
+function appendChildChangeToEntry(catalog, revision, anchorNode, changeText) {
+  const entries = catalog.entries[revision] || (catalog.entries[revision] = [])
+  const anchorId = anchorNode.getId()
+  const entry = entries.find((e) => e.anchor === anchorId)
+  if (entry) {
+    entry.change = (entry.change && String(entry.change).length) ? `${entry.change} * ${changeText}` : changeText
+  } else {
+    catalog.addEntry(revision, anchorId, changeText, {
+      title: anchorNode.getTitle ? anchorNode.getTitle() : null,
+      context: anchorNode.getContext ? anchorNode.getContext() : null
+    })
+  }
+}
+
+// Appends onto catalog's existing -all change text for this revision, or
+// sets it fresh if none exists yet. Same shape as Converter#append_child_change_to_all.
+function appendChildChangeToAll(catalog, revision, changeText) {
+  const existing = catalog.allEntries[revision]
+  const combined = (existing && String(existing).length) ? `${existing} * ${changeText}` : changeText
+  catalog.addAllEntry(revision, combined)
+}
+
+// Gathers every marked rollup-context node in one unified, document-order
+// traversal (findBy returns document order on its own, confirmed directly,
+// no separate sort needed). Must run after the row-level scan in
+// collectAllEntries, so a section's own entry, if it is also independently
+// marked, already exists for a child's bullet to append onto instead of
+// racing to create a duplicate.
+function rollupChildRevisionEntries(catalog, doc, prefix) {
+  const nodes = doc.findBy((n) => ROLLUP_CONTEXTS.includes(n.getContext()))
+  nodes.forEach((node) => {
+    const attrs = node.getAttributes()
+    if (!attrs) return
+    const section = enclosingSection(node)
+    const hasSection = !!(section && section.getId())
+    Object.keys(attrs).forEach((key) => {
+      if (!key.startsWith(prefix)) return
+      if (key.includes('-all') || key.endsWith('-cover')) return
+      const revision = key.substring(prefix.length)
+      const value = String(attrs[key])
+      if (hasSection) {
+        appendChildChangeToEntry(catalog, revision, section, value)
+      } else {
+        appendChildChangeToAll(catalog, revision, value)
+      }
+    })
+  })
+}
+
+// Table cells cannot carry an rhrev attribute of their own through normal
+// AsciiDoc parsing: a plain (|) cell never parses its content as blocks at
+// all, an attribute list there is just literal text. An AsciiDoc-style (a|)
+// cell does parse its content as blocks, so [rhrev1-2="..."] attaches, but
+// to the first nested block, not the cell, and that nested block lives in a
+// structurally separate inner document (getInnerDocument()), unreachable
+// from the outer document's own findBy. Confirmed directly, same gotcha as
+// the Ruby side.
+//
+// Copies any rhrev-prefixed attribute from a marked nested rollup-context
+// node onto the enclosing cell (for the revision-history entry, see
+// rollupTableCellRevisionEntries below, which needs it on the cell), then
+// strips it from the nested node. For the visual side, tagging the cell's
+// own <td>/<th> needs a converter-level override (see the NOT IMPLEMENTED
+// note further down: built, verified standalone, broke real Antora builds
+// on a sibling package's dependency conflict, dropped). Tagging the nested
+// node itself instead needs no override at all: it renders through the
+// same, completely unmodified converter as any other rollup-context block,
+// which already supports a role. So when this key matches the *current*
+// revision's change attribute and change bars are enabled, the role is set
+// here directly, on the node inside the cell's own inner document, before
+// the attribute is stripped. The outer change-bar tagging treeProcessor
+// cannot reach this on its own: it walks the outer document only, and the
+// inner document is structurally separate, unreachable from the outer
+// document's own findBy, confirmed directly, same gotcha as the Ruby side.
+//
+// Must run at treeprocessor time (see below), not lazily inside
+// collectAllEntries: treeprocessors all run before conversion starts.
+// Safe to call twice (collectAllEntries also calls it directly, for the
+// block-macro's own-page fallback path): once a mark is propagated,
+// tagged, and stripped, a second pass finds nothing left to move.
+function propagateCellContentMarks(doc, prefix) {
+  const changeBarsEnabled = doc.hasAttribute('rhrev-change-bars')
+  const revnumber = doc.getAttribute('revnumber')
+  const changeAttr = (changeBarsEnabled && revnumber) ? prefix + String(revnumber).replace(/\./g, '-') : null
+
+  doc.findBy((n) => n.getContext() === 'table').forEach((table) => {
+    const rows = table.getRows()
+    const cells = [].concat(rows.head.flat(), rows.foot.flat(), rows.body.flat())
+    cells.forEach((cell) => {
+      if (cell.getStyle() !== 'asciidoc') return
+      const inner = cell.getInnerDocument ? cell.getInnerDocument() : null
+      if (!inner) return
+      inner.findBy((n) => ROLLUP_CONTEXTS.includes(n.getContext())).forEach((node) => {
+        const attrs = node.getAttributes()
+        if (!attrs) return
+        Object.keys(attrs).forEach((key) => {
+          if (!key.startsWith(prefix)) return
+          cell.setAttribute(key, attrs[key])
+          if (key === changeAttr) {
+            const roles = attrs.role
+            node.setAttribute('role', roles ? `${roles} rhrev-changed` : 'rhrev-changed')
+          }
+          node.removeAttribute(key)
+        })
+      })
+    })
+  })
+}
+
+// A marked table cell is not a rollup context itself: it rolls up to its
+// own enclosing table, not the nearest section, and cells are not reachable
+// through the same context-based findBy a normal block-level node is, so
+// this walks table.getRows() directly. Same three-tier fallback as
+// rollupChildRevisionEntries: the table's own entry if it has an id, else
+// its nearest enclosing section's entry, else the document-level -all
+// entry only when neither exists. Same shape as
+// Converter#rollup_table_cell_revision_entries / Html5Converter#rollup_table_cell_revision_entries
+// on the Ruby side.
+function rollupTableCellRevisionEntries(catalog, doc, prefix) {
+  doc.findBy((n) => n.getContext() === 'table').forEach((table) => {
+    const rows = table.getRows()
+    const cells = [].concat(rows.head.flat(), rows.foot.flat(), rows.body.flat())
+    cells.forEach((cell) => {
+      const attrs = cell.getAttributes()
+      if (!attrs) return
+      Object.keys(attrs).forEach((key) => {
+        if (!key.startsWith(prefix)) return
+        if (key.includes('-all') || key.endsWith('-cover')) return
+        const revision = key.substring(prefix.length)
+        const value = String(attrs[key])
+        if (table.getId()) {
+          appendChildChangeToEntry(catalog, revision, table, value)
+        } else {
+          const section = enclosingSection(table)
+          if (section && section.getId()) {
+            appendChildChangeToEntry(catalog, revision, section, value)
+          } else {
+            appendChildChangeToAll(catalog, revision, value)
+          }
+        }
+      })
+    })
+  })
+}
+
+// The cell's own <td>/<th> DOES carry the rhrev-changed role, via a
+// converter-level override, patched directly onto the SAME live converter
+// class object Antora's own pipeline is already using for this document
+// (doc.getConverter().$$class, reached through Asciidoctor's own public
+// API), never a separately-required or separately-registered class.
+//
+// EARLIER ATTEMPT, SUPERSEDED (kept here since the next engineer will
+// otherwise reach for the same idea first): a real Opal subclass of
+// Html5Converter, registered via ConverterFactory, the same way the Ruby
+// gem's PDF converter is overridden. Built and verified working
+// standalone, but broke real Antora builds: this exact demo site had
+// three separate, non-deduped @asciidoctor/core installs (rhrev, the site
+// itself, and baiyibai-extensions, whose cite-it extension wraps Antora's
+// own document loading), one of them a different version. Antora's own
+// converter/html5.js reads whatever is currently registered as the
+// 'html5' converter and builds a real Opal subclass on top of that; with
+// non-identical copies of the Opal runtime involved, defining a SECOND,
+// independent subclass crashed (Object.setPrototypeOf called on null or
+// undefined), confirmed against a real local build, not assumed. A
+// require('@antora/asciidoc-loader') from inside this file cannot avoid
+// that risk either, even now that baiyibai-extensions' own version drift
+// is fixed (1.15.1): this package ships its own @asciidoctor/core copy
+// for its own test suite, so a plain require() here resolves against
+// THIS package's node_modules first, not necessarily the consuming
+// site's, and remains a live, standing risk of resolving a different
+// copy regardless of what any sibling package currently pins.
+//
+// doc.getConverter() sidesteps the whole class of problem: it returns
+// whichever converter object is ACTUALLY resolved for THIS document, in
+// THIS process, by Antora's own pipeline, guaranteed correct by
+// construction rather than by keeping multiple packages' pins in sync.
+// Confirmed directly: asciidoctor.load(text).getConverter() already
+// returns a real, usable converter instance, with a real $$class, before
+// convert() is ever called, meaning it is available in time from inside a
+// treeprocessor (treeprocessors run during load(), before conversion).
+const PATCHED_CONVERT_TABLE = Symbol.for('rhrev.patchedConvertTable')
+
+// Idempotency is keyed on the converter CLASS, not the document: a single
+// Antora build converts many documents against the same resolved
+// converter class object, and redefining $convert_table would otherwise
+// re-wrap the previous wrapper on every single page, nesting deeper each
+// time (and, worse, the second pass would capture the FIRST WRAPPER as
+// its own "original", not the real one, once the reference below is
+// overwritten).
+//
+// Captures the real, original $convert_table function reference directly
+// off the class's own prototype before replacing it, and calls that
+// reference directly, rather than Opal.find_super_dispatcher (Antora's
+// own html5.js pattern, copied from initially, then found wrong for this
+// case, confirmed against a real crash: find_super_dispatcher climbs an
+// inheritance chain, correct when Opal.klass creates a genuine SUBCLASS
+// the way Antora's own converter/html5.js does, but this patches the
+// SAME class object in place, no subclass involved, so there is no
+// superclass boundary to dispatch across; the original implementation
+// lives directly on classDef.$$prototype itself, confirmed directly, and
+// Opal.defn below overwrites that exact slot).
+function patchConvertTableForCellTagging (doc) {
+  const Opal = global.Opal
+  if (!Opal) return
+  const converter = doc.getConverter && doc.getConverter()
+  const classDef = converter && converter.$$class
+  if (!classDef || classDef[PATCHED_CONVERT_TABLE]) return
+  const originalConvertTable = classDef.$$prototype['$convert_table']
+  if (typeof originalConvertTable !== 'function') return
+  classDef[PATCHED_CONVERT_TABLE] = true
+
+  Opal.defn(classDef, '$convert_table', function convertTableWithCellTags (node) {
+    const html = originalConvertTable.call(this, node)
+    return typeof html === 'string' ? liftRhrevChangedToCells(html) : html
+  })
+}
+
+// Moves the rhrev-changed marker from a marked cell's own nested content
+// (propagateCellContentMarks above) onto its enclosing <td>/<th>, so the
+// site stylesheet highlights the whole cell box, matching the PDF
+// backend's own margin bar spanning the cell's full row height, rather
+// than only the changed paragraph inside it. Operates on the already-
+// rendered HTML string, not the AST: Asciidoctor's real convert_table has
+// no per-cell hook to override cleanly (table rendering is one self-
+// contained method, the same reason the PDF gem needed a Prawn-level
+// patch rather than an ordinary converter override, confirmed against
+// Asciidoctor's own source), so this calls the real, unmodified super()
+// implementation first and only adjusts its output afterward.
+//
+// Finds the nearest PRECEDING <td/<th opening tag before each marker,
+// confirmed against real rendered output (a plain cell's own <p
+// class="tableblock"> vs an a| cell's <div class="content">, both
+// verified). A table nested inside a cell, itself containing its own
+// <td>/<th> tags between the marker and its true enclosing cell, would
+// defeat that heuristic: a known, accepted limitation, not handled.
+function liftRhrevChangedToCells (html) {
+  const cellTagRx = /<(td|th)\b[^>]*>/g
+  const cellTags = []
+  let m
+  while ((m = cellTagRx.exec(html))) {
+    cellTags.push({ start: m.index, end: m.index + m[0].length, text: m[0] })
+  }
+  if (cellTags.length === 0) return html
+
+  const markerRx = /class="[^"]*\brhrev-changed\b[^"]*"/g
+  const toPatch = new Set()
+  while ((m = markerRx.exec(html))) {
+    let owner
+    for (const tag of cellTags) {
+      if (tag.start <= m.index) owner = tag
+      else break
+    }
+    if (owner) toPatch.add(owner)
+  }
+  if (toPatch.size === 0) return html
+
+  let out = ''
+  let cursor = 0
+  for (const tag of cellTags) {
+    if (!toPatch.has(tag)) continue
+    out += html.slice(cursor, tag.start)
+    out += addRoleClass(tag.text, 'rhrev-changed')
+    cursor = tag.end
+  }
+  out += html.slice(cursor)
+  return out
+}
+
+function addRoleClass (tagText, role) {
+  if (new RegExp(`\\bclass="[^"]*\\b${role}\\b[^"]*"`).test(tagText)) return tagText
+  if (/\bclass="/.test(tagText)) return tagText.replace(/\bclass="/, `class="${role} `)
+  return tagText.replace(/^<(td|th)\b/, `<$1 class="${role}"`)
+}
+
 // Catalog for storing revision entries
 class RevisionCatalog {
   constructor() {
@@ -24,7 +323,7 @@ class RevisionCatalog {
     if (!this.entries[revision]) {
       this.entries[revision] = []
     }
-    
+
     this.entries[revision].push({
       anchor,
       change,
@@ -66,13 +365,13 @@ function isInitialRelease(revnumber) {
 function formatPrevRev(prevTitle, prevDate, doc) {
   const includeDateAttr = doc.getAttribute('rhrev-customization-prevrev-include-date')
   const includeDate = includeDateAttr !== undefined
-  
+
   if (includeDate && prevDate) {
     const dateFormat = doc.getAttribute('rhrev-customization-date-format') || '%Y-%m-%d'
     // Simple date formatting (Node.js doesn't have strftime, keep it simple)
     return `${prevTitle} ${prevDate}`
   }
-  
+
   return prevTitle
 }
 
@@ -83,20 +382,20 @@ function preprocessAttributeContent(text) {
 
 function formatChangeAsHtmlList(text) {
   if (!text) return ''
-  
+
   const processed = preprocessAttributeContent(text)
-  
+
   // Split by asterisks to create list items
   const tokens = processed.split(/\s(?=\*+\s)/)
   const items = []
-  
+
   if (tokens.length === 1 && !processed.includes('*')) {
     // Single item without asterisk - wrap in list anyway
     items.push({ level: 1, content: processed })
   } else {
     tokens.forEach(token => {
       if (!token.trim()) return
-      
+
       const match = token.trim().match(/^(\*+)\s+(.+)/)
       if (match) {
         items.push({ level: match[1].length, content: match[2] })
@@ -105,60 +404,58 @@ function formatChangeAsHtmlList(text) {
       }
     })
   }
-  
+
   // Always generate HTML list
   const html = ['<ul>']
   items.forEach(item => {
     html.push(`<li>${item.content}</li>`)
   })
   html.push('</ul>')
-  
+
   return html.join('\n')
 }
 
 function collectAllEntries(doc) {
   const catalog = new RevisionCatalog()
   const prefix = doc.getAttribute('revhistoryprefix') || 'rhrev'
-  
+
   // Collect document-level entries (-all)
   for (let major = 0; major <= 9; major++) {
     for (let minor = 0; minor <= 9; minor++) {
       const revision = `${major}-${minor}`
       const prevrevAttr = `${revision}-prevrev`
-      
+
       if (doc.getAttribute(prevrevAttr)) {
         const allAttrName = `${prefix}${revision}-all`
         const allValue = doc.getAttribute(allAttrName)
-        
+
         if (allValue) {
           catalog.addAllEntry(revision, allValue)
         }
       }
     }
   }
-  
+
   // Collect block-level entries by scanning document
-  const contexts = ['section', 'floating_title', 'example', 'listing', 'table', 'image']
-  
   function scanBlocks(blocks) {
     if (!blocks) return
-    
+
     blocks.forEach(block => {
       const blockId = block.getId()
       const blockContext = block.getContext()
-      
-      if (contexts.includes(blockContext) && blockId) {
+
+      if (ROW_LEVEL_CONTEXTS.includes(blockContext) && blockId) {
         // Try both getAttributes() and direct attribute access
         const attrs = block.getAttributes()
-        
+
         // Also check if attributes are exposed differently
         // Some Asciidoctor.js versions expose them via getAttribute(name) only
         Object.keys(attrs).forEach(key => {
           const value = attrs[key]
-          
+
           if (key.startsWith(prefix) && !key.includes('-all') && !key.endsWith('-cover')) {
             const revision = key.substring(prefix.length)
-            
+
             catalog.addEntry(revision, blockId, String(value), {
               title: block.getTitle(),
               context: blockContext
@@ -166,30 +463,38 @@ function collectAllEntries(doc) {
           }
         })
       }
-      
+
       // Recurse into nested blocks
       if (block.getBlocks) {
         scanBlocks(block.getBlocks())
       }
     })
   }
-  
+
   scanBlocks(doc.getBlocks())
-  
+
+  // Paragraphs, lists, and the other rollup contexts, plus table cells:
+  // see propagateCellContentMarks/rollupChildRevisionEntries/rollupTableCellRevisionEntries
+  // above. Must run after the row-level scan above, so a section's own
+  // entry, if independently marked, already exists for a child to append onto.
+  propagateCellContentMarks(doc, prefix)
+  rollupChildRevisionEntries(catalog, doc, prefix)
+  rollupTableCellRevisionEntries(catalog, doc, prefix)
+
   return catalog
 }
 
 function generateInitialReleaseHtml(doc) {
   const discrete = doc.hasAttribute('rhrev-discrete')
   const html = []
-  
+
   // Wrapper
   if (discrete) {
     html.push('<div class="rhrev-section">')
   } else {
     html.push('<section id="revision-history">')
   }
-  
+
   // Title
   const customTitle = doc.getAttribute('rhrev-customization-title')
   if (customTitle !== undefined && customTitle === '') {
@@ -202,12 +507,12 @@ function generateInitialReleaseHtml(doc) {
     const versionLabel = String(doc.getAttribute('version-label') || 'Revision')
     html.push(`<h2>${versionLabel} History</h2>`)
   }
-  
+
   // Simple table
   const initialText = doc.getAttribute('rhrev-customization-initial-release-text') ||
                      doc.getAttribute('rhrev-localization-initial-release') ||
                      'Initial release'
-  
+
   const columnWidths = String(doc.getAttribute('rhrev-table-column-width') || '30,70').split(',').map(w => w.trim())
   const sectionLabel = doc.getAttribute('rhrev-localization-location') || 'Section'
 
@@ -215,7 +520,7 @@ function generateInitialReleaseHtml(doc) {
   const frame = doc.getAttribute('rhrev-table-frame') || 'all'
   const grid = doc.getAttribute('rhrev-table-grid') || 'all'
   html.push(`<table class="tableblock frame-${frame} grid-${grid} stretch">`)
-  
+
   // Caption as title div
   if (!doc.hasAttribute('rhrev-disable-caption')) {
     const caption = doc.getAttribute('rhrev-table-caption')
@@ -223,7 +528,7 @@ function generateInitialReleaseHtml(doc) {
       html.push(`<div class="title">${caption}</div>`)
     }
   }
-  
+
   html.push('<colgroup>')
   columnWidths.forEach(w => {
     html.push(`<col style="width: ${w}%;">`)
@@ -253,24 +558,24 @@ function generateInitialReleaseHtml(doc) {
   html.push('</tr>')
   html.push('</tbody>')
   html.push('</table>')
-  
+
   // Close wrapper
   html.push(discrete ? '</div>' : '</section>')
-  
+
   return html.join('\n')
 }
 
 function generateHtmlOutput(doc, catalog, currentPage = '') {
   const discrete = doc.hasAttribute('rhrev-discrete')
   const html = []
-  
+
   // Wrapper
   if (discrete) {
     html.push('<div class="rhrev-section">')
   } else {
     html.push('<section id="revision-history">')
   }
-  
+
   // Title
   const customTitle = doc.getAttribute('rhrev-customization-title')
   if (customTitle !== undefined && customTitle === '') {
@@ -283,25 +588,25 @@ function generateHtmlOutput(doc, catalog, currentPage = '') {
     const versionLabel = String(doc.getAttribute('version-label') || 'Revision')
     html.push(`<h2>${versionLabel} History</h2>`)
   }
-  
+
   // Table
   html.push(generateHtmlTable(doc, catalog, currentPage))
-  
+
   // Close wrapper
   html.push(discrete ? '</div>' : '</section>')
-  
+
   return html.join('\n')
 }
 
 function generateHtmlTable(doc, catalog, currentPage = '') {
   const columnWidths = String(doc.getAttribute('rhrev-table-column-width') || '30,70').split(',').map(w => w.trim())
   const html = []
-  
+
   // Build table with frame/grid classes
   const frame = doc.getAttribute('rhrev-table-frame') || 'all'
   const grid = doc.getAttribute('rhrev-table-grid') || 'all'
   html.push(`<table class="tableblock frame-${frame} grid-${grid} stretch">`)
-  
+
   // Caption as title div
   if (!doc.hasAttribute('rhrev-disable-caption')) {
     const caption = doc.getAttribute('rhrev-table-caption')
@@ -309,19 +614,19 @@ function generateHtmlTable(doc, catalog, currentPage = '') {
       html.push(`<div class="title">${caption}</div>`)
     }
   }
-  
+
   html.push('<colgroup>')
   columnWidths.forEach(w => {
     html.push(`<col style="width: ${w}%;">`)
   })
   html.push('</colgroup>')
   html.push('<tbody>')
-  
+
   // Custom first row
   const firstRow = doc.getAttribute('rhrev-customization-first-row')
   const firstRowLeft = doc.getAttribute('rhrev-customization-first-row-left')
   const firstRowRight = doc.getAttribute('rhrev-customization-first-row-right')
-  
+
   if (firstRow) {
     html.push('<tr class="rhrev-custom-first-row">')
     html.push(`<td colspan="2">${firstRow}</td>`)
@@ -332,11 +637,11 @@ function generateHtmlTable(doc, catalog, currentPage = '') {
     html.push(`<td>${firstRowRight || '&nbsp;'}</td>`)
     html.push('</tr>')
   }
-  
+
   const sectionLabel = doc.getAttribute('rhrev-localization-location') || 'Section'
   const majorChangesText = doc.getAttribute('rhrev-localization-major-changes') || 'Major changes since'
   const allText = doc.getAttribute('rhrev-localization-all') || 'All'
-  
+
   catalog.sortedRevisions().forEach(revision => {
     const prevrevAttr = `${revision}-prevrev`
     const prevrevdateAttr = `${revision}-prevrevdate`
@@ -344,7 +649,7 @@ function generateHtmlTable(doc, catalog, currentPage = '') {
     const prevTitle = String(doc.getAttribute(prevrevAttr) || revision.replaceAll('-', '.'))
     const prevDate = String(doc.getAttribute(prevrevdateAttr) || '')
     const prevRevText = formatPrevRev(prevTitle, prevDate, doc)
-    
+
     // Build header text
     let headerText
     if (prevTitle.trim().toLowerCase().startsWith(revisionLabel.toLowerCase())) {
@@ -352,13 +657,13 @@ function generateHtmlTable(doc, catalog, currentPage = '') {
     } else {
       headerText = `${majorChangesText} ${revisionLabel} ${prevRevText}`
     }
-    
+
     // Header row for this revision
     html.push('<tr class="rhrev-header">')
     html.push(`<th class="tableblock halign-left valign-top">${sectionLabel}</th>`)
     html.push(`<th class="tableblock halign-left valign-top"><strong>${headerText}</strong></th>`)
     html.push('</tr>')
-    
+
     // All entry
     const allChange = catalog.allEntries[revision]
     if (allChange) {
@@ -367,17 +672,17 @@ function generateHtmlTable(doc, catalog, currentPage = '') {
       html.push(`<td>${formatChangeAsHtmlList(allChange)}</td>`)
       html.push('</tr>')
     }
-    
+
     // Block entries
     const entries = catalog.entries[revision] || []
     entries.sort((a, b) => (a.sequence || 0) - (b.sequence || 0))
-    
+
     entries.forEach(entry => {
       const anchor = entry.anchor
-      const title = entry.title || anchor.replace(/[_-]/g, ' ').split(' ').map(w => 
+      const title = entry.title || anchor.replace(/[_-]/g, ' ').split(' ').map(w =>
         w.charAt(0).toUpperCase() + w.slice(1)
       ).join(' ')
-      
+
       html.push('<tr>')
 
       // Build link: local anchor if the section lives on the current page (directly or via include)
@@ -421,10 +726,10 @@ function generateHtmlTable(doc, catalog, currentPage = '') {
       html.push('</tr>')
     })
   })
-  
+
   html.push('</tbody>')
   html.push('</table>')
-  
+
   return html.join('\n')
 }
 
@@ -433,30 +738,30 @@ module.exports.register = function (registry, context = {}) {
   // Register block macro for rhrev::[]
   registry.blockMacro('rhrev', function () {
     const self = this
-    
+
     self.process(function (parent, target, attrs) {
       const doc = parent.getDocument()
-      
+
       // Check if manual mode
       if (doc.getAttribute('rhrev') === 'manual') {
         return self.createBlock(parent, 'paragraph', '')
       }
-      
+
       // Check initial release handling
       const revnumber = doc.getAttribute('revnumber') || '1.0'
       const initialHandling = doc.getAttribute('rhrev-initial-handling') || 'initial-release'
-      
+
       if (isInitialRelease(revnumber)) {
         if (initialHandling === 'skip') {
           return self.createBlock(parent, 'paragraph', '')
         }
-        
+
         if (initialHandling === 'initial-release') {
           const html = generateInitialReleaseHtml(doc)
           return self.createBlock(parent, 'pass', html)
         }
       }
-      
+
       // Try to use catalog from Antora pipeline extension (component-scoped by default).
       // global.antoraRhrevCatalog is the site-wide catalog; .byComponent holds per-component catalogs.
       let catalog
@@ -489,11 +794,35 @@ module.exports.register = function (registry, context = {}) {
       return self.createBlock(parent, 'pass', html)
     })
   })
-  
+
+  // Propagates a marked nested block's rhrev attribute onto its enclosing
+  // a| table cell, and strips it from the nested block. See
+  // propagateCellContentMarks above for the full reasoning (the same
+  // isolated-inner-document gap the PDF gem's converter works around).
+  // Must be registered, and therefore run, before the change-bar tagging
+  // treeProcessor immediately below: treeprocessors all run before
+  // conversion starts, so if propagation happened later, that pass would
+  // already have tagged the nested paragraph at its original, unpropagated
+  // location, since it is a rollup context in its own right.
+  registry.treeProcessor(function () {
+    const self = this
+
+    self.process(function (doc) {
+      const prefix = doc.getAttribute('revhistoryprefix') || 'rhrev'
+      propagateCellContentMarks(doc, prefix)
+      return doc
+    })
+  })
+
   // Tag blocks carrying the current revision attribute with the rhrev-changed
   // role so the site stylesheet can draw an HTML change bar (right-side border).
   // Enabled by rhrev-change-bars, mirroring the PDF backend; color/width/offset
   // overrides are emitted as CSS custom properties. Side is always right in HTML.
+  // The first six contexts get their own revision-history row when marked;
+  // the other nine (mirrors ROLLUP_CONTEXTS) roll up into their enclosing
+  // section's entry instead (see rollupChildRevisionEntries), but still get
+  // their own bar here: tagging needs no id or anchor, a role is a role
+  // regardless of block type.
   registry.treeProcessor(function () {
     const self = this
 
@@ -503,7 +832,18 @@ module.exports.register = function (registry, context = {}) {
       if (!revnumber) return doc
       const prefix = doc.getAttribute('revhistoryprefix') || 'rhrev'
       const changeAttr = prefix + String(revnumber).replace(/\./g, '-')
-      const contexts = ['section', 'floating_title', 'example', 'listing', 'table', 'image']
+      const contexts = ROW_LEVEL_CONTEXTS.concat(ROLLUP_CONTEXTS)
+
+      // A marked table cell was already tagged on its own nested content by
+      // propagateCellContentMarks, in the earlier treeprocessor: that walk
+      // is scoped to each cell's own, structurally separate inner document,
+      // invisible to this treeprocessor's own outer-document findBy below,
+      // so `tagged` (which only reflects THIS loop) is never a reliable
+      // signal for whether a cell needs patching. Runs unconditionally once
+      // change bars are known enabled, before the tagged/return-early check,
+      // so a document whose only marked content is a table cell (no other
+      // block matched below) still gets its converter patched.
+      patchConvertTableForCellTagging(doc)
 
       let tagged = false
       doc.findBy((b) => contexts.includes(b.getContext())).forEach((block) => {
@@ -533,33 +873,30 @@ module.exports.register = function (registry, context = {}) {
   // Register treeprocessor for auto-injection
   registry.treeProcessor(function () {
     const self = this
-    
+
     self.process(function (doc) {
       if (!doc.hasAttribute('rhrev')) {
         return doc
       }
-      
+
       const rhrevValue = doc.getAttribute('rhrev')
       if (rhrevValue === 'macro' || rhrevValue === 'manual') {
         return doc
       }
-      
+
       // Auto-inject revision history at document start
       const blocks = doc.getBlocks()
-      
-      // Create rhrev block
-      const rhrevBlock = self.createBlock(doc, 'pass', '')
-      
+
       // Check initial release handling
       const revnumber = doc.getAttribute('revnumber') || '1.0'
       const initialHandling = doc.getAttribute('rhrev-initial-handling') || 'initial-release'
-      
+
       let html
       if (isInitialRelease(revnumber)) {
         if (initialHandling === 'skip') {
           return doc
         }
-        
+
         if (initialHandling === 'initial-release') {
           html = generateInitialReleaseHtml(doc)
         } else {
@@ -568,19 +905,23 @@ module.exports.register = function (registry, context = {}) {
         }
       } else {
         const catalog = collectAllEntries(doc)
-        
+
         if (catalog.sortedRevisions().length === 0) {
           return doc
         }
-        
+
         html = generateHtmlOutput(doc, catalog)
       }
-      
-      rhrevBlock.setContent(html)
-      
+
+      // Create the block with its content directly: self.createBlock(...).setContent(html)
+      // used to be two steps here, but Block#setContent is not a function
+      // on a modern @asciidoctor/core (confirmed against 2.2.9, a
+      // pre-existing bug, unrelated to anything else in this file).
+      const rhrevBlock = self.createBlock(doc, 'pass', html)
+
       // Insert at beginning
       blocks.unshift(rhrevBlock)
-      
+
       return doc
     })
   })

package/antora-extension/antora-rhrev-html.js

@@ -10,6 +10,53 @@
 
 const RHREV_MACRO_RX = /^rhrev::(\[.*?\])?$/gm
 
+// Used only to parse each page's raw AsciiDoc into a real document tree
+// (buildComponentCatalog below), replacing the previous regex/heuristic-
+// anchor-guessing scan. Never used to convert or register a converter, so
+// none of the cross-package Opal/ConverterFactory conflict from
+// antora-rhrev-asciidoc.js applies here.
+const asciidoctor = require('@asciidoctor/core')()
+
+// Antora resource-id includes (page$file.adoc) are not real filesystem
+// paths; a bare asciidoctor.load() outside Antora's own content-catalog-
+// aware include resolver would try, and fail, to read them as literal
+// files. A no-op include processor means each page parses on its own,
+// without needing (or attempting) cross-file resolution at all: the
+// existing includedBy/crossIncludeRx scan below already handles cross-
+// component include detection for href purposes, a separate, unrelated,
+// line-based mechanism (tags have no AST representation, so it stays
+// regex-based on purpose), reused unchanged.
+const noIncludeRegistry = asciidoctor.Extensions.create()
+noIncludeRegistry.includeProcessor(function () {
+  this.handles(() => true)
+  this.process(() => {})
+})
+
+// Mirrors ROLLUP_CONTEXTS in antora-rhrev-asciidoc.js and
+// Converter::ROLLUP_CONTEXTS on the Ruby gem's PDF side: block types with
+// no revision-history row of their own. A marked one rolls up as a bullet
+// into its nearest enclosing section's entry instead (or the document-
+// level -all entry, if it has no enclosing section, or its enclosing
+// section has no id). Duplicated here rather than required from the
+// sibling file: the two files are independent Antora extension entry
+// points, loaded and registered separately, matching the existing
+// duplication between this file and antora-rhrev-asciidoc.js (each has
+// its own copy of, for example, compareRevisions and formatChangeAsHtmlList).
+const ROLLUP_CONTEXTS = ['paragraph', 'ulist', 'olist', 'dlist', 'admonition', 'open', 'quote', 'verse', 'sidebar']
+
+// Row-level: gets its own revision-history row when marked, requires an id.
+const ROW_LEVEL_CONTEXTS = ['section', 'floating_title', 'example', 'listing', 'table', 'image']
+
+// Walks up from node to its nearest enclosing section, or null if none
+// exists (the document preamble).
+function enclosingSection(node) {
+  let section = node.getParent ? node.getParent() : null
+  while (section && section.getContext && section.getContext() !== 'section') {
+    section = section.getParent ? section.getParent() : null
+  }
+  return section || null
+}
+
 module.exports.register = function ({ config: extensionConfig = {} }) {
   const logger = this.getLogger('rhrev-extension')
   const quiet = extensionConfig.quiet !== undefined ? extensionConfig.quiet : true
@@ -115,6 +162,41 @@ function mergeCatalogs(catalogs) {
   return merged
 }
 
+// Finds anchorNode's existing entry for this revision on catalog and
+// appends another bullet onto its change text, or creates the entry
+// (carrying the same cross-page metadata a row-level entry gets: page,
+// component, version, module, stem, matchLine, containingTags, all needed
+// downstream for href resolution and the includedBy check) if anchorNode
+// has none yet. meta carries the marked child's own line/tag information
+// for a rollup entry (anchorNode is a section, not the marked node), or
+// the anchor node's own for a row-level entry (anchorNode is the marked
+// node itself, so meta === the anchor's own position).
+function appendChildChangeToEntry(catalog, revision, anchorNode, changeText, pageMeta, meta) {
+  const entries = catalog.entries[revision] || (catalog.entries[revision] = [])
+  const anchorId = anchorNode.getId()
+  const entry = entries.find((e) => e.anchor === anchorId)
+  if (entry) {
+    entry.change = (entry.change && String(entry.change).length) ? `${entry.change} * ${changeText}` : changeText
+  } else {
+    entries.push({
+      anchor: anchorId,
+      change: changeText,
+      title: anchorNode.getTitle ? anchorNode.getTitle() : null,
+      sequence: catalog.sequence++,
+      ...pageMeta,
+      ...meta
+    })
+  }
+}
+
+// Appends onto catalog's existing -all change text for this revision, or
+// sets it fresh if none exists yet.
+function appendChildChangeToAll(catalog, revision, changeText) {
+  const existing = catalog.allEntries[revision]
+  const combined = (existing && String(existing).length) ? `${existing} * ${changeText}` : changeText
+  catalog.allEntries[revision] = combined
+}
+
 function buildComponentCatalog(pageFiles, logger, quiet) {
   const catalog = {
     entries: {},      // { '1-1': [...], '1-2': [...] }
@@ -160,22 +242,29 @@ function buildComponentCatalog(pageFiles, logger, quiet) {
     }
   }
   
-  // Collect block-level entries from ALL pages
+  // Collect block-level entries from ALL pages, by real parsing (each page
+  // its own asciidoctor.load(), sourcemap: true for real line numbers,
+  // the no-op include processor above so a cross-component include::
+  // never touches the filesystem or throws), not the previous regex/
+  // heuristic-anchor-guessing scan: that scan could only recognize a
+  // marked block immediately followed, within 200 characters of raw text,
+  // by [#anchor], .Title, or a heading line, so it had no way to reach
+  // paragraphs, lists, admonitions, or any of the other rollup contexts,
+  // or table cells, at all. Real parsing has no such limit.
   pageFiles.forEach(file => {
     if (!file.contents) return
-    
+
     const content = file.contents.toString()
-    
+
     if (!quiet && content.includes(prefix)) {
       logger.debug(`rhrev-extension: Scanning ${file.src?.relative} for block attributes`)
     }
-    
-    // Strip delimited block content (source, literal, listing) to avoid matching examples
-    const strippedContent = stripVerbatimBlocks(content)
 
-    // Compute tag regions in the stripped content (for cross-component include detection)
+    // Tag-region boundary detection stays line-based, on purpose: tags are
+    // a raw preprocessor concept for include::, with no AST representation
+    // to walk instead. Unrelated to the block-type-scanning gap above.
     const fileTagBoundaries = {}
-    strippedContent.split('\n').forEach((line, lineNum) => {
+    content.split('\n').forEach((line, lineNum) => {
       const startM = line.match(/^\/\/ tag::([^\[\]]+)\[\]$/)
       if (startM) fileTagBoundaries[startM[1]] = { startLine: lineNum }
       const endM = line.match(/^\/\/ end::([^\[\]]+)\[\]$/)
@@ -183,79 +272,152 @@ function buildComponentCatalog(pageFiles, logger, quiet) {
     })
     catalog.fileMeta[file.src?.relative || file.path] = fileTagBoundaries
 
-    // Match block attribute lines: [rhrev1-1="text"] or [rhrev1-0-1="text"] (N-part versions)
-    const blockAttrRx = new RegExp(`\\[${prefix}([0-9]+(?:-[0-9]+)+)="([^"]+)"\\]`, 'g')
-    let match
+    let doc
+    try {
+      doc = asciidoctor.load(content, { safe: 'safe', sourcemap: true, extension_registry: noIncludeRegistry, attributes: componentAttrs })
+    } catch (e) {
+      if (!quiet) logger.debug(`rhrev-extension: failed to parse ${file.src?.relative}, skipped: ${e.message}`)
+      return
+    }
 
-    while ((match = blockAttrRx.exec(strippedContent)) !== null) {
-      const revision = match[1]
-      const changeText = match[2]
-      const matchLine = strippedContent.substring(0, match.index).split('\n').length - 1
-      const containingTags = Object.entries(fileTagBoundaries)
+    const pageMeta = {
+      page: file.src?.relative || file.path,
+      component: file.src?.component,
+      version: file.src?.version,
+      module: file.src?.module || 'ROOT',
+      stem: file.src?.stem || (file.src?.basename || '').replace(/\.[^.]+$/, '')
+    }
+
+    // node.getLineNumber() is 1-based; startLine/endLine above are 0-based
+    // (from Array#forEach's index), matching the original regex scan's own
+    // 0-based matchLine, so this converts once, here, rather than at every
+    // comparison site.
+    const metaFor = (node) => {
+      const lineNumber = node.getLineNumber ? node.getLineNumber() : null
+      const matchLine = lineNumber ? lineNumber - 1 : undefined
+      const containingTags = (matchLine === undefined) ? [] : Object.entries(fileTagBoundaries)
         .filter(([, b]) => b.startLine !== undefined && b.endLine !== undefined &&
           matchLine > b.startLine && matchLine < b.endLine)
         .map(([name]) => name)
-      
-      // Look for anchor/title IMMEDIATELY after the attribute (within next 200 chars)
-      const matchEnd = match.index + match[0].length
-      const nextChunk = strippedContent.substring(matchEnd, matchEnd + 200)
-      
-      // Look for [#anchor], .Title, or === Section in that order
-      const anchorMatch = nextChunk.match(/^\s*\[#([^\]]+)\]/)
-      const titleMatch = nextChunk.match(/^\s*\.([^\n]+)/)
-      const sectionMatch = nextChunk.match(/^\s*(==+)\s+([^\n]+)/)
-      
-      let anchor = null
-      let title = null
-      
-      if (anchorMatch) {
-        anchor = anchorMatch[1]
-        // Still need to find title after anchor
-        const afterAnchor = nextChunk.substring(anchorMatch[0].length)
-        const titleAfterAnchor = afterAnchor.match(/^\s*\.([^\n]+)/)
-        const sectionAfterAnchor = afterAnchor.match(/^\s*(==+)\s+([^\n]+)/)
-        title = titleAfterAnchor ? titleAfterAnchor[1] : (sectionAfterAnchor ? sectionAfterAnchor[2] : anchor)
-      } else if (sectionMatch) {
-        title = sectionMatch[2]
-        // Generate anchor from section title (Asciidoctor's default behavior)
-        anchor = '_' + title.toLowerCase().replace(/[^a-z0-9]+/g, '_').replace(/^_+|_+$/g, '')
-      } else if (titleMatch) {
-        title = titleMatch[1]
-        // No explicit anchor, will use title as fallback
-      }
-      
-      if (!quiet) {
-        logger.debug(`rhrev-extension: Found ${revision} -> anchor=${anchor}, title=${title} in ${file.src?.relative}`)
-      }
-          
-          if (anchor) {
-            if (!catalog.entries[revision]) {
-              catalog.entries[revision] = []
-            }
+      return { matchLine, containingTags }
+    }
 
-            catalog.entries[revision].push({
-              anchor,
-              change: changeText,
-              title,
-              sequence: catalog.sequence++,
-              page: file.src?.relative || file.path,
-              component: file.src?.component,
-              version: file.src?.version,
-              module: file.src?.module || 'ROOT',
-              stem: file.src?.stem || (file.src?.basename || '').replace(/\.[^.]+$/, ''),
-              matchLine,
-              containingTags
-            })
-            
+    // Row-level: same six contexts as before, still requires an id.
+    doc.findBy((n) => ROW_LEVEL_CONTEXTS.includes(n.getContext())).forEach((block) => {
+      const blockId = block.getId()
+      if (!blockId) return
+      const attrs = block.getAttributes()
+      if (!attrs) return
+      Object.keys(attrs).forEach((key) => {
+        if (!key.startsWith(prefix)) return
+        if (key.includes('-all') || key.endsWith('-cover')) return
+        const revision = key.substring(prefix.length)
+        catalog.entries[revision] = catalog.entries[revision] || []
+        catalog.entries[revision].push({
+          anchor: blockId,
+          change: String(attrs[key]),
+          title: block.getTitle(),
+          sequence: catalog.sequence++,
+          ...pageMeta,
+          ...metaFor(block)
+        })
         if (!quiet) {
-          logger.debug(`rhrev-extension: Found block entry ${revision} -> ${anchor} in ${file.src?.relative}`)
+          logger.debug(`rhrev-extension: Found block entry ${revision} -> ${blockId} in ${file.src?.relative}`)
         }
-      } else if (!quiet) {
-        logger.debug(`rhrev-extension: Could not determine anchor for ${revision} in ${file.src?.relative}`)
-      }
-    }
+      })
+    })
+
+    // Table cells cannot carry an rhrev attribute of their own through
+    // normal AsciiDoc parsing: a plain (|) cell never parses its content
+    // as blocks at all, an attribute list there is just literal text. An
+    // AsciiDoc-style (a|) cell does parse its content as blocks, so
+    // [rhrev1-2="..."] attaches, but to the first nested block, not the
+    // cell, and that nested block lives in a structurally separate inner
+    // document (getInnerDocument()), unreachable from the outer document's
+    // own findBy. Same gotcha as antora-rhrev-asciidoc.js and the Ruby
+    // gem's converter.rb. Copies the mark onto the enclosing cell (for the
+    // revision-history entry below) and strips it from the nested node.
+    doc.findBy((n) => n.getContext() === 'table').forEach((table) => {
+      const rows = table.getRows()
+      const cells = [].concat(rows.head.flat(), rows.foot.flat(), rows.body.flat())
+      cells.forEach((cell) => {
+        if (cell.getStyle() !== 'asciidoc') return
+        const inner = cell.getInnerDocument ? cell.getInnerDocument() : null
+        if (!inner) return
+        inner.findBy((n) => ROLLUP_CONTEXTS.includes(n.getContext())).forEach((node) => {
+          const attrs = node.getAttributes()
+          if (!attrs) return
+          Object.keys(attrs).forEach((key) => {
+            if (!key.startsWith(prefix)) return
+            cell.setAttribute(key, attrs[key])
+            node.removeAttribute(key)
+          })
+        })
+      })
+    })
+
+    // Paragraphs, lists, admonitions, and the other rollup contexts: no
+    // row of their own, since they have no title/section-number for the
+    // location column. A marked one contributes a bullet to its nearest
+    // enclosing section's entry instead (creating that entry, with the
+    // section's own metadata, if the section has none yet for this
+    // revision), or the document-level -all entry if it has no enclosing
+    // section or that section has no id. findBy returns document order on
+    // its own, no separate sort needed (the same fix the Ruby side needed
+    // for its own node.lineno-based sort, which silently no-ops without
+    // sourcemap: true; this file already sets that, and findBy doesn't
+    // need it for ordering regardless).
+    doc.findBy((n) => ROLLUP_CONTEXTS.includes(n.getContext())).forEach((node) => {
+      const attrs = node.getAttributes()
+      if (!attrs) return
+      const section = enclosingSection(node)
+      const hasSection = !!(section && section.getId())
+      Object.keys(attrs).forEach((key) => {
+        if (!key.startsWith(prefix)) return
+        if (key.includes('-all') || key.endsWith('-cover')) return
+        const revision = key.substring(prefix.length)
+        const value = String(attrs[key])
+        if (hasSection) {
+          appendChildChangeToEntry(catalog, revision, section, value, pageMeta, metaFor(section))
+        } else {
+          appendChildChangeToAll(catalog, revision, value)
+        }
+      })
+    })
+
+    // A marked table cell is not a rollup context itself: it rolls up to
+    // its own enclosing table, not the nearest section, and cells are not
+    // reachable through the same context-based findBy a normal block-level
+    // node is, so this walks table.getRows() directly. Same three-tier
+    // fallback as the rollup pass above: the table's own entry if it has
+    // an id, else its nearest enclosing section's entry, else the
+    // document-level -all entry only when neither exists.
+    doc.findBy((n) => n.getContext() === 'table').forEach((table) => {
+      const rows = table.getRows()
+      const cells = [].concat(rows.head.flat(), rows.foot.flat(), rows.body.flat())
+      cells.forEach((cell) => {
+        const attrs = cell.getAttributes()
+        if (!attrs) return
+        Object.keys(attrs).forEach((key) => {
+          if (!key.startsWith(prefix)) return
+          if (key.includes('-all') || key.endsWith('-cover')) return
+          const revision = key.substring(prefix.length)
+          const value = String(attrs[key])
+          if (table.getId()) {
+            appendChildChangeToEntry(catalog, revision, table, value, pageMeta, metaFor(table))
+          } else {
+            const section = enclosingSection(table)
+            if (section && section.getId()) {
+              appendChildChangeToEntry(catalog, revision, section, value, pageMeta, metaFor(section))
+            } else {
+              appendChildChangeToAll(catalog, revision, value)
+            }
+          }
+        })
+      })
+    })
   })
-  
+
   return catalog
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "asciidoctor-rhrev",
-  "version": "1.3.0",
+  "version": "1.5.1",
   "description": "Revision history block macro extension for Asciidoctor.js and Antora (HTML5 backend)",
   "main": "antora-extension/antora-rhrev-asciidoc.js",
   "scripts": {