metanorma-document 0.2.12 → 0.2.13

data/lib/metanorma/html/bipm_renderer.rb

@@ -2,22 +2,151 @@
 
 module Metanorma
   module Html
+    # Renders BipmDocument components to HTML.
+    # Extends IsoRenderer with BIPM-specific branding (institutional navy, scientific precision).
     class BipmRenderer < IsoRenderer
-      register_render Metanorma::BipmDocument::Root, :render_document
-      register_render Metanorma::StandardDocument::Sections::Preface,
-                      :render_preface
-      register_render Metanorma::StandardDocument::Sections::ClauseSection,
-                      :render_clause
-      register_render Metanorma::StandardDocument::Sections::AnnexSection,
-                      :render_annex
-      register_render Metanorma::StandardDocument::Sections::ContentSection,
-                      :render_clause
-      register_render Metanorma::StandardDocument::Sections::TermsSection,
-                      :render_terms_section
-      register_render Metanorma::StandardDocument::Sections::BibliographySection,
-                      :render_clause
-      register_render Metanorma::StandardDocument::Sections::DefinitionSection,
-                      :render_clause
+      def flavor_publishers(_doc_id)
+        ["BIPM"]
+      end
+
+      def flavor_publisher_name
+        "BIPM"
+      end
+
+      def publisher_logo_map
+        { "BIPM" => "bipm-logo.svg" }
+      end
+
+      # Strip redundant publisher prefix from doc identifiers.
+      # XML has "BIPM BIPM-2015/02" but we already show the BIPM logo.
+      def clean_doc_id(raw_id)
+        raw_id.to_s.gsub(/\ABIPM\s+/, "").strip
+      end
+
+      # BIPM logo: white fill for dark header
+      def load_logo_svg(filename, **opts)
+        svg = super
+        svg = svg.gsub("fill:#0f3c80", "fill:white") if svg
+        svg
+      end
+
+      # Strip BIPM prefix from doc IDs shown in header
+      def extract_primary_doc_id
+        raw = super
+        clean_doc_id(raw)
+      end
+
+      # Override cover page to show clean doc ID (without redundant "BIPM " prefix)
+      def render_coverpage(doc)
+        bibdata = doc.bibdata
+        return unless bibdata
+
+        @output << "<div class=\"title-section\">"
+        @output << "<div class=\"cover-grid\">"
+        @output << "<div class=\"cover-meta\">"
+
+        # Publisher logos
+        logos = publisher_logos_html(doc)
+        if logos && !logos.empty?
+          @output << "<div class=\"cover-publishers\">"
+          logos.each do |svg|
+            @output << "<span class=\"cover-logo\">#{svg}</span>"
+          end
+          @output << "</div>"
+        end
+
+        identifiers = Array(bibdata.doc_identifier).compact
+        cover_ids = identifiers.select do |di|
+          safe_attr(di, :type) == "iso-reference"
+        end
+        cover_ids = [identifiers.first].compact if cover_ids.empty?
+
+        cover_ids.each do |di|
+          id = clean_doc_id(extract_text_value(di))
+          next if id.to_s.empty?
+
+          @output << "<p class=\"cover-doc-id\">#{escape_html(id)}</p>"
+        end
+
+        bibdata.date&.each do |date|
+          date_type = extract_text_value(safe_attr(date,
+                                                   :type_attr) || safe_attr(
+                                                     date, :type
+                                                   ))
+          date_val = extract_text_value(date.is_a?(Metanorma::Document::Relaton::BibliographicDate) ? date.on : safe_attr(
+            date, :text
+          ))
+          if date_type == "published" && date_val
+            @output << "<p class=\"cover-date\">#{escape_html(date_val)}</p>"
+          end
+        end
+
+        @output << "</div>"
+        @output << "<div class=\"cover-body\">"
+
+        title_text = extract_display_title(bibdata)
+        if title_text && !title_text.empty?
+          @output << "<div class=\"cover-title\"><span>#{escape_html(title_text)}</span></div>"
+        end
+
+        if bibdata.status&.stage
+          stages = Array(bibdata.status.stage)
+          stage_text = stages.map { |s| Array(s.value).join }.join(" ")
+          unless stage_text.empty?
+            @output << "<div class=\"cover-stage\"><p>#{escape_html(stage_text)}</p></div>"
+          end
+        end
+
+        @output << "</div>"
+        @output << "</div>"
+        @output << "</div><hr class=\"cover-separator\" />"
+      end
+
+      def theme
+        @theme ||= Theme.new.tap do |t|
+          t.primary        = "#0f3c80"
+          t.accent         = "#3d7ec7"
+          t.accent_deep    = "#1a5a9e"
+          t.gradient       = "linear-gradient(135deg, #082247 0%, #0f3c80 50%, #1a5a9e 100%)"
+          t.primary_light  = "#edf1f7"
+          t.accent_light   = "#e8f0fa"
+          t.warm           = "#7a6952"
+          t.warm_light     = "#f5f0e8"
+          t.sidebar_bg     = "#f4f6fa"
+          t.font_body      = '"Crimson Pro", "Georgia", "Times New Roman", serif'
+          t.font_sans      = '"IBM Plex Sans", "Helvetica Neue", Arial, sans-serif'
+          t.font_mono      = '"IBM Plex Mono", "Fira Code", "Courier New", monospace'
+          t.font_url       = "https://fonts.googleapis.com/css2?family=Crimson+Pro:ital,wght@0,300;0,400;0,500;0,600;0,700;1,400&family=IBM+Plex+Sans:ital,wght@0,400;0,500;0,600;0,700;1,400&family=IBM+Plex+Mono:wght@400;500&display=swap"
+          t.header_background = "linear-gradient(135deg, #082247 0%, #0f3c80 50%, #1a5a9e 100%)"
+          t.cover_background  = "linear-gradient(175deg, #04122a 0%, #0a2e5c 25%, #0f3c80 55%, #1a5a9e 80%, #3d7ec7 100%)"
+          t.cover_before_bg   = "background: radial-gradient(ellipse at 25% 15%, rgba(61,126,199,0.15) 0%, transparent 50%), radial-gradient(ellipse at 75% 85%, rgba(15,60,128,0.18) 0%, transparent 40%), radial-gradient(circle at 50% 50%, rgba(255,255,255,0.02) 0%, transparent 70%)"
+          t.cover_after_bg    = "height: 3px; background: linear-gradient(90deg, transparent, #3d7ec7 20%, #0f3c80 50%, #3d7ec7 80%, transparent)"
+          t.progress_bar_color = "#3d7ec7"
+          t.note_border     = "#3d7ec7"
+          t.note_bg         = "#edf1f7"
+          t.note_color      = "#3d7ec7"
+          t.example_border  = "#0f3c80"
+          t.example_bg      = "#f5f0e8"
+          t.example_color   = "#7a6952"
+          t.admonition_border = "#7a6952"
+          t.admonition_bg = "#f5f0e8"
+          t.admonition_color = "#7a6952"
+          t.footer_border_color = "#3d7ec7"
+          t.cover_separator_color = "rgba(61,126,199,0.25)"
+          t.dark_note_bg    = "#0d1520"
+          t.dark_example_bg = "#14100e"
+          t.dark_admonition_bg = "#141210"
+          t.extra_css = <<~CSS
+            .sourcecode pre { background: #0a1628; border-color: #1a2d4a; }
+            .reading-progress { box-shadow: 0 0 10px rgba(61,126,199,0.4); }
+            mark.search-match { background: #edf1f7; box-shadow: 0 0 0 1px rgba(15,60,128,0.25); }
+            mark.search-match.search-current { background: #3d7ec7; color: #fff; }
+            [data-theme="dark"] .sourcecode pre { background: #060a14; border-color: #1a2040; }
+            [data-theme="dark"] mark.search-match { background: #0d1a30; box-shadow: 0 0 0 1px rgba(61,126,199,0.4); }
+            [data-theme="dark"] mark.search-match.search-current { background: #1a5a9e; }
+          CSS
+        end
+      end
     end
   end
 end

data/lib/metanorma/html/cc_renderer.rb

@@ -2,8 +2,52 @@
 
 module Metanorma
   module Html
+    # Renders CcDocument (CalConnect) components to HTML.
+    # Extends IsoRenderer with CalConnect branding.
     class CcRenderer < IsoRenderer
-      register_render Metanorma::CcDocument::Root, :render_document
+      def flavor_publishers(_doc_id)
+        ["CalConnect"]
+      end
+
+      def flavor_publisher_name
+        "CalConnect"
+      end
+
+      def publisher_logo_map
+        {}
+      end
+
+      def theme
+        @theme ||= Theme.new.tap do |t|
+          t.font_body      = '"Lora", "Georgia", serif'
+          t.font_sans      = '"Karla", "Helvetica Neue", Arial, sans-serif'
+          t.font_mono      = '"JetBrains Mono", "Fira Code", monospace'
+          t.font_url       = "https://fonts.googleapis.com/css2?family=Lora:ital,wght@0,400;0,500;0,600;0,700;1,400&family=Karla:wght@400;500;600;700&family=JetBrains+Mono:wght@400;500&display=swap"
+          t.primary        = "#003d7c"
+          t.accent         = "#0078d4"
+          t.accent_deep    = "#005fa3"
+          t.gradient       = "linear-gradient(135deg, #002244 0%, #003d7c 50%, #0078d4 100%)"
+          t.primary_light  = "#edf3fa"
+          t.accent_light   = "#e0effc"
+          t.warm           = "#c9982e"
+          t.warm_light     = "#fdf8ec"
+          t.header_background = "linear-gradient(135deg, #002244 0%, #003d7c 50%, #0078d4 100%)"
+          t.cover_background  = "linear-gradient(175deg, #001a33 0%, #003d7c 40%, #0078d4 80%, #0092d6 100%)"
+          t.cover_before_bg   = "background: radial-gradient(ellipse at 25% 15%, rgba(0,120,212,0.2) 0%, transparent 50%), radial-gradient(ellipse at 75% 85%, rgba(201,152,46,0.15) 0%, transparent 40%)"
+          t.cover_after_bg    = "height: 3px; background: linear-gradient(90deg, transparent, #c9982e, transparent)"
+          t.progress_bar_color = "#0078d4"
+          t.note_border     = "#0078d4"
+          t.note_bg         = "#e0effc"
+          t.note_color      = "#0078d4"
+          t.example_border  = "#003d7c"
+          t.example_bg      = "#edf3fa"
+          t.example_color   = "#003d7c"
+          t.admonition_border = "#c9982e"
+          t.admonition_color  = "#c9982e"
+          t.footer_border_color = "#0078d4"
+          t.cover_separator_color = "rgba(0,120,212,0.25)"
+        end
+      end
     end
   end
 end

data/lib/metanorma/html/component/base.rb

@@ -38,6 +38,11 @@ module Metanorma
           raise NotImplementedError, "#{self.class}#render not implemented"
         end
 
+        def output
+          renderer.instance_variable_get(:@output)
+        end
+
+        def tag(...) = renderer.tag(...)
         def escape_html(...) = renderer.escape_html(...)
         def render_mixed_inline(...) = renderer.render_mixed_inline(...)
         def render_mixed_content_in_order(...) = renderer.render_mixed_content_in_order(...)
@@ -45,9 +50,9 @@ module Metanorma
         def safe_attr(obj, method_name) = renderer.safe_attr(obj, method_name)
         def extract_plain_text(node) = renderer.extract_plain_text(node)
         def extract_text_value(val) = renderer.extract_text_value(val)
-        def render_liquid(...) = renderer.render_liquid(...)
 
-        def extract_block_label(block, default)
+        def extract_block_label(block,
+default)
           renderer.extract_block_label(block, default)
         end
 

data/lib/metanorma/html/component/index_section.rb

@@ -7,28 +7,24 @@ module Metanorma
         def render(collector, **_opts)
           return if collector.nil? || collector.empty?
 
-          quicknav = render_quicknav(collector.sorted_groups)
-          letter_groups = render_letter_groups(collector.sorted_groups)
-          content = quicknav + letter_groups
-
-          attrs = %( id="index" class="index-section" data-component="index")
-          index_html = render_liquid("_element.html.liquid", "tag" => "div",
-                                                             "extra_attrs" => attrs, "content" => content)
+          output << tag(:div,
+                        %( id="index" class="index-section" data-component="index")) do
+            html = tag(:h2) { "Index" }
+            html << render_quicknav(collector.sorted_groups)
+            html << render_letter_groups(collector.sorted_groups)
+            html
+          end
 
           renderer.register_toc_entry(id: "index", level: 1, text: "Index")
-          index_html
         end
 
         private
 
         def render_quicknav(groups)
           links = groups.filter_map do |g|
-            letter = escape_html(g.letter)
-            render_liquid("_link.html.liquid",
-                          "attrs" => %( href="#index-letter-#{letter}"), "display_text" => letter)
+            %(<a href="#index-letter-#{escape_html(g.letter)}">#{escape_html(g.letter)}</a>)
           end.join
-          render_liquid("_element.html.liquid", "tag" => "div",
-                                                "extra_attrs" => " class=\"index-quicknav\"", "content" => links)
+          %(<div class="index-quicknav">#{links}</div>)
         end
 
         def render_letter_groups(groups)
@@ -36,48 +32,54 @@ module Metanorma
         end
 
         def render_letter_group(group)
-          letter = escape_html(group.letter)
-          heading = render_liquid("_heading.html.liquid", "tag" => "h3",
-                                                          "class_attr" => " class=\"index-letter\"", "content" => letter)
-          entries = group.entries.map { |e| render_entry(e, "primary") }.join
-          render_liquid("_element.html.liquid", "tag" => "div",
-                                                "extra_attrs" => %( class="index-letter-group" id="index-letter-#{letter}"), "content" => "#{heading}#{entries}")
+          tag(:div,
+              %( class="index-letter-group" id="index-letter-#{escape_html(group.letter)}")) do
+            html = tag(:h3, %( class="index-letter")) { group.letter }
+            html << group.entries.map { |e| render_entry(e, "primary") }.join
+            html
+          end
         end
 
         def render_entry(entry, level)
-          term_html = render_liquid("_element.html.liquid", "tag" => "span",
-                                                            "extra_attrs" => " class=\"index-term\"", "content" => escape_html(entry.term))
-          locators_html = render_locators(entry.locators)
-          inner = term_html + locators_html
-          inner << render_see(entry.see) if entry.see
-          inner << render_see_also(entry.see_also_entries) unless entry.see_also_entries.empty?
-          unless entry.children.empty?
-            inner << entry.children.map { |c|
-              render_entry(c, next_level(level))
-            }.join
+          tag(:div, %( class="index-entry index-entry--#{level}")) do
+            html = +""
+            html << tag(:span, %( class="index-term")) do
+              escape_html(entry.term)
+            end
+            html << render_locators(entry.locators)
+            html << render_see(entry.see) if entry.see
+            html << render_see_also(entry.see_also_entries) unless entry.see_also_entries.empty?
+            unless entry.children.empty?
+              html << entry.children.map { |c|
+                render_entry(c, next_level(level))
+              }.join
+            end
+            html
           end
-          render_liquid("_element.html.liquid", "tag" => "div",
-                                                "extra_attrs" => %( class="index-entry index-entry--#{level}"), "content" => inner)
         end
 
         def render_locators(locators)
           links = locators.map do |loc|
-            render_liquid("_link.html.liquid",
-                          "attrs" => %( href="##{escape_html(loc.id)}"), "display_text" => escape_html(loc.text))
-          end.join(", ")
-          render_liquid("_element.html.liquid", "tag" => "span",
-                                                "extra_attrs" => " class=\"index-locator\"", "content" => links)
+            tag(:a, %( href="##{escape_html(loc.id)}")) do
+              escape_html(loc.text)
+            end
+          end
+          tag(:span, %( class="index-locator")) { links.join(", ") }
         end
 
         def render_see(term)
-          render_liquid("_element.html.liquid", "tag" => "div",
-                                                "extra_attrs" => " class=\"index-see\"", "content" => "<em>see</em> #{escape_html(term)}")
+          tag(:div, %( class="index-see")) do
+            "<em>see</em> #{escape_html(term)}"
+          end
         end
 
         def render_see_also(terms)
-          text = terms.map { |t| escape_html(t) }.join(", ")
-          render_liquid("_element.html.liquid", "tag" => "div",
-                                                "extra_attrs" => " class=\"index-see-also\"", "content" => "<em>see also</em> #{text}")
+          tag(:div,
+              %( class="index-see-also")) do
+            "<em>see also</em> #{terms.map do |t|
+              escape_html(t)
+            end.join(', ')}"
+          end
         end
 
         def next_level(level)

data/lib/metanorma/html/drops/admonition_drop.rb

@@ -8,7 +8,10 @@ module Metanorma
           type = renderer.safe_attr(admonition, :type) || "note"
           id = renderer.safe_attr(admonition, :id)
 
-          content_html = renderer.render_simple_children(admonition) || ""
+          content_html = renderer.capture_output do
+            renderer.render_block_children(admonition,
+                                           children: BaseRenderer::SIMPLE_CHILDREN)
+          end
 
           new(
             id: id,

data/lib/metanorma/html/drops/block_element_drop.rb

@@ -6,13 +6,8 @@ module Metanorma
       class BlockElementDrop < Liquid::Drop
         attr_reader :id, :type, :label_html, :content_html, :css_class
 
-        def initialize(id: nil, type: nil, label_html: nil, content_html: nil,
-css_class: nil)
-          @id = id
-          @type = type
-          @label_html = label_html
-          @content_html = content_html
-          @css_class = css_class
+        def initialize(attrs = {})
+          attrs.each { |k, v| instance_variable_set(:"@#{k}", v) }
         end
 
         # Subclasses override to build from model + RendererContext

data/lib/metanorma/html/drops/example_drop.rb

@@ -8,7 +8,10 @@ module Metanorma
           id = renderer.safe_attr(example, :id)
           label = renderer.extract_block_label(example, "EXAMPLE")
 
-          content_html = renderer.render_full_block_children(example) || ""
+          content_html = renderer.capture_output do
+            renderer.render_block_children(example,
+                                           children: BaseRenderer::BLOCK_CHILDREN)
+          end
 
           new(
             id: id,

data/lib/metanorma/html/drops/figure_drop.rb

@@ -6,16 +6,6 @@ module Metanorma
       class FigureDrop < BlockElementDrop
         attr_reader :image_html, :caption_html, :key_html, :sub_figures_html
 
-        def initialize(id: nil, image_html: nil, caption_html: nil, key_html: nil,
-                       sub_figures_html: nil, css_class: nil)
-          @id = id
-          @image_html = image_html
-          @caption_html = caption_html
-          @key_html = key_html
-          @sub_figures_html = sub_figures_html
-          @css_class = css_class
-        end
-
         def self.from_model(figure, renderer:)
           id = renderer.safe_attr(figure, :id)
           fig_name = renderer.safe_attr(figure,
@@ -27,34 +17,35 @@ module Metanorma
                                            text: renderer.extract_plain_text(fig_name))
           end
 
-          image_html = if figure.image
-                         renderer.render_image(figure.image)
-                       elsif renderer.safe_attr(figure, :source)
-                         src = renderer.safe_attr(figure, :source)
-                         renderer.render_liquid("_image.html.liquid",
-                                                "attrs" => %( src="#{renderer.escape_html(src)}"))
-                       end
+          image_html = renderer.capture_output do
+            if figure.image
+              renderer.render_image(figure.image)
+            elsif renderer.safe_attr(figure, :source)
+              src = renderer.safe_attr(figure, :source)
+              @output << %(<img src="#{renderer.escape_html(src)}" />)
+            end
+          end
 
           caption_html = if fig_name || renderer.safe_attr(figure, :name)
-                           el = renderer.safe_attr(figure,
-                                                   :fmt_name) || figure.name
-                           renderer.render_inline_element(el)
+                           renderer.capture_output do
+                             el = renderer.safe_attr(figure,
+                                                     :fmt_name) || figure.name
+                             renderer.render_inline_element(el)
+                           end
                          end
 
-          sub_figures_parts = []
-          figure.figure&.each do |sub|
-            sub_figures_parts << (renderer.render_figure(sub) || "")
+          sub_figures_html = renderer.capture_output do
+            figure.figure&.each { |sub| renderer.render_figure(sub) }
           end
-          sub_figures_html = sub_figures_parts.join
 
-          key_parts = []
-          renderer.safe_attr(figure, :note)&.each do |n|
-            key_parts << (renderer.render_note(n) || "")
-          end
-          renderer.safe_attr(figure, :dl)&.then do |dl|
-            key_parts << (renderer.render_definition_list(dl) || "")
+          key_html = renderer.capture_output do
+            renderer.safe_attr(figure, :note)&.each do |n|
+              renderer.render_note(n)
+            end
+            renderer.safe_attr(figure, :dl)&.then do |dl|
+              renderer.render_definition_list(dl)
+            end
           end
-          key_html = key_parts.join
 
           new(
             id: id,

data/lib/metanorma/html/drops/footnote_drop.rb

@@ -13,7 +13,7 @@ module Metanorma
           @entry.number
         end
 
-        def label
+        def reference
           @entry.reference
         end
 

data/lib/metanorma/html/drops/formula_drop.rb

@@ -4,74 +4,45 @@ module Metanorma
   module Html
     module Drops
       class FormulaDrop < BlockElementDrop
-        attr_reader :stem_html, :where_html, :where_label, :number_html
-
-        def initialize(id: nil, stem_html: nil, where_html: nil, where_label: nil,
-                       number_html: nil, css_class: nil)
-          @id = id
-          @stem_html = stem_html
-          @where_html = where_html
-          @where_label = where_label
-          @number_html = number_html
-          @css_class = css_class
-        end
+        attr_reader :stem_html, :where_html, :number_html
 
         def self.from_model(formula, renderer:)
           id = renderer.safe_attr(formula, :id)
 
-          stem_html = if formula.stem
-                        renderer.render_stem_content(formula.stem)
-                      end
-
-          where_parts = []
-          if formula.key
-            if formula.key.dl
-              where_parts << (renderer.render_definition_list(formula.key.dl) || "")
-            end
-            formula.key.p&.each do |para|
-              where_parts << (renderer.render_paragraph(para) || "")
-            end
-          end
-          formula.dl&.then do |dl|
-            where_parts << (renderer.render_definition_list(dl) || "")
+          stem_html = renderer.capture_output do
+            renderer.render_stem_content(formula.stem) if formula.stem
           end
-          formula.p&.each do |para|
-            next if renderer.safe_attr(para, :keep_with_next)
 
-            where_parts << (renderer.render_paragraph(para) || "")
+          where_html = renderer.capture_output do
+            if formula.key
+              if formula.key.dl
+                @output = renderer.capture_output {}
+                # "where" label rendered in template, just render the dl
+                renderer.render_definition_list(formula.key.dl)
+              end
+              formula.key.p&.each { |para| renderer.render_paragraph(para) }
+            end
+            formula.dl&.then { |dl| renderer.render_definition_list(dl) }
           end
-          where_html = where_parts.join
-
-          needs_where_label = !formula.key.nil? || !formula.dl.nil? ||
-            has_where_paragraph?(formula, renderer)
 
           name_el = renderer.safe_attr(formula,
                                        :fmt_name) || renderer.safe_attr(
                                          formula, :name
                                        )
           number_html = if name_el
-                          renderer.render_inline_element(name_el)
+                          renderer.capture_output do
+                            renderer.render_inline_element(name_el)
+                          end
                         end
 
           new(
             id: id,
             stem_html: stem_html,
             where_html: where_html,
-            where_label: needs_where_label,
             number_html: number_html,
             css_class: "formula",
           )
         end
-
-        class << self
-          private
-
-          def has_where_paragraph?(formula, renderer)
-            Array(formula.p).any? do |para|
-              renderer.safe_attr(para, :keep_with_next)
-            end
-          end
-        end
       end
     end
   end

data/lib/metanorma/html/drops/note_drop.rb

@@ -8,17 +8,15 @@ module Metanorma
           id = renderer.safe_attr(note, :id)
           label = renderer.extract_block_label(note, "NOTE")
 
-          content_parts = []
-          if note.content && !note.content.empty?
-            note.content.each do |para|
-              content_parts << (renderer.render_paragraph(para) || "")
+          content_html = renderer.capture_output do
+            if note.content && !note.content.empty?
+              note.content.each { |para| renderer.render_paragraph(para) }
+            else
+              renderer.render_mixed_inline(note)
             end
-          else
-            inline = renderer.render_mixed_inline(note)
-            content_parts << inline if inline
+            renderer.render_block_children(note,
+                                           children: BaseRenderer::NOTE_CHILDREN)
           end
-          content_parts << (renderer.render_note_children(note) || "")
-          content_html = content_parts.join
 
           new(
             id: id,

data/lib/metanorma/html/drops/sourcecode_drop.rb

@@ -6,27 +6,20 @@ module Metanorma
       class SourcecodeDrop < BlockElementDrop
         attr_reader :lang, :name_html, :code_html
 
-        def initialize(id: nil, lang: nil, name_html: nil, code_html: nil,
-css_class: nil)
-          @id = id
-          @lang = lang
-          @name_html = name_html
-          @code_html = code_html
-          @css_class = css_class
-        end
-
         def self.from_model(sc, renderer:)
           id = renderer.safe_attr(sc, :id)
           lang = renderer.safe_attr(sc, :lang)
 
           name_html = if sc.name
-                        renderer.render_inline_element(sc.name)
+                        renderer.capture_output do
+                          renderer.render_inline_element(sc.name)
+                        end
                       end
 
           code_text = if sc.body&.content
-                        Array(sc.body.content).join
+                        sc.body.content
                       elsif sc.content
-                        Array(sc.content).join
+                        sc.content
                       else
                         ""
                       end

data/lib/metanorma/html/drops.rb

@@ -14,8 +14,6 @@ module Metanorma
       autoload :TocEntryDrop, "metanorma/html/drops/toc_entry_drop"
       autoload :FigureListEntryDrop,
                "metanorma/html/drops/figure_list_entry_drop"
-      autoload :BiblioEntryDrop,
-               "metanorma/html/drops/biblio_entry_drop"
     end
   end
 end