jekyll-vitepress-theme 1.9.1 → 1.10.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e183c8f8f2ffa9c7a63a0bd5e581f47cd41e377c3271331cdb709ba318157360
-  data.tar.gz: 57afd8252f5ef2dec3c09a1b26051a2c6b13f26867148f0cc2f6efd8876a6744
+  metadata.gz: 0fa9bd9f39f9a07a853282a881aff54b24f4adde9c87f9c2f03b89bcafff8617
+  data.tar.gz: 19d2551ffa4497e178771471091d3655dd0678e6cbcd823e79eefd6c617546ef
 SHA512:
-  metadata.gz: 8aec92127430303041ff8337187776d67bd5e779a77b50263ffc4a756df212bc847987002c9a824966bee7ce3d5293439eefbd3b3ba9ff63bffd52a8d258bfa5
-  data.tar.gz: abb74bb84cf29cf52d4de84832ec2e6e78d6e55be445c51aea4ef3c7029f8fe21cc3cfdbdf2aaae5a98d0340fffa7f6303279e9aae4ae79b119bd047e9709cd4
+  metadata.gz: b5041e3e3a4019083374bba8ead0db79724322337d945605168214d3e430ac225c925a2b41040154431fd55da644fdcf0f42c2058daf99d326903f1ea3a77c61
+  data.tar.gz: 87e47129bd88e563ba4187118029c1de8311a7662cc7233432a05a8dc3911013b84c0b930bb582c79dd88bf23ad4d570326b9d93756db22016720f36eed38466

data/assets/css/vitepress-overrides.css

@@ -985,7 +985,7 @@ body.vp-search-open {
   height: 100%;
   padding: 18px;
   object-fit: contain;
-  filter: drop-shadow(-2px 4px 6px rgba(0, 0, 0, 0.2));
+  filter: drop-shadow(-2px 4px 6px rgb(0, 0, 0, 0.2));
   transform: translate(-50%, -50%);
 }
 

data/lib/jekyll/vitepress_theme/hooks.rb

@@ -3,7 +3,7 @@ require 'rouge'
 
 module Jekyll
   module VitePressTheme
-    # rubocop:disable Metrics/ModuleLength
+    # rubocop:disable-next Metrics/ModuleLength
     module Sidebar
       module_function
 
@@ -243,7 +243,6 @@ module Jekyll
         )
       end
     end
-    # rubocop:enable Metrics/ModuleLength
 
     module SearchIndex
       module_function
@@ -319,24 +318,6 @@ module Jekyll
       end
     end
 
-    module LastUpdated
-      module_function
-
-      def source_file_time(site, path)
-        return nil unless path
-
-        source_path = if Pathname.new(path).absolute?
-                        path
-                      else
-                        File.join(site.source, path)
-                      end
-
-        return nil unless File.file?(source_path)
-
-        File.mtime(source_path).utc
-      end
-    end
-
     module RougeStyles
       module_function
 
@@ -475,6 +456,54 @@ module Jekyll
       end
 
       def resolved_markdown(item, payload)
+        markdown = MarkdownExport.convert(rendered_markdown(item, payload))
+        hero = hero_markdown(item)
+        return markdown if hero.empty?
+
+        markdown.to_s.strip.empty? ? "#{hero}\n" : "#{hero}\n\n#{markdown}"
+      end
+
+      # A home page keeps its headline, tagline, and calls to action in the
+      # hero front matter rather than in the page content.
+      def hero_markdown(item)
+        data = item.respond_to?(:data) && item.data.is_a?(Hash) ? item.data : {}
+        hero = data['hero']
+        return '' unless hero.is_a?(Hash)
+
+        [hero_name(hero, data['title']), inline_markdown(hero['text']), inline_markdown(hero['tagline']),
+         hero_actions(item, hero['actions'])].reject(&:empty?).join("\n\n")
+      end
+
+      def hero_name(hero, title)
+        name = inline_markdown(hero['name'])
+        name.empty? || name == inline_markdown(title) ? '' : "**#{name}**"
+      end
+
+      def inline_markdown(text)
+        MarkdownExport.convert(text.to_s).strip
+      end
+
+      def hero_actions(item, actions)
+        return '' unless actions.is_a?(Array)
+
+        actions.filter_map do |action|
+          next unless action.is_a?(Hash)
+
+          text = inline_markdown(action['text'])
+          link = action['link'].to_s.strip
+          next if text.empty?
+
+          link.empty? ? text : "[#{text}](#{site_relative(item, link)})"
+        end.join(' · ')
+      end
+
+      def site_relative(item, link)
+        return link if link.include?('://') || link.start_with?('mailto:', 'tel:')
+
+        "#{item.site.config['baseurl'].to_s.sub(%r{/+\z}, '')}/#{link.sub(%r{\A/+}, '')}"
+      end
+
+      def rendered_markdown(item, payload)
         raw = item.content.to_s
         return raw unless item.respond_to?(:render_with_liquid?) && item.render_with_liquid?
 

data/lib/jekyll/vitepress_theme/last_updated.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'pathname'
+
+module Jekyll
+  module VitePressTheme
+    # Dates each page by the last commit that touched its source file, read
+    # from one `git log` pass per build. Files Git cannot date reliably
+    # (untracked, locally modified, outside the repository, or older than a
+    # shallow clone's history) use their modification time instead.
+    module LastUpdated
+      module_function
+
+      FIELD_SEPARATOR = "\x1e"
+
+      # Git's view of the files under a site source: commit times keyed by
+      # real path, plus the paths whose working copy differs from HEAD.
+      class GitIndex
+        def self.empty
+          new({}, [])
+        end
+
+        def initialize(times, modified)
+          @times = times
+          @modified = modified.to_h { |path| [path, true] }
+        end
+
+        def time_for(path)
+          return nil if @modified.key?(path)
+
+          @times[path]
+        end
+      end
+
+      def source_file_time(site, path)
+        source_path = resolved_source_path(site, path)
+        return nil unless source_path
+
+        git_index(site).time_for(source_path) || File.mtime(source_path).utc
+      end
+
+      def resolved_source_path(site, path)
+        return nil unless path
+
+        source_path = Pathname.new(path).absolute? ? path : File.join(site.source, path)
+        return nil unless File.file?(source_path)
+
+        File.realpath(source_path)
+      end
+
+      def git_index(site)
+        @git_indexes ||= {}
+        @git_indexes[site] ||= build_git_index(site.source)
+      end
+
+      def reset(site)
+        @git_indexes&.delete(site)
+      end
+
+      def build_git_index(source)
+        source = File.realpath(source)
+        root = repository_root(source)
+        return GitIndex.empty unless root
+
+        pathspec = relative_pathspec(source, root)
+        boundaries = shallow_boundaries(root)
+        warn_shallow if boundaries.any?
+
+        GitIndex.new(commit_times(root, pathspec, boundaries), modified_paths(root, pathspec))
+      rescue SystemCallError, ArgumentError => e
+        Jekyll.logger.debug('jekyll-vitepress-theme', "Git dates unavailable: #{e.message}")
+        GitIndex.empty
+      end
+
+      def repository_root(source)
+        root = git(source, 'rev-parse', '--show-toplevel').to_s.strip
+        root.empty? ? nil : File.realpath(root)
+      end
+
+      def relative_pathspec(source, root)
+        Pathname.new(source).relative_path_from(Pathname.new(root)).to_s
+      end
+
+      def commit_times(root, pathspec, boundaries)
+        log = git(root, 'log', '--no-renames', "--format=#{FIELD_SEPARATOR}%H %ct", '--name-only', '-z', '--', pathspec)
+        return {} unless log
+
+        log.split(FIELD_SEPARATOR).each_with_object({}) do |entry, times|
+          sha, time, files = parse_log_entry(entry)
+          next if files.empty? || boundaries.include?(sha)
+
+          files.each do |file|
+            path = File.join(root, file)
+            times[path] = time if times[path].nil? || time > times[path]
+          end
+        end
+      end
+
+      def parse_log_entry(entry)
+        header, files = entry.split("\0", 2)
+        sha, timestamp = header.to_s.split
+        return [sha, nil, []] if files.nil?
+
+        [sha, Time.at(Integer(timestamp)).utc, files.delete_prefix("\n").split("\0").reject(&:empty?)]
+      end
+
+      def modified_paths(root, pathspec)
+        status = git(root, 'status', '--porcelain=v1', '-z', '--untracked-files=no', '--', pathspec)
+        return [] unless status
+
+        entries = status.split("\0")
+        paths = []
+        until entries.empty?
+          entry = entries.shift
+          paths << File.join(root, entry[3..])
+          entries.shift if entry.start_with?('R', 'C')
+        end
+        paths
+      end
+
+      def shallow_boundaries(root)
+        return [] unless git(root, 'rev-parse', '--is-shallow-repository')&.strip == 'true'
+
+        shallow_file = git(root, 'rev-parse', '--git-path', 'shallow')&.strip
+        return [] unless shallow_file
+
+        shallow_file = File.expand_path(shallow_file, root)
+        return [] unless File.file?(shallow_file)
+
+        File.read(shallow_file).split
+      end
+
+      def warn_shallow
+        Jekyll.logger.warn(
+          'jekyll-vitepress-theme',
+          'Shallow Git clone: pages last changed before the clone\'s history use their file ' \
+          'modification time for "Last updated". Fetch the full history (fetch-depth: 0) for accurate dates.'
+        )
+      end
+
+      def git(directory, *args)
+        output, status = Open3.capture2('git', '-C', directory, *args, err: File::NULL)
+        status.success? ? output : nil
+      rescue SystemCallError
+        nil
+      end
+    end
+  end
+end
+
+Jekyll::Hooks.register :site, :after_reset do |site|
+  Jekyll::VitePressTheme::LastUpdated.reset(site)
+end

data/lib/jekyll/vitepress_theme/llms.rb

@@ -4,7 +4,7 @@ module Jekyll
   module VitePressTheme
     # Generates the proposed llms.txt index and its full-text companion from
     # the same canonical, indexable content used by the theme's SEO layer.
-    # rubocop:disable Metrics/AbcSize, Metrics/ModuleLength
+    # rubocop:disable-next Metrics/AbcSize, Metrics/ModuleLength
     module LLMS
       module_function
 
@@ -231,6 +231,5 @@ module Jekyll
         value.is_a?(Hash) ? value : {}
       end
     end
-    # rubocop:enable Metrics/AbcSize, Metrics/ModuleLength
   end
 end

data/lib/jekyll/vitepress_theme/markdown_export.rb

@@ -0,0 +1,636 @@
+# frozen_string_literal: true
+
+require 'kramdown'
+require 'set'
+require 'strscan'
+
+module Jekyll
+  module VitePressTheme
+    # Converts the HTML that a page's Markdown source carries, written inline or
+    # produced by includes and filters, into Markdown. The "Copy page" button,
+    # the exported .md files, and llms-full.txt all share it. Fenced code
+    # blocks and code spans pass through untouched, and a page without HTML
+    # comes back unchanged.
+    # rubocop:disable-next Metrics/AbcSize, Metrics/ModuleLength
+    module MarkdownExport
+      module_function
+
+      Element = Struct.new(:name, :attrs, :children, :parent)
+      Text = Struct.new(:text)
+
+      BLOCK_CODE = "\u0000B%d\u0000"
+      SPAN_CODE = "\u0000S%d\u0000"
+      BLOCK_CODE_PATTERN = /\u0000B\d+\u0000/
+      PLACEHOLDER_PATTERN = /\u0000([BS])(\d+)\u0000/
+      LINE_BREAK = "\u0001"
+
+      KNOWN_ELEMENTS = %w[
+        a abbr address article aside audio b bdi bdo blockquote body br button canvas caption cite code col colgroup
+        data dd del details dfn dialog div dl dt em embed fieldset figcaption figure footer form h1 h2 h3 h4 h5 h6
+        head header hgroup hr html i iframe img input ins kbd label legend li link main map mark menu meta meter nav
+        noscript object ol optgroup option output p picture pre progress q s samp script search section select small
+        source span strike strong style sub summary sup svg table tbody td template textarea tfoot th thead time tr
+        track tt u ul var video wbr
+      ].to_set.freeze
+
+      VOID_ELEMENTS = %w[area base br col embed hr img input link meta source track wbr].to_set.freeze
+      RAW_TEXT_ELEMENTS = %w[script style textarea].to_set.freeze
+      DROPPED_ELEMENTS = %w[
+        audio button canvas embed fieldset head iframe input link map meta noscript object script select style svg
+        template textarea video
+      ].to_set.freeze
+      FORM_CONTROLS = %w[input select textarea].to_set.freeze
+
+      BLOCK_ELEMENTS = %w[
+        address article aside blockquote body caption dd details dialog div dl dt fieldset figcaption figure footer
+        form h1 h2 h3 h4 h5 h6 header hgroup hr html legend li main menu nav ol p pre search section summary table
+        tbody td tfoot th thead tr ul
+      ].to_set.freeze
+
+      IMPLIED_CLOSES = {
+        'li' => %w[li],
+        'dt' => %w[dt dd],
+        'dd' => %w[dt dd],
+        'tr' => %w[tr td th],
+        'td' => %w[td th],
+        'th' => %w[td th],
+        'option' => %w[option]
+      }.freeze
+
+      EMPHASIS = {
+        'em' => '*', 'i' => '*', 'cite' => '*', 'dfn' => '*', 'var' => '*',
+        'strong' => '**', 'b' => '**',
+        'del' => '~~', 's' => '~~', 'strike' => '~~'
+      }.freeze
+
+      CODE_ELEMENTS = %w[code kbd samp tt].to_set.freeze
+
+      TAG_PATTERN = %r{
+        <!--.*?-->
+        |
+        <(/)?([a-zA-Z][a-zA-Z0-9-]*)
+        ((?:\s+[^\s"'>/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s"'=<>`]+))?)*)
+        \s*(/)?>
+      }mx
+
+      ATTRIBUTE_PATTERN = %r{([^\s"'>/=]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+)))?}
+      ENTITY_PATTERN = /&(?:#(\d+)|#[xX](\h+)|([a-zA-Z][a-zA-Z0-9]*));/
+      IAL_LINE_PATTERN = /^[ \t]*\{:[^\n]*\}[ \t]*(?:\n|\z)/
+      FENCE_OPEN_PATTERN = /\A((?:[ \t]*>)*[ \t]*)(`{3,}|~{3,})(.*)\z/
+      LIST_ITEM_PATTERN = /\A(?:[-*+]|\d+[.)])[ \t]/
+      CODE_SPAN_PATTERN = /(?<!`)(`+)(?!`)((?:(?!\n[ \t]*\n).)+?)(?<!`)\1(?!`)/m
+
+      def convert(markdown)
+        source = markdown.to_s
+        codes = []
+        text = protect_code(source, codes)
+        return source unless html?(text) || text.match?(IAL_LINE_PATTERN)
+
+        output = render_markdown(parse(text).children, dedent: false, codes: codes)
+        restore_code(finish(output, source), codes)
+      end
+
+      def html?(text)
+        text.scan(TAG_PATTERN).any? { |_, name| name.nil? || known?(name) }
+      end
+
+      def known?(name)
+        name = name.downcase
+        KNOWN_ELEMENTS.include?(name) || name.include?('-')
+      end
+
+      def protect_code(source, codes)
+        output = +''
+        prose = +''
+        lines = source.lines
+        index = 0
+        while index < lines.length
+          line = lines[index]
+          match = line.chomp.match(FENCE_OPEN_PATTERN)
+          if match && !(match[2].start_with?('`') && match[3].include?('`'))
+            closing = closing_fence_index(lines, index, match[2])
+            output << protect_spans(prose, codes)
+            prose = +''
+            block = lines[index..closing].join
+            newline = block.end_with?("\n") ? "\n" : ''
+            output << code_title(lines[closing + 1], match[1], output)
+            output << register(codes, block.chomp, BLOCK_CODE) << newline
+            index = closing + 1
+          else
+            prose << line
+            index += 1
+          end
+        end
+        output << protect_spans(prose, codes)
+      end
+
+      def closing_fence_index(lines, start, fence)
+        closing = /\A(?:[ \t]*>)*[ \t]*#{Regexp.escape(fence[0])}{#{fence.length},}[ \t]*\z/
+        ((start + 1)...lines.length).find { |i| lines[i].chomp.match?(closing) } || (lines.length - 1)
+      end
+
+      # The IAL after a fence gives the code block its title bar, so the title
+      # moves to a line of its own before the fence when the IAL goes.
+      def code_title(line, prefix, output)
+        return '' unless line&.match?(IAL_LINE_PATTERN)
+
+        title = ial_value(line, 'data-title')
+        return '' if title.empty?
+
+        href = ial_value(line, 'data-href')
+        title = "[#{title}](#{href})" unless href.empty?
+        separator = output.empty? || output.end_with?("\n\n") ? '' : "#{prefix.rstrip}\n"
+        "#{separator}#{prefix}**#{title}**\n#{prefix.rstrip}\n"
+      end
+
+      def ial_value(line, name)
+        match = line.match(/(?:\A|[\s{:])#{Regexp.escape(name)}=(?:"([^"]*)"|'([^']*)')/)
+        match ? decode(match[1] || match[2]).strip : ''
+      end
+
+      def protect_spans(text, codes)
+        text.gsub(CODE_SPAN_PATTERN) { |span| register(codes, span, SPAN_CODE) }
+      end
+
+      def register(codes, code, format)
+        codes << code
+        format(format, codes.length - 1)
+      end
+
+      def restore_code(text, codes)
+        8.times do
+          break unless text.include?("\u0000")
+
+          text = text.gsub(/^([ \t>]*)#{BLOCK_CODE_PATTERN.source}/) do |match|
+            prefix = Regexp.last_match(1)
+            code = codes[match[/\d+/].to_i]
+            prefix + code.gsub(/\n(?=(.?))/) { Regexp.last_match(1).empty? ? "\n" : "\n#{prefix}" }
+          end
+          text = text.gsub(PLACEHOLDER_PATTERN) { codes[Regexp.last_match(2).to_i] }
+        end
+        text
+      end
+
+      def finish(output, source)
+        text = output.gsub(/^[ \t]+$/, '')
+                     .gsub(/\n{3,}/, "\n\n")
+                     .sub(/\A\n+/, '')
+                     .sub(/\s+\z/, '')
+                     .gsub(LINE_BREAK, "  \n")
+        source.end_with?("\n") && !text.empty? ? "#{text}\n" : text
+      end
+
+      # Parsing
+
+      def parse(text)
+        root = Element.new('#root', {}, [], nil)
+        stack = [root]
+        scanner = StringScanner.new(text)
+        while (consumed = scanner.scan_until(TAG_PATTERN))
+          tag = scanner.matched
+          closing, name, attributes, self_closing = scanner.captures
+          append_text(stack.last, consumed[0...-tag.length])
+          name = name&.downcase
+          next if name.nil?
+
+          if !known?(name)
+            append_text(stack.last, tag)
+          elsif closing
+            close_element(stack, name)
+          else
+            element = open_element(stack, name, parse_attributes(attributes))
+            if RAW_TEXT_ELEMENTS.include?(name)
+              append_text(element, raw_text(scanner, name))
+              stack.pop
+            elsif VOID_ELEMENTS.include?(name) || self_closing
+              stack.pop
+            end
+          end
+        end
+        append_text(stack.last, scanner.rest)
+        root
+      end
+
+      def raw_text(scanner, name)
+        consumed = scanner.scan_until(%r{</#{name}\s*>}i)
+        return consumed[0...-scanner.matched.length] if consumed
+
+        scanner.rest.tap { scanner.terminate }
+      end
+
+      def open_element(stack, name, attrs)
+        closes = IMPLIED_CLOSES.fetch(name, [])
+        stack.pop while stack.length > 1 && closes.include?(stack.last.name)
+        stack.pop if stack.length > 1 && stack.last.name == 'p' && BLOCK_ELEMENTS.include?(name)
+
+        element = Element.new(name, attrs, [], stack.last)
+        stack.last.children << element
+        stack << element
+        element
+      end
+
+      def close_element(stack, name)
+        index = stack.rindex { |element| element.name == name }
+        stack.slice!(index..) if index&.positive?
+      end
+
+      def append_text(parent, text)
+        parent.children << Text.new(text) unless text.nil? || text.empty?
+      end
+
+      def parse_attributes(source)
+        source.to_s.scan(ATTRIBUTE_PATTERN).to_h do |name, double, single, bare|
+          [name.downcase, decode(double || single || bare || '')]
+        end
+      end
+
+      # Rendering
+
+      def render_markdown(nodes, dedent:, codes:)
+        output = nodes.each_with_object(+'') do |node, out|
+          if node.is_a?(Text)
+            out << node.text.gsub(IAL_LINE_PATTERN, '')
+          elsif dropped?(node)
+            next
+          elsif block?(node)
+            out << "\n\n" << render_block(node, codes) << "\n\n"
+          else
+            unindent_paragraph_start(out)
+            out << render_inline(node, codes, breaks: true)
+          end
+        end
+        dedent ? dedent(output) : output
+      end
+
+      # Includes often indent the HTML they write, and Markdown would read a
+      # paragraph indented four spaces as code. Indentation that continues a
+      # list item stays.
+      def unindent_paragraph_start(out)
+        return unless out.match?(/(?:\A|\n[ \t]*\n)[ \t]+\z/)
+
+        previous = out.rstrip.lines.last.to_s
+        return if previous.match?(/\A[ \t]/) || previous.match?(LIST_ITEM_PATTERN)
+
+        out.sub!(/[ \t]+\z/, '')
+      end
+
+      def dedent(text)
+        lines = text.split("\n", -1)
+        indents = lines.drop(1).reject { |line| line.strip.empty? || line.match?(/\A[ \t]*#{BLOCK_CODE_PATTERN.source}/) }
+                       .map { |line| line[/\A[ \t]*/].length }
+        indent = indents.min.to_i
+        return text if indent.zero?
+
+        lines.each_with_index.map { |line, i| i.zero? ? line : line.sub(/\A[ \t]{0,#{indent}}/, '') }.join("\n")
+      end
+
+      def render_flow(nodes, codes)
+        blocks = []
+        run = +''
+        previous = nil
+        flush = lambda do
+          inline = normalize_inline(run)
+          blocks << inline unless inline.empty?
+          run = +''
+        end
+
+        nodes.each do |node|
+          if node.is_a?(Text)
+            node.text.split(/(#{BLOCK_CODE_PATTERN.source})/).each do |piece|
+              if piece.match?(BLOCK_CODE_PATTERN)
+                flush.call
+                blocks << piece
+              else
+                run << inline_text_node(piece)
+              end
+            end
+          elsif dropped?(node)
+            next
+          elsif block?(node)
+            flush.call
+            block = render_block(node, codes)
+            blocks << block unless block.strip.empty?
+          else
+            append_inline(run, render_inline(node, codes, breaks: true), previous, node)
+          end
+          previous = node
+        end
+        flush.call
+        blocks.join("\n\n")
+      end
+
+      def render_block(element, codes)
+        return strong_block(element, codes) if class?(element, 'custom-block-title')
+
+        case element.name
+        when /\Ah([1-6])\z/
+          text = inline_text(element.children, codes, breaks: false)
+          text.empty? ? '' : "#{'#' * Regexp.last_match(1).to_i} #{text}"
+        when 'summary', 'dt', 'legend' then strong_block(element, codes)
+        when 'pre' then render_pre(element, codes)
+        when 'ul', 'ol', 'menu' then render_list(element, codes)
+        when 'li' then list_item(render_flow(element.children, codes), '- ')
+        when 'blockquote' then quote(render_flow(element.children, codes))
+        when 'table' then render_table(element, codes)
+        when 'hr' then '---'
+        when 'a' then render_block_link(element, codes)
+        else
+          body = if markdown_attribute?(element)
+                   render_markdown(element.children, dedent: true, codes: codes)
+                 else
+                   render_flow(element.children, codes)
+                 end
+          class?(element, 'custom-block') ? quote(body) : body
+        end
+      end
+
+      def strong_block(element, codes)
+        text = inline_text(element.children, codes, breaks: false)
+        text.empty? ? '' : "**#{text}**"
+      end
+
+      def render_inline(node, codes, breaks:)
+        return inline_text_node(node.text) if node.is_a?(Text)
+        return '' if dropped?(node)
+
+        name = node.name
+        return " #{inline_text(node.children, codes, breaks: breaks)} " if BLOCK_ELEMENTS.include?(name)
+
+        if name == 'a'
+          render_link(node, codes, breaks: breaks)
+        elsif CODE_ELEMENTS.include?(name)
+          code_span(text_content(node).gsub(/\s+/, ' ').strip)
+        elsif EMPHASIS.key?(name)
+          emphasize(render_children_inline(node, codes, breaks: breaks), EMPHASIS[name])
+        elsif name == 'br'
+          breaks ? LINE_BREAK : ' '
+        elsif name == 'img'
+          duplicate_image?(node) ? '' : node.attrs['alt'].to_s.strip
+        else
+          render_children_inline(node, codes, breaks: breaks)
+        end
+      end
+
+      def render_children_inline(element, codes, breaks:)
+        render_inline_nodes(element.children, codes, breaks: breaks)
+      end
+
+      def inline_text(nodes, codes, breaks:)
+        normalize_inline(render_inline_nodes(nodes, codes, breaks: breaks))
+      end
+
+      def render_inline_nodes(nodes, codes, breaks:)
+        previous = nil
+        nodes.each_with_object(+'') do |node, buffer|
+          append_inline(buffer, render_inline(node, codes, breaks: breaks), previous, node)
+          previous = node
+        end
+      end
+
+      # Sibling elements with no whitespace between them are laid out apart by
+      # CSS, such as a name and a job title in a flex row, so keep them apart.
+      def append_inline(buffer, text, previous, node)
+        separate = previous.is_a?(Element) && node.is_a?(Element) &&
+                   buffer.match?(/[^\s#{LINE_BREAK}]\z/o) && text.match?(/\A[^\s#{LINE_BREAK}]/o)
+        buffer << ' ' if separate
+        buffer << text
+      end
+
+      def inline_text_node(text)
+        decode(text.gsub(/[ \t\r\n]+/, ' ')).tr("\u00A0", ' ')
+      end
+
+      def normalize_inline(text)
+        text.gsub(/[ \t\r\n]+/, ' ')
+            .gsub(/ ?#{LINE_BREAK} ?/o, LINE_BREAK)
+            .gsub(/\A[ #{LINE_BREAK}]+|[ #{LINE_BREAK}]+\z/o, '')
+      end
+
+      def render_link(element, codes, breaks:)
+        label = inline_text(element.children, codes, breaks: breaks)
+        label = accessible_name(element) if label.empty?
+        href = element.attrs['href'].to_s.strip
+        return label if href.empty? || label.empty?
+
+        "[#{label}](#{href})"
+      end
+
+      def render_block_link(element, codes)
+        body = render_flow(element.children, codes)
+        href = element.attrs['href'].to_s.strip
+        return body if href.empty?
+
+        label = accessible_name(element)
+        label = body.lines.first.to_s.sub(/\A[#*\s]+/, '').sub(/[*\s]+\z/, '') if label.empty?
+        [body, "[#{label}](#{href})"].reject(&:empty?).join("\n\n")
+      end
+
+      # An image repeats its neighbour when it is the dark-mode twin of the
+      # previous image or an avatar next to the name it shows.
+      def duplicate_image?(image)
+        alt = normalize_inline(image.attrs['alt'].to_s)
+        return false if alt.empty?
+
+        siblings = image.parent.children.reject { |child| child.is_a?(Text) && child.text.strip.empty? }
+        index = siblings.index { |child| child.equal?(image) }
+        previous = index.positive? ? siblings[index - 1] : nil
+        following = siblings[index + 1]
+
+        (previous.is_a?(Element) && previous.name == 'img' && normalize_inline(previous.attrs['alt'].to_s) == alt) ||
+          (following.is_a?(Element) && following.name != 'img' && normalize_inline(text_content(following)) == alt)
+      end
+
+      def accessible_name(element)
+        normalize_inline(element.attrs['aria-label'] || element.attrs['title'] || '')
+      end
+
+      def emphasize(text, marker)
+        core = text.strip
+        return text if core.empty?
+
+        leading = text.match?(/\A\s/) ? ' ' : ''
+        trailing = text.match?(/\s\z/) ? ' ' : ''
+        "#{leading}#{marker}#{core}#{marker}#{trailing}"
+      end
+
+      def code_span(text)
+        return '' if text.empty?
+
+        fence = '`' * (longest_run(text, '`') + 1)
+        padding = text.start_with?('`') || text.end_with?('`') ? ' ' : ''
+        "#{fence}#{padding}#{text}#{padding}#{fence}"
+      end
+
+      def render_pre(element, codes)
+        code = text_content(element).sub(/\A\n/, '').sub(/\s+\z/, '')
+        return '' if code.empty?
+
+        fence = '`' * [3, longest_run(code, '`') + 1].max
+        register(codes, "#{fence}#{language(element)}\n#{code}\n#{fence}", BLOCK_CODE)
+      end
+
+      def language(element)
+        candidates = element.children.grep(Element).select { |child| child.name == 'code' }
+        node = element
+        while node
+          candidates << node
+          node = node.parent
+        end
+        candidates.each do |candidate|
+          match = candidate.attrs['class'].to_s.match(/(?:\A|\s)(?:language|lang)-(\S+)/)
+          return match[1] if match
+        end
+        ''
+      end
+
+      def render_list(element, codes)
+        number = (element.attrs['start'] || 1).to_i
+        items = element.children.grep(Element).select { |child| child.name == 'li' && !dropped?(child) }
+        items.filter_map do |item|
+          body = render_flow(item.children, codes)
+          next if body.empty?
+
+          marker = element.name == 'ol' ? "#{number}. " : '- '
+          number += 1
+          list_item(body, marker)
+        end.join("\n")
+      end
+
+      def list_item(body, marker)
+        indent = ' ' * marker.length
+        body.lines.each_with_index.map do |line, index|
+          if index.zero? then "#{marker}#{line}"
+          elsif line.strip.empty? then line
+          else
+            "#{indent}#{line}"
+          end
+        end.join
+      end
+
+      def quote(body)
+        body = body.gsub(/^[ \t]+$/, '').gsub(/\n{3,}/, "\n\n").sub(/\A\n+/, '').sub(/\s+\z/, '')
+        body.lines.map do |line|
+          line.strip.empty? ? ">\n" : "> #{line}"
+        end.join.chomp
+      end
+
+      def render_table(element, codes)
+        rows = table_rows(element)
+        return render_flow(element.children, codes) unless tabular?(rows)
+
+        caption = element.children.grep(Element).find { |child| child.name == 'caption' && !dropped?(child) }
+        width = rows.map { |cells| cells.sum { |cell| colspan(cell) } }.max
+        lines = rows.map { |cells| table_row(cells, width, codes) }
+        lines.insert(1, "|#{' --- |' * width}")
+        table = lines.join("\n")
+        caption_text = caption ? inline_text(caption.children, codes, breaks: false) : ''
+        caption_text.empty? ? table : "#{caption_text}\n\n#{table}"
+      end
+
+      def table_rows(table)
+        rows = []
+        table.children.grep(Element).each do |child|
+          next if dropped?(child)
+
+          case child.name
+          when 'tr' then rows << child
+          when 'thead', 'tbody', 'tfoot'
+            rows.concat(child.children.grep(Element).select { |row| row.name == 'tr' && !dropped?(row) })
+          end
+        end
+        rows.map { |row| row.children.grep(Element).select { |cell| %w[td th].include?(cell.name) } }
+            .reject(&:empty?)
+      end
+
+      def tabular?(rows)
+        return false if rows.empty?
+
+        rows.flatten.none? do |cell|
+          cell.attrs['rowspan'].to_i > 1 || descendant?(cell) { |node| %w[table pre ul ol dl blockquote].include?(node.name) }
+        end
+      end
+
+      def table_row(cells, width, codes)
+        texts = cells.flat_map do |cell|
+          text = cell_text(cell, codes).gsub('|', '\\|')
+          text = "**#{text}**" if cells.length == 1 && colspan(cell) > 1 && !text.empty?
+          [text] + Array.new(colspan(cell) - 1, '')
+        end
+        texts.fill('', texts.length...width)
+        "|#{texts.map { |text| text.empty? ? ' ' : " #{text} " }.join('|')}|"
+      end
+
+      # Sortable tables label their columns with buttons, which are otherwise
+      # dropped, so a header cell falls back to its full text.
+      def cell_text(cell, codes)
+        text = inline_text(cell.children, codes, breaks: false)
+        return text unless text.empty? && cell.name == 'th'
+
+        normalize_inline(text_content(cell))
+      end
+
+      def colspan(cell)
+        [cell.attrs['colspan'].to_i, 1].max
+      end
+
+      # Queries
+
+      def dropped?(element)
+        DROPPED_ELEMENTS.include?(element.name) ||
+          element.attrs['aria-hidden'] == 'true' ||
+          (element.name == 'label' && control_label?(element)) ||
+          (element.name == 'dialog' && !element.attrs.key?('open'))
+      end
+
+      def control_label?(label)
+        label.children.any? do |child|
+          child.is_a?(Element) && (FORM_CONTROLS.include?(child.name) || control_label?(child))
+        end
+      end
+
+      def block?(element)
+        BLOCK_ELEMENTS.include?(element.name) || descendant?(element) { |node| BLOCK_ELEMENTS.include?(node.name) }
+      end
+
+      def descendant?(element, &block)
+        element.children.any? do |child|
+          child.is_a?(Element) && !dropped?(child) && (yield(child) || descendant?(child, &block))
+        end
+      end
+
+      def class?(element, name)
+        element.attrs['class'].to_s.split.include?(name)
+      end
+
+      def markdown_attribute?(element)
+        %w[1 block span].include?(element.attrs['markdown'])
+      end
+
+      def text_content(element)
+        element.children.map do |child|
+          child.is_a?(Text) ? decode(child.text) : text_content(child)
+        end.join
+      end
+
+      def longest_run(text, character)
+        text.scan(/#{Regexp.escape(character)}+/).map(&:length).max.to_i
+      end
+
+      def decode(text)
+        text.gsub(ENTITY_PATTERN) do |entity|
+          code_point = entity_code_point(Regexp.last_match(1), Regexp.last_match(2), Regexp.last_match(3))
+          code_point ? [code_point].pack('U') : entity
+        end
+      end
+
+      def entity_code_point(decimal, hex, name)
+        return decimal.to_i if decimal
+        return hex.to_i(16) if hex
+
+        Kramdown::Utils::Entities.entity(name).code_point
+      rescue Kramdown::Error, RangeError
+        nil
+      end
+    end
+  end
+end

data/lib/jekyll/vitepress_theme/seo.rb

@@ -10,7 +10,7 @@ module Jekyll
     # Generates the metadata shared by the HTML head, sitemap, and robots.txt.
     # Keeping those outputs on one canonical URL resolver prevents contradictory
     # indexing signals across theme consumers.
-    # rubocop:disable Metrics/AbcSize, Metrics/ModuleLength
+    # rubocop:disable-next Metrics/AbcSize, Metrics/ModuleLength
     module SEO
       module_function
 
@@ -588,6 +588,5 @@ module Jekyll
         CGI.escapeHTML(value.to_s)
       end
     end
-    # rubocop:enable Metrics/AbcSize, Metrics/ModuleLength
   end
 end

data/lib/jekyll/vitepress_theme/version.rb

@@ -1,5 +1,5 @@
 module Jekyll
   module VitePressTheme
-    VERSION = "1.9.1".freeze
+    VERSION = "1.10.1".freeze
   end
 end

data/lib/jekyll-vitepress-theme.rb

@@ -1,5 +1,7 @@
 require 'jekyll'
 require_relative 'jekyll/vitepress_theme/version'
+require_relative 'jekyll/vitepress_theme/markdown_export'
 require_relative 'jekyll/vitepress_theme/seo'
 require_relative 'jekyll/vitepress_theme/llms'
+require_relative 'jekyll/vitepress_theme/last_updated'
 require_relative 'jekyll/vitepress_theme/hooks'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jekyll-vitepress-theme
 version: !ruby/object:Gem::Version
-  version: 1.9.1
+  version: 1.10.1
 platform: ruby
 authors:
 - Carmine Paolino
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-08-14 00:00:00.000000000 Z
+date: 2026-10-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cgi
@@ -56,20 +56,20 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '4.1'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '6.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '4.1'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '6.0'
 description: Jekyll VitePress Theme brings VitePress-style documentation UX, search,
   structured metadata, and Jekyll-native extensions to Ruby static sites.
 email:
@@ -177,7 +177,9 @@ files:
 - assets/vendor/turbo.js
 - lib/jekyll-vitepress-theme.rb
 - lib/jekyll/vitepress_theme/hooks.rb
+- lib/jekyll/vitepress_theme/last_updated.rb
 - lib/jekyll/vitepress_theme/llms.rb
+- lib/jekyll/vitepress_theme/markdown_export.rb
 - lib/jekyll/vitepress_theme/seo.rb
 - lib/jekyll/vitepress_theme/version.rb
 homepage: https://jekyll-vitepress.dev