metanorma-iso 2.0.8.1 → 2.1.2

data/lib/isodoc/iso/metadata.rb

@@ -5,11 +5,8 @@ module IsoDoc
     class Metadata < IsoDoc::Metadata
       def initialize(lang, script, i18n)
         super
-        set(:tc, "XXXX")
-        set(:sc, "XXXX")
-        set(:wg, "XXXX")
+        DATETYPES.each { |w| @metadata["#{w.gsub(/-/, '_')}date".to_sym] = nil }
         set(:editorialgroup, [])
-        set(:secretariat, "XXX")
         set(:obsoletes, nil)
         set(:obsoletes_part, nil)
       end
@@ -21,8 +18,7 @@ module IsoDoc
           stage = "DTS" if stage == "DIS"
           stage = "FDTS" if stage == "FDIS"
         end
-        %w(PWI NWIP WD CD).include?(stage) && iter and
-          stage += iter
+        %w(PWI NWIP WD CD).include?(stage) && iter and stage += iter
         stage = "Pre#{stage}" if /^0\./.match?(draft)
         stage
       end
@@ -32,21 +28,20 @@ module IsoDoc
         set(:unpublished, false)
         revdate = isoxml.at(ns("//bibdata/version/revision-date"))
         set(:revdate, revdate&.text)
-        if docstatus
-          docstatus1(isoxml, docstatus)
-        end
+        docstatus and docstatus1(isoxml, docstatus)
       end
 
       def docstatus1(isoxml, docstatus)
         set(:stage, docstatus.text)
         set(:stage_int, docstatus.text.to_i)
+        set(:substage_int, isoxml.at(ns("//bibdata/status/substage"))&.text)
         set(:unpublished, unpublished(docstatus.text))
         set(:statusabbr,
             status_abbrev(docstatus["abbreviation"] || "??",
-                          isoxml&.at(ns("//bibdata/status/substage"))&.text,
-                          isoxml&.at(ns("//bibdata/status/iteration"))&.text,
-                          isoxml&.at(ns("//bibdata/version/draft"))&.text,
-                          isoxml&.at(ns("//bibdata/ext/doctype"))&.text))
+                          isoxml.at(ns("//bibdata/status/substage"))&.text,
+                          isoxml.at(ns("//bibdata/status/iteration"))&.text,
+                          isoxml.at(ns("//bibdata/version/draft"))&.text,
+                          isoxml.at(ns("//bibdata/ext/doctype"))&.text))
         unpublished(docstatus.text) and
           set(:stageabbr, docstatus["abbreviation"])
       end
@@ -68,28 +63,11 @@ module IsoDoc
 
       # we don't leave this to i18n.rb, because we have both English and
       # French titles in the same document
-      def part_label(lang)
-        case lang
-        when "en" then "Part"
-        when "fr" then "Partie"
-        when "ru" then "Часть"
-        end
-      end
-
-      def amd_label(lang)
-        case lang
-        when "en", "fr" then "AMENDMENT"
-        when "ru" then "ПОПРАВКА"
-        end
-      end
-
-      def corr_label(lang)
-        case lang
-        when "en" then "TECHNICAL CORRIGENDUM"
-        when "fr" then "RECTIFICATIF TECHNIQUE"
-        when "ru" then "ТЕХНИЧЕСКОЕ ИСПРАВЛЕНИЕ"
-        end
-      end
+      PART_LABEL = { en: "Part", fr: "Partie", ru: "Часть" }.freeze
+      AMD_LABEL = { en: "AMENDMENT", fr: "AMENDMENT", ru: "ПОПРАВКА" }.freeze
+      CORR_LABEL = { en: "TECHNICAL CORRIGENDUM",
+                     fr: "RECTIFICATIF TECHNIQUE",
+                     ru: "ТЕХНИЧЕСКОЕ ИСПРАВЛЕНИЕ" }.freeze
 
       def part_title(part, titlenums, lang)
         return "" unless part
@@ -97,25 +75,25 @@ module IsoDoc
         suffix = @c.encode(part.text, :hexadecimal)
         p = titlenums[:part]
         titlenums[:part] && titlenums[:subpart] and
-          p = "#{titlenums[:part]}&ndash;#{titlenums[:subpart]}"
+          p = "#{titlenums[:part]}&#x2013;#{titlenums[:subpart]}"
         titlenums[:part] and
-          suffix = "#{part_label(lang)}&nbsp;#{p}: " + suffix
+          suffix = "#{PART_LABEL[lang.to_sym]}&#xa0;#{p}: " + suffix
         suffix
       end
 
       def part_prefix(titlenums, lang)
         p = titlenums[:part]
         titlenums[:part] && titlenums[:subpart] and
-          p = "#{titlenums[:part]}&ndash;#{titlenums[:subpart]}"
-        "#{part_label(lang)}&nbsp;#{p}"
+          p = "#{titlenums[:part]}&#x2013;#{titlenums[:subpart]}"
+        "#{PART_LABEL[lang.to_sym]}&#xa0;#{p}"
       end
 
       def amd_prefix(titlenums, lang)
-        "#{amd_label(lang)}&nbsp;#{titlenums[:amd]}"
+        "#{AMD_LABEL[lang.to_sym]}&#xa0;#{titlenums[:amd]}"
       end
 
       def corr_prefix(titlenums, lang)
-        "#{corr_label(lang)}&nbsp;#{titlenums[:corr]}"
+        "#{CORR_LABEL[lang.to_sym]}&#xa0;#{titlenums[:corr]}"
       end
 
       def compose_title(tparts, tnums, lang)
@@ -124,29 +102,30 @@ module IsoDoc
           main = @c.encode(tparts[:main].text, :hexadecimal)
         tparts[:intro] &&
           main = "#{@c.encode(tparts[:intro].text,
-                              :hexadecimal)}&nbsp;&mdash; #{main}"
+                              :hexadecimal)}&#xa0;&#x2014; #{main}"
         if tparts[:part]
           suffix = part_title(tparts[:part], tnums, lang)
-          main = "#{main}&nbsp;&mdash; #{suffix}"
+          main = "#{main}&#xa0;&#x2014; #{suffix}"
         end
         main
       end
 
       def title_nums(isoxml)
-        { part: isoxml.at(ns("//bibdata//project-number/@part")),
-          subpart: isoxml.at(ns("//bibdata//project-number/@subpart")),
-          amd: isoxml.at(ns("//bibdata//project-number/@amendment")),
-          corr: isoxml.at(ns("//bibdata//project-number/@corrigendum")) }
+        prefix = "//bibdata/ext/structuredidentifier/project-number"
+        { part: isoxml.at(ns("#{prefix}/@part")),
+          subpart: isoxml.at(ns("#{prefix}/@subpart")),
+          amd: isoxml.at(ns("#{prefix}/@amendment")),
+          corr: isoxml.at(ns("#{prefix}/@corrigendum")) }
       end
 
       def title_parts(isoxml, lang)
-        { intro: isoxml.at(ns("//bibdata//title[@type='title-intro' and "\
+        { intro: isoxml.at(ns("//bibdata/title[@type='title-intro' and "\
                               "@language='#{lang}']")),
-          main: isoxml.at(ns("//bibdata//title[@type='title-main' and "\
+          main: isoxml.at(ns("//bibdata/title[@type='title-main' and "\
                              "@language='#{lang}']")),
-          part: isoxml.at(ns("//bibdata//title[@type='title-part' and "\
+          part: isoxml.at(ns("//bibdata/title[@type='title-part' and "\
                              "@language='#{lang}']")),
-          amd: isoxml.at(ns("//bibdata//title[@type='title-amd' and "\
+          amd: isoxml.at(ns("//bibdata/title[@type='title-amd' and "\
                             "@language='#{lang}']")) }
       end
 
@@ -164,10 +143,9 @@ module IsoDoc
             @c.encode(tp[:main] ? tp[:main].text : "", :hexadecimal))
         main = compose_title(tp, tn, lang)
         set(:doctitle, main)
-        if tp[:intro]
+        tp[:intro] and
           set(:doctitleintro,
               @c.encode(tp[:intro] ? tp[:intro].text : "", :hexadecimal))
-        end
         set(:doctitlepartlabel, part_prefix(tn, lang))
         set(:doctitlepart, @c.encode(tp[:part].text, :hexadecimal)) if tp[:part]
         set(:doctitleamdlabel, amd_prefix(tn, lang)) if tn[:amd]
@@ -184,15 +162,13 @@ module IsoDoc
             @c.encode(tp[:main] ? tp[:main].text : "", :hexadecimal))
         main = compose_title(tp, tn, lang)
         set(:docsubtitle, main)
-        if tp[:intro]
+        tp[:intro] and
           set(:docsubtitleintro,
               @c.encode(tp[:intro] ? tp[:intro].text : "", :hexadecimal))
-        end
         set(:docsubtitlepartlabel, part_prefix(tn, lang))
-        if tp[:part]
+        tp[:part] and
           set(:docsubtitlepart,
               @c.encode(tp[:part].text, :hexadecimal))
-        end
         set(:docsubtitleamdlabel, amd_prefix(tn, lang)) if tn[:amd]
         set(:docsubtitleamd, @c.encode(tp[:amd].text, :hexadecimal)) if tp[:amd]
         set(:docsubtitlecorrlabel, corr_prefix(tn, lang)) if tn[:corr]
@@ -203,40 +179,58 @@ module IsoDoc
         tc(xml)
         sc(xml)
         wg(xml)
+        approvalgroup(xml)
         secretariat(xml)
       end
 
       def tc(xml)
-        tc_type = xml.at(ns("//bibdata/ext/editorialgroup/technical-committee/"\
+        tcid = tc_base(xml, "editorialgroup") or return
+        set(:tc, tcid)
+        set(:editorialgroup, get[:editorialgroup] << tcid)
+      end
+
+      def tc_base(xml, grouptype)
+        tc_num = xml.at(ns("//bibdata/ext/#{grouptype}/"\
+                           "technical-committee/@number")) or return nil
+        tc_type = xml.at(ns("//bibdata/ext/#{grouptype}/technical-committee/"\
                             "@type"))&.text || "TC"
-        if tc_num = xml.at(ns("//bibdata/ext/editorialgroup/"\
-                              "technical-committee/@number"))
-          tcid = "#{tc_type} #{tc_num.text}"
-          set(:tc,  tcid)
-          set(:editorialgroup, get[:editorialgroup] << tcid)
-        end
+        "#{tc_type} #{tc_num.text}"
       end
 
       def sc(xml)
-        sc_num = xml.at(ns("//bibdata/ext/editorialgroup/subcommittee/@number"))
-        sc_type = xml.at(ns("//bibdata/ext/editorialgroup/subcommittee/"\
+        scid = sc_base(xml, "editorialgroup") or return
+        set(:sc, scid)
+        set(:editorialgroup, get[:editorialgroup] << scid)
+      end
+
+      def sc_base(xml, grouptype)
+        sc_num = xml.at(ns("//bibdata/ext/#{grouptype}/subcommittee/"\
+                           "@number")) or return nil
+        sc_type = xml.at(ns("//bibdata/ext/#{grouptype}/subcommittee/"\
                             "@type"))&.text || "SC"
-        if sc_num
-          scid = "#{sc_type} #{sc_num.text}"
-          set(:sc, scid)
-          set(:editorialgroup, get[:editorialgroup] << scid)
-        end
+        "#{sc_type} #{sc_num.text}"
       end
 
       def wg(xml)
-        wg_num = xml.at(ns("//bibdata/ext/editorialgroup/workgroup/@number"))
-        wg_type = xml.at(ns("//bibdata/ext/editorialgroup/workgroup/"\
+        wgid = wg_base(xml, "editorialgroup") or return
+        set(:wg, wgid)
+        set(:editorialgroup, get[:editorialgroup] << wgid)
+      end
+
+      def wg_base(xml, grouptype)
+        wg_num = xml.at(ns("//bibdata/ext/#{grouptype}/workgroup/"\
+                           "@number")) or return
+        wg_type = xml.at(ns("//bibdata/ext/#{grouptype}/workgroup/"\
                             "@type"))&.text || "WG"
-        if wg_num
-          wgid = "#{wg_type} #{wg_num.text}"
-          set(:wg, wgid)
-          set(:editorialgroup, get[:editorialgroup] << wgid)
-        end
+        "#{wg_type} #{wg_num.text}"
+      end
+
+      def approvalgroup(xml)
+        ag = tc_base(xml, "approvalgroup") or return
+        ret = [ag]
+        ret << sc_base(xml, "approvalgroup")
+        ret << wg_base(xml, "approvalgroup")
+        set(:approvalgroup, ret)
       end
 
       def secretariat(xml)

data/lib/isodoc/iso/presentation_bibdata.rb

@@ -0,0 +1,74 @@
+module IsoDoc
+  module Iso
+    class PresentationXMLConvert < IsoDoc::PresentationXMLConvert
+      def bibdata(docxml)
+        super
+        editorialgroup_identifier(docxml)
+        warning_for_missing_metadata(docxml)
+      end
+
+      def warning_for_missing_metadata(docxml)
+        return unless @meta.get[:unpublished]
+
+        ret = ""
+        docxml.at(ns("//bibdata/ext//secretariat")) or
+          ret += "<p>Secretariat is missing.</p>"
+        docxml.at(ns("//bibdata/ext//editorialgroup")) or
+          ret += "<p>Editorial groups are missing.</p>"
+        docxml.at(ns("//bibdata/date[@type = 'published' or @type = 'issued' "\
+                     "or @type = 'created']")) ||
+          docxml.at(ns("//bibdata/version/revision-date")) or
+          ret += "<p>Document date is missing.</p>"
+        return if ret.empty?
+
+        warning_for_missing_metadata1(docxml, ret)
+      end
+
+      def warning_for_missing_metadata1(docxml, ret)
+        id = UUIDTools::UUID.random_create
+        ret = "<review date='#{Date.today}' reviewer='Metanorma' id='_#{id}'>"\
+              "<p><strong>Metadata warnings:<strong></p> #{ret}</review>"
+        ins = docxml.at(ns("//sections//title")) or return
+        ins.children.first.previous = ret
+      end
+
+      def editorialgroup_identifier(docxml)
+        %w(editorialgroup approvalgroup).each do |v|
+          docxml.xpath(ns("//bibdata/ext/#{v}")).each do |a|
+            editorialgroup_identifier1(a)
+          end
+        end
+      end
+
+      def editorialgroup_identifier1(group)
+        agency = group.xpath(ns("./agency"))&.map(&:text)
+        ret = %w(technical-committee subcommittee workgroup)
+          .each_with_object([]) do |v, m|
+          a = group.at(ns("./#{v}")) or next
+          m << "#{a['type']} #{a['number']}"
+        end
+        group["identifier"] = (agency + ret).join("/")
+      end
+
+      def bibdata_i18n(bib)
+        hash_translate(bib, @i18n.get["doctype_dict"], "./ext/doctype")
+        bibdata_i18n_stage(bib, bib.at(ns("./status/stage")),
+                           bib.at(ns("./ext/doctype")))
+        hash_translate(bib, @i18n.get["substage_dict"],
+                       "./status/substage")
+        edition_translate(bib)
+      end
+
+      def bibdata_i18n_stage(bib, stage, type, lang: @lang, i18n: @i18n)
+        return unless stage
+
+        i18n.get["stage_dict"][stage.text].is_a?(Hash) or
+          return hash_translate(bib, i18n.get["stage_dict"],
+                                "./status/stage", lang)
+        i18n.get["stage_dict"][stage.text][type&.text] and
+          tag_translate(stage, lang,
+                        i18n.get["stage_dict"][stage.text][type&.text])
+      end
+    end
+  end
+end

data/lib/isodoc/iso/presentation_xml_convert.rb

@@ -1,11 +1,15 @@
 require_relative "init"
 require "isodoc"
 require_relative "index"
+require_relative "presentation_xref"
+require_relative "presentation_bibdata"
+require_relative "../../relaton/render/general"
 
 module IsoDoc
   module Iso
     class PresentationXMLConvert < IsoDoc::PresentationXMLConvert
       def convert1(docxml, filename, dir)
+        @iso_class = instance_of?(IsoDoc::Iso::PresentationXMLConvert)
         if amd(docxml)
           @oldsuppressheadingnumbers = @suppressheadingnumbers
           @suppressheadingnumbers = true
@@ -22,104 +26,19 @@ module IsoDoc
         amd(isoxml) and @suppressheadingnumbers = true
       end
 
-      def xref_init(lang, script, klass, labels, options)
-        @xrefs = Xref.new(lang, script, klass, labels, options)
-      end
-
       def figure1(node)
         lbl = @xrefs.anchor(node["id"], :label, false) or return
         figname = node.parent.name == "figure" ? "" : "#{@i18n.figure} "
-        connective = node.parent.name == "figure" ? "&nbsp; " : "&nbsp;&mdash; "
+        connective = node.parent.name == "figure" ? "&#xa0; " : "&#xa0;&#x2014; "
         prefix_name(node, connective, l10n("#{figname}#{lbl}"), "name")
       end
 
       def example1(node)
         n = @xrefs.get[node["id"]]
-        lbl = if n.nil? || n[:label].nil? || n[:label].empty?
-                @i18n.example
-              else
-                l10n("#{@i18n.example} #{n[:label]}")
-              end
-        prefix_name(node, "&nbsp;&mdash; ", lbl, "name")
-      end
-
-      def eref_delim(delim, type)
-        if delim == ";" then ";"
-        else type == "list" ? " " : delim
-        end
-      end
-
-      def can_conflate_eref_rendering?(refs)
-        super or return false
-
-        first = subclause?(nil, refs.first.at(ns("./locality/@type"))&.text,
-                           refs.first.at(ns("./locality/referenceFrom"))&.text)
-        refs.all? do |r|
-          subclause?(nil, r.at(ns("./locality/@type"))&.text,
-                     r.at(ns("./locality/referenceFrom"))&.text) == first
-        end
-      end
-
-      def locality_delimiter(loc)
-        loc&.next_element&.attribute("type")&.text == "list" and return " "
-        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
-        eref_localities1(target,
-                         prefix_clause(target, refs.first.at(ns("./locality"))),
-                         l10n(ret[1..-1].join), nil, node, @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&.match?(/\./) && type == "clause") ||
-          type == "list" || target&.match(/^IEV$|^IEC 60050-/)
-      end
-
-      def eref_localities1_zh(target, type, from, upto, node)
-        ret = " 第#{from}" if from
-        ret += "&ndash;#{upto}" if upto
-        if node["droploc"] != "true" && !subclause?(target, type, from)
-          ret += eref_locality_populate(type, node)
-        end
-        ret += ")" if type == "list"
-        ret
-      end
-
-      def eref_localities1(target, type, from, upto, node, lang = "en")
-        return nil if type == "anchor"
-
-        type = type.downcase
-        lang == "zh" and
-          return l10n(eref_localities1_zh(target, type, from, upto, node))
-        ret = if node["droploc"] != "true" && !subclause?(target, type, from)
-                eref_locality_populate(type, node)
-              else ""
+        lbl = if n.nil? || blank?(n[:label]) then @i18n.example
+              else l10n("#{@i18n.example} #{n[:label]}")
               end
-        ret += " #{from}" if from
-        ret += "&ndash;#{upto}" if upto
-        ret += ")" if type == "list"
-        l10n(ret)
-      end
-
-      def prefix_container(container, linkend, target)
-        delim = @xrefs.anchor(target, :type) == "listitem" ? " " : ", "
-        l10n(@xrefs.anchor(container, :xref) + delim + linkend)
+        prefix_name(node, "&#xa0;&#x2014; ", lbl, "name")
       end
 
       def example_span_label(_node, div, name)
@@ -141,8 +60,7 @@ module IsoDoc
       def clause(docxml)
         docxml.xpath(ns("//clause[not(ancestor::annex)] | "\
                         "//terms | //definitions | //references | "\
-                        "//preface/introduction[clause]"))
-          .each do |f|
+                        "//preface/introduction[clause]")).each do |f|
           clause1(f)
         end
       end
@@ -158,9 +76,7 @@ module IsoDoc
       def concept_term(docxml)
         docxml.xpath(ns("//term")).each do |f|
           m = {}
-          f.xpath(ns(".//concept")).each do |c|
-            concept_term1(c, m)
-          end
+          f.xpath(ns(".//concept")).each { |c| concept_term1(c, m) }
         end
       end
 
@@ -177,12 +93,11 @@ module IsoDoc
       end
 
       def concept1_ref_content(ref)
-        if ref.name == "termref"
-          ref.replace(@i18n.term_defined_in.sub(/%/,
-                                                ref.to_xml))
-        else
-          ref.replace("(#{ref.to_xml})")
-        end
+        repl = if ref.name == "termref"
+                 @i18n.term_defined_in.sub(/%/, ref.to_xml)
+               else "(#{ref.to_xml})"
+               end
+        ref.replace(repl)
       end
 
       def concept1(node)
@@ -244,6 +159,43 @@ module IsoDoc
         super
       end
 
+      def admonition1(elem)
+        super
+        return unless n = elem.at(ns("./name"))
+
+        p = n.next_element
+        return unless p.name == "p"
+
+        p.children.first.previous = admonition_name(n.remove.children.to_xml)
+      end
+
+      def admonition_name(xml)
+        "#{xml} &#x2014; "
+      end
+
+      def bibrenderer
+        ::Relaton::Render::Iso::General.new(language: @lang,
+                                            i18nhash: @i18n.get)
+      end
+
+      def bibrender(xml)
+        unless xml.at(ns("./formattedref"))
+          xml.children =
+            "#{bibrenderer.render(xml.to_xml)}"\
+            "#{xml.xpath(ns('./docidentifier | ./uri | ./note')).to_xml}"
+        end
+      end
+
+      def ol_depth(node)
+        depth = node.ancestors(@iso_class ? "ol" : "ul, ol").size + 1
+        type = :alphabet
+        type = :arabic if [2, 7].include? depth
+        type = :roman if [3, 8].include? depth
+        type = :alphabet_upper if [4, 9].include? depth
+        type = :roman_upper if [5, 10].include? depth
+        type
+      end
+
       include Init
     end
   end

data/lib/isodoc/iso/presentation_xref.rb

@@ -0,0 +1,132 @@
+module IsoDoc
+  module Iso
+    class PresentationXMLConvert < IsoDoc::PresentationXMLConvert
+      def xref_init(lang, script, klass, labels, options)
+        @xrefs = Xref.new(lang, script, klass, labels, options)
+      end
+
+      def eref_delim(delim, type)
+        if delim == ";" then ";"
+        else type == "list" ? " " : delim
+        end
+      end
+
+      def can_conflate_eref_rendering?(refs)
+        super or return false
+
+        first = subclause?(nil, refs.first.at(ns("./locality/@type"))&.text,
+                           refs.first.at(ns("./locality/referenceFrom"))&.text)
+        refs.all? do |r|
+          subclause?(nil, r.at(ns("./locality/@type"))&.text,
+                     r.at(ns("./locality/referenceFrom"))&.text) == first
+        end
+      end
+
+      def locality_delimiter(loc)
+        loc&.next_element&.attribute("type")&.text == "list" and return " "
+        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
+        eref_localities1(target,
+                         prefix_clause(target, refs.first.at(ns("./locality"))),
+                         l10n(ret[1..-1].join), nil, node, @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&.match?(/\./) && type == "clause") ||
+          type == "list" ||
+          target&.gsub(/<[^>]+>/, "")&.match(/^IEV$|^IEC 60050-/)
+      end
+
+      LOCALITY2SPAN = {
+        annex: "citeapp",
+        dunno: "citebase",
+        dunno2: "citebib",
+        dunno3: "citebox",
+        dunno4: "citeen",
+        dunno5: "citeeq",
+        figure: "citefig",
+        dunno6: "citefn",
+        clause: "citesec",
+        dunno7: "citesection",
+        table: "citetbl",
+        dunno8: "citetfn",
+      }.freeze
+
+      def locality_span_wrap(ret, type)
+        type or return ret
+        m = /^(\s*)(.+?)(\s*)$/.match(ret) or return ret
+        ret = [m[1], m[2], m[3]]
+        spanclass = LOCALITY2SPAN[type.to_sym] and
+          ret[1] = "<span class='#{spanclass}'>#{ret[1]}</span>"
+        ret.join
+      end
+
+      def eref_localities1_zh(target, type, from, upto, node)
+        ret = " 第#{from}" if from
+        ret += "&#x2013;#{upto}" if upto
+        node["droploc"] != "true" && !subclause?(target, type, from) and
+          ret += eref_locality_populate(type, node)
+        ret += ")" if type == "list"
+        locality_span_wrap(ret, type)
+      end
+
+      def eref_localities1(target, type, from, upto, node, lang = "en")
+        return nil if type == "anchor"
+
+        type = type.downcase
+        lang == "zh" and
+          return l10n(eref_localities1_zh(target, type, from, upto, node))
+        ret = ""
+        node["droploc"] != "true" && !subclause?(target, type, from) and
+          ret = eref_locality_populate(type, node)
+        ret += " #{from}" if from
+        ret += "&#x2013;#{upto}" if upto
+        ret += ")" if type == "list"
+        ret = l10n(ret)
+        locality_span_wrap(ret, type)
+      end
+
+      def prefix_container(container, linkend, target)
+        delim = ", "
+        type = :xref
+        if @xrefs.anchor(target, :type) == "listitem" &&
+            !@xrefs.anchor(target, :refer_list)
+          delim = " "
+          type = :label # 7 a) not Clause 7 a), but Clause 7 List 1 a)
+        end
+        l10n(@xrefs.anchor(container, type) + delim + linkend)
+      end
+
+      def expand_citeas(text)
+        std_docid_semantic(super)
+      end
+
+      def anchor_value(id)
+        locality_span_wrap(super, @xrefs.anchor(id, :subtype) ||
+                            @xrefs.anchor(id, :type))
+      end
+
+      def anchor_linkend1(node)
+        locality_span_wrap(super, @xrefs.anchor(node["target"], :subtype) ||
+                           @xrefs.anchor(node["target"], :type))
+      end
+    end
+  end
+end