unaltraweb 0.3.0

data/_plugins/figure_captions.rb

@@ -0,0 +1,800 @@
+# frozen_string_literal: true
+
+require "cgi"
+
+module Unaltraweb
+  module FigureCaptions
+    module_function
+
+    PANEL_SEQUENCE = ("a".."z").to_a.freeze
+    FENCED_CODE_BLOCK = /^[ \t]*(`{3,}|~{3,})[^\n]*\n.*?^[ \t]*\1[ \t]*$/m.freeze
+
+    def enabled?(site)
+      config = config_for(site)
+      config.fetch("enabled", true) != false
+    end
+
+    def collections(site)
+      config = config_for(site)
+      Array(config["collections"] || ["chapters"]).map(&:to_s)
+    end
+
+    def config_for(site)
+      unaltraweb = site.config["unaltraweb"] || {}
+      unaltraweb["figure_captions"] || {}
+    end
+
+    def process_collection?(site, label)
+      enabled?(site) && collections(site).include?(label.to_s)
+    end
+
+    def process_page?(page)
+      return false unless enabled?(page.site)
+
+      value = page.data["figure_captions"]
+      value == true || value.to_s == "true" || (value.respond_to?(:fetch) && value.fetch("enabled", true) != false)
+    end
+
+    def detect_lang(doc)
+      return doc.data["lang"].to_s unless doc.data["lang"].to_s.empty?
+
+      rel = doc.relative_path.to_s.tr("\\", "/")
+      parts = rel.split("/")
+      parts[1].to_s.empty? ? doc.site.config["default_lang"].to_s : parts[1].to_s
+    end
+
+    def label_for(site, lang)
+      i18n = site.data["i18n"] || {}
+      lang_data = i18n[lang] || i18n[site.config["default_lang"]] || {}
+      label = lang_data.dig("figures", "label") if lang_data.respond_to?(:dig)
+      label ||= lang_data["figure"]
+      label ||= "Figure"
+      label.to_s
+    end
+
+    def table_label_for(site, lang)
+      i18n = site.data["i18n"] || {}
+      lang_data = i18n[lang] || i18n[site.config["default_lang"]] || {}
+      label = lang_data.dig("tables", "label") if lang_data.respond_to?(:dig)
+      label ||= lang_data["table"]
+      label ||= "Table"
+      label.to_s
+    end
+
+    def listing_label_for(site, lang)
+      i18n = site.data["i18n"] || {}
+      lang_data = i18n[lang] || i18n[site.config["default_lang"]] || {}
+      label = lang_data.dig("listings", "label") if lang_data.respond_to?(:dig)
+      label ||= lang_data["listing"]
+      label ||= "Code example"
+      label.to_s
+    end
+
+    def transform_markdown_images(text, lang, label)
+      out = +""
+      source = text.to_s
+      index = 0
+      count = 0
+
+      while index < source.length
+        if (block = parse_subfigures_block(source, index))
+          html, count = subfigures_html(block, lang, label, count)
+          out << "\n\n" << html << "\n\n"
+          index = block[:end_idx]
+          next
+        end
+
+        if source[index] == "!" && source[index + 1] == "["
+          parsed = parse_markdown_image(source, index)
+          if parsed
+            alt = parsed[:alt]
+            url_and_title = parsed[:url_and_title]
+            attrs_raw = parsed[:attrs]
+            next_index = parsed[:end_idx]
+
+            if attrs_raw && attrs_raw.match?(/(\.no-figure|data-no-figure\s*=\s*["']true["'])/)
+              out << source[index...next_index]
+            else
+              url, title = split_url_and_title(url_and_title)
+              caption = title.to_s.empty? ? alt.to_s : title.to_s
+              attrs = kramdown_attrs_to_html(attrs_raw)
+              count += 1
+
+              out << "\n\n"
+              out << figure_html(
+                img: %(<img src="#{h(url.strip)}" alt="#{h(strip_liquid(alt))}"#{attrs.empty? ? "" : " #{attrs}"}>),
+                caption: render_inline_markdown(caption),
+                label: label,
+                lang: lang,
+                count: count,
+                classes: figure_classes_for(url),
+                attrs: figure_container_attrs(attrs_raw)
+              )
+              out << "\n\n"
+            end
+            index = next_index
+            next
+          end
+        end
+
+        out << source[index]
+        index += 1
+      end
+
+      out
+    end
+
+    def transform_markdown_tables(text, lang, label)
+      out = +""
+      source = text.to_s
+      index = 0
+      count = 0
+
+      while index < source.length
+        if (block = parse_table_block(source, index))
+          html, count = table_html(block, lang, label, count)
+          out << "\n\n" << html << "\n\n"
+          index = block[:end_idx]
+          next
+        end
+
+        out << source[index]
+        index += 1
+      end
+
+      out
+    end
+
+    def transform_markdown_listings(text, lang, label)
+      out = +""
+      source = text.to_s
+      index = 0
+      count = 0
+
+      while index < source.length
+        if (block = parse_listing_block(source, index))
+          html, count = listing_html(block, lang, label, count)
+          out << "\n\n" << html << "\n\n"
+          index = block[:end_idx]
+          next
+        end
+
+        out << source[index]
+        index += 1
+      end
+
+      out
+    end
+
+    def transform_markdown_sugar(text, lang, figure_label, table_label, listing_label = "Code example")
+      transform_outside_code_fences(text) do |chunk|
+        transformed = transform_markdown_images(chunk, lang, figure_label)
+        transformed = transform_markdown_tables(transformed, lang, table_label)
+        transform_markdown_listings(transformed, lang, listing_label)
+      end
+    end
+
+    def transform_outside_code_fences(text)
+      source = text.to_s
+      fences = []
+      protected_source = source.gsub(FENCED_CODE_BLOCK) do
+        token = "UNALTRAWEBFENCEDCODEBLOCK#{fences.length}"
+        fences << Regexp.last_match(0)
+        token
+      end
+
+      transformed = yield(protected_source)
+      fences.each_index.reverse_each do |index|
+        transformed.gsub!("UNALTRAWEBFENCEDCODEBLOCK#{index}", fences[index])
+      end
+
+      transformed
+    end
+
+    def parse_subfigures_block(source, start_index)
+      return nil unless line_start?(source, start_index) && source[start_index, 3] == ":::"
+
+      line_end = source.index("\n", start_index) || source.length
+      opening = source[start_index...line_end]
+      match = opening.match(/\A:::\s*subfigures(?:\s+([^\s"]+))?(?:\s+"([^"]+)")?\s*\z/)
+      return nil unless match
+
+      body_start = line_end == source.length ? line_end : line_end + 1
+      closing = source.match(/^:::\s*$/m, body_start)
+      return nil unless closing
+
+      {
+        layout: match[1].to_s,
+        caption: match[2].to_s,
+        body: source[body_start...closing.begin(0)],
+        raw: source[start_index...closing.end(0)],
+        end_idx: closing.end(0)
+      }
+    end
+
+    def parse_table_block(source, start_index)
+      return nil unless line_start?(source, start_index) && source[start_index, 3] == ":::"
+
+      line_end = source.index("\n", start_index) || source.length
+      opening = source[start_index...line_end]
+      match = opening.match(/\A:::\s*table(?:\s+"([^"]+)")?\s*\z/)
+      return nil unless match
+
+      body_start = line_end == source.length ? line_end : line_end + 1
+      closing = source.match(/^:::\s*$/m, body_start)
+      return nil unless closing
+
+      {
+        caption: match[1].to_s,
+        body: source[body_start...closing.begin(0)],
+        raw: source[start_index...closing.end(0)],
+        end_idx: closing.end(0)
+      }
+    end
+
+    def parse_listing_block(source, start_index)
+      return nil unless line_start?(source, start_index) && source[start_index, 3] == ":::"
+
+      line_end = source.index("\n", start_index) || source.length
+      opening = source[start_index...line_end]
+      match = opening.match(/\A:::\s*listing\s+"([^"]+)"\s*\z/)
+      return nil unless match
+
+      body_start = line_end == source.length ? line_end : line_end + 1
+      closing = source.match(/^:::\s*$/m, body_start)
+      return nil unless closing
+
+      {
+        caption: match[1],
+        body: source[body_start...closing.begin(0)],
+        raw: source[start_index...closing.end(0)],
+        end_idx: closing.end(0)
+      }
+    end
+
+    def line_start?(source, index)
+      index.zero? || source[index - 1] == "\n"
+    end
+
+    def subfigures_html(block, lang, label, count)
+      images = parse_subfigure_images(block[:body])
+      return [block[:raw], count] if images.empty?
+
+      count += 1
+      rows = subfigure_rows(block[:layout], images.length)
+      any_diagram = images.any? { |img| diagram_path?(img[:url]) }
+      outer_classes = ["md-figure", "md-subfigure-set"]
+      outer_classes << "mermaid-figure" if any_diagram
+
+      row_html = rows.map do |row|
+        cells = row.map do |slot|
+          image = images[slot[:index]]
+          attrs = kramdown_attrs_to_html(image[:attrs])
+          panel_attrs = subfigure_panel_attrs(image[:attrs])
+          caption = render_inline_markdown(image[:caption])
+          panel = h(slot[:label])
+          caption_html = caption.to_s.strip.empty? ? "" : %Q{<p class="md-subfigure-caption"><span class="md-subfigure-label">#{panel}</span> #{caption}</p>}
+          %Q{<div class="md-subfigure" data-panel="#{panel}"#{panel_attrs}>#{caption_html}<img src="#{h(image[:url].strip)}" alt="#{h(strip_liquid(image[:alt]))}"#{attrs.empty? ? "" : " #{attrs}"}></div>}
+        end.join("\n")
+        %Q{<div class="md-subfigure-row" data-count="#{row.length}">\n#{cells}\n</div>}
+      end.join("\n")
+
+      clean_caption = render_inline_markdown(block[:caption]).to_s.strip
+      figcaption = clean_caption.empty? ? "" : %(<figcaption class="md-figcaption"><span class="figlabel">#{h(label)} #{count}.</span> #{clean_caption}</figcaption>)
+
+      html = <<~HTML.strip
+        <figure id="fig-#{h(lang)}-#{count}" class="#{outer_classes.join(' ')}" data-layout="#{h(block[:layout])}">
+          #{figcaption}
+          <div class="md-figure-inner">
+            <div class="md-subfigure-grid">
+              #{row_html}
+            </div>
+          </div>
+        </figure>
+      HTML
+
+      [html, count]
+    end
+
+    def table_html(block, lang, label, count)
+      parsed_table = parse_markdown_table(block[:body])
+      return [block[:raw], count] unless parsed_table
+
+      count += 1
+      caption = render_inline_markdown(block[:caption]).to_s.strip
+      caption_html = caption.empty? ? "" : %(<figcaption class="md-table-caption"><span class="figlabel">#{h(label)} #{count}.</span> #{caption}</figcaption>)
+      thead = table_row_html(parsed_table[:headers], "th", parsed_table[:alignments])
+      tbody = parsed_table[:rows].map { |row| table_row_html(row, "td", parsed_table[:alignments]) }.join("\n")
+
+      html = <<~HTML.strip
+        <figure id="tbl-#{h(lang)}-#{count}" class="md-table">
+          #{caption_html}
+          <div class="md-table-inner">
+            <table class="md-table-element">
+              <thead>
+                #{thead}
+              </thead>
+              <tbody>
+                #{tbody}
+              </tbody>
+            </table>
+          </div>
+        </figure>
+      HTML
+
+      [html, count]
+    end
+
+    def listing_html(block, lang, label, count)
+      code_token = block[:body].to_s.strip
+      return [block[:raw], count] unless code_token.match?(/\AUNALTRAWEBFENCEDCODEBLOCK\d+\z/)
+
+      count += 1
+      caption = render_inline_markdown(block[:caption]).to_s.strip
+      caption_html = %(<figcaption class="md-code-caption"><span class="figlabel">#{h(label)} #{count}.</span> #{caption}</figcaption>)
+      html = <<~HTML.strip
+        <figure id="lst-#{h(lang)}-#{count}" class="md-code-listing" markdown="1">
+          #{caption_html}
+
+          #{code_token}
+        </figure>
+      HTML
+
+      [html, count]
+    end
+
+    def parse_markdown_table(body)
+      lines = body.to_s.lines.map(&:rstrip)
+      lines.shift while lines.first&.strip&.empty?
+      lines.pop while lines.last&.strip&.empty?
+      return nil if lines.length < 2
+
+      headers = split_table_row(lines[0])
+      alignments = parse_table_alignment(lines[1], headers.length)
+      return nil unless alignments
+
+      rows = lines[2..].to_a.reject { |line| line.strip.empty? }.map { |line| normalize_table_row(split_table_row(line), headers.length) }
+      {
+        headers: normalize_table_row(headers, headers.length),
+        alignments: alignments,
+        rows: rows
+      }
+    end
+
+    def split_table_row(line)
+      source = line.to_s.strip
+      source = source[1..] if source.start_with?("|")
+      source = source[0...-1] if source.end_with?("|") && !source.end_with?("\\|")
+
+      cells = []
+      current = +""
+      escaped = false
+      source.each_char do |char|
+        if char == "|" && !escaped
+          cells << current.strip
+          current = +""
+        else
+          current << char
+        end
+        escaped = char == "\\" && !escaped
+      end
+      cells << current.strip
+      cells.map { |cell| cell.gsub("\\|", "|") }
+    end
+
+    def parse_table_alignment(line, column_count)
+      cells = normalize_table_row(split_table_row(line), column_count)
+      return nil if cells.empty?
+
+      cells.map do |cell|
+        marker = cell.strip
+        return nil unless marker.match?(/\A:?-{3,}:?\z/)
+
+        if marker.start_with?(":") && marker.end_with?(":")
+          "center"
+        elsif marker.end_with?(":")
+          "right"
+        elsif marker.start_with?(":")
+          "left"
+        end
+      end
+    end
+
+    def normalize_table_row(cells, column_count)
+      row = cells.first(column_count)
+      row << "" while row.length < column_count
+      row
+    end
+
+    def table_row_html(cells, tag, alignments)
+      content = cells.each_with_index.map do |cell, index|
+        align = alignments[index]
+        align_attr = align.to_s.empty? ? "" : %( style="text-align: #{h(align)}")
+        %(<#{tag}#{align_attr}>#{render_inline_markdown(cell.to_s.strip)}</#{tag}>)
+      end.join
+
+      "<tr>#{content}</tr>"
+    end
+
+    def parse_subfigure_images(body)
+      images = []
+      index = 0
+      source = body.to_s
+
+      while index < source.length
+        if source[index] == "!" && source[index + 1] == "["
+          parsed = parse_markdown_image(source, index)
+          if parsed
+            url, title = split_url_and_title(parsed[:url_and_title])
+            images << {
+              alt: parsed[:alt].to_s,
+              url: url.to_s,
+              caption: title.to_s.empty? ? parsed[:alt].to_s : title.to_s,
+              attrs: parsed[:attrs]
+            }
+            index = parsed[:end_idx]
+            next
+          end
+        end
+        index += 1
+      end
+
+      images
+    end
+
+    def subfigure_rows(layout, image_count)
+      used = []
+      rows = []
+      parsed_rows = layout.to_s.split("/").map { |row| subfigure_row_tokens(row) }.reject(&:empty?)
+
+      parsed_rows.each do |tokens|
+        row = []
+        tokens.each do |token|
+          index = panel_index(token)
+          index = next_unused_index(image_count, used) if index.nil? || index >= image_count || used.include?(index)
+          next if index.nil?
+
+          used << index
+          row << { index: index, label: panel_label(token, index) }
+        end
+        rows << row if row.any?
+      end
+
+      while used.length < image_count
+        row = []
+        [4, image_count - used.length].min.times do
+          index = next_unused_index(image_count, used)
+          break if index.nil?
+
+          used << index
+          row << { index: index, label: PANEL_SEQUENCE[index] || (index + 1).to_s }
+        end
+        rows << row if row.any?
+      end
+
+      rows
+    end
+
+    def subfigure_row_tokens(row)
+      row.to_s.split("+").flat_map do |token|
+        value = token.strip
+        if value.match?(/\A[a-zA-Z]{2,}\z/)
+          value.each_char.map(&:downcase)
+        else
+          [value]
+        end
+      end.reject(&:empty?)
+    end
+
+    def panel_index(token)
+      value = token.to_s.strip
+      return nil if value.empty?
+      return value.downcase.ord - "a".ord if value.match?(/\A[a-zA-Z]\z/)
+      return value.to_i - 1 if value.match?(/\A\d+\z/)
+
+      nil
+    end
+
+    def panel_label(token, index)
+      value = token.to_s.strip
+      return value.downcase if value.match?(/\A[a-zA-Z]\z/)
+
+      PANEL_SEQUENCE[index] || (index + 1).to_s
+    end
+
+    def next_unused_index(image_count, used)
+      (0...image_count).find { |candidate| !used.include?(candidate) }
+    end
+
+    def parse_markdown_image(source, start_index)
+      index = start_index + 2
+      alt, index = read_balanced(source, index, "[", "]")
+      return nil unless alt && source[index - 1] == "]" && source[index] == "("
+
+      index += 1
+      url_and_title, index = read_until_closing_paren(source, index)
+      return nil unless url_and_title && source[index] == ")"
+
+      index += 1
+      index = skip_spaces(source, index)
+
+      attrs_raw = nil
+      if source[index] == "{"
+        close_index = source.index("}", index)
+        return nil unless close_index
+
+        attrs_raw = source[index..close_index].sub(/\A\{:\s*/, "{").strip
+        index = close_index + 1
+      end
+
+      { alt: alt, url_and_title: url_and_title, attrs: attrs_raw, end_idx: index }
+    end
+
+    def read_balanced(source, index, open_char, close_char)
+      depth = 1
+      start = index
+      while index < source.length
+        char = source[index]
+        if char == "\\"
+          index += 2
+          next
+        elsif char == open_char
+          depth += 1
+        elsif char == close_char
+          depth -= 1
+          return [source[start...index], index + 1] if depth.zero?
+        end
+        index += 1
+      end
+      [nil, index]
+    end
+
+    def read_until_closing_paren(source, index)
+      depth = 1
+      start = index
+      while index < source.length
+        char = source[index]
+        if char == "\\"
+          index += 2
+          next
+        elsif char == "("
+          depth += 1
+        elsif char == ")"
+          depth -= 1
+          return [source[start...index], index] if depth.zero?
+        end
+        index += 1
+      end
+      [nil, index]
+    end
+
+    def skip_spaces(source, index)
+      index += 1 while index < source.length && source[index] =~ /[ \t]/
+      index
+    end
+
+    def subfigure_panel_attrs(raw)
+      styles = []
+      width = kramdown_attr_value(raw, "data-subfigure-width") || kramdown_attr_value(raw, "width")
+      height = kramdown_attr_value(raw, "data-subfigure-height") || kramdown_attr_value(raw, "height")
+      figure_width = kramdown_attr_value(raw, "data-figure-width-web") || kramdown_attr_value(raw, "data-figure-width")
+      figure_height = kramdown_attr_value(raw, "data-figure-height-web") || kramdown_attr_value(raw, "data-figure-height")
+      inline_style = kramdown_attr_value(raw, "style")
+
+      styles << "--md-subfigure-width: #{width};" unless width.to_s.strip.empty?
+      styles << "--md-subfigure-image-height: #{height};" unless height.to_s.strip.empty?
+      styles << "--md-subfigure-image-width: #{figure_width};" unless figure_width.to_s.strip.empty?
+      styles << "--md-subfigure-image-max-height: #{figure_height};" unless figure_height.to_s.strip.empty?
+      inline_style.to_s.scan(/--md-subfigure-[\w-]+\s*:\s*[^;]+/) do |declaration|
+        styles << "#{declaration.strip};"
+      end
+
+      styles.empty? ? "" : %( style="#{h(styles.join(' '))}")
+    end
+
+    def kramdown_attr_value(raw, name)
+      source = raw.to_s.strip.sub(/\A\{:\s*/, "").sub(/\A\{\s*/, "").sub(/\s*\}\z/, "")
+      match = source.match(/(?:\A|\s)#{Regexp.escape(name)}\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s}]+))/)
+      return nil unless match
+
+      match[1] || match[2] || match[3]
+    end
+
+    def split_url_and_title(value)
+      text = value.to_s.strip
+      if text =~ /\s+["“]([^"”]+)["”]\s*\z/m
+        title = Regexp.last_match(1).strip
+        url = text.sub(/\s+["“][^"”]+["”]\s*\z/m, "").strip
+        [url, title]
+      elsif text =~ /\s+['‘]([^'’]+)['’]\s*\z/m
+        title = Regexp.last_match(1).strip
+        url = text.sub(/\s+['‘][^'’]+['’]\s*\z/m, "").strip
+        [url, title]
+      else
+        [text, nil]
+      end
+    end
+
+    def wrap_html_images(output, lang, label)
+      return output unless output.to_s.include?("<img")
+
+      count = output.scan(/<figure\b[^>]*\bclass=["'][^"']*\bmd-figure\b/i).size
+      output.gsub(%r{<p>\s*(<img\b[^>]*>)\s*</p>}mi) do
+        img_tag = Regexp.last_match(1)
+        next Regexp.last_match(0) if img_tag =~ /\bdata-no-figure\s*=\s*["']true["']/i
+
+        caption = extract_attr(img_tag, "title").to_s
+        caption = extract_attr(img_tag, "alt").to_s if caption.empty?
+        count += 1
+
+        figure_html(
+          img: img_tag,
+          caption: render_inline_markdown(CGI.unescapeHTML(caption)),
+          label: label,
+          lang: lang,
+          count: count,
+          classes: figure_classes_for(extract_attr(img_tag, "src")),
+          attrs: figure_container_attrs(img_tag)
+        )
+      end
+    end
+
+    def figure_html(img:, caption:, label:, lang:, count:, classes: ["md-figure"], attrs: "")
+      classes = Array(classes)
+      classes = ["md-figure"] if classes.empty?
+      clean_caption = caption.to_s.strip
+      figcaption = if clean_caption.empty?
+        ""
+      else
+        %(<figcaption class="md-figcaption"><span class="figlabel">#{h(label)} #{count}.</span> #{clean_caption}</figcaption>)
+      end
+
+      <<~HTML.strip
+        <figure id="fig-#{h(lang)}-#{count}" class="#{classes.map { |klass| h(klass) }.join(' ')}"#{attrs}>
+          #{figcaption}
+          <div class="md-figure-inner">#{img}</div>
+        </figure>
+      HTML
+    end
+
+    def figure_classes_for(path)
+      classes = ["md-figure"]
+      classes << "mermaid-figure" if diagram_path?(path)
+      classes
+    end
+
+    def figure_container_attrs(raw)
+      styles = []
+      width = kramdown_attr_value(raw, "data-figure-width-web") || kramdown_attr_value(raw, "data-figure-width")
+      height = kramdown_attr_value(raw, "data-figure-height-web") || kramdown_attr_value(raw, "data-figure-height")
+      unless width.to_s.strip.empty?
+        styles << "--md-figure-width: #{width.strip};"
+        styles << "--md-figure-image-width: 100%;"
+      end
+      styles << "--md-figure-height: #{height.strip};" unless height.to_s.strip.empty?
+      return "" if styles.empty?
+
+      %( style="#{h(styles.join(' '))}")
+    end
+
+    def diagram_path?(path)
+      path.to_s.match?(/\.(?:mmd|mermaid|puml|plantuml|uml)(?:\.edited)?\.svg(?:[?#].*)?\z/i) ||
+        path.to_s.match?(/\.(?:mmd|mermaid|puml|plantuml|uml)(?:[?#].*)?\z/i)
+    end
+
+    def mermaid_path?(path)
+      diagram_path?(path)
+    end
+
+    def render_inline_markdown(text)
+      html = text.to_s.dup
+      code_spans = []
+      html.gsub!(/`([^`\n]+)`/) do
+        index = code_spans.length
+        code_spans << %(<code class="language-plaintext highlighter-rouge">#{h(Regexp.last_match(1))}</code>)
+        "\u0000INLINE_CODE_#{index}\u0000"
+      end
+      math_spans = []
+      html.gsub!(/(^|[^\\$])\$(?!\$)((?:\\.|[^\n$\\])+?)\$(?!\$)/) do
+        index = math_spans.length
+        math_spans << %($#{Regexp.last_match(2)}$)
+        "#{Regexp.last_match(1)}\u0000INLINE_MATH_#{index}\u0000"
+      end
+      html.gsub!(/\[([^\]]+)\]\((\S+?)(?:\s+"([^"]*)")?\)/) do
+        label = Regexp.last_match(1)
+        url = Regexp.last_match(2)
+        title = Regexp.last_match(3)
+        title_attr = title.to_s.empty? ? "" : %( title="#{h(title)}")
+        %(<a href="#{h(url)}"#{title_attr}>#{label}</a>)
+      end
+      html.gsub!(/\*\*([^*]+)\*\*/, '<strong>\1</strong>')
+      html.gsub!(/\*([^*]+)\*/, '<em>\1</em>')
+      math_spans.each_with_index do |math, index|
+        html.gsub!("\u0000INLINE_MATH_#{index}\u0000", math)
+      end
+      code_spans.each_with_index do |code, index|
+        html.gsub!("\u0000INLINE_CODE_#{index}\u0000", code)
+      end
+      html
+    end
+
+    def extract_attr(tag, name)
+      tag[/\b#{Regexp.escape(name)}="([^"]*)"/i, 1] || tag[/\b#{Regexp.escape(name)}='([^']*)'/i, 1]
+    end
+
+    def strip_liquid(value)
+      value.to_s.gsub(/\{%.*?%\}/m, "").gsub(/\{\{.*?\}\}/m, "").strip
+    end
+
+    def h(value)
+      value.to_s.gsub("&", "&amp;").gsub("<", "&lt;").gsub(">", "&gt;").gsub('"', "&quot;")
+    end
+
+    def kramdown_attrs_to_html(raw)
+      return "" if raw.to_s.strip.empty?
+
+      source = raw.to_s.strip.sub(/\A\{:\s*/, "").sub(/\A\{\s*/, "").sub(/\s*\}\z/, "")
+      return "" if source.empty?
+
+      source = source.tr("“”’‘", %q{""''})
+      classes = []
+      id = nil
+      other = []
+      source.scan(/(?:[^\s"']+|"(?:\\.|[^"])*"|'(?:\\.|[^'])*')+/).each do |token|
+        if token.start_with?(".")
+          classes << token[1..]
+        elsif token.start_with?("#")
+          id = token[1..]
+        else
+          other << token
+        end
+      end
+
+      attrs = []
+      attrs << %(id="#{h(id)}") if id && !id.empty?
+      attrs << %(class="#{h(classes.join(" "))}") if classes.any?
+      attrs.concat(other)
+      attrs.join(" ")
+    end
+  end
+end
+
+class UnaltrawebFigureCaptionGenerator < Jekyll::Generator
+  safe true
+  priority :low
+
+  def generate(site)
+    return unless Unaltraweb::FigureCaptions.enabled?(site)
+
+    Unaltraweb::FigureCaptions.collections(site).each do |collection_label|
+      collection = site.collections[collection_label]
+      next unless collection
+
+      collection.docs.each do |doc|
+        lang = Unaltraweb::FigureCaptions.detect_lang(doc)
+        figure_label = Unaltraweb::FigureCaptions.label_for(site, lang)
+        table_label = Unaltraweb::FigureCaptions.table_label_for(site, lang)
+        listing_label = Unaltraweb::FigureCaptions.listing_label_for(site, lang)
+        doc.content = Unaltraweb::FigureCaptions.transform_markdown_sugar(doc.content, lang, figure_label, table_label, listing_label)
+      end
+    end
+  end
+end
+
+Jekyll::Hooks.register :documents, :post_render do |doc|
+  next unless doc.collection && Unaltraweb::FigureCaptions.process_collection?(doc.site, doc.collection.label)
+
+  lang = Unaltraweb::FigureCaptions.detect_lang(doc)
+  label = Unaltraweb::FigureCaptions.label_for(doc.site, lang)
+  doc.output = Unaltraweb::FigureCaptions.wrap_html_images(doc.output, lang, label)
+end
+
+Jekyll::Hooks.register :pages, :pre_render do |page|
+  next unless Unaltraweb::FigureCaptions.process_page?(page)
+
+  lang = Unaltraweb::FigureCaptions.detect_lang(page)
+  figure_label = Unaltraweb::FigureCaptions.label_for(page.site, lang)
+  table_label = Unaltraweb::FigureCaptions.table_label_for(page.site, lang)
+  listing_label = Unaltraweb::FigureCaptions.listing_label_for(page.site, lang)
+  page.content = Unaltraweb::FigureCaptions.transform_markdown_sugar(page.content, lang, figure_label, table_label, listing_label)
+end