metanorma-ieee 1.5.3 → 1.5.4

data/lib/isodoc/ieee/metadata.rb

@@ -54,6 +54,20 @@ module IsoDoc
         wg(xml)
         bg(xml)
         program(xml)
+        coverpage_stmt(xml)
+      end
+
+      def agency(xml)
+        super
+        logos = xml.xpath(ns("//bibdata/contributor[xmlns:role/@type = 'author']/" \
+                   "organization/logo/image/@src"))
+        set(:corporate_author_logos, logos.map { |l| to_datauri(l.value) })
+        set(:corporate_author_logo_attrs, contrib_logo_attrs(xml, "author"))
+      end
+
+      def coverpage_stmt(xml)
+        p = xml.at(ns("//presentation-metadata/coverpage-statement")) and
+          set(:coverpage_statement, p.children.to_xml)
       end
 
       def program(xml)
@@ -105,6 +119,8 @@ module IsoDoc
         set(:stdid_pdf, dn&.text || "STDXXXXX")
         dn = isoxml.at(ns("//#{id}[@scope = 'print']"))
         set(:stdid_print, dn&.text || "STDPDXXXXX")
+        dn = isoxml.at(ns("//bibdata/docidentifier[@type = 'IEEE-draft']")) and
+          set(:docid_draft, dn.text)
         dn = isoxml.at(ns("//bibdata/ext/structuredidentifier/amendment")) and
           set(:amd, dn.text)
         dn = isoxml.at(ns("//bibdata/ext/structuredidentifier/corrigendum")) and
@@ -114,18 +130,13 @@ module IsoDoc
       def title(isoxml, _out)
         metadata_parse_init(isoxml)
         super
-        draft = isoxml.at(ns("//bibdata/version/draft"))
         doctype(isoxml, _out)
-        set(:full_doctitle, fulltitle(@metadata[:doctype], draft))
-        set(:abbrev_doctitle, fulltitle(@metadata[:doctype_abbrev], draft))
-        prov = isoxml.at(ns("//bibdata/title[@type='provenance']")) and
-          set(:provenance_doctitle, Common::to_xml(prov.children))
-      end
-
-      def fulltitle(type, draft)
-        title = "#{type || '???'} for #{@metadata[:doctitle] || '???'}"
-        draft and title = "Draft #{title}"
-        title
+        { doctitle: "title-main", full_doctitle: "main",
+          abbrev_doctitle: "title-abbrev", provenance_doctitle: "provenance" }
+          .each do |k, v|
+          t = isoxml.at(ns("//bibdata/title[@type='#{v}']")) and
+            set(k, Common::to_xml(t.children))
+        end
       end
 
       def metadata_parse_init(isoxml)

data/lib/isodoc/ieee/presentation_bibitem.rb

@@ -0,0 +1,102 @@
+require_relative "../../relaton/render/general"
+
+module IsoDoc
+  module Ieee
+    class PresentationXMLConvert < IsoDoc::PresentationXMLConvert
+      def references_render(docxml)
+        @author = {}
+        super
+      end
+
+      def bibrender_relaton(xml, renderings)
+        bibrender_relaton1(xml, renderings)
+        author_date(xml, renderings)
+        @author[xml["id"]] = renderings[xml["id"]][:author]
+      end
+
+      def bibrender_relaton1(xml, renderings)
+        f = renderings[xml["id"]][:formattedref] or return
+        fn = availability_note(xml)
+        f = "<formattedref>#{f}#{fn}</formattedref>"
+        if x = xml.at(ns("./formattedref"))
+          x.replace(f)
+        elsif xml.children.empty?
+          xml << f
+        else
+          xml.children.first.previous = f
+        end
+      end
+
+      def author_date(xml, renderings)
+        author_date?(xml) or return
+        cit = renderings[xml["id"]][:citation]
+        xml << "<docidentifier type='metanorma'>#{cit}</docidentifier>"
+        xml.at(ns("./biblio-tag"))&.remove
+        xml << "<biblio-tag>#{cit}, </biblio-tag>"
+      end
+
+      def author_date?(xml)
+        ret = !xml["type"]
+        ret ||= %w(standard techreport website webresource)
+          .include?(xml["type"])
+        ret ||= xml.at(".//ancestor::xmlns:references[@normative = 'false']")
+        ret ||= xml.at(ns("./docidentifier[@type = 'metanorma']"))
+        ret and return false
+        true
+      end
+
+      def creatornames(bib)
+        ::Relaton::Render::Ieee::General
+          .new(language: @lang, i18nhash: @i18n.get,
+               # template: { (bib["type"] || "misc").to_sym =>
+               # "{{ creatornames }}" },
+               template: "{{ creatornames }}",
+               extenttemplate: { (bib["type"] || "misc").to_sym => "{{page}}" },
+               sizetemplate: { (bib["type"] || "misc").to_sym => "{{data}}" })
+          .render1(RelatonBib::XMLParser.from_xml(bib.to_xml))
+      end
+
+      def bibliography_bibitem_number1(bibitem, idx, normative)
+        bibitem.xpath(ns(".//docidentifier[@type = 'metanorma' or " \
+                         "@type = 'metanorma-ordinal']")).each do |mn|
+          /^\[?B?\d\]?$/.match?(mn&.text) and mn.remove
+        end
+        unless bibliography_bibitem_number_skip(bibitem) || normative
+          idx += 1
+          docidentifier_insert_pt(bibitem).next =
+            "<docidentifier type='metanorma-ordinal'>[B#{idx}]</docidentifier>"
+        end
+        idx
+      end
+
+      def docidentifier_insert_pt(bibitem)
+        bibitem.at(ns(".//docidentifier"))&.previous ||
+          bibitem.at(ns(".//title")) ||
+          bibitem.at(ns(".//formattedref"))
+      end
+
+      def availability_note(bib)
+        notes = bib.xpath(ns("./note[@type = 'Availability']"))
+        notes.map do |note|
+          id = UUIDTools::UUID.random_create.to_s
+          @new_ids[id] = nil
+          "<fn id='#{id}' reference='#{id}'><p>#{note.content}</p></fn>"
+        end.join
+      end
+
+      def omit_docid_prefix(prefix)
+        prefix == "DOI" and return true
+        super
+      end
+
+      def bracket_if_num(num)
+        num.nil? and return nil
+        ret = num.dup
+        ret.xpath(ns(".//fn")).each(&:remove)
+        ret = ret.text.strip.sub(/^\[/, "").sub(/\]$/, "")
+        /^B?\d+$/.match?(ret) and return "[#{ret}]"
+        ret
+      end
+    end
+  end
+end

data/lib/isodoc/ieee/presentation_ref.rb

@@ -1,142 +1,195 @@
-require_relative "../../relaton/render/general"
-
 module IsoDoc
   module Ieee
     class PresentationXMLConvert < IsoDoc::PresentationXMLConvert
+      def xref_empty?(node)
+        if node["citeas"] &&
+            @bibanchors[node["bibitemid"]] && !node.children.empty?
+          true
+        else super
+        end
+      end
+
+      def inline(docxml)
+        @bibanchors ||= biblio_ids_titles(docxml, false)
+        @normrefanchors ||= biblio_ids_titles(docxml, true)
+        super
+      end
+
       # Style manual 19
       def anchor_linkend(node, linkend)
-        @bibanchors ||= biblio_ids_titles(node.document)
         if node["citeas"] && i = @bibanchors[node["bibitemid"]]
           biblio_anchor_linkend(node, i)
+        elsif node["citeas"] && (i = @normrefanchors[node["bibitemid"]])
+          cit = normref_anchor_linkend(node, i)
+          cit || super
         else super
         end
       end
 
+      # force Author-Date referencing on non-standards in norm ref
+      def normref_anchor_linkend(node, bib)
+         @ref_renderings or return nil
+        %w(techreport standard).include?(bib[:type]) and return nil
+        cit = @ref_renderings[node["bibitemid"]][:citation]&.strip
+        cit.empty? and cit = nil
+        cit
+      end
+
       def biblio_anchor_linkend(node, bib)
         if %w(techreport standard).include?(bib[:type])
-          [node["citeas"], bib[:ord]].compact.join(" ")
-        elsif bib[:author]
-          "#{bib[:author]} " + node["citeas"]
-        else
-          node["citeas"]
+          if !node.children.empty?
+            to_xml(node.children).strip
+          elsif node["citeas"] == bib[:ord] then node["citeas"]
+          else [node["citeas"], bib[:ord]].compact.join(" ")
+          end
+        else biblio_anchor_linkend_nonstd(node, bib)
         end
       end
 
-      def biblio_ids_titles(xmldoc)
-        xmldoc.xpath(ns("//references[@normative = 'false']/bibitem"))
-          .each_with_object({}) do |b, m|
-          m[b["id"]] =
-            { docid: pref_ref_code(b), type: b["type"],
-              title: (b.at(ns("./title")) ||
-                     b.at(ns("./formattedref")))&.text,
-              author: @author[b["id"]] || (b.at(ns("./title")) ||
-                     b.at(ns("./formattedref")))&.text,
-              ord: b.at(ns("./docidentifier[@type = 'metanorma' or " \
-                           "@type = 'metanorma-ordinal']"))&.text }
+      def biblio_anchor_linkend_nonstd(node, bib)
+        node["style"] == "no-biblio-tag" or tag = node["citeas"]
+        if !node.children.empty?
+          "#{to_xml(node.children)} #{tag}".strip
+        elsif node["style"] == "title" && bib[:title]
+          "#{bib[:title]} #{tag}".strip
+        elsif bib[:author] # default, also if node["style"] == "title"
+          "#{bib[:author]} #{tag}".strip
+        else tag.strip
         end
       end
 
-      def citestyle
-        "author-date"
+      def biblio_ids_titles(xmldoc, normative)
+        xmldoc.xpath(ns("//references[@normative = '#{normative}']/bibitem"))
+          .each_with_object({}) do |b, acc|
+          biblio_ids_titles1(b, acc)
+        end
       end
 
-      def references_render(docxml)
-        @author = {}
-        super
+      def biblio_ids_titles1(bib, acc)
+        acc[bib["id"]] =
+          { docid: pref_ref_code(bib), type: bib["type"],
+            title: bib.at(ns("./title")) || bib.at(ns("./formattedref")),
+            author: @author[bib["id"]] || (bib.at(ns("./title")) ||
+                   bib.at(ns("./formattedref"))),
+            ord: bib.at(ns("./docidentifier[@type = 'metanorma' or " \
+                         "@type = 'metanorma-ordinal']")) }
+        %i(title author ord).each do |k|
+          acc[bib["id"]][k].is_a?(Nokogiri::XML::Node) and
+            acc[bib["id"]][k] = acc[bib["id"]][k].text
+        end
       end
 
-      def bibrender_relaton(xml, renderings)
-        bibrender_relaton1(xml, renderings)
-        author_date(xml, renderings)
-        @author[xml["id"]] = renderings[xml["id"]][:author]
+      def citestyle
+        "author-date"
       end
 
-      def bibrender_relaton1(xml, renderings)
-        f = renderings[xml["id"]][:formattedref] or return
-        fn = availability_note(xml)
-        f = "<formattedref>#{f}#{fn}</formattedref>"
-        if x = xml.at(ns("./formattedref"))
-          x.replace(f)
-        elsif xml.children.empty?
-          xml << f
-        else
-          xml.children.first.previous = f
-        end
+      def expand_citeas(text)
+        std_docid_semantic(super)
       end
 
-      def author_date(xml, renderings)
-        author_date?(xml) or return
-        cit = renderings[xml["id"]][:citation]
-        xml << "<docidentifier type='metanorma'>#{cit}</docidentifier>"
-        xml.at(ns("./biblio-tag"))&.remove
-        xml << "<biblio-tag>#{cit}, </biblio-tag>"
+      def eref_localities_conflated(refs, target, node)
+        droploc = node["droploc"]
+        node["droploc"] = true
+        ret = resolve_eref_connectives(eref_locality_stacks(refs, target,
+                                                            node))
+        node["droploc"] = droploc
+        p = prefix_clause(target, refs.first.at(ns("./locality")))
+        eref_localities1({ target: target, number: "pl",
+                           type: p,
+                           from: l10n(ret[1..-1].join), node: node,
+                           lang: @lang })
+      end
+
+      def prefix_clause(target, loc)
+        loc["type"] == "clause" or return loc["type"]
+        if subclause?(target, loc["type"],
+                      loc&.at(ns("./referenceFrom"))&.text)
+          ""
+        else "clause"
+        end
       end
 
-      def author_date?(xml)
-        ret = !xml["type"]
-        ret ||= %w(standard techreport website webresource)
-          .include?(xml["type"])
-        ret ||= xml.at(".//ancestor::xmlns:references[@normative = 'false']")
-        ret ||= xml.at(ns("./docidentifier[@type = 'metanorma']"))
-        ret and return false
-        true
+      def subclause?(target, type, from)
+        (from&.include?(".") && type == "clause") ||
+          target&.gsub(/<[^<>]+>/, "")&.match?(/^IEV$|^IEC 60050-/)
       end
 
-      def creatornames(bib)
-        ::Relaton::Render::Ieee::General
-          .new(language: @lang, i18nhash: @i18n.get,
-               # template: { (bib["type"] || "misc").to_sym =>
-               # "{{ creatornames }}" },
-               template: "{{ creatornames }}",
-               extenttemplate: { (bib["type"] || "misc").to_sym => "{{page}}" },
-               sizetemplate: { (bib["type"] || "misc").to_sym => "{{data}}" })
-          .render1(RelatonBib::XMLParser.from_xml(bib.to_xml))
+      def eref_localities1(opt)
+        opt[:type] == "anchor" and return nil
+        opt[:type].downcase!
+        opt[:lang] == "zh" and return l10n(eref_localities1_zh(opt))
+        ret = ""
+        opt[:node]["droploc"] != "true" &&
+          !subclause?(opt[:target], opt[:type], opt[:from]) and
+          ret = eref_locality_populate(opt[:type], opt[:node], opt[:number])
+        ret += " #{opt[:from]}" if opt[:from]
+        ret += "&#x2013;#{opt[:upto]}" if opt[:upto]
+        ret += ")" if opt[:type] == "list"
+        l10n(ret)
       end
 
-      def bibliography_bibitem_number1(bibitem, idx, normative)
-        bibitem.xpath(ns(".//docidentifier[@type = 'metanorma' or " \
-                         "@type = 'metanorma-ordinal']")).each do |mn|
-          /^\[?B?\d\]?$/.match?(mn&.text) and mn.remove
-        end
-        unless bibliography_bibitem_number_skip(bibitem) || normative
-          idx += 1
-          docidentifier_insert_pt(bibitem).next =
-            "<docidentifier type='metanorma-ordinal'>[B#{idx}]</docidentifier>"
-        end
-        idx
+      def anchor_linkend1(node)
+        linkend = @xrefs.anchor(node["target"], :xref)
+        @xrefs.anchor(node["target"], :type) == "clause" &&
+          @xrefs.anchor(node["target"], :level) > 1 &&
+          !start_of_sentence(node) and
+          linkend = strip_initial_clause(linkend)
+        container = @xrefs.anchor(node["target"], :container, false)
+        linkend = prefix_container(container, linkend, node, node["target"])
+        capitalise_xref(node, linkend, anchor_value(node["target"]))
       end
 
-      def docidentifier_insert_pt(bibitem)
-        bibitem.at(ns(".//docidentifier"))&.previous ||
-          bibitem.at(ns(".//title")) ||
-          bibitem.at(ns(".//formattedref"))
+      def strip_initial_clause(linkend)
+        x = Nokogiri::XML("<a>#{linkend}</a>")
+        x.at(".//span[@class = 'fmt-element-name']")&.remove
+        to_xml(x.elements.first.children).strip
       end
 
-      def expand_citeas(text)
-        std_docid_semantic(super)
+      def eref_locality_populate(type, node, number)
+        type == "page" and return ""
+        super
       end
 
-      def availability_note(bib)
-        notes = bib.xpath(ns("./note[@type = 'Availability']"))
-        notes.map do |note|
-          id = UUIDTools::UUID.random_create.to_s
-          @new_ids[id] = nil
-          "<fn id='#{id}' reference='#{id}'><p>#{note.content}</p></fn>"
-        end.join
+      def first_biblio_eref_fn(docxml)
+        @bibanchors ||= biblio_ids_titles(docxml)
+        docxml.xpath("//*[@citeas]").each do |node|
+          @bibanchors[node["bibitemid"]] or next
+          node.children.empty? or next
+          insert_biblio_footnote(node, docxml)
+          break
+        end
       end
 
-      def omit_docid_prefix(prefix)
-        prefix == "DOI" and return true
-        super
+      private
+
+      def insert_biblio_footnote(node, docxml)
+        n = node.next_sibling
+        # Check if the next sibling is a text node that starts with punctuation
+        if n&.text? && (match = n.content.match(/^([.,;:])(?=\s|$)/))
+          insert_biblio_footnote_with_punctuation1(n, match, docxml)
+        else # Default behavior: insert footnote immediately after the node
+          node.next = biblio_ref_inform_fn
+        end
       end
 
-      def bracket_if_num(num)
-        num.nil? and return nil
-        ret = num.dup
-        ret.xpath(ns(".//fn")).each(&:remove)
-        ret = ret.text.strip.sub(/^\[/, "").sub(/\]$/, "")
-        /^B?\d+$/.match?(ret) and return "[#{ret}]"
-        ret
+      # If so, split the text at the punctuation
+      # and replace the text node with punctuation + footnote + remaining text
+      def insert_biblio_footnote_with_punctuation1(node, match, docxml)
+        punct = match[0]
+        remaining_text = node.content[punct.length..-1]
+        node.content = punct
+        node.add_next_sibling(biblio_ref_inform_fn)
+        remaining_text && !remaining_text.empty? and
+          node.next_sibling
+            .add_next_sibling(Nokogiri::XML::Text.new(
+                                remaining_text, docxml
+                              ))
+      end
+
+      def biblio_ref_inform_fn
+        <<~XML
+          <fn reference='#{UUIDTools::UUID.random_create}'><p>#{@i18n.biblio_ref_inform_fn}</p></fn>
+        XML
       end
     end
   end

data/lib/isodoc/ieee/presentation_terms.rb

@@ -31,11 +31,21 @@ module IsoDoc
         end
       end
 
-      def wrap_nodeset_in_parens(xpath)
-        unless xpath.empty?
-          xpath[0].previous = " ("
-          xpath[-1].next = ")"
-        end
+      def wrap_termsource_in_parens(xpath)
+        xpath.empty? and return xpath
+        opening_paren = Nokogiri::XML::Node.new("span", xpath[0].document)
+        opening_paren["class"] = "fmt-termsource-delim"
+        opening_paren.content = "("
+        xpath[0].add_previous_sibling(opening_paren)
+        closing_paren = Nokogiri::XML::Node.new("span", xpath[-1].document)
+        closing_paren["class"] = "fmt-termsource-delim"
+        closing_paren.content = ")"
+        xpath[-1].add_next_sibling(closing_paren)
+        # Return expanded nodeset including parentheses
+        parent = xpath[0].parent
+        start_index = parent.children.index(opening_paren)
+        end_index = parent.children.index(closing_paren)
+        parent.children[start_index..end_index]
       end
 
       def unwrap_definition1(d)
@@ -44,11 +54,15 @@ module IsoDoc
           if v.elements.all? { |n| %w(source p).include?(n.name) }
             p = v.xpath(ns("./p"))
             s = v.xpath(ns("./source"))
-            s.empty? or s = " (#{s.map { |x| to_xml(x) }.join})"
+            s = wrap_termsource_in_parens(s) unless s.empty?
             v.children =
-              "#{p.map(&:children).map { |x| to_xml(x) }.join("\n")}#{s}"
+              "#{p.map(&:children).map do |x|
+                to_xml(x)
+              end.join("\n")}#{s.map do |x|
+                               to_xml(x)
+                             end.join}"
           else
-            wrap_nodeset_in_parens(v.xpath(ns("./source")))
+            wrap_termsource_in_parens(v.xpath(ns("./source")))
           end
           v.replace(v.children)
         end
@@ -120,15 +134,19 @@ module IsoDoc
       end
 
       def collapse_term_template_tail(opt)
-        opt[:source] and src = "(#{to_xml(opt[:source].children).strip})"
-        opt[:fns].empty? or fn = opt[:fns].map(&:to_xml).join
-        "#{collapse_term_related(opt[:rels])} #{src}#{fn}"
+        if opt[:source]
+          # For this context, we need to use the old string-based approach
+          # since the source element has been removed from its parent
+          src = "<span class='fmt-termsource-delim'>(</span>#{to_xml(opt[:source].children).strip}<span class='fmt-termsource-delim'>)</span>"
+        end
+        opt[:fns].empty? or fn = opt[:fns].map { |f| to_xml(f) }.join
+        "#{collapse_term_related(opt[:rels])} #{src}#{fn}".strip
       end
 
       def collapse_term_pref(opt)
         p = opt[:pref]
         p.text.strip.empty? and return "**TERM NOT FOUND**"
-        wrap_nodeset_in_parens(p.xpath(ns(".//semx[@element = 'source']")))
+        wrap_termsource_in_parens(p.xpath(ns(".//semx[@element = 'source']")))
         p.xpath(ns(".//fmt-termsource")).each { |x| x.replace(x.children) }
         to_xml(p.children).strip
       end
@@ -172,6 +190,28 @@ module IsoDoc
       end
 
       def term(docxml); end
+
+      def license_termnote(elem, idx)
+        elem.name = "fn"
+        elem["reference"] = "_termnote_license_#{idx}"
+        elem.parent << elem
+      end
+
+      def termsource_brackets(docxml)
+        docxml.xpath(ns("//term//semx[@element = 'source']")).each do |s|
+          text = termsource_text_content(s)
+          text&.include?("(") && text.include?(")") or next
+          prevbr = s.at("./preceding-sibling::xmlns:span[@class='fmt-termsource-delim']")
+          nextbr = s.at("./following-sibling::xmlns:span[@class='fmt-termsource-delim']")
+          prevbr.children = "["
+          nextbr.children = "]"
+        end
+      end
+
+      def termsource_text_content(span)
+        span.dup.xpath(ns(".//localityStack | .//locality")).each(&:remove)
+          .text
+      end
     end
   end
 end

data/lib/isodoc/ieee/presentation_xml_convert.rb

@@ -3,6 +3,7 @@ require_relative "presentation_bibdata"
 require_relative "presentation_terms"
 require_relative "presentation_concepts"
 require_relative "presentation_ref"
+require_relative "presentation_bibitem"
 require "isodoc"
 
 module IsoDoc
@@ -13,69 +14,6 @@ module IsoDoc
         super
       end
 
-      def eref_localities_conflated(refs, target, node)
-        droploc = node["droploc"]
-        node["droploc"] = true
-        ret = resolve_eref_connectives(eref_locality_stacks(refs, target,
-                                                            node))
-        node["droploc"] = droploc
-        p = prefix_clause(target, refs.first.at(ns("./locality")))
-        eref_localities1({ target: target, number: "pl",
-                           type: p,
-                           from: l10n(ret[1..-1].join), node: node,
-                           lang: @lang })
-      end
-
-      def prefix_clause(target, loc)
-        loc["type"] == "clause" or return loc["type"]
-        if subclause?(target, loc["type"],
-                      loc&.at(ns("./referenceFrom"))&.text)
-          ""
-        else "clause"
-        end
-      end
-
-      def subclause?(target, type, from)
-        (from&.include?(".") && type == "clause") ||
-          target&.gsub(/<[^<>]+>/, "")&.match?(/^IEV$|^IEC 60050-/)
-      end
-
-      def eref_localities1(opt)
-        opt[:type] == "anchor" and return nil
-        opt[:type].downcase!
-        opt[:lang] == "zh" and return l10n(eref_localities1_zh(opt))
-        ret = ""
-        opt[:node]["droploc"] != "true" &&
-          !subclause?(opt[:target], opt[:type], opt[:from]) and
-          ret = eref_locality_populate(opt[:type], opt[:node], opt[:number])
-        ret += " #{opt[:from]}" if opt[:from]
-        ret += "&#x2013;#{opt[:upto]}" if opt[:upto]
-        ret += ")" if opt[:type] == "list"
-        l10n(ret)
-      end
-
-      def anchor_linkend1(node)
-        linkend = @xrefs.anchor(node["target"], :xref)
-        @xrefs.anchor(node["target"], :type) == "clause" &&
-          @xrefs.anchor(node["target"], :level) > 1 &&
-          !start_of_sentence(node) and
-          linkend = strip_initial_clause(linkend)
-        container = @xrefs.anchor(node["target"], :container, false)
-        linkend = prefix_container(container, linkend, node, node["target"])
-        capitalise_xref(node, linkend, anchor_value(node["target"]))
-      end
-
-      def strip_initial_clause(linkend)
-        x = Nokogiri::XML("<a>#{linkend}</a>")
-        x.at(".//span[@class = 'fmt-element-name']")&.remove
-        to_xml(x.elements.first.children).strip
-      end
-
-      def eref_locality_populate(type, node, number)
-        type == "page" and return ""
-        super
-      end
-
       def block_delim
         "&#x2014;"
       end
@@ -183,7 +121,7 @@ module IsoDoc
             %w(icap industry-connection-report).include?(@subdoctype)
           %w(&#x25aa; &#x2014;)
         else
-          %w(&#x2013;)
+          %w(&#x2014;)
         end
       end
 
@@ -231,13 +169,23 @@ module IsoDoc
       # before processing, move license termnotes to fn at end of term,
       # so they aren't numbered as termnotes
       def conversions(docxml)
-        docxml.xpath(ns("//termnote[@type='license']")).each do |n|
-          n.name = "fn"
-          n.parent << n
+        docxml.xpath(ns("//termnote[@type='license']"))
+          .each_with_index do |n, i|
+          license_termnote(n, i)
         end
         super
       end
 
+      def cleanup(docxml)
+        termsource_brackets(docxml)
+        super
+      end
+
+      def document_footnotes(docxml)
+        first_biblio_eref_fn(docxml)
+        super
+      end
+
       include Init
     end
   end