metanorma-document 0.5.0 → 0.5.2.pre.alpha.1

data/lib/metanorma/document_collection.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module DocumentCollection
+    autoload :Root, "metanorma/document_collection/root"
+    autoload :Directive, "metanorma/document_collection/directive"
+    autoload :Entry, "metanorma/document_collection/entry"
+    autoload :DocContainer, "metanorma/document_collection/doc_container"
+  end
+end

data/lib/metanorma/html/base_renderer.rb

@@ -13,16 +13,8 @@ module Metanorma
       autoload :PubidRenderer, "metanorma/html/renderers/pubid_renderer"
       autoload :ElementOrderTraversal,
                "metanorma/html/renderers/element_order_traversal"
-    end
-
-    module Concerns
-      autoload :MetadataExtraction,
-               "metanorma/html/concerns/metadata_extraction"
-      autoload :PresentationValidation,
-               "metanorma/html/concerns/presentation_validation"
-      autoload :SvgProcessing, "metanorma/html/concerns/svg_processing"
-      autoload :TextExtraction, "metanorma/html/concerns/text_extraction"
-      autoload :TocRegistry, "metanorma/html/concerns/toc_registry"
+      autoload :SemanticRenderer,
+               "metanorma/html/renderers/semantic_renderer"
     end
 
     class BaseRenderer
@@ -69,7 +61,8 @@ module Metanorma
         end
 
         def register_render(type_class, method_name)
-          render_registry[type_class] = method_name
+          resolved = resolve_type(type_class)
+          render_registry[resolved] = method_name if resolved
         end
 
         def inline_registry
@@ -77,12 +70,32 @@ module Metanorma
         end
 
         def register_inline_render(type_class, method_name)
-          inline_registry[type_class] = method_name
+          resolved = resolve_type(type_class)
+          inline_registry[resolved] = method_name if resolved
+        end
+
+        # type_class may be a Class or a String constant name. String form
+        # requires the owning flavor gem, then resolves; if the gem is not
+        # installed the registration is skipped (that flavor cannot be
+        # rendered in this process anyway).
+        def resolve_type(type_class)
+          return type_class unless type_class.is_a?(String)
+
+          flavor = type_class.split("::")[1].to_s.downcase
+          begin
+            require "metanorma/#{flavor}/document"
+          rescue LoadError
+            nil
+          end
+          Object.const_defined?(type_class) ? Object.const_get(type_class) : nil
         end
       end
 
       attr_reader :inline_renderer, :block_renderer, :section_renderer,
                   :pubid_renderer, :index_term_collector, :footnote_collector
+      # While a table renders: table-scoped <fn>s collect here and lift
+      # into the table's visible footnotes row instead of endnote popups.
+      attr_accessor :table_fn_context
       private :inline_renderer, :block_renderer, :section_renderer,
               :pubid_renderer
 
@@ -109,10 +122,10 @@ module Metanorma
         end
 
         def render_paragraph(...) = @renderer.render_paragraph(...)
-        def render_inline_element(...)= @renderer.render_inline_element(...)
-        def render_unordered_list(...)= @renderer.render_unordered_list(...)
-        def render_ordered_list(...)= @renderer.render_ordered_list(...)
-        def render_definition_list(...)= @renderer.render_definition_list(...)
+        def render_inline_element(...) = @renderer.render_inline_element(...)
+        def render_unordered_list(...) = @renderer.render_unordered_list(...)
+        def render_ordered_list(...) = @renderer.render_ordered_list(...)
+        def render_definition_list(...) = @renderer.render_definition_list(...)
         def render_sourcecode(...)  = @renderer.render_sourcecode(...)
         def render_table(...)       = @renderer.render_table(...)
         def render_figure(...)      = @renderer.render_figure(...)
@@ -120,11 +133,13 @@ module Metanorma
         def render_formula(...)     = @renderer.render_formula(...)
         def render_note(...)        = @renderer.render_note(...)
         def render_image(...)       = @renderer.render_image(...)
-        def render_stem_content(...)= @renderer.render_stem_content(...)
-        def register_figure_entry(...)= @renderer.register_figure_entry(...)
+        def render_stem_content(...) = @renderer.render_stem_content(...)
+        def register_figure_entry(...) = @renderer.register_figure_entry(...)
         def render_note_children(...) = @renderer.render_note_children(...)
         def render_simple_children(...) = @renderer.render_simple_children(...)
+        def render_admonition_children(...) = @renderer.render_admonition_children(...)
         def render_full_block_children(...) = @renderer.render_full_block_children(...)
+        def render_label_paragraph(...) = @renderer.render_label_paragraph(...)
       end
 
       def renderer_context
@@ -134,6 +149,7 @@ module Metanorma
       attr_writer :document, :theme
 
       def generate_full_document(document, theme: nil, **)
+        Metanorma::Html.seed_flavors!
         @document = document
         @theme_override = theme
         validate_presentation_xml!
@@ -182,7 +198,7 @@ module Metanorma
       def flavor_name
         return nil unless defined?(@document) && @document
 
-        Metanorma::Html::Generator.flavors.name_for(@document.class)
+        Metanorma::Core::Flavors.flavor_for(@document)&.name
       end
 
       # Pubid module for the current document's flavor, or nil if the
@@ -190,7 +206,7 @@ module Metanorma
       def pubid_module
         return nil unless defined?(@document) && @document
 
-        Metanorma::Html::Generator.flavors.pubid_module_for(@document.class)
+        Metanorma::Core::Flavors.flavor_for(@document)&.pubid_module_const
       end
 
       def flavor_publishers(_doc_id)
@@ -381,7 +397,7 @@ module Metanorma
                       :render_note
       register_render Metanorma::Document::Components::AncillaryBlocks::ExampleBlock,
                       :render_example
-      register_render Metanorma::StandardDocument::Blocks::Form,
+      register_render "Metanorma::Standoc::Document::Blocks::Form",
                       :render_form
       register_render Metanorma::Document::Components::AncillaryBlocks::SourcecodeBlock,
                       :render_sourcecode
@@ -403,6 +419,12 @@ module Metanorma
                       :render_bookmark
       register_render Metanorma::Document::Components::Inline::SemxElement,
                       :render_semx_content
+      register_render Metanorma::Document::Components::Inline::ColumnbreakElement,
+                      :render_columnbreak
+      register_render Metanorma::Document::Components::AncillaryBlocks::SvgmapElement,
+                      :render_svgmap
+      register_render Metanorma::Document::Components::AncillaryBlocks::ImagemapElement,
+                      :render_imagemap
 
       register_inline_render Metanorma::Document::Components::Inline::EmRawElement,
                              :render_em
@@ -422,14 +444,18 @@ module Metanorma
                              :render_strike
       register_inline_render Metanorma::Document::Components::Inline::BrElement,
                              :render_br
+      register_inline_render Metanorma::Document::Components::TextElements::RubyElement,
+                             :render_ruby
+      register_inline_render Metanorma::Document::Components::Inline::ColumnbreakElement,
+                             :render_columnbreak
       register_inline_render Metanorma::Document::Components::Inline::TabElement,
                              :render_tab
       register_inline_render Metanorma::Document::Components::Inline::LinkElement,
                              :render_link
       register_inline_render Metanorma::Document::Components::Inline::XrefElement,
-                             :render_noop_inline
+                             :render_xref
       register_inline_render Metanorma::Document::Components::Inline::ErefElement,
-                             :render_noop_inline
+                             :render_eref
       register_inline_render Metanorma::Document::Components::Inline::SpanElement,
                              :render_span
       register_inline_render Metanorma::Document::Components::Inline::FnElement,
@@ -437,7 +463,7 @@ module Metanorma
       register_inline_render Metanorma::Document::Components::Inline::ConceptElement,
                              :render_concept
       register_inline_render Metanorma::Document::Components::Inline::StemInlineElement,
-                             :render_noop_inline
+                             :render_stem_inline
       register_inline_render Metanorma::Document::Components::TextElements::StemElement,
                              :render_stem
       register_inline_render Metanorma::Document::Components::Inline::SemxElement,
@@ -448,7 +474,11 @@ module Metanorma
                              :render_fmt_stem
       register_inline_render Metanorma::Document::Components::Inline::CommaElement,
                              :render_comma
-      register_inline_render Metanorma::StandardDocument::Elements::Input,
+      register_inline_render Metanorma::Document::Components::Inline::ReftermElement,
+                             :render_refterm
+      register_inline_render Metanorma::Document::Components::Inline::FmtPreferredElement,
+                             :render_fmt_preferred_inline
+      register_inline_render "Metanorma::Standoc::Document::Elements::Input",
                              :render_input
       register_inline_render Metanorma::Document::Components::Inline::EnumCommaElement,
                              :render_comma
@@ -472,6 +502,8 @@ module Metanorma
       # Grouped here so adding a new transparent wrapper is one entry,
       # not another register_inline_render line. Classes with a more
       # specific handler register themselves above.
+      FN_BLOCK_ATTRS = %i[ul ol table].freeze
+
       TRANSPARENT_INLINE_WRAPPERS = [
         Metanorma::Document::Components::Inline::FmtNameElement,
         Metanorma::Document::Components::Inline::FmtTitleElement,
@@ -513,6 +545,12 @@ module Metanorma
       # through when it appears in block context.
       register_render Metanorma::Document::Components::Inline::FmtXrefLabelElement,
                       :render_block_inline_content
+      # Annotation boundary markers fence an annotated region; they carry
+      # no renderable content of their own at block dispatch.
+      register_render Metanorma::Document::Components::Inline::FmtAnnotationStartElement,
+                      :render_noop
+      register_render Metanorma::Document::Components::Inline::FmtAnnotationEndElement,
+                      :render_noop
 
       def lookup_dispatch(type_class, registry_method)
         # Registry contents are fixed once renderer classes are loaded, so
@@ -540,6 +578,10 @@ module Metanorma
         ""
       end
 
+      def render_columnbreak(*)
+        render_liquid("_columnbreak.html.liquid", {})
+      end
+
       # Block-dispatch entry point for inline content reached as a direct
       # child of a block container (render passes keyword args; the inline
       # pipeline does not accept them).
@@ -558,6 +600,9 @@ module Metanorma
         @inline_renderer.walk_ordered(node, allow_filter: allow_filter, &)
       end
 
+      def footnote_label_text(fn) = @inline_renderer.footnote_label_text(fn)
+      def fn_content_html(fn) = @inline_renderer.fn_content_html(fn)
+
       def render_mixed_inline(node)
         @inline_renderer.render_mixed_inline(node)
       end
@@ -572,11 +617,15 @@ module Metanorma
       def render_underline(el) = @inline_renderer.render_underline(el)
       def render_strike(el) = @inline_renderer.render_strike(el)
       def render_br(*) = @inline_renderer.render_br
+      def render_ruby(el) = @inline_renderer.render_ruby(el)
       def render_tab(*) = @inline_renderer.render_tab
       def render_span(el) = @inline_renderer.render_span(el)
       def render_fn_inline(el) = @inline_renderer.render_fn_inline(el)
       def render_stem(el) = @inline_renderer.render_stem(el)
+      def render_stem_inline(el) = @inline_renderer.render_stem_inline(el)
       def render_semx_inline(el) = @inline_renderer.render_semx_inline(el)
+      def render_refterm(el) = @inline_renderer.render_refterm(el)
+      def render_fmt_preferred_inline(el) = @inline_renderer.render_fmt_preferred_inline(el)
       def render_fmt_xref(el) = @inline_renderer.render_fmt_xref(el)
       def render_comma(*) = @inline_renderer.render_comma
       def render_input(el) = @inline_renderer.render_input(el)
@@ -625,6 +674,16 @@ module Metanorma
         @block_renderer.render_definition_list(dl, **)
       end
 
+      def render_svgmap(svgmap,
+                        **)
+        @block_renderer.render_svgmap(svgmap, **)
+      end
+
+      def render_imagemap(imagemap,
+                          **)
+        @block_renderer.render_imagemap(imagemap, **)
+      end
+
       def render_figure(figure,
 **)
         @block_renderer.render_figure(figure, **)
@@ -668,13 +727,21 @@ module Metanorma
       end
 
       def render_block_children(model,
-children:)
-        @block_renderer.render_block_children(model, children: children)
+children:, **)
+        @block_renderer.render_block_children(model, children: children, **)
       end
 
       def render_note_children(model) = @block_renderer.render_note_children(model)
       def render_simple_children(model) = @block_renderer.render_simple_children(model)
-      def render_full_block_children(model) = @block_renderer.render_full_block_children(model)
+      def render_admonition_children(model) = @block_renderer.render_admonition_children(model)
+
+      def render_full_block_children(model, **)
+        @block_renderer.render_full_block_children(model, **)
+      end
+
+      def render_label_paragraph(content_html, **)
+        @block_renderer.render_label_paragraph(content_html, **)
+      end
 
       # Section rendering delegation
       def render_basic_section(section,
@@ -824,6 +891,16 @@ level = 1)
               render_paragraph(p)
             end.join
           end
+          # Footnotes may carry list/table block children (OIML R 7's
+          # bibliography lives inside footnote 3) — the native aside
+          # renders them, so the end-of-document entry must too.
+          FN_BLOCK_ATTRS.each do |attr|
+            next unless entry.source_fn.respond_to?(attr)
+
+            Array(entry.source_fn.public_send(attr)).each do |block|
+              content_html << (render(block) || "")
+            end
+          end
           Drops::FootnoteDrop.new(entry, content_html)
         end
 

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

@@ -4,37 +4,38 @@ module Metanorma
   module Html
     module Component
       # Collects footnote content encountered during rendering.
-      # Deduplicates by reference letter/number so each footnote definition
-      # appears once, even when referenced from multiple locations.
+      # Deduplicates by footnote definition (target id, falling back to the
+      # fn id/reference) so each definition appears once, even when several
+      # <fn> references with differing reference attrs point at it.
       class FootnoteCollector
         def initialize
           @footnotes = []
-          @ref_map = {}
-          @id_map = {}
+          @entries_by_key = {}
         end
 
-        # Register a footnote and return its sequential number.
-        # Deduplicates by reference: same reference = same footnote number.
-        def register(fn)
+        # Register a footnote and return its FootnoteEntry.
+        # +label_text+ is the fn's presentation autonum label; the first
+        # registration's label wins.
+        def register(fn, label_text: nil)
           fn_id = fn.id || fn.reference.to_s
-          ref = fn.reference.to_s
+          key = fn.respond_to?(:target) && fn.target && !fn.target.empty? ? fn.target : fn_id
 
-          # If we've seen this reference before, reuse its number
-          if @ref_map.key?(ref)
-            return @ref_map[ref]
+          if (seen = @entries_by_key[key])
+            seen.fmt_label ||= label_text
+            return seen
           end
 
-          number = @footnotes.size + 1
-          @ref_map[ref] = number
-          @id_map[fn_id] = number
-          @footnotes << FootnoteEntry.new(
+          entry = FootnoteEntry.new(
             id: fn_id,
-            number: number,
-            reference: ref,
+            number: @footnotes.size + 1,
+            reference: fn.reference.to_s,
             content: fn.p,
-            fmt_label: fn.fmt_fn_label,
+            fmt_label: label_text,
+            source_fn: fn,
           )
-          number
+          @footnotes << entry
+          @entries_by_key[key] = entry
+          entry
         end
 
         def empty?
@@ -51,7 +52,7 @@ module Metanorma
       end
 
       FootnoteEntry = Struct.new(:id, :number, :reference, :content, :fmt_label,
-                                 keyword_init: true)
+                                 :source_fn, keyword_init: true)
     end
   end
 end

data/lib/metanorma/html/concerns/metadata_extraction.rb

@@ -13,8 +13,11 @@ module Metanorma
 
           langs = bibdata.language
           if langs && !langs.empty?
-            lang = langs.find { |l| l.current == "true" } || langs.first
-            lang.value || lang.to_s
+            # Base bibdata carries plain Iso639Code entries (no
+            # `current` marker); flavor bibdata models mark one current.
+            lang = langs.find { |l| l.respond_to?(:current) && l.current == "true" } ||
+              langs.first
+            lang.respond_to?(:value) ? (lang.value || lang.to_s) : lang.to_s
           else
             "en"
           end
@@ -42,7 +45,9 @@ module Metanorma
           bibdata = @document.bibdata
           return nil unless bibdata
 
-          identifiers = bibdata.doc_identifier
+          # Flavor bibdata shapes diverge (e.g. IETF carries no ISO-ish
+          # doc_identifier): no id rather than a method error.
+          identifiers = safe_attr(bibdata, :doc_identifier)
           return nil unless identifiers && !identifiers.empty?
 
           first_id = identifiers.first

data/lib/metanorma/html/concerns/presentation_validation.rb

@@ -20,7 +20,7 @@ module Metanorma
 
         # Name kept for API stability (public renderer API); the boolean
         # return predates the Naming/PredicateMethod convention.
-        # rubocop:disable Naming/PredicateMethod
+        # rubocop:disable-next Naming/PredicateMethod
         def check_presentation_markers(node)
           return false unless node
           return false if node.is_a?(String)
@@ -54,7 +54,6 @@ module Metanorma
 
           false
         end
-        # rubocop:enable Naming/PredicateMethod
       end
     end
   end

data/lib/metanorma/html/concerns/text_extraction.rb

@@ -9,55 +9,171 @@ module Metanorma
       # attributes directly on the model — never strips tags from
       # rendered HTML.
       module TextExtraction
+        # Invisible MathML operators and joiners (word joiner, invisible
+        # times / function application, zero-width space): markup, not
+        # display text.
+        INVISIBLE_MATH_CHARS = "\u2060\u2061\u2062\u2063\u2064\u200b"
+
+        # Rendered fmt-* twins never contribute plain text alongside
+        # their semantic siblings — the pair linearizes one logical
+        # content (#51). Sibling-keyed twins skip only when the
+        # semantic element parsed; the always-skipped set are
+        # whole-block re-renderings (rendered to the exclusion of the
+        # semantic children by the overlay's own contract).
+        RENDERED_TWIN_SIBLING = {
+          "fmt-stem" => :stem,
+          "fmt-eref" => :eref,
+          "fmt-origin" => :origin,
+        }.freeze
+        RENDERED_TWIN_ALWAYS_SKIP = %w[
+          fmt-figure fmt-ul fmt-ol fmt-source fmt-date-inline
+        ].freeze
+
+        # The quoted unitsml(...) macro reference names a unit symbol;
+        # its linear form is the symbol itself ("unitsml(mV/V)" ->
+        # "mV/V"). One nesting level for grouped exponents.
+        UNITSML_MACRO =
+          /"?unitsml\(([^()]*(?:\([^()]*\)[^()]*)*)\)"?/
+
+        # The source linear forms spell operators as words (AsciiMath
+        # "pm", LaTeX "\pm"); extracted display text carries the glyphs.
+        # AsciiMath reserves these tokens as operators, so a bare "pm"
+        # in an expression IS the operator; inside a larger word ("rpm")
+        # the token boundaries hold the mapping off.
+        MATH_OPERATOR_GLYPHS = {
+          asciimath: [[/\bpm\b/, "±"], [/\bmp\b/, "∓"]],
+          latexmath: [[/\\pm\b/, "±"], [/\\mp\b/, "∓"]],
+        }.freeze
+
         def extract_plain_text(node)
           return node.to_s if node.is_a?(String)
           return extract_text_value(node).to_s unless node.is_a?(Lutaml::Model::Serializable)
 
-          parts = []
+          # nil = not a populated stem (e.g. a semx autonum slice also
+          # declares these attributes): fall through to the walk.
+          stem = stem_text(node)
+          return stem unless stem.nil?
+
+          parts = ordered_content_parts(node)
+          if parts.join.strip.empty?
+            t = safe_attr(node, :text)
+            parts << (t.is_a?(Array) ? t.join : t.to_s) if t
+          end
+
+          parts.join.strip.gsub(" ", " ")
+        end
+
+        def ordered_content_parts(node)
+          return [] unless node.element_order.is_a?(Array)
+
           xml_mapping = node.class.mappings_for(:xml, node.lutaml_register)
+          return [] unless xml_mapping
 
-          if node.element_order.is_a?(Array) && xml_mapping
-            element_to_attr =
-              Renderers::ElementOrderTraversal.element_to_attr_map(xml_mapping)
+          element_to_attr =
+            Renderers::ElementOrderTraversal.element_to_attr_map(xml_mapping)
 
-            indices = Hash.new(0)
-            node.element_order.each do |el|
-              next unless el.is_a?(Lutaml::Xml::Element)
+          parts = []
+          indices = Hash.new(0)
+          node.element_order.each do |el|
+            next unless el.is_a?(Lutaml::Xml::Element)
 
-              if el.text?
-                parts << el.text_content.to_s
-              elsif el.name == "tab"
-                parts << " "
-              # rubocop:disable Lint/DuplicateBranch
-              elsif el.name == "br"
+            if el.text?
+              parts << el.text_content.to_s
+            elsif el.name == "tab"
+              parts << " "
+            # rubocop:disable Lint/DuplicateBranch
+            elsif el.name == "br"
+              parts << " "
+            # rubocop:enable Lint/DuplicateBranch
+            elsif el.name == "rt"
+              # ruby annotation (pronunciation) rides along the base
+              # text, it is not content: display text is the base alone
+              next
+            elsif el.element?
+              next if rendered_twin?(el.name, node)
+
+              attr_name = element_to_attr[el.name]
+              if attr_name
+                coll = node.public_send(attr_name)
+                obj = if coll.is_a?(Array)
+                        idx = indices[attr_name]
+                        indices[attr_name] += 1
+                        coll[idx]
+                      else
+                        coll
+                      end
+                text = extract_plain_text(obj)
+                parts << (text.empty? ? " " : text)
+              elsif el.name == "span"
                 parts << " "
-              # rubocop:enable Lint/DuplicateBranch
-              elsif el.element?
-                attr_name = element_to_attr[el.name]
-                if attr_name
-                  coll = node.public_send(attr_name)
-                  obj = if coll.is_a?(Array)
-                          idx = indices[attr_name]
-                          indices[attr_name] += 1
-                          coll[idx]
-                        else
-                          coll
-                        end
-                  text = extract_plain_text(obj)
-                  parts << (text.empty? ? " " : text)
-                elsif el.name == "span"
-                  parts << " "
-                end
               end
             end
           end
+          parts
+        end
 
-          if parts.join.strip.empty?
-            t = safe_attr(node, :text)
-            parts << (t.is_a?(Array) ? t.join : t.to_s) if t
+        # A stem (or a semx slice of one) carries up to three
+        # serializations of a single expression: the AsciiMath source,
+        # the MathML rendering, the LaTeX source. Linearizing more than
+        # one concatenates duplicates — "30003000", 'n LCn_{"LC"}'
+        # (#51). Preference: the source linear form, then the MathML
+        # token walk. Returns nil when no form is populated — the node
+        # is then not stem-shaped content (an empty semx slice), and
+        # the caller falls back to the element_order walk.
+        def stem_text(stem)
+          return nil unless math_carrier?(stem)
+
+          populated = false
+          %i[asciimath math latexmath].each do |form|
+            value = safe_attr(stem, form)
+            next if value.nil? || (value.respond_to?(:empty?) && value.empty?)
+
+            populated = true
+            text = if form == :math
+                     Array(value).map { |m| extract_plain_text(m) }.join(" ")
+                   else
+                     display_math_text(extract_text_value(value), form)
+                   end
+            text = normalize_math_text(text)
+            return text unless text.empty?
           end
+          populated ? "" : nil
+        end
 
-          parts.join.strip.gsub(" ", " ")
+        def display_math_text(text, form)
+          MATH_OPERATOR_GLYPHS.fetch(form, []).reduce(text.to_s) do |acc, (pattern, glyph)|
+            acc.gsub(pattern, glyph)
+          end
+        end
+
+        # Duck-typed stem check: any model declaring both an asciimath
+        # and a math attribute serializes one expression in multiple
+        # forms (StemInlineElement, StemElement, SemxElement).
+        def math_carrier?(node)
+          attrs = node.class.attributes
+          attrs.key?(:asciimath) && attrs.key?(:math)
+        end
+
+        def rendered_twin?(name, node)
+          return true if RENDERED_TWIN_ALWAYS_SKIP.include?(name)
+
+          sibling = RENDERED_TWIN_SIBLING[name] or return false
+
+          values = safe_attr(node, sibling)
+          siblings = Array(values).compact
+          return false if siblings.empty?
+
+          # The semantic form is authoritative when it carries text; an
+          # empty semantic element defers its label to the rendered
+          # twin (the overlay resolves empty erefs into fmt-eref).
+          siblings.any? { |s| !extract_plain_text(s).to_s.strip.empty? }
+        end
+
+        def normalize_math_text(text)
+          text.to_s
+            .tr(INVISIBLE_MATH_CHARS, "")
+            .gsub(UNITSML_MACRO) { Regexp.last_match(1) }
+            .strip
         end
 
         def extract_text_value(val)
@@ -79,7 +195,10 @@ module Metanorma
                 if v
                   extract_text_value(v)
                 else
-                  val.to_s
+                  # NEVER fall back to val.to_s here: Serializable#to_s
+                  # serializes the whole XML subtree, which over large
+                  # documents costs quadratic time and memory.
+                  extract_plain_text(val) || ""
                 end
               end
             end

data/lib/metanorma/html/concerns.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Html
+    # Renderer concerns. Lives in its own file so any consumer (the
+    # model layer's PlainText extractor includes TextExtraction) can
+    # resolve it through the html.rb autoload — independent of whether
+    # BaseRenderer has loaded yet.
+    module Concerns
+      autoload :MetadataExtraction,
+               "metanorma/html/concerns/metadata_extraction"
+      autoload :PresentationValidation,
+               "metanorma/html/concerns/presentation_validation"
+      autoload :SvgProcessing, "metanorma/html/concerns/svg_processing"
+      autoload :TextExtraction, "metanorma/html/concerns/text_extraction"
+      autoload :TocRegistry, "metanorma/html/concerns/toc_registry"
+    end
+  end
+end

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

@@ -8,7 +8,7 @@ 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.render_admonition_children(admonition) || ""
 
           new(
             id: id,