metanorma-standoc 2.1.5 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9487b5701cc86946c27e560e244cc4f84fceb61b0a93dd271068875654eb49a0
-  data.tar.gz: c647cf6fb530aba3bc96c9087e7a9d49408ce239a6c6aa3a4a46a0e8cf1a5763
+  metadata.gz: 2d1015766df2dd6accbfd8de285d762403a1d874fcac93a3d6829055602f2904
+  data.tar.gz: b185321cbbbcb6de4bfb9cea996dec314e585f54fbdf7baf31fcce616be60ef5
 SHA512:
-  metadata.gz: c8356539be6d28f5dc6d4d148cfcabb8ed7dbc033392544d382d36e1e392e33da6b29a64b535f6c24cdab85a4d17d1dc5698367f0edff8f45eb02b1f8ed97330
-  data.tar.gz: 13c49550edea0d6169fef67357a5030e146cdf62fec3cb41900db7490d95c09f9dbb1c4f4b55bea4836651ba11fcaf0714b20f37fc3a96a48dd31596cf564549
+  metadata.gz: 9aa957125f263ab18defd53ff0086519c43de991346bbf1775ae10907a9a06e551b3b3ddc5bf078dc968f6cbbfb863f6690643d093ad8d29b22f490815e745cc
+  data.tar.gz: d687658d8b5d8e6194655f3e40605d9f5e610c599631e5bf13de586daaeefa0f57a22614884e71321abdc248f55dd42113fdc068e4ceb296cc88102f27db6acf

data/lib/metanorma/standoc/base.rb

@@ -50,6 +50,7 @@ module Metanorma
         @index_terms = node.attr("index-terms")
         @boilerplateauthority = node.attr("boilerplate-authority")
         @embed_hdr = node.attr("embed_hdr")
+        @document_scheme = node.attr("document-scheme")
       end
 
       def init_processing(node)

data/lib/metanorma/standoc/blocks.rb

@@ -238,11 +238,10 @@ module Metanorma
       end
 
       def pass(node)
-        c = HTMLEntities.new
         noko do |xml|
           xml.passthrough **attr_code(formats:
                                       node.attr("format") || "metanorma") do |p|
-            p << c.encode(c.decode(node.content), :basic, :hexadecimal)
+            p << @c.encode(@c.decode(node.content), :basic, :hexadecimal)
           end
         end
       end

data/lib/metanorma/standoc/cleanup.rb

@@ -5,7 +5,7 @@ require_relative "./cleanup_block"
 require_relative "./cleanup_table"
 require_relative "./cleanup_footnotes"
 require_relative "./cleanup_ref"
-require_relative "./cleanup_ref_dl"
+require_relative "./cleanup_biblio"
 require_relative "./cleanup_boilerplate"
 require_relative "./cleanup_section"
 require_relative "./cleanup_terms"

data/lib/metanorma/standoc/cleanup_biblio.rb

@@ -0,0 +1,204 @@
+require "set"
+require "relaton_bib"
+
+module Metanorma
+  module Standoc
+    module Cleanup
+      def ref_dl_cleanup(xmldoc)
+        xmldoc.xpath("//clause[@bibitem = 'true']").each do |c|
+          bib = dl_bib_extract(c) or next
+          validate_ref_dl(bib, c)
+          bibitemxml = RelatonBib::BibliographicItem.from_hash(bib).to_xml or next
+          bibitem = Nokogiri::XML(bibitemxml)
+          bibitem.root["id"] = c["id"] if c["id"] && !/^_/.match(c["id"])
+          c.replace(bibitem.root)
+        end
+      end
+
+      # do not accept implicit id
+      def validate_ref_dl(bib, clause)
+        id = bib["id"]
+        id ||= clause["id"] unless /^_/.match?(clause["id"])
+        unless id
+          @log.add("Anchors", clause,
+                   "The following reference is missing an anchor:\n"\
+                   "#{clause.to_xml}")
+          return
+        end
+        @refids << id
+        validate_ref_dl1(bib, id, clause)
+      end
+
+      def validate_ref_dl1(bib, id, clause)
+        bib["title"] or
+          @log.add("Bibliography", clause, "Reference #{id} is missing a title")
+        bib["docid"] or
+          @log.add("Bibliography", clause,
+                   "Reference #{id} is missing a document identifier (docid)")
+      end
+
+      def extract_from_p(tag, bib, key)
+        return unless bib[tag]
+
+        "<#{key}>#{bib[tag].at('p').children}</#{key}>"
+      end
+
+      # if the content is a single paragraph, replace it with its children
+      # single links replaced with uri
+      def p_unwrap(para)
+        elems = para.elements
+        if elems.size == 1 && elems[0].name == "p"
+          link_unwrap(elems[0]).children.to_xml.strip
+        else
+          para.to_xml.strip
+        end
+      end
+
+      def link_unwrap(para)
+        elems = para.elements
+        if elems.size == 1 && elems[0].name == "link"
+          para.at("./link").replace(elems[0]["target"].strip)
+        end
+        para
+      end
+
+      def dd_bib_extract(dtd)
+        return nil if dtd.children.empty?
+
+        dtd.at("./dl") and return dl_bib_extract(dtd)
+        elems = dtd.remove.elements
+        return p_unwrap(dtd) unless elems.size == 1 &&
+          %w(ol ul).include?(elems[0].name)
+
+        elems[0].xpath("./li").each_with_object([]) do |li, ret|
+          ret << p_unwrap(li)
+        end
+      end
+
+      def add_to_hash(bib, key, val)
+        Metanorma::Utils::set_nested_value(bib, key.split("."), val)
+      end
+
+      # definition list, with at most one level of unordered lists
+      def dl_bib_extract(clause, nested = false)
+        dl = clause.at("./dl") or return
+        key = ""
+        bib = dl.xpath("./dt | ./dd").each_with_object({}) do |dtd, m|
+          (dtd.name == "dt" and key = dtd.text.sub(/:+$/, "")) or
+            add_to_hash(m, key, dd_bib_extract(dtd))
+        end
+        clause.xpath("./clause").each do |c1|
+          key = c1&.at("./title")&.text&.downcase&.strip
+          next unless %w(contributor relation series).include? key
+
+          add_to_hash(bib, key, dl_bib_extract(c1, true))
+        end
+        dl_bib_extract_title(bib, clause, nested)
+      end
+
+      def dl_bib_extract_title(bib, clause, nested)
+        (!nested && clause.at("./title")) or return bib
+        title = clause.at("./title").remove.children.to_xml
+        bib["title"] = [bib["title"]] if bib["title"].is_a?(Hash) ||
+          bib["title"].is_a?(String)
+        bib["title"] ||= []
+        bib["title"] << title if !title.empty?
+        bib
+      end
+
+      # ---
+
+      def formattedref_spans(xmldoc)
+        xmldoc.xpath("//bibitem[formattedref//span]").each do |b|
+          spans_to_bibitem(b, spans_preprocess(extract_content(b)))
+        end
+      end
+
+      def extract_content(bib)
+        extract_docid(bib) + extract_spans(bib)
+      end
+
+      def extract_spans(bib)
+        bib.xpath("./formattedref//span").each_with_object([]) do |s, m|
+          keys = s["class"].split(".", 2)
+          m << { key: keys[0], type: keys[1],
+                 val: s.children.to_xml }
+          (s["class"] == "type" and s.remove) or s.replace(s.children)
+        end
+      end
+
+      def extract_docid(bib)
+        bib.xpath("./docidentifier").each_with_object([]) do |d, m|
+          m << { key: "docid", type: d["type"], val: d.text }
+          d.remove
+        end
+      end
+
+      def spans_preprocess(spans)
+        ret = { contributor: [], docid: [], uri: [], date: [] }
+        spans.each do |s|
+          case s[:key]
+          when "uri", "docid"
+            ret[s[:key].to_sym] << { type: s[:type], val: s[:val] }
+          when "pubyear" then ret[:date] << { type: "published", val: s[:val] }
+          when "pubplace", "title", "type" then ret[s[:key].to_sym] = s[:val]
+          when "publisher"
+            ret[:contributor] << { role: "publisher", entity: "organization",
+                                   name: s[:val] }
+          when "surname", "initials", "givenname"
+            ret[:contributor] = spans_preprocess_contrib(s, ret[:contributor])
+          end
+        end
+        ret
+      end
+
+      def spans_preprocess_contrib(span, contrib)
+        spans_preprocess_new_contrib?(span, contrib) and
+          contrib << { role: span[:type] || "author", entity: "person" }
+        contrib[-1][span[:key].to_sym] = span[:val]
+        contrib
+      end
+
+      def spans_preprocess_new_contrib?(span, contrib)
+        contrib.empty? ||
+          (if span[:key] == "surname" then contrib[-1][:surname]
+           else (contrib[-1][:initials] || contrib[-1][:givenname])
+           end) ||
+          contrib[-1][:role] != (span[:type] || "author")
+      end
+
+      def spans_to_bibitem(bib, spans)
+        ret = ""
+        spans[:title] and ret += "<title>#{spans[:title]}</title>"
+        spans[:uri].each { |s| ret += span_to_docid(s, "uri") }
+        spans[:docid].each { |s| ret += span_to_docid(s, "docidentifier") }
+        spans[:date].each { |s| ret += span_to_docid(s, "date") }
+        spans[:contributor].each { |s| ret += span_to_contrib(s) }
+        spans[:pubplace] and ret += "<place>#{spans[:place]}</place>"
+        spans[:type] and bib["type"] = spans[:type]
+        bib << ret
+      end
+
+      def span_to_docid(span, key)
+        if span[:type]
+          "<#{key} type='#{span[:type]}'>#{span[:val]}</#{key}>"
+        else
+          "<#{key}>#{span[:val]}</#{key}>"
+        end
+      end
+
+      def span_to_contrib(span)
+        e = if span[:entity] == "organization"
+              "<organization><name>#{span[:name]}</name></organization>"
+            else
+              pre = (span[:initials] and
+                     "<initial>#{span[:initials]}</initial>") ||
+                "<forename>#{span[:givenname]}</forename>"
+              "<person><name>#{pre}<surname>#{span[:surname]}</surname></name>"\
+                "</person>"
+            end
+        "<contributor><role type='#{span[:role]}'/>#{e}</contributor>"
+      end
+    end
+  end
+end

data/lib/metanorma/standoc/cleanup_block.rb

@@ -45,7 +45,8 @@ module Metanorma
 
       def figure_dl_cleanup1(xmldoc)
         q = "//figure/following-sibling::*[self::dl]"
-        xmldoc.xpath(q).each do |s|
+        q1 = "//figure/figure/following-sibling::*[self::dl]"
+        (xmldoc.xpath(q) - xmldoc.xpath(q1)).each do |s|
           s["key"] == "true" and s.previous_element << s.remove
         end
       end
@@ -65,8 +66,9 @@ module Metanorma
       # examples containing only figures become subfigures of figures
       def subfigure_cleanup(xmldoc)
         xmldoc.xpath("//example[figure]").each do |e|
-          next unless e.elements.map(&:name).reject do |m|
-            %w(name figure index).include? m
+          next unless e.elements.reject do |m|
+            %w(name figure index note).include?(m.name) ||
+              (m.name == "dl" && m["key"] == "true")
           end.empty?
 
           e.name = "figure"
@@ -84,9 +86,9 @@ module Metanorma
 
       def figure_cleanup(xmldoc)
         figure_footnote_cleanup(xmldoc)
+        subfigure_cleanup(xmldoc)
         figure_dl_cleanup1(xmldoc)
         figure_dl_cleanup2(xmldoc)
-        subfigure_cleanup(xmldoc)
         single_subfigure_cleanup(xmldoc)
       end
 

data/lib/metanorma/standoc/cleanup_maths.rb

@@ -1,24 +1,11 @@
-require "nokogiri"
-require "pathname"
-require "html2doc"
 require "asciimath2unitsml"
-require_relative "./cleanup_block"
-require_relative "./cleanup_footnotes"
-require_relative "./cleanup_ref"
-require_relative "./cleanup_ref_dl"
-require_relative "./cleanup_boilerplate"
-require_relative "./cleanup_section"
-require_relative "./cleanup_terms"
-require_relative "./cleanup_inline"
-require_relative "./cleanup_amend"
-require "relaton_iev"
 
 module Metanorma
   module Standoc
     module Cleanup
       def asciimath2mathml(text)
         text = text.gsub(%r{<stem type="AsciiMath">(.+?)</stem>}m) do
-          "<amathstem>#{HTMLEntities.new.decode($1)}</amathstem>"
+          "<amathstem>#{@c.decode($1)}</amathstem>"
         end
         text = Html2Doc.new({})
           .asciimath_to_mathml(text, ["<amathstem>", "</amathstem>"])
@@ -60,7 +47,7 @@ module Metanorma
       def mathml_italicise(xml)
         xml.xpath(".//m:mi[not(ancestor::*[@mathvariant])]",
                   "m" => MATHML_NS).each do |i|
-          char = HTMLEntities.new.decode(i.text)
+          char = @c.decode(i.text)
           i["mathvariant"] = "normal" if mi_italicise?(char)
         end
       end

data/lib/metanorma/standoc/cleanup_ref.rb

@@ -153,29 +153,28 @@ module Metanorma
 
       def reference_names(xmldoc)
         xmldoc.xpath("//bibitem[not(ancestor::bibitem)]").each do |ref|
-          docid = ref.at("./docidentifier[@type = 'metanorma']") ||
-            ref.at("./docidentifier[@primary = 'true'][@language = '#{@lang}']") ||
-            ref.at("./docidentifier[@primary = 'true'][not(@language)]") ||
-            ref.at("./docidentifier[@primary = 'true']") ||
-            ref.at("./docidentifier[not(@type = 'DOI')][@language = '#{@lang}']") ||
-            ref.at("./docidentifier[not(@type = 'DOI')][not(@language)]") ||
-            ref.at("./docidentifier[not(@type = 'DOI')]") or next
+          docid = select_docid(ref) or next
           reference = format_ref(docid.children.to_xml, docid["type"])
           @anchors[ref["id"]] = { xref: reference }
         end
       end
 
+      def select_docid(ref)
+        ref.at("./docidentifier[@type = 'metanorma']") ||
+          ref.at("./docidentifier[@primary = 'true'][@language = '#{@lang}']") ||
+          ref.at("./docidentifier[@primary = 'true'][not(@language)]") ||
+          ref.at("./docidentifier[@primary = 'true']") ||
+          ref.at("./docidentifier[not(@type = 'DOI')][@language = '#{@lang}']") ||
+          ref.at("./docidentifier[not(@type = 'DOI')][not(@language)]") ||
+          ref.at("./docidentifier[not(@type = 'DOI')]")
+      end
+
       def fetch_termbase(_termbase, _id)
         ""
       end
 
       def read_local_bibitem(uri)
-        return nil if %r{^https?://}.match?(uri)
-
-        file = "#{@localdir}#{uri}.rxl"
-        File.file?(file) or file = "#{@localdir}#{uri}.xml"
-        File.file?(file) or return nil
-        xml = Nokogiri::XML(File.read(file, encoding: "utf-8"))
+        xml = read_local_bibitem_file(uri) or return nil
         ret = xml.at("//*[local-name() = 'bibdata']") or return nil
         ret = Nokogiri::XML(ret.to_xml
           .sub(%r{(<bibdata[^>]*?) xmlns=("[^"]+"|'[^']+')}, "\\1")).root
@@ -186,6 +185,15 @@ module Metanorma
         ret
       end
 
+      def read_local_bibitem_file(uri)
+        return nil if %r{^https?://}.match?(uri)
+
+        file = "#{@localdir}#{uri}.rxl"
+        File.file?(file) or file = "#{@localdir}#{uri}.xml"
+        File.file?(file) or return nil
+        Nokogiri::XML(File.read(file, encoding: "utf-8"))
+      end
+
       # if citation uri points to local file, get bibitem from it
       def fetch_local_bibitem(xmldoc)
         xmldoc.xpath("//bibitem[formattedref][uri[@type = 'citation']]")
@@ -206,6 +214,7 @@ module Metanorma
       def bibitem_cleanup(xmldoc)
         bibitem_nested_id(xmldoc)
         ref_dl_cleanup(xmldoc)
+        formattedref_spans(xmldoc)
         fetch_local_bibitem(xmldoc)
       end
     end

data/lib/metanorma/standoc/cleanup_reqt.rb

@@ -5,10 +5,19 @@ module Metanorma
         requirement_metadata(xmldoc)
         requirement_inherit(xmldoc)
         requirement_descriptions(xmldoc)
+        requirement_identifier(xmldoc)
       end
 
       REQRECPER = "//requirement | //recommendation | //permission".freeze
 
+      def requirement_identifier(xmldoc)
+        xmldoc.xpath(REQRECPER).each do |r|
+          r.xpath("./identifier[link] | ./inherit[link]").each do |i|
+            i.children = i.at("./link/@target").text
+          end
+        end
+      end
+
       def requirement_inherit(xmldoc)
         xmldoc.xpath(REQRECPER).each do |r|
           ins = requirement_inherit_insert(r)
@@ -76,8 +85,16 @@ module Metanorma
         end
       end
 
+      def requirement_metadata1_attrs
+        %w(obligation model type)
+      end
+
       def requirement_metadata1_tags
-        %w(label subject inherit)
+        %w(identifier subject inherit)
+      end
+
+      def requirement_metadata_component_tags
+        []
       end
 
       def requirement_metadata1(reqt, dlist, ins)
@@ -85,20 +102,21 @@ module Metanorma
           reqt.children.first.previous = " "
           ins = reqt.children.first
         end
-        %w(obligation model type).each do |a|
+        requirement_metadata1_attrs.each do |a|
           dl_to_attrs(reqt, dlist, a)
         end
         requirement_metadata1_tags.each do |a|
           ins = dl_to_elems(ins, reqt, dlist, a)
         end
-        reqt_dl_to_classif(ins, reqt, dlist)
+        ins = reqt_dl_to_classif(ins, reqt, dlist)
+        reqt_dl_to_classif1(ins, reqt, dlist)
       end
 
       def reqt_dl_to_classif(ins, reqt, dlist)
         if a = reqt.at("./classification[last()]") then ins = a end
         dlist.xpath("./dt[text()='classification']").each do |e|
           val = e.at("./following::dd/p") || e.at("./following::dd")
-          req_classif_parse(val.text).each do |r|
+          req_classif_parse(val.children.to_xml).each do |r|
             ins.next = "<classification><tag>#{r[0]}</tag>"\
                        "<value>#{r[1]}</value></classification>"
             ins = ins.next
@@ -106,6 +124,21 @@ module Metanorma
         end
         ins
       end
+
+      def reqt_dl_to_classif1(ins, reqt, dlist)
+        if a = reqt.at("./classification[last()]") then ins = a end
+        dlist.xpath("./dt").each do |e|
+          next if (requirement_metadata1_attrs + requirement_metadata1_tags +
+                   requirement_metadata_component_tags + %w(classification))
+            .include?(e.text)
+
+          val = e.at("./following::dd/p") || e.at("./following::dd")
+          ins.next = "<classification><tag>#{e.text}</tag>"\
+                     "<value>#{val.children.to_xml}</value></classification>"
+          ins = ins.next
+        end
+        ins
+      end
     end
   end
 end

data/lib/metanorma/standoc/cleanup_symbols.rb

@@ -11,7 +11,7 @@ module Metanorma
             n.replace(grkletters(MathML2AsciiMath.m2a(n.to_xml)))
         end
         ret = Nokogiri::XML(key.to_xml)
-        HTMLEntities.new.decode(ret.text.downcase)
+        @c.decode(ret.text.downcase)
           .gsub(/[\[\]{}<>()]/, "").gsub(/\s/m, "")
           .gsub(/[[:punct:]]|[_^]/, ":\\0").gsub(/`/, "")
           .gsub(/[0-9]+/, "þ\\0")

data/lib/metanorma/standoc/cleanup_text.rb

@@ -7,7 +7,7 @@ module Metanorma
         text = text.gsub(/\s+<fn /, "<fn ")
         %w(passthrough passthrough-inline).each do |v|
           text.gsub!(%r{<#{v}\s+formats="metanorma">([^<]*)
-                    </#{v}>}mx) { HTMLEntities.new.decode($1) }
+                    </#{v}>}mx) { @c.decode($1) }
         end
         text
       end
@@ -34,11 +34,13 @@ module Metanorma
         end
       end
 
+      IGNORE_QUOTES_ELEMENTS =
+        %w(pre tt sourcecode stem figure bibdata passthrough identifier).freeze
+
       def uninterrupt_quotes_around_xml_skip(elem)
         !(/\A['"]/.match?(elem.text) &&
-          elem.previous.ancestors("pre, tt, sourcecode, stem, figure, bibdata,
-                                  passthrough, identifer")
-          .empty? &&
+          elem.previous.path.split(%r{/})[1..-2]
+          .intersection(IGNORE_QUOTES_ELEMENTS).empty? &&
           ((elem.previous.text.strip.empty? &&
             !empty_tag_with_text_content?(elem.previous)) ||
            elem.previous.name == "index"))
@@ -49,7 +51,7 @@ module Metanorma
         /\S\Z/.match?(prev.text) or return
         foll = elem.at(".//following::text()[1]")
         m = /\A(["'][[:punct:]]*)(\s|\Z)/
-          .match(HTMLEntities.new.decode(foll&.text)) or return
+          .match(@c.decode(foll&.text)) or return
         foll.content = foll.text.sub(/\A(["'][[:punct:]]*)/, "")
         prev.content = "#{prev.text}#{m[1]}"
       end
@@ -74,10 +76,10 @@ module Metanorma
           empty_tag_with_text_content?(x) and prev = "dummy"
           next unless x.text?
 
-          x.ancestors("pre, tt, sourcecode, stem, figure, bibdata, passthrough,
-                      identifier").empty? and
+          ancestors = x.path.split(%r{/})[1..-2]
+          ancestors.intersection(IGNORE_QUOTES_ELEMENTS).empty? and
             dumb2smart_quotes1(x, prev)
-          prev = x.text if x.ancestors("index").empty?
+          prev = x.text unless ancestors.include?("index")
         end
       end
 

data/lib/metanorma/standoc/cleanup_xref.rb

@@ -68,10 +68,9 @@ module Metanorma
       end
 
       def xref_to_eref(elem)
-        c = HTMLEntities.new
         elem["bibitemid"] = elem["target"]
         if ref = @anchors&.dig(elem["target"], :xref)
-          elem["citeas"] = c.decode(ref)
+          elem["citeas"] = @c.decode(ref)
         else
           elem["citeas"] = ""
           xref_to_eref1(elem)

data/lib/metanorma/standoc/converter.rb

@@ -29,6 +29,7 @@ module Metanorma
         preprocessor Metanorma::Plugin::Lutaml::LutamlUmlAttributesTablePreprocessor
         preprocessor Metanorma::Plugin::Lutaml::LutamlUmlDatamodelDescriptionPreprocessor
         inline_macro Metanorma::Standoc::PreferredTermInlineMacro
+        inline_macro Metanorma::Standoc::SpanInlineMacro
         inline_macro Metanorma::Standoc::AltTermInlineMacro
         inline_macro Metanorma::Standoc::AdmittedTermInlineMacro
         inline_macro Metanorma::Standoc::DeprecatedTermInlineMacro
@@ -93,6 +94,7 @@ module Metanorma
         basebackend "html"
         outfilesuffix ".xml"
         @libdir = File.dirname(self.class::_file || __FILE__)
+                @c = HTMLEntities.new
       end
 
       class << self

data/lib/metanorma/standoc/front.rb

@@ -121,7 +121,7 @@ module Metanorma
 
       def metadata_getrelation(node, xml, type, desc = nil)
         docs = node.attr(desc || type) or return
-        HTMLEntities.new.decode(docs).split(/;\s*/).each do |d|
+        @c.decode(docs).split(/;\s*/).each do |d|
           metadata_getrelation1(d, xml, type, desc)
         end
       end

data/lib/metanorma/standoc/inline.rb

@@ -79,8 +79,8 @@ module Metanorma
       end
 
       def inline_anchor_bibref(node)
-        eref_contents = HTMLEntities.new
-          .decode(node.text || node.target || node.id)
+        eref_contents =
+          @c.decode(node.text || node.target || node.id)
           &.sub(/^\[?([^\[\]]+?)\]?$/, "[\\1]")
         @refids << (node.target || node.id)
         noko do |xml|
@@ -125,14 +125,14 @@ module Metanorma
       end
 
       def xml_encode(text)
-        HTMLEntities.new.encode(text, :basic, :hexadecimal)
+        @c.encode(text, :basic, :hexadecimal)
           .gsub(/&amp;gt;/, ">").gsub(/&amp;lt;/, "<").gsub(/&amp;amp;/, "&")
           .gsub(/&gt;/, ">").gsub(/&lt;/, "<").gsub(/&amp;/, "&")
           .gsub(/&quot;/, '"').gsub(/&#xa;/, "\n").gsub(/&amp;#/, "&#")
       end
 
       def latex_parse1(text)
-        lxm_input = Unicode2LaTeX.unicode2latex(HTMLEntities.new.decode(text))
+        lxm_input = Unicode2LaTeX.unicode2latex(@c.decode(text))
         results = Latexmath.parse(lxm_input).to_mathml
         results.nil? and
           @log.add("Math", nil,
@@ -191,6 +191,10 @@ module Metanorma
             when "underline" then xml.underline { |s| s << node.text }
             when "smallcap" then xml.smallcap { |s| s << node.text }
             when "keyword" then xml.keyword { |s| s << node.text }
+            when /^css /
+              xml.span **{ style: node.role.sub(/^css /, "") } do |s|
+                s << node.text
+              end
             else
               xml << node.text
             end

data/lib/metanorma/standoc/isodoc.rng

@@ -1285,7 +1285,12 @@
   </define>
   <define name="span">
     <element name="span">
-      <attribute name="class"/>
+      <optional>
+        <attribute name="class"/>
+      </optional>
+      <optional>
+        <attribute name="style"/>
+      </optional>
       <oneOrMore>
         <ref name="TextElement"/>
       </oneOrMore>