docbook 0.1.0

data/docs/features/html-output/directory-mode.adoc

@@ -0,0 +1,180 @@
+---
+layout: default
+title: Directory Mode
+parent: HTML Output
+grand_parent: Features
+nav_order: 2
+---
+
+# Directory Mode
+
+Directory mode (`output_mode: :directory`) produces a directory of files suitable for serving over HTTP. Instead of inlining everything into a single HTML file, assets are separated into their own files and the Vue SPA fetches data at runtime.
+
+## Output Structure
+
+When directory mode is active, the output directory contains:
+
+[source]
+----
+output_dir/
+  index.html           # HTML shell with external asset references
+  docbook.data.json    # Full document data (TOC, content, index) as JSON
+  assets/
+    app.css            # Compiled Vue SPA stylesheet
+    app.iife.js        # Compiled Vue SPA JavaScript bundle
+----
+
+Images are **not** copied to the output directory. Instead, they are referenced by their resolved file paths relative to the source document. This means the source image directories must remain accessible at their original locations (or be served by the web server).
+
+## How It Works
+
+In directory mode, the `Output::Html` class performs these steps:
+
+. **Serialize data** -- The full `DocbookOutput` model is serialized to JSON and written to `docbook.data.json`
+. **Render template** -- The Liquid template is rendered with `assets_inline: false`, producing external `<link>` and `<script>` references
+. **Replace placeholders** -- The `[[DOCBOOK_DATA]]` placeholders are replaced with `null` comments since data is loaded separately
+. **Write files** -- The CLI copies frontend assets to `assets/` and writes the HTML to `index.html`
+
+## Asset References
+
+The template partials use the `assets_inline` flag to switch between inline and external references:
+
+**Head partial (`_head.liquid`):**
+
+[source,html]
+----
+<!-- Directory mode: external CSS -->
+{% if assets_inline %}
+  <style>{{ app_css }}</style>
+{% else %}
+  <link rel="stylesheet" href="{{ base_url }}/assets/app.css">
+{% endif %}
+----
+
+**Scripts partial (`_scripts.liquid`):**
+
+[source,html]
+----
+<!-- Directory mode: external JS -->
+{% if assets_inline %}
+  <script>{{ app_js }}</script>
+{% else %}
+  <script src="{{ base_url }}/assets/app.iife.js"></script>
+{% endif %}
+----
+
+## Data Loading
+
+In directory mode, the Vue SPA's `documentStore` does not find `window.DOCBOOK_DATA` and falls back to fetching `docbook.data.json` via HTTP:
+
+[source,typescript]
+----
+// From documentStore.ts
+function loadFromWindow(): Promise<void> {
+  const inlineData = (window as any).DOCBOOK_DATA
+  if (inlineData && inlineData !== null) {
+    // Single file mode: data is already in window
+    documentData.value = data as DocumentData
+    return Promise.resolve()
+  }
+
+  // Directory mode: fetch from JSON file
+  return fetch('docbook.data.json')
+    .then(res => res.json())
+    .then(data => {
+      documentData.value = data as DocumentData
+    })
+}
+----
+
+The `docbook.data.json` file contains the complete serialized `DocbookOutput` model, including the TOC tree, numbering map, all section content, and the generated index.
+
+## Image Handling
+
+In directory mode, images are referenced by file path rather than base64:
+
+[source,ruby]
+----
+def process_image(fileref)
+  if @output_mode == :single_file
+    embed_image_base64(fileref)
+  else
+    find_file_path(fileref) || fileref
+  end
+end
+----
+
+The `find_file_path` method searches the document's base path and parent directories to resolve image file paths. It tries common prefixes (`""`, `"resources/"`, `"../resources/"`) to accommodate various project structures.
+
+## Use Case
+
+Directory mode is designed for:
+
+- **Web serving** -- Deploy to any static file server (nginx, Apache, S3, GitHub Pages)
+- **Large documents** -- Avoids the size overhead of base64-encoded images
+- **CDN delivery** -- Assets can be cached independently by browsers
+- **Development** -- Faster rebuilds since only `docbook.data.json` changes when content changes
+
+## CLI Usage
+
+[source,bash]
+----
+# Directory mode requires an output directory
+docbook to-html document.xml -o ./output_dir --output-type directory
+----
+
+The CLI copies frontend assets automatically:
+
+[source,ruby]
+----
+# From cli.rb
+def write_output(content, output_path, output_type)
+  if output_type == :directory
+    FileUtils.mkdir_p(output_path)
+    File.write(File.join(output_path, "index.html"), content)
+
+    assets_dir = File.join(output_path, "assets")
+    FileUtils.mkdir_p(assets_dir)
+    FileUtils.cp(File.join(FRONTEND_ROOT, "app.css"), File.join(assets_dir, "app.css"))
+    FileUtils.cp(File.join(FRONTEND_ROOT, "app.iife.js"), File.join(assets_dir, "app.iife.js"))
+  end
+end
+----
+
+## Programmatic Usage
+
+[source,ruby]
+----
+require "docbook"
+
+document = Docbook::Document.from_xml(File.read("book.xml"))
+xref_resolver = Docbook::XrefResolver.new(document).resolve!
+base_path = File.dirname(File.expand_path("book.xml"))
+output_dir = "/path/to/output"
+
+html = Docbook::Output::Html.new(
+  document,
+  xref_resolver: xref_resolver,
+  output_mode: :directory,
+  base_path: base_path,
+  output_path: output_dir
+).to_html
+
+File.write(File.join(output_dir, "index.html"), html)
+----
+
+## Template Rendering Details
+
+The Liquid template is rendered with these variables in directory mode:
+
+[cols="1,2,3"]
+|===
+| Variable | Value | Purpose
+
+| `docbook_title` | Document title | Page `<title>` element
+| `base_url` | `"."` (current directory) | Relative URL base for asset references
+| `assets_inline` | `false` | Controls whether CSS/JS are inlined or linked
+| `app_css` | Contents of `frontend/dist/app.css` | Used only for template rendering (file is also copied to `assets/`)
+| `app_js` | Contents of `frontend/dist/app.iife.js` | Used only for template rendering (file is also copied to `assets/`)
+| `data_url` | `"docbook.data.json"` | URL the SPA fetches for document data
+|===

data/docs/features/html-output/index.adoc

@@ -0,0 +1,90 @@
+---
+layout: default
+title: HTML Output
+parent: Features
+nav_order: 1
+has_children: true
+---
+
+# HTML Output
+
+The HTML output system converts parsed DocBook XML into an interactive web publication. It uses a two-stage rendering approach: a Ruby-based data extraction layer that builds structured JSON data, and a Vue 3 single-page application (SPA) that renders the content client-side.
+
+## How It Works
+
+The `Docbook::Output::Html` class orchestrates the entire output pipeline:
+
+. **Section Collection** -- Traverses the document tree to build a `SectionData` hierarchy (the TOC)
+. **Numbering** -- `NumberingBuilder` assigns formatted numbers to each section
+. **Content Extraction** -- For each section, the element tree is walked to produce `ContentBlock` trees
+. **Index Collection** -- `IndexCollector` gathers all `indexterm` elements
+. **Data Assembly** -- Everything is packaged into a `DocbookOutput` model
+. **Template Rendering** -- A Liquid template produces the HTML shell with placeholders
+
+## Template System
+
+The HTML shell is generated using https://github.com/Shopify/liquid[Liquid templates] stored in `lib/docbook/templates/`. The main template (`document.html.liquid`) includes two partials:
+
+- `_head.liquid` -- Prism.js CSS for syntax highlighting, Google Fonts (Inter, Merriweather, JetBrains Mono), Tailwind CSS, and the compiled app CSS
+- `_scripts.liquid` -- Prism.js core with autoloader for additional languages, and the compiled Vue SPA JavaScript
+
+The template uses four placeholder tokens that are replaced during rendering:
+
+- `[[DOCBOOK_DATA]]` -- Document title and metadata
+- `[[DOCBOOK_TOC]]` -- TOC tree and numbering map
+- `[[DOCBOOK_CONTENT]]` -- Section content blocks
+- `[[DOCBOOK_INDEX]]` -- Generated index data
+
+## Vue 3 SPA Frontend
+
+The frontend is a Vue 3 application built with Vite and TypeScript, located in `frontend/`. It is compiled to `frontend/dist/` as a single IIFE bundle (`app.iife.js`) and a stylesheet (`app.css`).
+
+### Key Features
+
+- **Table of Contents** -- Recursive sidebar navigation with collapsible tree items, type badges (Pt, Ch, App, Gl, Bib, Idx, Pref, Ref), and section numbering
+- **Full-Text Search** -- Powered by https://github.com/nextapps-de/flexsearch[FlexSearch] with forward tokenization, persisted to IndexedDB for instant reloads
+- **Four Themes** -- Day (white), Sepia (warm amber), Night (dark gray), and OLED (pure black) -- each with proper dark mode Tailwind classes
+- **Reading Modes** -- Scroll (continuous), Page (paginated), Chapter (one chapter at a time), and Cards (reference entry cards)
+- **Syntax Highlighting** -- Prism.js with the Tomorrow Night theme and autoloader for on-demand language support
+- **Display Settings** -- Configurable font size (12-32px), font weight (300-700), line height (1.2-2.0), and margins (16-96px), persisted to localStorage
+- **Responsive Design** -- Collapsible sidebar, mobile-friendly navigation, and adaptive content width
+
+### Frontend Components
+
+[cols="1,3"]
+|===
+| Component | Purpose
+
+| `App.vue` | Root component, loads document data and initializes stores
+| `EbookContainer.vue` | Main layout container with theme application and CSS variables
+| `AppSidebar.vue` | Table of contents sidebar with recursive tree
+| `TocTreeItem.vue` | Recursive TOC item with expand/collapse and type badges
+| `ContentRenderer.vue` | Renders `ContentBlock` trees into HTML
+| `BlockRenderer.vue` | Renders individual `ContentBlock` items (paragraphs, code, lists, etc.)
+| `SectionContent.vue` | Section wrapper with heading and numbering
+| `PartSection.vue` | Part-specific rendering with Roman numeral prefix
+| `ChapterSection.vue` | Chapter-specific rendering with Arabic numeral prefix
+| `AppendixSection.vue` | Appendix-specific rendering with Alpha prefix
+| `ReferenceEntry.vue` | Reference page entry with badge, name, and description sections
+| `EbookTopBar.vue` | Top navigation bar with search and settings toggles
+| `SearchModal.vue` | Full-text search modal with FlexSearch integration
+| `SettingsPanel.vue` | Display settings panel (theme, font, size, margins)
+|===
+
+## Output Modes
+
+The gem supports two output modes, chosen by the `output_mode` parameter:
+
+### Single File Mode (`:single_file`)
+
+All assets are inlined into one self-contained HTML file. See <<single-file-mode,Single File Mode>> for details.
+
+### Directory Mode (`:directory`)
+
+A directory of files suitable for web serving. See <<directory-mode,Directory Mode>> for details.
+
+## Child Pages
+
+- <<single-file-mode,Single File Mode>> -- Self-contained HTML with base64 images
+- <<directory-mode,Directory Mode>> -- Multi-file output for web serving
+- <<data-model,Output Data Model>> -- JSON data structures and ContentBlock types

data/docs/features/html-output/single-file-mode.adoc

@@ -0,0 +1,125 @@
+---
+layout: default
+title: Single File Mode
+parent: HTML Output
+grand_parent: Features
+nav_order: 1
+---
+
+# Single File Mode
+
+Single file mode (`output_mode: :single_file`) produces a single, self-contained HTML file with all assets inlined. This is the default output mode and is ideal for distributing documents that can be opened directly in any browser, including via the `file://` protocol.
+
+## How It Works
+
+When single file mode is active, the `Output::Html` class inlines every asset directly into the HTML:
+
+. **CSS** -- The compiled `app.css` from `frontend/dist/` is injected inline via a `<style>` tag
+. **JavaScript** -- The compiled `app.iife.js` from `frontend/dist/` is injected inline via a `<script>` tag
+. **Fonts** -- Google Fonts (Inter, Merriweather, JetBrains Mono) are loaded from CDN in `_head.liquid`
+. **JSON Data** -- All document data (TOC, content, index) is serialized to JSON and injected via `[[DOCBOOK_DATA]]` placeholders, with `</script>` tags escaped to `<\/script>`
+
+The Liquid template is rendered with `assets_inline: true`, which causes the partials to inline assets rather than reference external files.
+
+## Image Embedding
+
+Images are embedded as base64 data URIs. The `process_image` method in `Output::Html` handles this:
+
+[source,ruby]
+----
+# When output_mode is :single_file, images are base64-encoded
+def process_image(fileref)
+  if @output_mode == :single_file
+    embed_image_base64(fileref)
+  else
+    find_file_path(fileref) || fileref
+  end
+end
+
+def embed_image_base64(fileref)
+  full_path = find_file_path(fileref)
+  data = File.binread(full_path)
+  mime = Marcel::MimeType.for(data)          # MIME detection via Marcel
+  encoded = Base64.strict_encode64(data)
+  "data:#{mime};base64,#{encoded}"
+end
+----
+
+The MIME type is detected automatically using the https://github.com/rails/marcel[Marcel] gem, which examines the file's magic bytes rather than relying on file extensions. This ensures correct MIME types even when file extensions are missing or incorrect.
+
+Image paths are resolved by searching the document's base path and its parent directories, trying common prefixes like `resources/` and `../resources/`. This accommodates the various directory structures used in DocBook projects.
+
+## Data Injection
+
+The template contains four placeholder tokens that are replaced with inline JSON:
+
+[source,html]
+----
+<script>
+window.DOCBOOK_DATA = Object.assign([[DOCBOOK_DATA]], {
+  toc: [[DOCBOOK_TOC]],
+  content: [[DOCBOOK_CONTENT]],
+  index: [[DOCBOOK_INDEX]]
+});
+</script>
+----
+
+In single file mode, the placeholders are replaced with actual JSON data. The Vue SPA's `documentStore` detects `window.DOCBOOK_DATA` and loads the data synchronously without any network requests.
+
+## Use Case
+
+Single file mode is designed for:
+
+- **Document distribution** -- Send a single HTML file via email or file share
+- **Offline reading** -- Works without a web server; open directly from the filesystem
+- **Archival** -- Self-contained documents with no external dependencies (except CDN fonts)
+- **Email attachments** -- One file to attach, no directory structures to manage
+
+## CLI Usage
+
+```bash
+# Default: single file mode, output to stdout
+docbook to-html document.xml
+
+# Write to a file
+docbook to-html document.xml -o output.html
+
+# Explicit single file mode
+docbook to-html document.xml -o output.html --output-type single_file
+```
+
+## Programmatic Usage
+
+[source,ruby]
+----
+require "docbook"
+
+document = Docbook::Document.from_xml(File.read("book.xml"))
+xref_resolver = Docbook::XrefResolver.new(document).resolve!
+base_path = File.dirname(File.expand_path("book.xml"))
+
+html = Docbook::Output::Html.new(
+  document,
+  xref_resolver: xref_resolver,
+  output_mode: :single_file,
+  base_path: base_path
+).to_html
+
+File.write("book.html", html)
+----
+
+## Template Rendering Details
+
+The Liquid template is rendered with these variables in single file mode:
+
+[cols="1,2,3"]
+|===
+| Variable | Value | Purpose
+
+| `docbook_title` | Document title | Page `<title>` element
+| `base_url` | `""` (empty string) | Relative URL base (not needed for single file)
+| `assets_inline` | `true` | Controls whether CSS/JS are inlined or linked
+| `app_css` | Contents of `frontend/dist/app.css` | Inlined as `<style>` tag
+| `app_js` | Contents of `frontend/dist/app.iife.js` | Inlined as `<script>` tag
+| `data_url` | Not used | Only relevant for directory mode
+|===

data/docs/features/index-generation.adoc

@@ -0,0 +1,197 @@
+---
+layout: default
+title: Index Generation
+parent: Features
+nav_order: 5
+---
+
+# Index Generation
+
+The index generation system collects `indexterm` elements from throughout the document, groups them by first letter, sorts them, and produces a structured index that the Vue SPA renders as a navigable back-of-book index.
+
+## Architecture
+
+Index generation uses two classes working in sequence:
+
+- **`IndexCollector`** -- Traverses the entire document tree to collect `indexterm` elements
+- **`IndexGenerator`** -- Groups collected terms by letter, sorts them, and builds the final index structure
+
+## IndexCollector
+
+The `IndexCollector` performs a recursive traversal of the document, visiting every element type that can contain `indexterm` elements.
+
+### Traversal Scope
+
+The collector traverses all major structural elements:
+
+[cols="1,2"]
+|===
+| Element | Traversed Children
+
+| `Book` | parts, chapters, appendices, prefaces, glossary, bibliography, index, setindex
+| `Part` | parts, chapters, appendices, references, prefaces, glossary, bibliography, index
+| `Article` | sections, glossary, bibliography, index
+| `Chapter` | sections, simplesects, paras, indexterms
+| `Appendix` | sections, simplesects, paras, indexterms
+| `Section` | sections, simplesects, paras, indexterms
+| `SimpleSect` | paras, indexterms
+| `RefEntry` | refsections
+| `RefSection` | paras, indexterms
+| `ListItem` | paras, simplesects, indexterms
+| `Entry` (table) | paras, indexterms
+| `Para` | mixed content (handles inline indexterms)
+|===
+
+### Term Extraction
+
+For each `indexterm` found, the collector extracts:
+
+[source,ruby]
+----
+term_info = {
+  primary: primary_text,           # Required: primary term text
+  primary_sort: sort_key,          # Sort key (lowercased or "SYMBOLS")
+  secondary: secondaries.first,    # Optional: secondary term
+  tertiary: tertiaries.first,      # Optional: tertiary term
+  sees: sees,                      # "see" cross-references
+  see_alsos: see_alsos,            # "see also" cross-references
+  type: indexterm.type,            # Optional type filter
+  section_id: section_info[:id],   # xml:id of containing section
+  section_title: section_info[:title]  # Title of containing section
+}
+----
+----
+
+### Sort Keys
+
+Sort keys determine grouping and ordering:
+
+- **Non-alphabetic terms** -- Terms starting with symbols or having `class="token"` are grouped under `SYMBOLS`
+- **Alphabetic terms** -- Leading punctuation is stripped and the text is lowercased
+
+[source,ruby]
+----
+def sort_key(text, indexterm)
+  return "SYMBOLS" if indexterm.class_value == "token" || text.start_with?("@")
+  text.gsub(/^[^a-zA-Z]+/, "").downcase
+end
+----
+----
+
+## IndexGenerator
+
+The `IndexGenerator` takes the collected terms and groups them:
+
+### Grouping by Letter
+
+Terms are grouped by the first letter of their sort key:
+
+[source,ruby]
+----
+def group_by_letter
+  result = {}
+  @index_terms.each do |term|
+    letter = letter_for(term[:primary_sort])
+    result[letter] ||= []
+    result[letter] << term
+  end
+  result
+end
+
+def letter_for(sort_key)
+  return "SYMBOLS" if sort_key == "SYMBOLS" || sort_key.start_with?("@")
+  first_char = sort_key.chars.find(&:letter?) || sort_key[0] || ""
+  first_char.upcase
+end
+----
+----
+
+### Sorting
+
+Within each letter group, terms are sorted by primary sort key and then by secondary term:
+
+[source,ruby]
+----
+def sort_entries(terms)
+  terms.sort_by { |t| [t[:primary_sort], t[:secondary].to_s] }
+end
+----
+----
+
+The `SYMBOLS` group sorts first by using `"{"` (ASCII after "Z") as its sort key:
+
+[source,ruby]
+----
+by_letter.sort_by { |letter, _| letter == "SYMBOLS" ? "{" : letter.downcase }
+----
+----
+
+## Index Model
+
+The final index is structured as:
+
+[source]
+----
+Index
+  title: "Index"
+  type: nil (or type filter)
+  groups:
+    - IndexGroup (letter: "A")
+        entries:
+          - IndexTerm (primary: "Apple", section_id: "fruit-sec", ...)
+          - IndexTerm (primary: "Application", secondary: "web", ...)
+    - IndexGroup (letter: "B")
+        entries: [...]
+    - IndexGroup (letter: "SYMBOLS")
+        entries:
+          - IndexTerm (primary: "@example", sort_as: "SYMBOLS", ...)
+----
+----
+
+## Type Filtering
+
+The DocBook `index` element supports a `type` attribute for creating multiple specialized indexes. When an `index` element has a `type`, the builder filters `indexterm` elements to only include those with a matching `type`:
+
+[source,ruby]
+----
+def build_index_content(index_element, all_index_terms)
+  index_type = index_element.type
+  filtered_terms = all_index_terms.select { |t| t[:type] == index_type }
+  # ...
+end
+----
+----
+
+## Cross-References
+
+Index terms support two cross-reference mechanisms:
+
+- **`see`** -- Directs the reader to a different primary term ("see [term]")
+- **`seealso`** -- Suggests additional related terms ("see also [term]")
+
+These are collected from `see` and `seealso` child elements within `indexterm`:
+
+[source,xml]
+----
+<indexterm>
+  <primary>cars</primary>
+  <see>automobiles</see>
+</indexterm>
+
+<indexterm>
+  <primary>automobiles</primary>
+  <secondary>electric</secondary>
+  <seealso>hybrid vehicles</seealso>
+</indexterm>
+----
+
+## Index Content Rendering
+
+The index is rendered in the Vue SPA using `ContentBlock` trees with dedicated block types:
+
+- `index_section` -- Container for an index section
+- `index_letter` -- Letter group heading with child entries
+- `index_entry` -- Individual term with primary text
+- `index_reference` -- Link to the section where the term appears
+- `index_see` -- "see" cross-reference
+- `index_see_also` -- "see also" cross-reference

data/docs/features/index.adoc

@@ -0,0 +1,63 @@
+---
+layout: default
+title: Features
+nav_order: 4
+has_children: true
+---
+
+# Features
+
+The Metanorma DocBook gem provides a complete pipeline for converting DocBook XML documents into modern, interactive HTML publications. It parses DocBook XML through a typed element model, resolves cross-references and XIncludes, and produces structured data consumed by a Vue 3 single-page application frontend.
+
+## Feature Overview
+
+[cols="3,4,5"]
+|===
+| Feature | Description | Details
+
+| <<html-output/index,HTML Output>>
+| Converts DocBook XML to interactive HTML with a Vue 3 SPA frontend, supporting both single-file and directory output modes.
+| Two modes: *single file* (self-contained, base64 images) and *directory* (multi-file, web-serving ready)
+
+| <<xinclude/index,XInclude Resolution>>
+| Resolves `xi:include` elements for modular document composition, supporting both XML and text parsing modes with advanced filtering.
+| Custom iterative resolver with `search=`, `line=`, and `char=` fragid schemes
+
+| <<numbering,Section Numbering>>
+| Automatic numbering of Parts (Roman), Chapters (Arabic), Sections (hierarchical), and Appendices (Alpha) with proper scoping.
+| `NumberingBuilder` with per-part chapter scoping and hierarchical dot notation
+
+| <<toc-generation,TOC Generation>>
+| Builds a recursive tree of document sections with type metadata, numbering, and navigation badges.
+| `SectionData` tree with type badges (Pt, Ch, App, Gl, Bib, Idx, Pref, Ref)
+
+| <<index-generation,Index Generation>>
+| Collects `indexterm` elements throughout the document and generates a grouped, sorted index with cross-references.
+| `IndexCollector` + `IndexGenerator` with `see`/`seealso` support and SYMBOLS grouping
+
+| <<element-coverage,Element Coverage>>
+| Comprehensive support for 157 DocBook element classes organized across 20+ categories.
+| Structural, metadata, block, list, link, inline, media, table, admonition, bibliography, glossary, index, and more
+|===
+
+## Architecture
+
+The processing pipeline follows these stages:
+
+. **Parse** -- DocBook XML is parsed into Lutaml::Model-based element classes (`Docbook::Document.from_xml`)
+. **Resolve XIncludes** -- `XIncludeResolver` replaces `xi:include` elements iteratively, handling nested includes
+. **Resolve XRefs** -- `XrefResolver` builds an O(1) lookup map of `xml:id` to element titles
+. **Build Output Data** -- `Output::Html` traverses the element tree to produce a `DocbookOutput` model containing:
+  * `Toc` -- section tree with numbering
+  * `ContentData` -- section content as `ContentBlock` trees
+  * `Index` -- grouped index entries
+. **Render** -- A Liquid template produces the HTML shell, and the Vue 3 SPA renders the content client-side
+
+## Child Pages
+
+- <<html-output/index,HTML Output>> -- Single-file and directory output modes, data model
+- <<xinclude/index,XInclude Resolution>> -- XML includes, text includes, fragid schemes
+- <<numbering,Section Numbering>> -- Roman, Arabic, hierarchical, and Alpha numbering
+- <<toc-generation,TOC Generation>> -- Table of contents tree structure and rendering
+- <<index-generation,Index Generation>> -- Index collection, grouping, and cross-references
+- <<element-coverage,Element Coverage>> -- Full list of supported DocBook element classes