metanorma-iso 2.0.7 → 2.1.0

data/lib/isodoc/iso/metadata.rb

@@ -21,8 +21,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,9 +31,7 @@ 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)
@@ -56,10 +53,14 @@ module IsoDoc
       end
 
       def docid(isoxml, _out)
-        set(:docnumber, isoxml&.at(ns("//bibdata/docidentifier[@type = 'ISO']"))&.text)
-        set(:tc_docnumber, isoxml.xpath(ns("//bibdata/docidentifier[@type = 'iso-tc']")).map(&:text))
-        set(:docnumber_lang, isoxml&.at(ns("//bibdata/docidentifier[@type = 'iso-with-lang']"))&.text)
-        set(:docnumber_reference, isoxml&.at(ns("//bibdata/docidentifier[@type = 'iso-reference']"))&.text)
+        set(:tc_docnumber, isoxml
+          .xpath(ns("//bibdata/docidentifier[@type = 'iso-tc']")).map(&:text))
+        { docnumber: "ISO", docnumber_lang: "iso-with-lang",
+          docnumber_reference: "iso-reference",
+          docnumber_undated: "iso-undated" }.each do |k, v|
+          set(k,
+              isoxml&.at(ns("//bibdata/docidentifier[@type = '#{v}']"))&.text)
+        end
       end
 
       # we don't leave this to i18n.rb, because we have both English and
@@ -87,55 +88,63 @@ module IsoDoc
         end
       end
 
-      def part_title(part, partnum, subpartnum, lang)
+      def part_title(part, titlenums, lang)
         return "" unless part
 
         suffix = @c.encode(part.text, :hexadecimal)
-        partnum = "#{partnum}–#{subpartnum}" if partnum && subpartnum
-        suffix = "#{part_label(lang)} #{partnum}: " + suffix if partnum
+        p = titlenums[:part]
+        titlenums[:part] && titlenums[:subpart] and
+          p = "#{titlenums[:part]}–#{titlenums[:subpart]}"
+        titlenums[:part] and
+          suffix = "#{part_label(lang)} #{p}: " + suffix
         suffix
       end
 
-      def part_prefix(partnum, subpartnum, lang)
-        partnum = "#{partnum}–#{subpartnum}" if partnum && subpartnum
-        "#{part_label(lang)} #{partnum}"
+      def part_prefix(titlenums, lang)
+        p = titlenums[:part]
+        titlenums[:part] && titlenums[:subpart] and
+          p = "#{titlenums[:part]}–#{titlenums[:subpart]}"
+        "#{part_label(lang)} #{p}"
       end
 
-      def amd_prefix(num, lang)
-        "#{amd_label(lang)} #{num}"
+      def amd_prefix(titlenums, lang)
+        "#{amd_label(lang)} #{titlenums[:amd]}"
       end
 
-      def corr_prefix(num, lang)
-        "#{corr_label(lang)} #{num}"
+      def corr_prefix(titlenums, lang)
+        "#{corr_label(lang)} #{titlenums[:corr]}"
       end
 
-      def compose_title(main, intro, part, partnum, subpartnum, lang)
-        main = main.nil? ? "" : @c.encode(main.text, :hexadecimal)
-        intro &&
-          main = "#{@c.encode(intro.text, :hexadecimal)} — #{main}"
-        if part
-          suffix = part_title(part, partnum, subpartnum, lang)
+      def compose_title(tparts, tnums, lang)
+        main = ""
+        tparts[:main].nil? or
+          main = @c.encode(tparts[:main].text, :hexadecimal)
+        tparts[:intro] &&
+          main = "#{@c.encode(tparts[:intro].text,
+                              :hexadecimal)} — #{main}"
+        if tparts[:part]
+          suffix = part_title(tparts[:part], tnums, lang)
           main = "#{main} — #{suffix}"
         end
         main
       end
 
       def title_nums(isoxml)
-        [isoxml.at(ns("//bibdata//project-number/@part")),
-         isoxml.at(ns("//bibdata//project-number/@subpart")),
-         isoxml.at(ns("//bibdata//project-number/@amendment")),
-         isoxml.at(ns("//bibdata//project-number/@corrigendum"))]
+        { 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")) }
       end
 
       def title_parts(isoxml, lang)
-        [isoxml.at(ns("//bibdata//title[@type='title-intro' and "\
-                      "@language='#{lang}']")),
-         isoxml.at(ns("//bibdata//title[@type='title-main' and "\
-                      "@language='#{lang}']")),
-         isoxml.at(ns("//bibdata//title[@type='title-part' and "\
-                      "@language='#{lang}']")),
-         isoxml.at(ns("//bibdata//title[@type='title-amd' and "\
-                      "@language='#{lang}']"))]
+        { intro: isoxml.at(ns("//bibdata//title[@type='title-intro' and "\
+                              "@language='#{lang}']")),
+          main: isoxml.at(ns("//bibdata//title[@type='title-main' and "\
+                             "@language='#{lang}']")),
+          part: isoxml.at(ns("//bibdata//title[@type='title-part' and "\
+                             "@language='#{lang}']")),
+          amd: isoxml.at(ns("//bibdata//title[@type='title-amd' and "\
+                            "@language='#{lang}']")) }
       end
 
       def title(isoxml, _out)
@@ -144,40 +153,43 @@ module IsoDoc
                when "ru" then "ru"
                else "en"
                end
-        intro, main, part, amd = title_parts(isoxml, lang)
-        partnumber, subpartnumber, amdnumber, corrnumber = title_nums(isoxml)
+        # intro, main, part, amd = title_parts(isoxml, lang)
+        tp = title_parts(isoxml, lang)
+        tn = title_nums(isoxml)
 
-        set(:doctitlemain, @c.encode(main ? main.text : "", :hexadecimal))
-        main = compose_title(main, intro, part, partnumber, subpartnumber, lang)
+        set(:doctitlemain,
+            @c.encode(tp[:main] ? tp[:main].text : "", :hexadecimal))
+        main = compose_title(tp, tn, lang)
         set(:doctitle, main)
-        if intro
+        tp[:intro] and
           set(:doctitleintro,
-              @c.encode(intro ? intro.text : "", :hexadecimal))
-        end
-        set(:doctitlepartlabel, part_prefix(partnumber, subpartnumber, lang))
-        set(:doctitlepart, @c.encode(part.text, :hexadecimal)) if part
-        set(:doctitleamdlabel, amd_prefix(amdnumber, lang)) if amdnumber
-        set(:doctitleamd, @c.encode(amd.text, :hexadecimal)) if amd
-        set(:doctitlecorrlabel, corr_prefix(corrnumber, lang)) if corrnumber
+              @c.encode(tp[:intro] ? tp[:intro].text : "", :hexadecimal))
+        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]
+        set(:doctitleamd, @c.encode(tp[:amd].text, :hexadecimal)) if tp[:amd]
+        set(:doctitlecorrlabel, corr_prefix(tn, lang)) if tn[:corr]
       end
 
       def subtitle(isoxml, _out)
         lang = @lang == "en" ? "fr" : "en"
-        intro, main, part, amd = title_parts(isoxml, lang)
-        partnumber, subpartnumber, amdnumber, corrnumber = title_nums(isoxml)
+        tp = title_parts(isoxml, lang)
+        tn = title_nums(isoxml)
 
-        set(:docsubtitlemain, @c.encode(main ? main.text : "", :hexadecimal))
-        main = compose_title(main, intro, part, partnumber, subpartnumber, lang)
+        set(:docsubtitlemain,
+            @c.encode(tp[:main] ? tp[:main].text : "", :hexadecimal))
+        main = compose_title(tp, tn, lang)
         set(:docsubtitle, main)
-        if intro
+        tp[:intro] and
           set(:docsubtitleintro,
-              @c.encode(intro ? intro.text : "", :hexadecimal))
-        end
-        set(:docsubtitlepartlabel, part_prefix(partnumber, subpartnumber, lang))
-        set(:docsubtitlepart, @c.encode(part.text, :hexadecimal)) if part
-        set(:docsubtitleamdlabel, amd_prefix(amdnumber, lang)) if amdnumber
-        set(:docsubtitleamd, @c.encode(amd.text, :hexadecimal)) if amd
-        set(:docsubtitlecorrlabel, corr_prefix(corrnumber, lang)) if corrnumber
+              @c.encode(tp[:intro] ? tp[:intro].text : "", :hexadecimal))
+        set(:docsubtitlepartlabel, part_prefix(tn, lang))
+        tp[:part] and
+          set(:docsubtitlepart,
+              @c.encode(tp[:part].text, :hexadecimal))
+        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]
       end
 
       def author(xml, _out)
@@ -231,8 +243,8 @@ module IsoDoc
         ics = []
         isoxml.xpath(ns("//bibdata/ext/ics/code")).each { |i| ics << i.text }
         set(:ics, ics.empty? ? nil : ics.join(", "))
-        a = isoxml.at(ns("//bibdata/ext/horizontal")) and set(:horizontal,
-                                                              a.text)
+        a = isoxml.at(ns("//bibdata/ext/horizontal")) and
+          set(:horizontal, a.text)
       end
     end
   end

data/lib/isodoc/iso/presentation_inline.rb

@@ -0,0 +1,90 @@
+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&.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 ""
+              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)
+      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_inline"
+require_relative "presentation_xref"
+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,13 +26,7 @@ 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)
-        return if labelled_ancestor(node) && node.ancestors("figure").empty?
-
         lbl = @xrefs.anchor(node["id"], :label, false) or return
         figname = node.parent.name == "figure" ? "" : "#{@i18n.figure} "
         connective = node.parent.name == "figure" ? "&nbsp; " : "&nbsp;&mdash; "
@@ -37,93 +35,12 @@ module IsoDoc
 
       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]}")
+        lbl = if n.nil? || blank?(n[:label]) then @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 ""
-              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)
-      end
-
       def example_span_label(_node, div, name)
         return if name.nil?
 
@@ -143,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
@@ -160,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
 
@@ -179,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)
@@ -246,6 +159,32 @@ 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
+
       include Init
     end
   end

data/lib/isodoc/iso/presentation_xref.rb

@@ -0,0 +1,126 @@
+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 += "&ndash;#{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 += "&ndash;#{upto}" if upto
+        ret += ")" if type == "list"
+        ret = l10n(ret)
+        locality_span_wrap(ret, type)
+      end
+
+      def prefix_container(container, linkend, target)
+        delim = @xrefs.anchor(target, :type) == "listitem" ? " " : ", "
+        l10n(@xrefs.anchor(container, :xref) + 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

data/lib/isodoc/iso/word_cleanup.rb

@@ -65,7 +65,7 @@ module IsoDoc
         insert = docxml.at("//div[@id = 'boilerplate-license-destination']")
         auth = docxml&.at("//div[@class = 'boilerplate-license']")&.remove
         auth&.xpath(".//p[not(@class)]")&.each { |p| p["class"] = "zzWarning" }
-        auth and insert.children = auth
+        auth and insert and insert.children = auth
         insert = docxml.at("//div[@id = 'boilerplate-copyright-destination']")
         auth = docxml&.at("//div[@class = 'boilerplate-copyright']")&.remove
         auth&.xpath(".//p[not(@class)]")&.each do |p|
@@ -80,7 +80,8 @@ module IsoDoc
         auth&.xpath(".//p[@id = 'boilerplate-place']")&.each do |p|
           p["class"] = "zzCopyright1"
         end
-        auth and insert.children = auth
+        auth and insert and insert.children = auth
+        coverpage_note_cleanup(docxml)
       end
 
       def word_cleanup(docxml)
@@ -89,6 +90,19 @@ module IsoDoc
         style_cleanup(docxml)
         docxml
       end
+
+      # supply missing annex title
+      def make_WordToC(docxml, level)
+        toc = ""
+        xpath = (1..level).each.map { |i| "//h#{i}" }.join (" | ")
+        docxml.xpath(xpath).each do |h|
+          x = ""
+          x = @anchor[h.parent["id"]][:xref] if h["class"] == "ANNEX"
+          toc += word_toc_entry(h.name[1].to_i, x + header_strip(h))
+        end
+        toc.sub(/(<p class="MsoToc1">)/,
+                %{\\1#{word_toc_preface(level)}}) + WORD_TOC_SUFFIX1
+      end
     end
   end
 end