asciidoctor-lists-extended 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 763b4829cf12a23c7ae9c993f9f10fc394919af9adb8c4e5eaf34f82a017ce76
+  data.tar.gz: 1a22a3265585f57715f25d0f14f8d3c44889eb9efd9976698dd7aa42b760dc46
+SHA512:
+  metadata.gz: 3260b2cbe8a43684258c6a2a9e33f0e236b01453e99dc4cec4dcf967f15011c1f8f96daf833160d7e24d18593838d6752271050b22fc53a6f8edfcd58ccc77bd
+  data.tar.gz: f42056096abc9bd690b97abbffcc40ee61ad3dc8f64b4f041eec42ec5fbdf87de9c61e5605cdf608eb4e73b5e0105ec0ce04c74ff79e99e70ffe290035f4c3cf

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 白一百 baiyibai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.adoc

@@ -0,0 +1,424 @@
+= asciidoctor-lists-extended
+:toc: left
+:toclevels: 2
+:source-highlighter: rouge
+
+A converter-aware asciidoctor extension that generates a *List of Figures*, *List of Tables*, *List of Listings*, and *List of Examples* — or any custom captioned block type.
+
+Replaces and supersedes `asciidoctor-pdf-lofte`.
+Compatible with the `asciidoctor-lists` macro syntax.
+
+== Features
+
+* Works with *HTML5* (xref links) and *asciidoctor-pdf* (dot-leader style matching the ToC)
+* *No hardcoded `[#anchor]` required* — IDs are auto-generated via `SecureRandom.uuid`
+* *Any element type* — image, table, listing, example, or custom block contexts
+* *ToC integration* — lists optionally appear in the PDF Table of Contents and bookmark outline
+* *Compatible with `asciidoctor-lists`* — same `list-of::element[]` macro syntax
+
+== Installation
+
+Add to your `Gemfile`:
+
+[source,ruby]
+----
+gem 'asciidoctor-lists-extended', path: '/path/to/asciidoctor-lists-extended'
+----
+
+Or require directly:
+
+[source,bash]
+----
+asciidoctor-pdf -r /path/to/lib/asciidoctor-lists-extended.rb document.adoc
+----
+
+For HTML5 only (no `asciidoctor-pdf` needed):
+
+[source,bash]
+----
+asciidoctor -r /path/to/lib/asciidoctor-lists-extended.rb document.adoc
+----
+
+== Quick Start
+
+[source,asciidoc]
+----
+= My Document
+:toc:
+:doctype: book
+
+\== List of Figures          <1>
+list-of::image[]             <2>
+
+\== List of Tables
+list-of::table[]
+
+\== Chapter 1
+
+.My Architecture Diagram     <3>
+image::arch.png[]
+
+.Configuration Parameters
+|===
+|Name |Value
+|timeout |30
+|===
+----
+<1> The section heading becomes the title in the PDF front matter.
+<2> The macro generates the list. In PDF mode the section is consumed and moved to the front matter; in HTML mode it is rendered inline.
+<3> No `[#anchor]` needed — IDs are assigned automatically.
+
+== Macro Syntax
+
+[source,asciidoc]
+----
+list-of::<element>[]
+list-of::<element>[<positional-options>,key=value,...]
+----
+
+=== Positional Options
+
+[cols="1,3"]
+|===
+|Option |Effect
+
+|`enhanced_rendering`
+|In HTML mode, renders caption and title on separate spans rather than concatenated.
+
+|`hide_empty_section`
+|Removes the containing section entirely if no captioned/titled elements of the requested type exist in the document.
+In HTML mode, omitting this flag leaves an orphaned section heading with no content, which is rarely useful.
+Kept as an explicit opt-in for backwards compatibility with the original `asciidoctor-lists` gem.
+
+|`exclude_from_toc`
+|PDF only. Omits this list from the PDF Table of Contents while keeping it in the bookmark outline.
+
+|`exclude_from_outline`
+|PDF only. Omits this list from the PDF bookmark outline while keeping it in the Table of Contents.
+|===
+
+=== Named Parameters
+
+[cols="1,1,3"]
+|===
+|Parameter |Backend |Description
+
+|`title`
+|Both
+|Override the list heading. When set, takes precedence over the parent section title.
+
+|`caption_prefix`
+|Both
+|Override the caption prefix label (e.g. `"Figure"`). Currently informational; caption is taken from the element's own `captioned_title`.
+|===
+
+=== Supported Element Types
+
+Any valid Asciidoctor block context string works:
+
+[cols="1,2"]
+|===
+|Macro |Collects
+
+|`list-of::image[]`
+|Blocks with `context: :image` that have a title or caption.
+
+|`list-of::table[]`
+|Blocks with `context: :table` that have a title or caption.
+
+|`list-of::listing[]`
+|Blocks with `context: :listing` (source code, literal) that have a title or caption.
+
+|`list-of::example[]`
+|Blocks with `context: :example` that have a title or caption.
+
+|`list-of::video[]`
+|Any custom block type registered with that context name.
+|===
+
+Elements *without* a title or caption are silently skipped.
+
+== Document Attributes
+
+=== Caption Attributes (standard Asciidoctor)
+
+[source,asciidoc]
+----
+:figure-caption:  Figure
+:table-caption:   Table
+:listing-caption: Listing
+:example-caption: Example
+----
+
+These control the prefix that appears in each list entry, e.g. `Figure 1. My Diagram`.
+
+== PDF Behaviour
+
+In PDF mode the extension hooks into `asciidoctor-pdf`'s ToC allocation/rendering lifecycle:
+
+. *`allocate_toc`* — dry-runs each list to measure required page space, then reserves those pages immediately after the ToC.
+. *`ink_toc`* — renders each list with ToC-style dot leaders and page numbers.
+. The `== List of Figures` section and its `list-of::` macro are *removed from the document body* so they do not appear again as body text.
+
+=== Placement
+
+All lists are placed in the *front matter* (directly after the ToC) regardless of where the `list-of::` macros appear in the source.
+The macro order in the source determines the order of the lists in the front matter.
+
+You can place additional `list-of::` macros inside chapter subsections to generate *chapter-scoped* lists.
+The scope is determined automatically from where the macro appears in the document hierarchy:
+
+[cols="1,2"]
+|===
+|Macro placement |Collection scope
+
+|Inside a top-level section (`== …`) +
+e.g. a front-matter `== List of Figures`
+|*Document-wide* — collects all matching elements in the entire document.
+
+|Inside a subsection (`=== …`) nested within a chapter +
+e.g. `=== Chapter 1 Figures` inside `== Chapter 1`
+|*Chapter-scoped* — collects only elements from that chapter and its child sections.
+|===
+
+.Example: global list plus a per-chapter list
+[source,asciidoc]
+----
+\== List of Figures        <1>
+list-of::image[]
+
+\== Chapter 1
+
+.Overview Diagram
+image::arch.png[]
+
+\=== Chapter 1 Figures    <2>
+list-of::image[]
+
+.Detailed Flow
+image::flow.png[]
+----
+<1> Document-wide: collects all images.
+<2> Chapter-scoped: collects only Chapter 1's images.
+
+=== Styling
+
+Lists inherit all ToC styling from your PDF theme:
+
+[source,yaml]
+----
+toc:
+  font_size: 10
+  line_height: 1.5
+  dot_leader:
+    font_color: '#CCCCCC'
+    content: '. '
+    levels: all
+----
+
+You can add a list-specific title style with a theme key based on the element type:
+
+[source,yaml]
+----
+image_list_title:
+  font_size: 16
+  font_style: bold
+  text_align: center
+----
+
+== HTML Behaviour
+
+In HTML5 mode the macro is replaced *in-place* with a list of cross-reference links:
+
+[source,html]
+----
+<p><a href="#uuid-of-figure-1">Figure 1.</a> Architecture Diagram<br>
+<a href="#uuid-of-figure-2">Figure 2.</a> Data Model<br></p>
+----
+
+The containing section and heading are rendered normally.
+
+== Full Example
+
+[source,asciidoc]
+----
+= Technical Reference
+:doctype: book
+:toc:
+:toclevels: 3
+:figure-caption: Figure
+:table-caption: Table
+:listing-caption: Listing
+
+\== List of Figures
+list-of::image[]                                        <1>
+
+\== List of Tables
+list-of::table[hide_empty_section]                      <2>
+
+\== List of Code Examples
+list-of::listing[title="Code Examples"]                 <3>
+
+\== List of Appendix Examples
+list-of::example[exclude_from_outline]                  <4>
+
+\== Chapter 1: Architecture
+
+.System Overview
+image::arch.png[]
+
+.Configuration Parameters
+|===
+|Name |Default |Description
+|timeout |30 |Seconds
+|===
+
+.bootstrap.sh
+[source,bash]
+----
+#!/bin/bash
+echo "Starting..."
+----
+----
+<1> Plain usage — collects all images with captions. Appears in PDF ToC and outline by default.
+<2> If no tables exist, the "List of Tables" section is omitted entirely.
+<3> Per-list title override.
+<4> Appears in the PDF Table of Contents but not in the PDF bookmark outline.
+
+== Running the Tests
+
+=== HTML test (requires only `asciidoctor` gem):
+
+[source,bash]
+----
+ruby test/run_html.rb
+----
+
+=== PDF test (requires `asciidoctor-pdf` and its dependencies):
+
+[source,bash]
+----
+ruby test/run_pdf.rb
+----
+
+Output files are written to `test/out/`.
+All six test documents are rendered by both runners: every document produces both an HTML and a PDF output.
+
+=== VSCode AsciiDoc preview (HTML5)
+
+To use the extension with the https://marketplace.visualstudio.com/items?itemName=asciidoctor.asciidoctor-vscode[AsciiDoc extension for VS Code] preview:
+
+. A `.asciidoctor/lib/lists-extended.js` linker file is included in this repository — no setup needed.
+. A `.vscode/settings.json` is also included that enables workspace extensions:
++
+[source,json]
+----
+{
+  "asciidoc.extensions.registerWorkspaceExtensions": true
+}
+----
++
+If you already have a `.vscode/settings.json`, add the key manually.
+. Open any `.adoc` file and use the AsciiDoc preview button (or kbd:[Ctrl+Shift+V]).
+
+The preview uses the JS extension (`js/lib/extension.js`) via Asciidoctor.js.
+The `list-of::` macros render as `<ul>` lists with `<a href="#…">` links.
+
+== Migration from asciidoctor-pdf-lofte
+
+[cols="1,1"]
+|===
+|Old (lofte) |New (lists-extended)
+
+|`:lof-title: List of Figures` +
+`:lot-title: List of Tables`
+|`\== List of Figures` +
+`list-of::image[]` +
+ +
+`\== List of Tables` +
+`list-of::table[]`
+
+|`:include-lists-in-toc:`
+|Lists are included in the PDF ToC and bookmark outline by default.
+Use `exclude_from_toc` or `exclude_from_outline` on individual macros to opt out.
+
+|Required `[#anchor]` on every block
+|Auto-generated — no anchors needed
+
+|PDF only
+|HTML5 + PDF
+
+|4 copy-pasted converter classes (~1200 lines)
+|1 unified converter class (~320 lines)
+|===
+
+== Architecture Overview
+
+[source]
+----
+lib/
+  asciidoctor-lists-extended.rb       Main entry point (conditional PDF loading)
+  asciidoctor-lists-extended/
+    extensions.rb                     ListMacro + ListTreeprocessor
+    html_renderer.rb                  UUID → xref replacement for HTML5
+    pdf_renderer.rb                   Drawing primitives (ink_list_content, etc.)
+    pdf_converter.rb                  Lifecycle orchestration (allocate_toc, ink_toc)
+----
+
+=== Why pdf_converter.rb and pdf_renderer.rb are separate
+
+`pdf_converter.rb` subclasses the asciidoctor-pdf converter and overrides the lifecycle hooks that the PDF engine calls during document generation.
+It is responsible for *orchestration*: when to run, which pages to reserve, and in what order to render each list.
+
+`pdf_renderer.rb` is a module mixed into the converter.
+It contains the *drawing primitives*: how to render a heading, how to draw a dot-leader row, how to build the dot-leader configuration from the PDF theme.
+
+The split exists because `ink_list_content` (the method that draws one complete list section) is called from two different places — once inside a dry run to measure page space, and once during real rendering to ink the output.
+Keeping the drawing logic in a separate mixin makes that reuse clean: the converter orchestrates, the renderer draws, and neither knows the other's internal details.
+
+=== Process flow
+
+==== HTML backend
+
+. *Macro registration* (`extensions.rb`) — when Asciidoctor parses a `list-of::element[]` macro, `ListMacro#process` runs.
+  It stores the macro options in a global hash keyed by a UUID and emits a plain paragraph containing only that UUID as a placeholder in the document AST.
+
+. *Tree processing* (`extensions.rb`) — after the full AST is built, `ListTreeprocessor#process` runs.
+  It first auto-generates IDs for every captioned/titled element referenced by any `list-of::` macro (so manual `[#anchor]` blocks are not needed).
+  It then delegates to `HtmlRenderer#render`.
+
+. *UUID replacement* (`html_renderer.rb`) — `HtmlRenderer` finds every UUID placeholder paragraph, looks up its config, collects the matching elements, and replaces the placeholder with xref links.
+  If `hide_empty_section` is set and no entries exist, it removes the enclosing section entirely.
+
+==== PDF backend
+
+. *Macro registration* — identical to HTML: UUID placeholder paragraph is inserted into the AST.
+
+. *Tree processing* — auto-generates IDs for referenced elements, then returns early (the placeholder paragraphs are left in place for the PDF converter to find).
+
+. *`allocate_toc`* (`pdf_converter.rb`) — called by asciidoctor-pdf before any body rendering, after the ToC pages are reserved.
+  `PDFConverterWithLists` calls `super` first (reserving the real ToC), then iterates over every UUID placeholder.
+  For each one it captures the title of the enclosing `==` section, removes that section from the body AST (so it does not appear again as body text), then dry-runs `ink_list_content` to measure how many pages the list needs and reserves that space.
+
+. *`ink_toc`* (`pdf_converter.rb`) — called by asciidoctor-pdf when it is time to render the front matter.
+  For each allocated list, `ink_list` navigates to the reserved pages and calls `ink_list_content`.
+  A virtual `Section` node is always inserted into the document AST.
+  If `exclude_from_toc` is set, the section is marked `list-exclude-from-toc` so the `get_entries_for_toc` override hides it from the visible ToC — but it remains in `doc.sections`, so the PDF bookmark outline still sees it.
+  If `exclude_from_outline` is set, the section is marked `list-exclude-from-outline` so the `add_outline_level` override filters it from the bookmark tree.
+  After all lists are rendered, `super` runs to render the real Table of Contents.
+
+. *`ink_list_content`* (`pdf_renderer.rb`) — draws the heading (using the `==` section title captured in step 3) and then calls `ink_toc_level` to draw the dot-leader rows.
+
+. *`ink_toc_level` override* (`pdf_converter.rb`) — when `@rendering_list` is true (set only during list rendering), dispatches to `ink_list_toc_level` which uses `captioned_title` (e.g. "Figure 1. My Diagram") for non-section entries instead of the bare title.
+  For real ToC rendering the override is bypassed and `super` is called unchanged.
+
+. *`get_entries_for_toc` override* (`pdf_converter.rb`) — called by asciidoctor-pdf when collecting sections to render in the Table of Contents.
+  Filters out virtual list sections marked with `list-exclude-from-toc` before delegating to `super`.
+  Because the PDF outline builder reads `doc.sections` directly (not via this method), excluded sections remain visible in the bookmark outline.
+
+. *`add_outline_level` override* (`pdf_converter.rb`) — called by asciidoctor-pdf when building the PDF bookmark outline.
+  Filters out any virtual list sections marked with `list-exclude-from-outline` before delegating to `super`, implementing the `exclude_from_outline` flag.
+
+== Licence
+
+MIT

data/lib/asciidoctor-lists-extended/extensions.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require 'asciidoctor'
+require 'asciidoctor/extensions'
+require 'securerandom'
+
+module Asciidoctor
+  module ListsExtended
+    # Global hash storing macro configurations, keyed by UUID placeholder string.
+    # Ruby Hash preserves insertion order since 1.9, so document order of
+    # list-of:: macros is maintained automatically.
+    ListMacroAttributes = Hash.new
+
+    # BlockMacroProcessor for the list-of::element[] syntax.
+    #
+    # Supported parameters:
+    #   enhanced_rendering   — separate caption and title display (positional)
+    #   hide_empty_section   — remove the parent section if no entries found (positional)
+    #   exclude_from_toc     — omit this list from the PDF Table of Contents and outline (positional, PDF only)
+    #   exclude_from_outline — omit this list from the PDF bookmark outline only (positional, PDF only)
+    #   caption_prefix       — override the caption prefix (e.g. "Figure")
+    #   title                — override the list heading
+    #
+    # Example:
+    #   list-of::image[]
+    #   list-of::table[hide_empty_section]
+    #   list-of::listing[caption_prefix="Code",title="Code Examples"]
+    class ListMacro < ::Asciidoctor::Extensions::BlockMacroProcessor
+      use_dsl
+      named :'list-of'
+
+      def process(parent, target, attrs)
+        uuid = SecureRandom.uuid
+        # Positional flags like [enhanced_rendering] may be stored under integer or string keys
+        pos_flags = (1..10).flat_map { |i| [attrs[i], attrs[i.to_s]] }.compact
+        ListMacroAttributes[uuid] = {
+          element:            target,
+          enhanced_rendering:   attrs['enhanced_rendering']   || pos_flags.include?('enhanced_rendering'),
+          hide_empty_section:   attrs['hide_empty_section']   || pos_flags.include?('hide_empty_section'),
+          exclude_from_toc:     attrs['exclude_from_toc']     || pos_flags.include?('exclude_from_toc'),
+          exclude_from_outline: attrs['exclude_from_outline'] || pos_flags.include?('exclude_from_outline'),
+          caption_prefix:       attrs['caption_prefix'],
+          title:                attrs['title'],
+        }
+        create_paragraph parent, uuid, {}
+      end
+    end
+
+    # Treeprocessor that runs after the full document AST is built.
+    #
+    # Responsibilities:
+    #   1. Auto-generate IDs for all captioned/titled elements referenced by
+    #      list-of:: macros. This eliminates the need for manual [#anchor] on
+    #      every block.
+    #   2. For HTML5/other backends: replace UUID placeholder paragraphs with
+    #      xref-based content (delegated to HtmlRenderer).
+    #   3. For PDF backend: leave UUID placeholder paragraphs in place so that
+    #      PDFConverterWithLists can locate and render them during allocate_toc /
+    #      ink_toc.
+    class ListTreeprocessor < ::Asciidoctor::Extensions::Treeprocessor
+      def process(document)
+        return if ListMacroAttributes.empty?
+
+        # Auto-generate IDs for all elements referenced by list-of:: macros.
+        # Works for both HTML and PDF — the IDs must exist before either renderer runs.
+        ListMacroAttributes.each_value do |config|
+          document
+            .find_by(traverse_documents: true, context: config[:element].to_sym)
+            .each do |element|
+              next unless element.caption || element.title
+              next if element.id
+
+              element.id = SecureRandom.uuid
+              document.catalog[:refs][element.id] = element
+            end
+        end
+
+        # PDF backend: UUID placeholders are handled by PDFConverterWithLists.
+        return if document.backend == 'pdf'
+
+        # HTML5 and other backends: replace UUID placeholders with xref content.
+        HtmlRenderer.new.render(document)
+      end
+    end
+  end
+end
+
+Asciidoctor::Extensions.register do
+  block_macro Asciidoctor::ListsExtended::ListMacro
+  treeprocessor Asciidoctor::ListsExtended::ListTreeprocessor
+end

data/lib/asciidoctor-lists-extended/html_renderer.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Asciidoctor
+  module ListsExtended
+    # Replaces list-of:: UUID placeholder paragraphs with AsciiDoc xref content
+    # for HTML5 and other non-PDF backends.
+    #
+    # Preserves full backwards-compatibility with the original asciidoctor-lists gem:
+    #   - enhanced_rendering parameter: separates caption and title
+    #   - hide_empty_section parameter: removes parent section when no entries found
+    class HtmlRenderer
+      def render(document)
+        uuid_blocks = document.find_by do |b|
+          b.content_model == :simple &&
+            b.lines.size == 1 &&
+            ListMacroAttributes.key?(b.lines[0])
+        end
+
+        uuid_blocks.each do |block|
+          params             = ListMacroAttributes[block.lines[0]]
+          enhanced_rendering = params[:enhanced_rendering]
+          hide_empty_section = params[:hide_empty_section]
+
+          scope    = scope_node_for(block, document)
+          elements = scope.find_by(
+            traverse_documents: true,
+            context: params[:element].to_sym
+          )
+
+          titled_elements = elements.select { |e| e.caption || e.title }
+
+          if titled_elements.empty? && hide_empty_section
+            block.parent.parent.blocks.delete(block.parent)
+            next
+          end
+
+          references_asciidoc = titled_elements.map do |element|
+            if enhanced_rendering
+              if element.caption
+                %(xref:#{element.id}[#{element.caption.rstrip}] #{element.instance_variable_get(:@title)} +)
+              else
+                %(xref:#{element.id}[#{element.instance_variable_get(:@title)}] +)
+              end
+            else
+              if element.caption
+                %(xref:#{element.id}[#{element.caption.rstrip}] #{element.title} +)
+              else
+                %(xref:#{element.id}[#{element.title}] +)
+              end
+            end
+          end
+
+          block_index     = block.parent.blocks.index { |b| b == block }
+          parsed_blocks   = parse_asciidoc(block.parent, references_asciidoc)
+          parsed_blocks.reverse_each { |b| block.parent.blocks.insert block_index, b }
+          block.parent.blocks.delete_at block_index + parsed_blocks.size
+        end
+      end
+
+      private
+
+      # Determine collection scope for a UUID placeholder block.
+      # Mirrors the logic in PdfRenderer#scope_node_for.
+      def scope_node_for(block, document)
+        node = block.parent
+        return document unless node.respond_to?(:context) && node.context == :section
+        node.parent.context == :document ? document : chapter_ancestor(node)
+      end
+
+      def chapter_ancestor(section)
+        node = section
+        node = node.parent while node.parent&.context == :section
+        node
+      end
+
+      # Parse AsciiDoc source lines in the context of +parent+, returning the
+      # resulting blocks without attaching them to the parent.
+      # Adapted from asciidoctor-bibtex / original asciidoctor-lists.
+      def parse_asciidoc(parent, content, attributes = {})
+        result = []
+        reader = ::Asciidoctor::Reader.new content
+        while reader.has_more_lines?
+          block = ::Asciidoctor::Parser.next_block reader, parent, attributes
+          result << block if block
+        end
+        result
+      end
+    end
+  end
+end

data/lib/asciidoctor-lists-extended/pdf_converter.rb

@@ -0,0 +1,395 @@
+# frozen_string_literal: true
+
+require 'asciidoctor/pdf' unless defined? Asciidoctor::PDF
+
+require_relative 'pdf_renderer'
+
+module Asciidoctor
+  module ListsExtended
+    # Single unified PDF converter that replaces the four copy-pasted classes
+    # (PDFConverterWithLOF, PDFConverterWithLOT, PDFConverterWithLOE,
+    # PDFConverterWithLOL) from asciidoctor-pdf-lofte.
+    #
+    # Hooks into asciidoctor-pdf's allocate_toc / ink_toc lifecycle to:
+    #   1. Reserve page space for each list-of:: macro found in the document
+    #      (allocate_toc → allocate_list via dry_run).
+    #   2. Render each list with ToC-style dot leaders (ink_toc → ink_list).
+    #   3. Insert virtual Section nodes so lists appear in the PDF ToC and
+    #      bookmark outline by default. Per-macro flags exclude_from_toc and
+    #      exclude_from_outline opt individual lists out.
+    #
+    # ink_toc_level is overridden only for list rendering (guarded by
+    # @rendering_list flag), leaving normal ToC behavior untouched.
+    class PDFConverterWithLists < ::Asciidoctor::Converter.for('pdf')
+      register_for 'pdf'
+
+      include PdfRenderer
+
+      def initialize(*args)
+        super
+        @list_extents                  = {}   # UUID → Extent (front-matter lists only)
+        @list_configs_ordered          = []   # front-matter list configs in document order
+        @inline_list_configs           = {}   # UUID → config for chapter-scoped inline lists
+        @inline_num_front_matter_pages = 0    # saved from ink_toc for inline page-number math
+        @rendering_list                = false
+        @list_toc_insert_idx           = 0
+      end
+
+      # -----------------------------------------------------------------------
+      # ink_toc_level override
+      # -----------------------------------------------------------------------
+      # When @rendering_list is true (set by PdfRenderer#ink_list_content),
+      # dispatch to our list-specific implementation that uses captioned_title
+      # for non-section entries.  Otherwise delegate to the parent unchanged so
+      # that the real Table of Contents is not affected.
+      def ink_toc_level(entries, num_levels, dot_leader, num_front_matter_pages)
+        if @rendering_list
+          ink_list_toc_level entries, num_levels, dot_leader, num_front_matter_pages
+        else
+          super
+        end
+      end
+
+      # -----------------------------------------------------------------------
+      # allocate_toc hook
+      # -----------------------------------------------------------------------
+      # Called by asciidoctor-pdf early in document generation to reserve page
+      # space for the ToC.  We call super first (allocate the real ToC), then
+      # iterate over all list-of:: macros and allocate space for each list.
+      def allocate_toc(doc, num_levels, toc_start_cursor, break_after_toc)
+        result = super
+        collect_and_allocate_lists doc, num_levels, toc_start_cursor, break_after_toc
+        result
+      end
+
+      # -----------------------------------------------------------------------
+      # ink_toc hook
+      # -----------------------------------------------------------------------
+      # Render every allocated list before delegating to super (which renders
+      # the real ToC).  Always inserts a virtual Section node for each list so
+      # it appears in the PDF bookmark outline.  exclude_from_toc marks the
+      # section so get_entries_for_toc filters it from the visible ToC;
+      # exclude_from_outline marks it so add_outline_level skips it.
+      def ink_toc(doc, num_levels, toc_page_number, start_cursor, num_front_matter_pages = 0)
+        @inline_num_front_matter_pages = num_front_matter_pages
+        @list_toc_insert_idx = 0
+
+        @list_configs_ordered.each do |config|
+          extent = @list_extents[config[:uuid]]
+          next unless extent
+
+          ink_list doc, config, extent, num_levels, num_front_matter_pages
+
+          list_title     = config[:title] || config[:section_title]
+          list_page_nums = extent.page_range
+          list_id        = "_list_of_#{config[:element].tr('-', '_')}"
+          insert_list_into_toc_section doc, list_title, list_page_nums, list_id, @list_toc_insert_idx,
+            exclude_from_toc:     config[:exclude_from_toc],
+            exclude_from_outline: config[:exclude_from_outline]
+          @list_toc_insert_idx += 1
+        end
+
+        super
+      end
+
+      # -----------------------------------------------------------------------
+      # get_entries_for_toc override
+      # -----------------------------------------------------------------------
+      # Filters out virtual list sections marked with 'list-exclude-from-toc'
+      # so they are hidden from the rendered Table of Contents while remaining
+      # present in doc.sections (and therefore still visible in the PDF outline).
+      def get_entries_for_toc(node)
+        super.reject { |s| s.attr? 'list-exclude-from-toc' }
+      end
+
+      # -----------------------------------------------------------------------
+      # add_outline_level override
+      # -----------------------------------------------------------------------
+      # Filters out virtual list sections marked with 'list-exclude-from-outline'
+      # before delegating to the parent implementation, which builds PDF bookmarks.
+      # This lets exclude_from_outline keep a list in the ToC while hiding it
+      # from the PDF bookmark outline.
+      def add_outline_level(outline, sections, num_levels, expand_levels)
+        super outline, sections.reject { |s| s.attr? 'list-exclude-from-outline' }, num_levels, expand_levels
+      end
+
+      # -----------------------------------------------------------------------
+      # convert_paragraph override
+      # -----------------------------------------------------------------------
+      # Intercepts UUID placeholder paragraphs belonging to chapter-scoped
+      # inline lists (those stored in @inline_list_configs by
+      # collect_and_allocate_lists).  Renders the list entries at the current
+      # cursor position without a heading (the enclosing === section provides
+      # the heading) and without any page break before or after.
+      # All other paragraphs delegate to super unchanged.
+      def convert_paragraph(node)
+        if node.content_model == :simple && node.lines.size == 1 &&
+           (config = @inline_list_configs[node.lines[0]])
+          entries = get_list_entries(config[:scope_node], config[:element])
+          unless entries.empty?
+            entries.each { |e| e.level = 2 if e.title }
+            num_levels = (node.document.attr 'toclevels', 2).to_i
+            dot_leader = build_dot_leader_config(num_levels)
+            begin
+              @rendering_list = true
+              ink_toc_level entries, num_levels, dot_leader, @inline_num_front_matter_pages
+            ensure
+              @rendering_list = false
+            end
+          end
+          return
+        end
+        super
+      end
+
+      private
+
+      # -----------------------------------------------------------------------
+      # collect_and_allocate_lists
+      # -----------------------------------------------------------------------
+      # Scan the document AST for UUID placeholder paragraphs (in document
+      # order, which matches the order the author placed the list-of:: macros).
+      # For each placeholder that has at least one captioned/titled element,
+      # allocate page space via a dry run.
+      def collect_and_allocate_lists(doc, num_levels, start_cursor, break_after)
+        uuid_blocks = doc.find_by do |b|
+          b.content_model == :simple &&
+            b.lines.size == 1 &&
+            ListMacroAttributes.key?(b.lines[0])
+        end
+
+        uuid_blocks.each do |block|
+          uuid       = block.lines[0]
+          config     = ListMacroAttributes[uuid]
+          scope_node = scope_node_for(block)
+          entries    = get_list_entries(scope_node, config[:element])
+          parent     = block.parent
+
+          if scope_node.equal?(doc)
+            # ── Document-wide macro ────────────────────────────────────────
+            # Remove from body and render in PDF front matter after the ToC.
+            # Capture the parent section title first — it becomes the list heading.
+            section_title = (parent.context == :section) ? parent.title : nil
+            parent.blocks.delete(block)
+            if parent.context == :section && parent.blocks.empty?
+              parent.parent&.blocks&.delete(parent)
+            end
+
+            next if entries.empty?
+
+            config_with_uuid = config.merge(uuid: uuid, section_title: section_title, scope_node: scope_node)
+            @list_configs_ordered << config_with_uuid
+            @list_extents[uuid] = allocate_list(doc, config_with_uuid, num_levels, start_cursor, break_after)
+          else
+            # ── Chapter-scoped macro ───────────────────────────────────────
+            # Leave the placeholder in the body; convert_paragraph will render
+            # it inline at the macro's position without a page break.
+            # The enclosing section heading is preserved as-is.
+            config_with_uuid = config.merge(uuid: uuid, section_title: nil, scope_node: scope_node)
+            @inline_list_configs[uuid] = config_with_uuid
+          end
+        end
+      end
+
+      # -----------------------------------------------------------------------
+      # allocate_list
+      # -----------------------------------------------------------------------
+      # Dry-run render of one list to measure the space it needs, then reserve
+      # that many pages.  Follows the same pattern as rhrev's
+      # allocate_revision_history_extent and asciidoctor-pdf-lofte's allocate_lof.
+      def allocate_list(doc, config, num_levels, _start_cursor, break_after)
+        to_page = nil
+        extent  = dry_run onto: self do
+          to_page = ink_list(doc, config, nil, num_levels, 0).last
+          theme_margin :block, :bottom unless break_after
+        end
+
+        if to_page && to_page > extent.to.page
+          extent.to.page   = to_page
+          extent.to.cursor = bounds.height
+        end
+
+        if break_after
+          extent.each_page { start_new_page }
+        else
+          extent.each_page { |first_page| start_new_page unless first_page }
+          move_cursor_to extent.to.cursor
+        end
+
+        extent
+      end
+
+      # -----------------------------------------------------------------------
+      # ink_list
+      # -----------------------------------------------------------------------
+      # Navigate to the allocated pages and render one list section.
+      # When called from inside a dry_run block (extent is nil / scratch? true),
+      # navigation is skipped and only layout measurement happens.
+      # Returns the page range occupied by the list.
+      def ink_list(doc, config, extent, num_levels, num_front_matter_pages)
+        if extent && !scratch?
+          go_to_page extent.from.page
+          move_cursor_to extent.from.cursor
+        end
+
+        start_page = page_number
+        entries    = get_list_entries(config[:scope_node] || doc, config[:element])
+
+        # Set level = 2 on every entry so ink_list_toc_level uses toc_h3 indent,
+        # producing a flat indented list that matches asciidoctor-pdf-lofte output.
+        entries.each { |e| e.level = 2 if e.title }
+
+        ink_list_content doc, config, entries, num_levels, num_front_matter_pages
+
+        page_range = (start_page..(start_page + (page_number - start_page)))
+        go_to_page page_count unless scratch?
+        page_range
+      end
+
+      # -----------------------------------------------------------------------
+      # ink_list_toc_level
+      # -----------------------------------------------------------------------
+      # Custom ink_toc_level used exclusively when @rendering_list is true.
+      # Adapted from asciidoctor-pdf-lofte FormatTOC#ink_toc_level, which is
+      # itself a copy of the asciidoctor-pdf ink_toc_level implementation with
+      # two additions:
+      #   a) Non-section entries (image, table, etc.) use captioned_title
+      #      ("Figure 1. My Diagram") instead of bare title.
+      #   b) The no-ID skip from the original lofte is removed — auto-generated
+      #      UUIDs from the TreeProcessor guarantee all entries have IDs.
+      def ink_list_toc_level(entries, num_levels, dot_leader, num_front_matter_pages)
+        toc_font_info  = theme_font(:toc) { { font: font, size: @font_size } }
+        hanging_indent = @theme.toc_hanging_indent
+
+        entries.each do |entry|
+          next if (num_levels_for_entry = (entry.attr 'toclevels', num_levels).to_i) <
+                    (entry_level = entry.level + 1).pred ||
+                  ((entry.option? 'notitle') && entry == entry.document.last_child && entry.empty?)
+
+          # Base title: sections use numbered_title; blocks use plain title or xreftext
+          entry_title = entry.context == :section \
+            ? entry.numbered_title \
+            : (entry.title? ? entry.title : (entry.xreftext 'basic'))
+
+          # For captioned blocks (image, table, example, listing, custom) prefer
+          # captioned_title, e.g. "Figure 1. My Diagram" over "My Diagram".
+          if entry.context != :section && entry.respond_to?(:captioned_title)
+            captioned = entry.captioned_title
+            entry_title = captioned unless captioned.nil_or_empty?
+          end
+
+          next if entry_title.nil_or_empty?
+
+          theme_font :toc, level: entry_level do
+            entry_title = transform_text entry_title, @text_transform if @text_transform
+            pgnum_label_placeholder_width = rendered_width_of_string '0' * @toc_max_pagenum_digits
+
+            if scratch?
+              # Dry-run pass: measure space only
+              indent 0, pgnum_label_placeholder_width do
+                ink_prose entry_title,
+                  anchor:               true,
+                  normalize:            false,
+                  hanging_indent:       hanging_indent,
+                  normalize_line_height: true,
+                  margin:               0
+              end
+            else
+              # Real render pass: resolve page number and draw dot leader
+              entry_anchor = (entry.attr 'pdf-anchor') || entry.id
+              unless (physical_pgnum = entry.attr 'pdf-page-start')
+                if (target_page_ref = (get_dest entry_anchor)&.first) &&
+                   (target_page_idx = state.pages.index { |c| c.dictionary == target_page_ref })
+                  physical_pgnum = target_page_idx + 1
+                end
+              end
+
+              pgnum_label = if physical_pgnum
+                virtual_pgnum = physical_pgnum - num_front_matter_pages
+                (virtual_pgnum < 1 \
+                  ? Asciidoctor::PDF::RomanNumeral.new(physical_pgnum, :lower) \
+                  : virtual_pgnum).to_s
+              else
+                '?'
+              end
+
+              start_page_number = page_number
+              start_cursor      = cursor
+              start_dots        = nil
+
+              entry_title_inherited = (apply_text_decoration ::Set.new, :toc, entry_level)
+                .merge(anchor: entry_anchor, color: @font_color)
+              entry_title_fragments = text_formatter.format entry_title,
+                inherited: entry_title_inherited
+              line_metrics = calc_line_metrics @base_line_height
+
+              indent 0, pgnum_label_placeholder_width do
+                fragment_positions = entry_title_fragments.map do |fragment|
+                  fp = ::Asciidoctor::PDF::FormattedText::FragmentPositionRenderer.new
+                  (fragment[:callback] ||= []) << fp
+                  fp
+                end
+                typeset_formatted_text entry_title_fragments, line_metrics,
+                  hanging_indent:       hanging_indent,
+                  normalize_line_height: true
+                last_fp = fragment_positions.select(&:page_number).last
+                break unless last_fp
+
+                start_dots = last_fp.right + hanging_indent
+                last_frag_cursor = last_fp.top + line_metrics.padding_top
+                if last_fp.page_number > start_page_number ||
+                   (start_cursor - last_frag_cursor) > line_metrics.height
+                  start_cursor = last_frag_cursor
+                end
+              end
+
+              break unless start_dots
+
+              end_cursor = cursor
+              move_cursor_to start_cursor
+
+              if dot_leader[:width] > 0
+                pgnum_label_width     = rendered_width_of_string pgnum_label
+                pgnum_label_font_opts = {
+                  color:  @font_color,
+                  font:   font_family,
+                  size:   @font_size,
+                  styles: font_styles,
+                }
+                save_font do
+                  set_font toc_font_info[:font], dot_leader[:font_size]
+                  font_style dot_leader[:font_style]
+                  num_dots = [
+                    ((bounds.width - start_dots - dot_leader[:spacer_width] - pgnum_label_width) /
+                     dot_leader[:width]).floor,
+                    0,
+                  ].max
+                  typeset_formatted_text [
+                    { text: dot_leader[:text] * num_dots, color: dot_leader[:font_color] },
+                    dot_leader[:spacer],
+                    ({ text: pgnum_label, anchor: entry_anchor }.merge pgnum_label_font_opts),
+                  ], line_metrics, align: :right
+                end
+              else
+                typeset_formatted_text [
+                  { text: pgnum_label, color: @font_color, anchor: entry_anchor },
+                ], line_metrics, align: :right
+              end
+
+              move_cursor_to end_cursor
+            end
+          end
+
+          # Recurse for child entries (typically none for images/tables, but
+          # preserves compatibility with any custom element type that has children)
+          if num_levels_for_entry >= entry_level
+            indent @theme.toc_indent do
+              ink_toc_level get_entries_for_toc(entry), num_levels_for_entry,
+                dot_leader, num_front_matter_pages
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/asciidoctor-lists-extended/pdf_renderer.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+module Asciidoctor
+  module ListsExtended
+    # Mixed into PDFConverterWithLists to provide list-rendering helpers.
+    # All methods here run in the context of the PDF converter instance,
+    # so asciidoctor-pdf methods (ink_general_heading, theme_font_cascade,
+    # add_dest_for_block, ink_toc_level, etc.) are available via self.
+    module PdfRenderer
+      # Render one list section: title heading + dot-leader entry rows.
+      # Called both during the dry run (scratch? == true) and the real ink pass.
+      #
+      # config keys used here:
+      #   :element        — element type string ('image', 'table', …)
+      #   :title          — explicit title override from macro attribute
+      #   :section_title  — title of the parent section captured before it was removed
+      #
+      # Sets @rendering_list = true around the ink_toc_level call so that
+      # PDFConverterWithLists#ink_toc_level activates the list-aware code path.
+      def ink_list_content(doc, config, entries, num_levels, num_front_matter_pages = 0)
+        element_type = config[:element]
+        dest_id      = "_list_of_#{element_type.tr('-', '_')}"
+
+        list_title = config[:title] || config[:section_title]
+        unless list_title.nil_or_empty?
+          # Theme key mirrors asciidoctor-pdf-lofte convention, e.g. :image_list_title
+          theme_key_sym = :"#{element_type.tr('-', '_')}_list_title"
+          theme_font_cascade [[:heading, level: 2], theme_key_sym] do
+            align_method = :"#{theme_key_sym}_text_align"
+            title_align  = (@theme.respond_to?(align_method) ? @theme.send(align_method) : nil) ||
+                           @theme.heading_h2_text_align ||
+                           @theme.heading_text_align    ||
+                           @base_text_align
+            ink_general_heading doc, list_title,
+              align:   title_align.to_sym,
+              level:   2,
+              outdent: true,
+              role:    theme_key_sym
+            add_dest_for_block doc, id: dest_id, y: (at_page_top? ? page_height : nil)
+          end
+        end
+
+        unless num_levels < 0 || entries.empty?
+          dot_leader = build_dot_leader_config(num_levels)
+          theme_margin :toc, :top
+          begin
+            @rendering_list = true
+            ink_toc_level entries, num_levels, dot_leader, num_front_matter_pages
+          ensure
+            @rendering_list = false
+          end
+        end
+      end
+
+      # Collect all captioned/titled elements of the requested type from scope_node.
+      # scope_node is either the whole document (document-wide) or a chapter section
+      # (chapter-scoped), as determined by scope_node_for at collection time.
+      def get_list_entries(scope_node, element_type)
+        scope_node
+          .find_by(traverse_documents: true, context: element_type.to_sym)
+          .select { |e| e.caption || e.title }
+      end
+
+      # Insert a virtual Section node into the document AST at the correct position
+      # so that asciidoctor-pdf's get_entries_for_toc picks it up and renders it
+      # in the Table of Contents.
+      #
+      # insert_idx is the 0-based position among sibling list sections being inserted,
+      # which preserves document order in the ToC.
+      def insert_list_into_toc_section(doc, list_title, list_page_nums, list_id, insert_idx, exclude_from_toc: false, exclude_from_outline: false)
+        if (doc.attr? 'toc-placement', 'macro') && (toc_node = (doc.find_by context: :toc)[0])
+          if (parent_section = toc_node.parent).context == :section
+            grandparent_section = parent_section.parent
+            toc_level           = parent_section.level
+            base_idx            = (grandparent_section.blocks.index parent_section) + 1
+          else
+            grandparent_section = doc
+            toc_level           = doc.sections[0]&.level || 1
+            base_idx            = 0
+          end
+          toc_dest = toc_node.attr 'pdf-destination'
+        else
+          grandparent_section = doc
+          toc_level           = doc.sections[0]&.level || 1
+          base_idx            = 0
+          toc_dest            = dest_top list_page_nums.first
+        end
+
+        list_section       = Asciidoctor::Section.new grandparent_section, toc_level, false,
+          attributes: { 'pdf-destination' => toc_dest }
+        list_section.title = list_title
+        list_section.id    = list_id
+        list_section.set_attr 'list-exclude-from-toc',     '' if exclude_from_toc
+        list_section.set_attr 'list-exclude-from-outline', '' if exclude_from_outline
+        grandparent_section.blocks.insert base_idx + insert_idx, list_section
+        list_section
+      end
+
+      private
+
+      # Build the dot-leader configuration hash expected by ink_toc_level.
+      # Reads theme variables from the asciidoctor-pdf theme loader.
+      # Falls back to sensible defaults if the theme does not define them.
+      def build_dot_leader_config(num_levels)
+        theme_font :toc do
+          dot_leader_font_style = @theme.toc_dot_leader_font_style&.to_sym || :normal
+          font_style dot_leader_font_style if dot_leader_font_style != font_style
+          font_size @theme.toc_dot_leader_font_size
+          dot_leader_text = @theme.toc_dot_leader_content || dot_leader_text_default
+          {
+            font_color:   @theme.toc_dot_leader_font_color || @font_color,
+            font_style:   dot_leader_font_style,
+            font_size:    font_size,
+            levels:       build_dot_leader_levels(num_levels),
+            text:         dot_leader_text,
+            width:        dot_leader_text.empty? ? 0 : (rendered_width_of_string dot_leader_text),
+            spacer:       { text: no_break_space, size: (spacer_font_size = @font_size * 0.25) },
+            spacer_width: (rendered_width_of_char no_break_space, size: spacer_font_size),
+          }
+        end
+      end
+
+      def build_dot_leader_levels(num_levels)
+        dot_leader_l = @theme.toc_dot_leader_levels
+        if dot_leader_l == 'none'
+          ::Set.new
+        elsif dot_leader_l && dot_leader_l != 'all'
+          dot_leader_l.to_s.split.map(&:to_i).to_set
+        else
+          (0..num_levels).to_set
+        end
+      end
+
+      # Determine the collection scope for a list-of:: UUID placeholder block.
+      #
+      # Rule: if the macro's parent section is a top-level section (its parent is
+      # the Document), scope is the whole document.  If the macro is nested inside
+      # a chapter (grandparent is another section), scope is the chapter ancestor —
+      # the first ancestor section whose parent is the Document.
+      #
+      # This means front-matter lists (== List of Figures) collect everything, while
+      # per-chapter lists (=== Chapter Figures inside == Chapter 1) collect only
+      # their chapter's content automatically.
+      def scope_node_for(block)
+        node = block.parent
+        return block.document unless node.respond_to?(:context) && node.context == :section
+        node.parent.context == :document ? block.document : chapter_ancestor(node)
+      end
+
+      # Walk up the parent chain to find the first section whose parent is the Document.
+      def chapter_ancestor(section)
+        node = section
+        node = node.parent while node.parent&.context == :section
+        node
+      end
+
+      # Safe accessor: use the asciidoctor-pdf constant if available, else fall back.
+      def dot_leader_text_default
+        defined?(DotLeaderTextDefault) ? DotLeaderTextDefault : '. '
+      end
+
+      def no_break_space
+        defined?(NoBreakSpace) ? NoBreakSpace : "\u00a0"
+      end
+    end
+  end
+end

data/lib/asciidoctor-lists-extended.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# asciidoctor-lists-extended
+# Converter-aware extension providing List of Figures, Tables, Listings, and Examples.
+# Supports asciidoctor HTML5, asciidoctor-pdf, and Antora.
+# Compatible with asciidoctor-lists macro syntax: list-of::element[]
+#
+# Macro flags (PDF only):
+#   exclude_from_toc     — omit this list from the PDF ToC and bookmark outline
+#   exclude_from_outline — omit this list from the PDF bookmark outline only
+
+require_relative 'asciidoctor-lists-extended/html_renderer'
+require_relative 'asciidoctor-lists-extended/extensions'
+
+# PDF support is optional — loaded only if asciidoctor-pdf is present
+begin
+  require 'asciidoctor-pdf'
+  require_relative 'asciidoctor-lists-extended/pdf_renderer'
+  require_relative 'asciidoctor-lists-extended/pdf_converter'
+rescue LoadError
+  # asciidoctor-pdf not available; HTML-only mode
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification
+name: asciidoctor-lists-extended
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- 白一百 baiyibai
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: asciidoctor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: |
+  An asciidoctor extension that generates List of Figures, List of Tables,
+  List of Listings, and List of Examples. Works with HTML5 (xref links) and
+  asciidoctor-pdf (dot-leader style matching the ToC, optional ToC integration,
+  PDF bookmarks). Compatible with asciidoctor-lists macro syntax.
+  No hardcoded anchors required — IDs are auto-generated.
+email: rubygems@baiyibai.cyou
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.adoc
+- lib/asciidoctor-lists-extended.rb
+- lib/asciidoctor-lists-extended/extensions.rb
+- lib/asciidoctor-lists-extended/html_renderer.rb
+- lib/asciidoctor-lists-extended/pdf_converter.rb
+- lib/asciidoctor-lists-extended/pdf_renderer.rb
+homepage: https://gitlab.com/baiyibai-asciidoc/asciidoctor-lists-extended
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://gitlab.com/baiyibai-asciidoc/asciidoctor-lists-extended.git
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Converter-aware list-of-figures/tables/listings/examples for asciidoctor
+  (HTML5 + PDF)
+test_files: []