diff --git a/isodoc.gemspec b/isodoc.gemspec
index d490e43c..1a270824 100644
--- a/isodoc.gemspec
+++ b/isodoc.gemspec
@@ -55,5 +55,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "sassc", "~> 2.4.0"
   spec.add_development_dependency "simplecov", "~> 0.15"
   spec.add_development_dependency "timecop", "~> 0.9"
+  spec.add_development_dependency "xml-c14n"
   # spec.metadata["rubygems_mfa_required"] = "true"
 end
diff --git a/lib/isodoc/metadata.rb b/lib/isodoc/metadata.rb
index 2fb2363c..5afe1fcf 100644
--- a/lib/isodoc/metadata.rb
+++ b/lib/isodoc/metadata.rb
@@ -14,7 +14,7 @@ def l10n(expr, lang = @lang, script = @script, locale = @locale)
     end
 
     def initialize(lang, script, locale, i18n, fonts_options = {})
-      @metadata = { lang: lang, script: script }
+      @metadata = { lang:, script: }
       DATETYPES.each { |w| @metadata["#{w.gsub('-', '_')}date".to_sym] = "XXX" }
       @lang = lang
       @script = script
@@ -29,10 +29,6 @@ def get
       @metadata
     end
 
-    def labels
-      @labels
-    end
-
     def set(key, value)
       @metadata[key] = value
     end
@@ -44,12 +40,12 @@ def currlang
     end
 
     def doctype(isoxml, _out)
-      b = isoxml&.at(ns("//bibdata/ext/doctype#{NOLANG}"))&.text || return
-      set(:doctype, status_print(b))
-      b1 = isoxml&.at(ns("//bibdata/ext/doctype#{currlang}"))&.text || b
-      set(:doctype_display, status_print(b1))
-      b = isoxml&.at(ns("//bibdata/ext/subdoctype#{NOLANG}"))&.text || return
-      set(:subdoctype, status_print(b))
+      b = isoxml.at(ns("//bibdata/ext/doctype#{NOLANG}")) || return
+      set(:doctype, status_print(b.text))
+      b1 = isoxml.at(ns("//bibdata/ext/doctype#{currlang}")) || b
+      set(:doctype_display, status_print(b1.text))
+      b = isoxml.at(ns("//bibdata/ext/subdoctype#{NOLANG}")) || return
+      set(:subdoctype, status_print(b.text))
     end
 
     def docstatus(xml, _out)
@@ -59,11 +55,11 @@ def docstatus(xml, _out)
       s1 = xml.at(ns("//bibdata/status/stage#{currlang}")) || s
       set(:stage, status_print(s.text))
       s1 and set(:stage_display, status_print(s1.text))
-      (i = xml&.at(ns("//bibdata/status/substage#{NOLANG}"))&.text) and
+      (i = xml.at(ns("//bibdata/status/substage#{NOLANG}"))&.text) and
         set(:substage, i)
-      (i1 = xml&.at(ns("//bibdata/status/substage#{currlang}"))&.text || i) and
+      (i1 = xml.at(ns("//bibdata/status/substage#{currlang}"))&.text || i) and
         set(:substage_display, i1)
-      (i2 = xml&.at(ns("//bibdata/status/iteration"))&.text) and
+      (i2 = xml.at(ns("//bibdata/status/iteration"))&.text) and
         set(:iteration, i2)
       set(:unpublished, unpublished(s.text))
       unpublished(s.text) && set(:stageabbr, stage_abbr(s.text))
diff --git a/lib/isodoc/xref/xref_gen.rb b/lib/isodoc/xref/xref_gen.rb
index 164c8bdd..cfeb3d00 100644
--- a/lib/isodoc/xref/xref_gen.rb
+++ b/lib/isodoc/xref/xref_gen.rb
@@ -137,15 +137,16 @@ def list_item_anchor_names(list, list_anchor, depth, prev_label, refer_list)
         c = Counter.new(list["start"] ? list["start"].to_i - 1 : 0)
         list.xpath(ns("./li")).each do |li|
           bare_label, label =
-            list_item_value(li, c, depth, { list_anchor: list_anchor, prev_label: prev_label,
+            list_item_value(li, c, depth, { list_anchor:, prev_label:,
                                             refer_list: depth == 1 ? refer_list : nil })
           li["id"] and @anchors[li["id"]] =
                          { label: bare_label, bare_xref: "#{label})",
                            xref: "#{label})",
-                           type: "listitem", refer_list: refer_list,
+                           type: "listitem", refer_list:,
                            container: list_anchor[:container] }
           (li.xpath(ns(".//ol")) - li.xpath(ns(".//ol//ol"))).each do |ol|
-            list_item_anchor_names(ol, list_anchor, depth + 1, label, refer_list)
+            list_item_anchor_names(ol, list_anchor, depth + 1, label,
+                                   refer_list)
           end
         end
       end
@@ -227,7 +228,7 @@ def bookmark_container(parent)
       def bookmark_anchor_names(xml)
         xml.xpath(ns(".//bookmark")).noblank.each do |n|
           _parent, id = id_ancestor(n)
-          #container = bookmark_container(parent)
+          # container = bookmark_container(parent)
           @anchors[n["id"]] = { type: "bookmark", label: nil, value: nil,
                                 xref: @anchors.dig(id, :xref) || "???",
                                 container: @anchors.dig(id, :container) }
diff --git a/spec/isodoc/blocks_notes_spec.rb b/spec/isodoc/blocks_notes_spec.rb
index 9a3c25ec..0fb5a965 100644
--- a/spec/isodoc/blocks_notes_spec.rb
+++ b/spec/isodoc/blocks_notes_spec.rb
@@ -105,12 +105,12 @@
         </body>
       </html>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
-      .convert("test", input, true)))).to be_equivalent_to xmlpp(presxml)
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
-      .convert("test", presxml, true))).to be_equivalent_to xmlpp(html)
-    expect(xmlpp(IsoDoc::WordConvert.new({})
-      .convert("test", presxml, true))).to be_equivalent_to xmlpp(doc)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+      .convert("test", input, true)))).to be_equivalent_to Xml::C14n.format(presxml)
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
+      .convert("test", presxml, true))).to be_equivalent_to Xml::C14n.format(html)
+    expect(Xml::C14n.format(IsoDoc::WordConvert.new({})
+      .convert("test", presxml, true))).to be_equivalent_to Xml::C14n.format(doc)
   end
 
   it "processes sequences of notes" do
@@ -169,10 +169,10 @@
                </body>
            </html>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
-      .convert("test", input, true)))).to be_equivalent_to xmlpp(presxml)
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
-      .convert("test", presxml, true))).to be_equivalent_to xmlpp(output)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+      .convert("test", input, true)))).to be_equivalent_to Xml::C14n.format(presxml)
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
+      .convert("test", presxml, true))).to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "processes multi-para notes" do
@@ -205,8 +205,8 @@
             </body>
         </html>
     OUTPUT
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
-      .convert("test", input, true))).to be_equivalent_to xmlpp(output)
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
+      .convert("test", input, true))).to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "processes non-para notes" do
@@ -280,10 +280,10 @@
         </body>
       </html>
     OUTPUT
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
-      .convert("test", input, true))).to be_equivalent_to xmlpp(html)
-    expect(xmlpp(IsoDoc::WordConvert.new({})
-      .convert("test", input, true))).to be_equivalent_to xmlpp(doc)
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
+      .convert("test", input, true))).to be_equivalent_to Xml::C14n.format(html)
+    expect(Xml::C14n.format(IsoDoc::WordConvert.new({})
+      .convert("test", input, true))).to be_equivalent_to Xml::C14n.format(doc)
   end
 
   it "processes paragraphs containing notes" do
@@ -367,10 +367,10 @@
          </body>
        </html>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::HtmlConvert.new({})
-      .convert("test", input, true)))).to be_equivalent_to xmlpp(html)
-    expect(xmlpp(strip_guid(IsoDoc::WordConvert.new({})
-      .convert("test", input, true)))).to be_equivalent_to xmlpp(doc)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::HtmlConvert.new({})
+      .convert("test", input, true)))).to be_equivalent_to Xml::C14n.format(html)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::WordConvert.new({})
+      .convert("test", input, true)))).to be_equivalent_to Xml::C14n.format(doc)
   end
 
   it "converts notes and admonitions intended for coverpage" do
@@ -467,12 +467,12 @@
         </body>
       </html>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
-      .convert("test", input, true)))).to be_equivalent_to xmlpp(presxml)
-    expect(xmlpp(strip_guid(IsoDoc::HtmlConvert.new({})
-      .convert("test", presxml, true)))).to be_equivalent_to xmlpp(html)
-    expect(xmlpp(strip_guid(IsoDoc::WordConvert.new({})
-      .convert("test", presxml, true)))).to be_equivalent_to xmlpp(doc)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+      .convert("test", input, true)))).to be_equivalent_to Xml::C14n.format(presxml)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::HtmlConvert.new({})
+      .convert("test", presxml, true)))).to be_equivalent_to Xml::C14n.format(html)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::WordConvert.new({})
+      .convert("test", presxml, true)))).to be_equivalent_to Xml::C14n.format(doc)
   end
 
   it "numbers notes in tables and figures separately from notes outside them" do
@@ -517,8 +517,8 @@
           </preface>
         </iso-standard>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
-      .convert("test", input, true)))).to be_equivalent_to xmlpp(output)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+      .convert("test", input, true)))).to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "processes admonitions" do
@@ -567,10 +567,10 @@
         </body>
       </html>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
-      .convert("test", input, true)))).to be_equivalent_to xmlpp(presxml)
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
-      .convert("test", presxml, true))).to be_equivalent_to xmlpp(output)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+      .convert("test", input, true)))).to be_equivalent_to Xml::C14n.format(presxml)
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
+      .convert("test", presxml, true))).to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "processes empty admonitions" do
@@ -596,8 +596,8 @@
         </preface>
       </iso-standard>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
-        .convert("test", input, true)))).to be_equivalent_to xmlpp(presxml)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+        .convert("test", input, true)))).to be_equivalent_to Xml::C14n.format(presxml)
   end
 
   it "processes admonitions with titles" do
@@ -651,10 +651,10 @@
               </body>
           </html>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
-      .convert("test", input, true)))).to be_equivalent_to xmlpp(presxml)
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
-      .convert("test", presxml, true))).to be_equivalent_to xmlpp(output)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+      .convert("test", input, true)))).to be_equivalent_to Xml::C14n.format(presxml)
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
+      .convert("test", presxml, true))).to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "processes box admonitions" do
@@ -708,9 +708,12 @@
          </body>
        </html>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
-      .convert("test", input, true)))).to be_equivalent_to xmlpp(presxml)
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
-      .convert("test", presxml, true))).to be_equivalent_to xmlpp(output)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert
+      .new(presxml_options)
+      .convert("test", input, true))))
+      .to be_equivalent_to Xml::C14n.format(presxml)
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
+      .convert("test", presxml, true)))
+      .to be_equivalent_to Xml::C14n.format(output)
   end
 end
diff --git a/spec/isodoc/blocks_spec.rb b/spec/isodoc/blocks_spec.rb
index 82b0a169..7b3c1704 100644
--- a/spec/isodoc/blocks_spec.rb
+++ b/spec/isodoc/blocks_spec.rb
@@ -244,12 +244,12 @@
            </body>
          </html>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
       .convert("test", input, true))
       .sub(%r{<localized-strings>.*</localized-strings>}m, "")))
-      .to be_equivalent_to xmlpp(presxml)
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
-      .convert("test", presxml, true))).to be_equivalent_to xmlpp(html)
+      .to be_equivalent_to Xml::C14n.format(presxml)
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
+      .convert("test", presxml, true))).to be_equivalent_to Xml::C14n.format(html)
   end
 
   it "processes examples" do
@@ -352,12 +352,12 @@
         </body>
       </html>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
-      .convert("test", input, true)))).to be_equivalent_to xmlpp(presxml)
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
-      .convert("test", presxml, true))).to be_equivalent_to xmlpp(html)
-    expect(xmlpp(IsoDoc::WordConvert.new({})
-      .convert("test", presxml, true))).to be_equivalent_to xmlpp(doc)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+      .convert("test", input, true)))).to be_equivalent_to Xml::C14n.format(presxml)
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
+      .convert("test", presxml, true))).to be_equivalent_to Xml::C14n.format(html)
+    expect(Xml::C14n.format(IsoDoc::WordConvert.new({})
+      .convert("test", presxml, true))).to be_equivalent_to Xml::C14n.format(doc)
   end
 
   it "processes sequences of examples" do
@@ -401,8 +401,8 @@
         </preface>
       </iso-standard>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
-      .convert("test", input, true)))).to be_equivalent_to xmlpp(output)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+      .convert("test", input, true)))).to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "processes formulae" do
@@ -555,12 +555,12 @@
            </body>
          </html>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
-      .convert("test", input, true)))).to be_equivalent_to xmlpp(presxml)
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
-      .convert("test", presxml, true))).to be_equivalent_to xmlpp(html)
-    expect(xmlpp(IsoDoc::WordConvert.new({})
-      .convert("test", presxml, true))).to be_equivalent_to xmlpp(word)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+      .convert("test", input, true)))).to be_equivalent_to Xml::C14n.format(presxml)
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
+      .convert("test", presxml, true))).to be_equivalent_to Xml::C14n.format(html)
+    expect(Xml::C14n.format(IsoDoc::WordConvert.new({})
+      .convert("test", presxml, true))).to be_equivalent_to Xml::C14n.format(word)
   end
 
   it "processes paragraph attributes" do
@@ -626,10 +626,10 @@
           </body>
       </html>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::HtmlConvert.new({})
-      .convert("test", input, true)))).to be_equivalent_to xmlpp(html)
-    expect(xmlpp(strip_guid(IsoDoc::WordConvert.new({})
-      .convert("test", input, true)))).to be_equivalent_to xmlpp(word)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::HtmlConvert.new({})
+      .convert("test", input, true)))).to be_equivalent_to Xml::C14n.format(html)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::WordConvert.new({})
+      .convert("test", input, true)))).to be_equivalent_to Xml::C14n.format(word)
   end
 
   it "processes blockquotes" do
@@ -675,10 +675,10 @@
           </body>
       </html>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
-      .convert("test", input, true)))).to be_equivalent_to xmlpp(presxml)
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
-      .convert("test", presxml, true))).to be_equivalent_to xmlpp(html)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+      .convert("test", input, true)))).to be_equivalent_to Xml::C14n.format(presxml)
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
+      .convert("test", presxml, true))).to be_equivalent_to Xml::C14n.format(html)
   end
 
   it "processes term domains" do
@@ -710,8 +710,8 @@
                  </body>
              </html>
     OUTPUT
-    expect(xmlpp(IsoDoc::HtmlConvert.new({}).convert("test", input, true)))
-      .to be_equivalent_to xmlpp(output)
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({}).convert("test", input, true)))
+      .to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "processes permissions" do
@@ -862,10 +862,10 @@
               </body>
             </html>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
-      .convert("test", input, true)))).to be_equivalent_to xmlpp(presxml)
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
-      .convert("test", presxml, true))).to be_equivalent_to xmlpp(html)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+      .convert("test", input, true)))).to be_equivalent_to Xml::C14n.format(presxml)
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
+      .convert("test", presxml, true))).to be_equivalent_to Xml::C14n.format(html)
   end
 
   it "processes requirements" do
@@ -981,10 +981,10 @@
                   </body>
                 </html>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
-  .convert("test", input, true)))).to be_equivalent_to xmlpp(presxml)
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
-  .convert("test", presxml, true))).to be_equivalent_to xmlpp(output)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+  .convert("test", input, true)))).to be_equivalent_to Xml::C14n.format(presxml)
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
+  .convert("test", presxml, true))).to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "processes recommendation" do
@@ -1104,11 +1104,11 @@
                   </body>
                 </html>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
-      .convert("test", input, true)))).to be_equivalent_to xmlpp(presxml)
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+      .convert("test", input, true)))).to be_equivalent_to Xml::C14n.format(presxml)
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
       .convert("test", presxml, true)))
-      .to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "processes passthrough with compatible format" do
@@ -1124,9 +1124,9 @@
       .new(presxml_options.merge(output_formats: { html: "html", rfc: "rfc" }))
       .convert("test", input, true)
     IsoDoc::HtmlConvert.new({}).convert("test", presxml, false)
-    expect(xmlpp(File.read("test.html")
+    expect(Xml::C14n.format(File.read("test.html")
       .gsub(%r{^.*<h1 class="ForewordTitle">Foreword</h1>}m, "")
-      .gsub(%r{</div>.*}m, ""))).to be_equivalent_to xmlpp(<<~OUTPUT)
+      .gsub(%r{</div>.*}m, ""))).to be_equivalent_to Xml::C14n.format(<<~OUTPUT)
         <A><i>Hello</i></A>
       OUTPUT
   end
@@ -1179,8 +1179,8 @@
     presxml = IsoDoc::PresentationXMLConvert
       .new(presxml_options.merge(output_formats: { html: "html", rfc: "rfc" }))
       .convert("test", input, true)
-    expect(xmlpp(strip_guid(IsoDoc::HtmlConvert.new({})
-     .convert("test", presxml, true)))).to be_equivalent_to xmlpp(output)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::HtmlConvert.new({})
+     .convert("test", presxml, true)))).to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "ignores columnbreak" do
@@ -1205,8 +1205,8 @@
             </body>
           </html>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::HtmlConvert.new({})
-     .convert("test", input, true)))).to be_equivalent_to xmlpp(output)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::HtmlConvert.new({})
+     .convert("test", input, true)))).to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "processes toc" do
@@ -1448,11 +1448,11 @@
         </body>
       </html>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
      .convert("test", input, true)
      .sub(%r{<localized-strings>.*</localized-strings>}m, ""))))
-      .to be_equivalent_to xmlpp(presxml)
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
-  .convert("test", presxml, true))).to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(presxml)
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
+  .convert("test", presxml, true))).to be_equivalent_to Xml::C14n.format(output)
   end
 end
diff --git a/spec/isodoc/cleanup_spec.rb b/spec/isodoc/cleanup_spec.rb
index 3047164d..8e6fa45b 100644
--- a/spec/isodoc/cleanup_spec.rb
+++ b/spec/isodoc/cleanup_spec.rb
@@ -24,8 +24,8 @@
       </body>
       </html>
     OUTPUT
-    expect(xmlpp(IsoDoc::WordConvert.new({})
-      .cleanup(Nokogiri::XML(input)).to_s)).to be_equivalent_to xmlpp((output))
+    expect(Xml::C14n.format(IsoDoc::WordConvert.new({})
+      .cleanup(Nokogiri::XML(input)).to_s)).to be_equivalent_to Xml::C14n.format((output))
   end
 
   it "cleans up figures" do
@@ -54,8 +54,8 @@
       </body>
       </html>
     OUTPUT
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
-      .cleanup(Nokogiri::XML(input)).to_s)).to be_equivalent_to xmlpp((output))
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
+      .cleanup(Nokogiri::XML(input)).to_s)).to be_equivalent_to Xml::C14n.format((output))
   end
 
   it "cleans up figures (Word)" do
@@ -84,8 +84,8 @@
       </body>
       </html>
     OUTPUT
-    expect(xmlpp(IsoDoc::WordConvert.new({})
-      .cleanup(Nokogiri::XML(input)).to_s)).to be_equivalent_to xmlpp((output))
+    expect(Xml::C14n.format(IsoDoc::WordConvert.new({})
+      .cleanup(Nokogiri::XML(input)).to_s)).to be_equivalent_to Xml::C14n.format((output))
   end
 
   it "cleans up inline headers" do
@@ -156,8 +156,8 @@
         </head>
       </html>
     OUTPUT
-    expect(xmlpp(IsoDoc::WordConvert.new({})
-      .cleanup(Nokogiri::XML(input)).to_s)).to be_equivalent_to xmlpp((output))
+    expect(Xml::C14n.format(IsoDoc::WordConvert.new({})
+      .cleanup(Nokogiri::XML(input)).to_s)).to be_equivalent_to Xml::C14n.format((output))
   end
 
   it "cleans up footnotes" do
@@ -201,8 +201,8 @@
              </body>
          </html>
     OUTPUT
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
-      .cleanup(Nokogiri::XML(input)).to_s)).to be_equivalent_to xmlpp((output))
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
+      .cleanup(Nokogiri::XML(input)).to_s)).to be_equivalent_to Xml::C14n.format((output))
   end
 
   it "cleans up footnotes (Word)" do
@@ -275,8 +275,8 @@
                 </body>
             </html>
     OUTPUT
-    expect(xmlpp(IsoDoc::WordConvert.new({})
-      .cleanup(Nokogiri::XML(input)).to_s)).to be_equivalent_to xmlpp((output))
+    expect(Xml::C14n.format(IsoDoc::WordConvert.new({})
+      .cleanup(Nokogiri::XML(input)).to_s)).to be_equivalent_to Xml::C14n.format((output))
   end
 
   it "cleans up tables with tfoot" do
@@ -441,8 +441,8 @@
         </head>
       </html>
     OUTPUT
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
-      .cleanup(Nokogiri::XML(input)).to_s)).to be_equivalent_to xmlpp((html))
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
+      .cleanup(Nokogiri::XML(input)).to_s)).to be_equivalent_to Xml::C14n.format((html))
   end
 
   it "cleans up tables without tfoot" do
@@ -589,7 +589,7 @@
         </head>
       </html>
     OUTPUT
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
-      .cleanup(Nokogiri::XML(input)).to_s)).to be_equivalent_to xmlpp((html))
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
+      .cleanup(Nokogiri::XML(input)).to_s)).to be_equivalent_to Xml::C14n.format((html))
   end
 end
diff --git a/spec/isodoc/figures_spec.rb b/spec/isodoc/figures_spec.rb
index 497f8ef4..d2423833 100644
--- a/spec/isodoc/figures_spec.rb
+++ b/spec/isodoc/figures_spec.rb
@@ -225,17 +225,17 @@
                </body>
              </html>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
       .convert("test", input, true).gsub(/&lt;/, "&#x3c;"))))
-      .to be_equivalent_to xmlpp(presxml)
-    expect(xmlpp(strip_guid(IsoDoc::HtmlConvert.new({})
-      .convert("test", presxml, true)))).to be_equivalent_to xmlpp(html)
+      .to be_equivalent_to Xml::C14n.format(presxml)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::HtmlConvert.new({})
+      .convert("test", presxml, true)))).to be_equivalent_to Xml::C14n.format(html)
     FileUtils.rm_rf "spec/assets/odf1.emf"
-    expect(xmlpp(strip_guid(IsoDoc::WordConvert.new({})
+    expect(Xml::C14n.format(strip_guid(IsoDoc::WordConvert.new({})
       .convert("test", presxml, true)
       .gsub(/['"][^'".]+\.(gif|xml)['"]/, "'_.\\1'")
       .gsub(/mso-bookmark:_Ref\d+/, "mso-bookmark:_Ref"))))
-      .to be_equivalent_to xmlpp(word)
+      .to be_equivalent_to Xml::C14n.format(word)
   end
 
   it "processes subfigures" do
@@ -346,17 +346,17 @@
         </body>
       </html>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
       .convert("test", input, true).gsub(/&lt;/, "&#x3c;"))))
-      .to be_equivalent_to xmlpp(presxml)
-    expect(xmlpp(strip_guid(IsoDoc::HtmlConvert.new({})
-      .convert("test", presxml, true)))).to be_equivalent_to xmlpp(html)
+      .to be_equivalent_to Xml::C14n.format(presxml)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::HtmlConvert.new({})
+      .convert("test", presxml, true)))).to be_equivalent_to Xml::C14n.format(html)
     FileUtils.rm_rf "spec/assets/odf1.emf"
-    expect(xmlpp(strip_guid(IsoDoc::WordConvert.new({})
+    expect(Xml::C14n.format(strip_guid(IsoDoc::WordConvert.new({})
       .convert("test", presxml, true)
       .gsub(/['"][^'".]+\.(gif|xml)['"]/, "'_.\\1'")
       .gsub(/mso-bookmark:_Ref\d+/, "mso-bookmark:_Ref"))))
-      .to be_equivalent_to xmlpp(word)
+      .to be_equivalent_to Xml::C14n.format(word)
   end
 
   it "processes figure classes" do
@@ -433,9 +433,9 @@
            </preface>
          </iso-standard>
     OUTPUT
-    expect(strip_guid(xmlpp(IsoDoc::PresentationXMLConvert.new(presxml_options)
+    expect(strip_guid(Xml::C14n.format(IsoDoc::PresentationXMLConvert.new(presxml_options)
         .convert("test", input, true).gsub(/&lt;/, "&#x3c;"))))
-      .to be_equivalent_to xmlpp(presxml)
+      .to be_equivalent_to Xml::C14n.format(presxml)
   end
 
   it "processes raw SVG" do
@@ -472,11 +472,11 @@
            </preface>
          </iso-standard>
     OUTPUT
-    expect(strip_guid(xmlpp(IsoDoc::PresentationXMLConvert.new(presxml_options)
+    expect(strip_guid(Xml::C14n.format(IsoDoc::PresentationXMLConvert.new(presxml_options)
         .convert("test", input, true)
         .gsub(/&lt;/, "&#x3c;")
         .gsub(%r{data:image/emf;base64,[^"']+}, "data:image/emf;base64"))))
-      .to be_equivalent_to xmlpp(presxml
+      .to be_equivalent_to Xml::C14n.format(presxml
            .gsub(%r{data:image/emf;base64,[^"']+}, "data:image/emf;base64"))
   end
 
@@ -576,19 +576,19 @@
     output = IsoDoc::PresentationXMLConvert
       .new(presxml_options.merge(output_formats: { html: "html", doc: "doc" }))
       .convert("test", input, true)
-    expect(strip_guid(xmlpp(output
+    expect(strip_guid(Xml::C14n.format(output
       .gsub(/&lt;/, "&#x3c;")
       .sub(%r{<metanorma-extension>.*</metanorma-extension}m, "")
       .gsub(%r{data:image/emf;base64,[^"']+}, "data:image/emf;base64"))))
-      .to be_equivalent_to xmlpp(presxml
+      .to be_equivalent_to Xml::C14n.format(presxml
          .gsub(%r{data:image/emf;base64,[^"']+}, "data:image/emf;base64"))
-    expect(xmlpp(strip_guid(IsoDoc::HtmlConvert.new({})
-      .convert("test", output, true)))).to be_equivalent_to strip_guid(xmlpp(html))
-    expect(xmlpp(strip_guid(IsoDoc::WordConvert.new({})
+    expect(Xml::C14n.format(strip_guid(IsoDoc::HtmlConvert.new({})
+      .convert("test", output, true)))).to be_equivalent_to strip_guid(Xml::C14n.format(html))
+    expect(Xml::C14n.format(strip_guid(IsoDoc::WordConvert.new({})
       .convert("test", output, true)
       .gsub(/['"][^'".]+(?<!odf1)(?<!odf)\.emf['"]/, "'_.emf'")
       .gsub(/['"][^'".]+\.(gif|xml)['"]/, "'_.\\1'"))))
-      .to be_equivalent_to strip_guid(xmlpp(doc))
+      .to be_equivalent_to strip_guid(Xml::C14n.format(doc))
   end
 
   it "converts SVG (Word)" do
@@ -679,18 +679,18 @@
     output = IsoDoc::PresentationXMLConvert
       .new(presxml_options.merge(output_formats: { html: "html", doc: "doc" }))
       .convert("test", input, true)
-    expect(strip_guid(xmlpp(output
+    expect(strip_guid(Xml::C14n.format(output
       .sub(%r{<metanorma-extension>.*</metanorma-extension}m, "")
      .gsub(/&lt;/, "&#x3c;"))
           .gsub(%r{data:image/emf;base64,[^"']+}, "data:image/emf;base64")))
-      .to be_equivalent_to xmlpp(presxml
+      .to be_equivalent_to Xml::C14n.format(presxml
         .gsub(%r{data:image/emf;base64,[^"']+}, "data:image/emf;base64"))
-    expect(xmlpp(strip_guid(IsoDoc::WordConvert.new({})
+    expect(Xml::C14n.format(strip_guid(IsoDoc::WordConvert.new({})
       .convert("test", output, true)
       .gsub(/['"][^'".]+(?<!odf1)(?<!odf)\.emf['"]/, "'_.emf'")
       .gsub(/['"][^'".]+\.(gif|xml)['"]/, "'_.\\1'")
       .gsub(/mso-bookmark:_Ref\d+/, "mso-bookmark:_Ref"))))
-      .to be_equivalent_to strip_guid(xmlpp(word))
+      .to be_equivalent_to strip_guid(Xml::C14n.format(word))
   end
 
   it "does not label embedded figures, sourcecode" do
@@ -742,8 +742,8 @@
                </body>
              </html>
     OUTPUT
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
-      .convert("test", input, true))).to be_equivalent_to xmlpp(output)
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
+      .convert("test", input, true))).to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "processes svgmap" do
@@ -809,12 +809,12 @@
     OUTPUT
     FileUtils.rm_rf("spec/assets/action_schemaexpg1.emf")
     FileUtils.rm_rf("spec/assets/action_schemaexpg2.emf")
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
       .convert("test", input, true))
       .sub(%r{<localized-strings>.*</localized-strings>}m, "")
       .gsub(%r{"\.\\}, '"./')
       .gsub(%r{'\.\\}, "'./")
       .gsub(%r{data:image/emf;base64,[^"']+}, "data:image/emf;base64")))
-      .to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(output)
   end
 end
diff --git a/spec/isodoc/footnotes_spec.rb b/spec/isodoc/footnotes_spec.rb
index d3ea4a19..330015f8 100644
--- a/spec/isodoc/footnotes_spec.rb
+++ b/spec/isodoc/footnotes_spec.rb
@@ -123,11 +123,11 @@
         </body>
       </html>
     OUTPUT
-    expect(xmlpp(IsoDoc::HtmlConvert.new({}).convert("test", input, true)))
-      .to be_equivalent_to xmlpp(html)
-    expect(xmlpp(IsoDoc::WordConvert.new({}).convert("test", input, true)
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({}).convert("test", input, true)))
+      .to be_equivalent_to Xml::C14n.format(html)
+    expect(Xml::C14n.format(IsoDoc::WordConvert.new({}).convert("test", input, true)
       .gsub(/_Ref\d+/, "_Ref")))
-      .to be_equivalent_to xmlpp(word)
+      .to be_equivalent_to Xml::C14n.format(word)
   end
 
   it "processes IsoXML reviewer notes" do
@@ -252,14 +252,14 @@
     out = File.read("test.html").sub(/^.*<main/m, "<main").sub(
       %r{</main>.*$}m, "</main>"
     )
-    expect(xmlpp(out)).to be_equivalent_to xmlpp(html)
+    expect(Xml::C14n.format(out)).to be_equivalent_to Xml::C14n.format(html)
     FileUtils.rm_f "test.doc"
     IsoDoc::WordConvert.new({ wordstylesheet: "spec/assets/word.css",
                               htmlstylesheet: "spec/assets/html.scss" })
       .convert("test", input, false)
     out = File.read("test.doc").sub(/^.*<body/m, "<body").sub(%r{</body>.*$}m,
                                                               "</body>")
-    expect(xmlpp(out)).to be_equivalent_to xmlpp(word)
+    expect(Xml::C14n.format(out)).to be_equivalent_to Xml::C14n.format(word)
   end
 
   it "processes IsoXML reviewer notes spanning list" do
@@ -383,13 +383,13 @@
     out = File.read("test.html").sub(/^.*<main/m, "<main").sub(
       %r{</main>.*$}m, "</main>"
     )
-    expect(xmlpp(out)).to be_equivalent_to xmlpp(html)
+    expect(Xml::C14n.format(out)).to be_equivalent_to Xml::C14n.format(html)
     FileUtils.rm_f "test.doc"
     IsoDoc::WordConvert.new({ wordstylesheet: "spec/assets/word.css",
                               htmlstylesheet: "spec/assets/html.scss" })
       .convert("test", input, false)
     out = File.read("test.doc").sub(/^.*<body/m, "<body").sub(%r{</body>.*$}m,
                                                               "</body>")
-    expect(xmlpp(out)).to be_equivalent_to xmlpp(word)
+    expect(Xml::C14n.format(out)).to be_equivalent_to Xml::C14n.format(word)
   end
 end
diff --git a/spec/isodoc/form_spec.rb b/spec/isodoc/form_spec.rb
index f05bc5bc..0f79c052 100644
--- a/spec/isodoc/form_spec.rb
+++ b/spec/isodoc/form_spec.rb
@@ -155,9 +155,9 @@
          </html>
     DOC
 
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
-      .convert("test", input, true))).to be_equivalent_to xmlpp(html)
-    expect(xmlpp(IsoDoc::WordConvert.new({})
-      .convert("test", input, true))).to be_equivalent_to xmlpp(doc)
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
+      .convert("test", input, true))).to be_equivalent_to Xml::C14n.format(html)
+    expect(Xml::C14n.format(IsoDoc::WordConvert.new({})
+      .convert("test", input, true))).to be_equivalent_to Xml::C14n.format(doc)
   end
 end
diff --git a/spec/isodoc/i18n_spec.rb b/spec/isodoc/i18n_spec.rb
index 75315a5f..d556b402 100644
--- a/spec/isodoc/i18n_spec.rb
+++ b/spec/isodoc/i18n_spec.rb
@@ -227,12 +227,12 @@
                  </body>
              </html>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert
       .new(presxml_options).convert("test", input, true)
       .sub(%r{<localized-strings>.*</localized-strings>}m, ""))))
-      .to be_equivalent_to xmlpp(presxml)
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
-      .convert("test", presxml, true))).to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(presxml)
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
+      .convert("test", presxml, true))).to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "defaults to English" do
@@ -382,10 +382,10 @@
           </bibliography>
           </iso-standard>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
       .convert("test", input, true)
       .sub(%r{<localized-strings>.*</localized-strings>}m, ""))))
-      .to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "processes French" do
@@ -614,12 +614,12 @@
                  </body>
              </html>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
       .convert("test", input, true)
       .sub(%r{<localized-strings>.*</localized-strings>}m, ""))))
-      .to be_equivalent_to xmlpp(presxml)
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
-      .convert("test", presxml, true))).to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(presxml)
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
+      .convert("test", presxml, true))).to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "processes Simplified Chinese" do
@@ -867,12 +867,12 @@
          </body>
        </html>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
       .convert("test", input, true)
       .sub(%r{<localized-strings>.*</localized-strings>}m, ""))))
-      .to be_equivalent_to xmlpp(presxml)
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
-      .convert("test", presxml, true))).to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(presxml)
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
+      .convert("test", presxml, true))).to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "processes i18n file" do
@@ -1172,16 +1172,16 @@
              </html>
     OUTPUT
 
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert
       .new({ i18nyaml: "spec/assets/i18n.yaml" }
       .merge(presxml_options))
       .convert("test", input, true)
       .sub(%r{<localized-strings>.*</localized-strings>}m, ""))))
-      .to be_equivalent_to xmlpp(presxml)
-    expect(xmlpp(IsoDoc::HtmlConvert
+      .to be_equivalent_to Xml::C14n.format(presxml)
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert
       .new({ i18nyaml: "spec/assets/i18n.yaml" })
       .convert("test", presxml, true)))
-      .to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "internationalises locality" do
@@ -1229,12 +1229,12 @@
         </p>
       </foreword>
     OUTPUT
-    expect(xmlpp(Nokogiri::XML(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(Nokogiri::XML(IsoDoc::PresentationXMLConvert
       .new({ i18nyaml: "spec/assets/i18n.yaml" }
       .merge(presxml_options))
       .convert("test", input, true))
       .at("//xmlns:foreword").to_xml))
-      .to be_equivalent_to xmlpp(presxml)
+      .to be_equivalent_to Xml::C14n.format(presxml)
   end
 
   it "processes LTR within RTL" do
@@ -1360,10 +1360,10 @@
         </preface>
       </iso-standard>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert
   .new(presxml_options).convert("test", input, true)
   .sub(%r{<localized-strings>.*</localized-strings>}m, ""))))
-      .to be_equivalent_to xmlpp(presxml)
+      .to be_equivalent_to Xml::C14n.format(presxml)
   end
 
   private
diff --git a/spec/isodoc/inline_spec.rb b/spec/isodoc/inline_spec.rb
index 2a81603b..2bf6e9c8 100644
--- a/spec/isodoc/inline_spec.rb
+++ b/spec/isodoc/inline_spec.rb
@@ -57,14 +57,14 @@
            </p>
          </div>
     OUTPUT
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
       .convert("test", input, true))
       .sub(/^.*<h1/m, "<div><h1").sub(%r{</div>.*$}m, "</div>"))
-      .to be_equivalent_to xmlpp(html)
-    expect(xmlpp(IsoDoc::WordConvert.new({})
+      .to be_equivalent_to Xml::C14n.format(html)
+    expect(Xml::C14n.format(IsoDoc::WordConvert.new({})
       .convert("test", input, true))
       .sub(/^.*<h1/m, "<div><h1").sub(%r{</div>.*$}m, "</div>"))
-      .to be_equivalent_to xmlpp(doc)
+      .to be_equivalent_to Xml::C14n.format(doc)
   end
 
   it "processes dates" do
@@ -89,8 +89,8 @@
         <sections> </sections>
       </iso-standard>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
-      .convert("test", input, true)))).to be_equivalent_to xmlpp(output)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+      .convert("test", input, true)))).to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "ignores index entries" do
@@ -118,8 +118,8 @@
         <sections> </sections>
       </iso-standard>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
-      .convert("test", input, true)))).to be_equivalent_to xmlpp(output)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+      .convert("test", input, true)))).to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "processes concept markup" do
@@ -352,10 +352,10 @@
          </body>
        </html>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
-      .convert("test", input, true)))).to be_equivalent_to xmlpp(presxml)
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
-      .convert("test", presxml, true))).to be_equivalent_to xmlpp(output)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+      .convert("test", input, true)))).to be_equivalent_to Xml::C14n.format(presxml)
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
+      .convert("test", presxml, true))).to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "processes concept attributes" do
@@ -470,10 +470,10 @@
          </body>
        </html>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
-      .convert("test", input, true)))).to be_equivalent_to xmlpp(presxml)
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
-      .convert("test", presxml, true))).to be_equivalent_to xmlpp(output)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+      .convert("test", input, true)))).to be_equivalent_to Xml::C14n.format(presxml)
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
+      .convert("test", presxml, true))).to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "processes concept markup for symbols" do
@@ -560,10 +560,10 @@
         </body>
       </html>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
-      .convert("test", input, true)))).to be_equivalent_to xmlpp(presxml)
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
-      .convert("test", presxml, true))).to be_equivalent_to xmlpp(output)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+      .convert("test", input, true)))).to be_equivalent_to Xml::C14n.format(presxml)
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
+      .convert("test", presxml, true))).to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "processes embedded inline formatting" do
@@ -593,8 +593,8 @@
              </body>
          </html>
     OUTPUT
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
-      .convert("test", input, true))).to be_equivalent_to xmlpp(output)
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
+      .convert("test", input, true))).to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "processes inline images" do
@@ -623,8 +623,8 @@
         </body>
       </html>
     OUTPUT
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
-      .convert("test", input, true))).to be_equivalent_to xmlpp(output)
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
+      .convert("test", input, true))).to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "processes links" do
@@ -666,8 +666,8 @@
              </body>
          </html>
     OUTPUT
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
-      .convert("test", input, true))).to be_equivalent_to xmlpp(output)
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
+      .convert("test", input, true))).to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "processes updatetype links" do
@@ -703,14 +703,14 @@
       </p>
               </div>
     OUTPUT
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
       .convert("test", input, true))
       .sub(/^.*<h1/m, "<div><h1").sub(%r{</div>.*$}m, "</div>"))
-      .to be_equivalent_to xmlpp(html)
-    expect(xmlpp(IsoDoc::WordConvert.new({})
+      .to be_equivalent_to Xml::C14n.format(html)
+    expect(Xml::C14n.format(IsoDoc::WordConvert.new({})
       .convert("test", input, true))
       .sub(/^.*<h1/m, "<div><h1").sub(%r{</div>.*$}m, "</div>"))
-      .to be_equivalent_to xmlpp(doc)
+      .to be_equivalent_to Xml::C14n.format(doc)
   end
 
   it "processes unrecognised markup" do
@@ -740,8 +740,8 @@
              </body>
          </html>
     OUTPUT
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
-      .convert("test", input, true))).to be_equivalent_to xmlpp(output)
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
+      .convert("test", input, true))).to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "processes AsciiMath and MathML" do
@@ -783,9 +783,9 @@
              </body>
          </html>
     OUTPUT
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
       .convert("test", input, true).sub("<html", "<html xmlns:m='m'")))
-      .to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "overrides AsciiMath delimiters" do
@@ -818,8 +818,8 @@
              </body>
          </html>
     OUTPUT
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
-      .convert("test", input, true))).to be_equivalent_to xmlpp(output)
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
+      .convert("test", input, true))).to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "duplicates MathML with AsciiMath" do
@@ -866,11 +866,11 @@
         <sections> </sections>
       </iso-standard>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
       .convert("test", input, true)
       .gsub("<!--", "<comment>")
       .gsub("-->", "</comment>"))))
-      .to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "overrides duplication of MathML with AsciiMath" do
@@ -916,13 +916,13 @@
           <sections> </sections>
         </iso-standard>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert
       .new({ suppressasciimathdup: true }
       .merge(presxml_options))
       .convert("test", input, true)
       .gsub("<!--", "<comment>")
       .gsub("-->", "</comment>"))))
-      .to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "processes eref types" do
@@ -1008,11 +1008,11 @@
     OUTPUT
     output = IsoDoc::PresentationXMLConvert.new(presxml_options)
       .convert("test", input, true)
-    expect(xmlpp(strip_guid(Nokogiri::XML(output)
+    expect(Xml::C14n.format(strip_guid(Nokogiri::XML(output)
       .at("//xmlns:foreword").to_xml)))
-      .to be_equivalent_to xmlpp(presxml)
-    expect(xmlpp(strip_guid(IsoDoc::HtmlConvert.new({})
-      .convert("test", output, true)))).to be_equivalent_to xmlpp(html)
+      .to be_equivalent_to Xml::C14n.format(presxml)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::HtmlConvert.new({})
+      .convert("test", output, true)))).to be_equivalent_to Xml::C14n.format(html)
   end
 
   it "processes eref content" do
@@ -1130,10 +1130,10 @@
                  </body>
              </html>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
-      .convert("test", input, true)))).to be_equivalent_to xmlpp(presxml)
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
-      .convert("test", presxml, true))).to be_equivalent_to xmlpp(html)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+      .convert("test", input, true)))).to be_equivalent_to Xml::C14n.format(presxml)
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
+      .convert("test", presxml, true))).to be_equivalent_to Xml::C14n.format(html)
   end
 
   it "processes eref content pointing to reference with citation URL" do
@@ -1277,19 +1277,19 @@
     OUTPUT
     output = IsoDoc::PresentationXMLConvert.new(presxml_options)
       .convert("test", input, true)
-    expect(xmlpp(strip_guid(Nokogiri::XML(output)
+    expect(Xml::C14n.format(strip_guid(Nokogiri::XML(output)
       .at("//xmlns:foreword").to_xml)))
-      .to be_equivalent_to xmlpp(presxml)
+      .to be_equivalent_to Xml::C14n.format(presxml)
     xml = IsoDoc::HtmlConvert.new({})
       .convert("test", output, true)
-    expect(xmlpp(Nokogiri::XML(xml)
+    expect(Xml::C14n.format(Nokogiri::XML(xml)
       .at("//div[h1/@class='ForewordTitle']").to_xml))
-      .to be_equivalent_to xmlpp(html)
+      .to be_equivalent_to Xml::C14n.format(html)
     xml = IsoDoc::WordConvert.new({})
       .convert("test", output, true)
-    expect(xmlpp(Nokogiri::XML(xml)
+    expect(Xml::C14n.format(Nokogiri::XML(xml)
       .at("//div[h1/@class='ForewordTitle']").to_xml))
-      .to be_equivalent_to xmlpp(word)
+      .to be_equivalent_to Xml::C14n.format(word)
   end
 
   it "processes eref content pointing to hidden bibliographic entries" do
@@ -1463,12 +1463,12 @@
        </html>
     OUTPUT
 
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
-      .convert("test", input, true)))).to be_equivalent_to xmlpp(presxml)
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
-      .convert("test", presxml, true))).to be_equivalent_to xmlpp(html)
-    expect(xmlpp(IsoDoc::WordConvert.new({})
-      .convert("test", presxml, true))).to be_equivalent_to xmlpp(word)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+      .convert("test", input, true)))).to be_equivalent_to Xml::C14n.format(presxml)
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
+      .convert("test", presxml, true))).to be_equivalent_to Xml::C14n.format(html)
+    expect(Xml::C14n.format(IsoDoc::WordConvert.new({})
+      .convert("test", presxml, true))).to be_equivalent_to Xml::C14n.format(word)
   end
 
   it "processes eref content with Unicode characters" do
@@ -1503,8 +1503,8 @@
     OUTPUT
     xml = Nokogiri::XML(IsoDoc::PresentationXMLConvert.new(presxml_options)
       .convert("test", input, true))
-    expect(xmlpp(strip_guid(xml.at("//xmlns:foreword").to_xml)))
-      .to be_equivalent_to xmlpp(presxml)
+    expect(Xml::C14n.format(strip_guid(xml.at("//xmlns:foreword").to_xml)))
+      .to be_equivalent_to Xml::C14n.format(presxml)
   end
 
   it "processes variant" do
@@ -1571,10 +1571,10 @@
         </preface>
       </iso-standard>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
       .convert("test", input, true)
       .sub(%r{<localized-strings>.*</localized-strings>}m, ""))))
-      .to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "processes add, del" do
@@ -1604,8 +1604,8 @@
          </body>
        </html>
     OUTPUT
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
-      .convert("test", input, true))).to be_equivalent_to xmlpp(output)
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
+      .convert("test", input, true))).to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "processes formatting in eref/@citeas" do
@@ -1642,8 +1642,8 @@
          </preface>
        </itu-standard>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
-      .convert("test", input, true)))).to be_equivalent_to xmlpp(output)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+      .convert("test", input, true)))).to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "combines locality stacks with connectives" do
@@ -1785,8 +1785,8 @@
          <eref type="inline" bibitemid="ref1" citeas="XYZ"><localityStack connective="from"><locality type="clause"><referenceFrom>3</referenceFrom></locality></localityStack><localityStack connective="to"><locality type="clause"><referenceFrom>5</referenceFrom></locality></localityStack><localityStack connective="and"><locality type="clause"><referenceFrom>8</referenceFrom></locality></localityStack><localityStack connective="to"><locality type="clause"><referenceFrom>10</referenceFrom></locality></localityStack>XYZ,  Clauses  3 to  5 and  8 to  10</eref>
        </itu-standard>
     OUTPUT
-    expect(xmlpp(IsoDoc::PresentationXMLConvert.new(presxml_options)
-      .convert("test", input, true))).to be_equivalent_to xmlpp(output)
+    expect(Xml::C14n.format(IsoDoc::PresentationXMLConvert.new(presxml_options)
+      .convert("test", input, true))).to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "processes ruby markup" do
@@ -1847,17 +1847,17 @@
          <ruby><rb>護</rb><rt style="font-size: 6pt;">プロテゴ</rt></ruby>(まも)!</p>
        </div>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert
       .new(presxml_options.merge(output_formats: { html: "html", doc: "doc" }))
       .convert("test", input, true))
        .sub(%r{<metanorma-extension>.*</metanorma-extension>}m, "")
        .sub(%r{<localized-strings>.*</localized-strings>}m, "")))
-      .to be_equivalent_to xmlpp(presxml)
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
-      .convert("test", presxml, true))).to be_equivalent_to xmlpp(html)
-    expect(xmlpp(IsoDoc::WordConvert.new({})
+      .to be_equivalent_to Xml::C14n.format(presxml)
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
+      .convert("test", presxml, true))).to be_equivalent_to Xml::C14n.format(html)
+    expect(Xml::C14n.format(IsoDoc::WordConvert.new({})
       .convert("test", presxml, true)
       .sub(/^.*<h1/m, "<div><h1").sub(%r{</div>.*$}m, "</div>")))
-      .to be_equivalent_to xmlpp(doc)
+      .to be_equivalent_to Xml::C14n.format(doc)
   end
 end
diff --git a/spec/isodoc/lists_spec.rb b/spec/isodoc/lists_spec.rb
index d11b303f..68dd801f 100644
--- a/spec/isodoc/lists_spec.rb
+++ b/spec/isodoc/lists_spec.rb
@@ -84,12 +84,12 @@
           </body>
         </html>
     OUTPUT
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
       .convert("test", input, true)))
-      .to be_equivalent_to xmlpp(html)
-    expect(xmlpp(IsoDoc::WordConvert.new({})
+      .to be_equivalent_to Xml::C14n.format(html)
+    expect(Xml::C14n.format(IsoDoc::WordConvert.new({})
       .convert("test", input, true)))
-      .to be_equivalent_to xmlpp(word)
+      .to be_equivalent_to Xml::C14n.format(word)
   end
 
   it "processes unordered checklists" do
@@ -179,12 +179,12 @@
                 </body>
               </html>
     OUTPUT
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
       .convert("test", input, true)))
-      .to be_equivalent_to xmlpp(html)
-    expect(xmlpp(IsoDoc::WordConvert.new({})
+      .to be_equivalent_to Xml::C14n.format(html)
+    expect(Xml::C14n.format(IsoDoc::WordConvert.new({})
       .convert("test", input, true)))
-      .to be_equivalent_to xmlpp(word)
+      .to be_equivalent_to Xml::C14n.format(word)
   end
 
   it "processes ordered lists" do
@@ -299,12 +299,12 @@
           </body>
         </html>
     OUTPUT
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
       .convert("test", input, true)))
-      .to be_equivalent_to xmlpp(html)
-    expect(xmlpp(IsoDoc::WordConvert.new({})
+      .to be_equivalent_to Xml::C14n.format(html)
+    expect(Xml::C14n.format(IsoDoc::WordConvert.new({})
       .convert("test", input, true)))
-      .to be_equivalent_to xmlpp(word)
+      .to be_equivalent_to Xml::C14n.format(word)
   end
 
   it "processes Roman Upper ordered lists" do
@@ -351,9 +351,9 @@
                </body>
            </html>
     OUTPUT
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
       .convert("test", input, true)))
-      .to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "processes definition lists" do
@@ -466,12 +466,12 @@
            </body>
        </html>
     OUTPUT
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
       .convert("test", input, true)))
-      .to be_equivalent_to xmlpp(html)
-    expect(xmlpp(IsoDoc::WordConvert.new({})
+      .to be_equivalent_to Xml::C14n.format(html)
+    expect(Xml::C14n.format(IsoDoc::WordConvert.new({})
       .convert("test", input, true)))
-      .to be_equivalent_to xmlpp(word)
+      .to be_equivalent_to Xml::C14n.format(word)
   end
 
   it "processes nested definition lists (Word)" do
@@ -559,8 +559,8 @@
          </body>
        </html>
     OUTPUT
-    expect(xmlpp(IsoDoc::WordConvert.new({})
+    expect(Xml::C14n.format(IsoDoc::WordConvert.new({})
       .convert("test", input, true)))
-      .to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(output)
   end
 end
diff --git a/spec/isodoc/postproc_spec.rb b/spec/isodoc/postproc_spec.rb
index 43e11018..c2c13997 100644
--- a/spec/isodoc/postproc_spec.rb
+++ b/spec/isodoc/postproc_spec.rb
@@ -368,8 +368,8 @@
         </body>
       </html>
     OUTPUT
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
-      .convert("test", input, true))).to be_equivalent_to xmlpp(output)
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
+      .convert("test", input, true))).to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "cleans up HTML output preface placeholder paragraphs" do
@@ -405,7 +405,7 @@
     INPUT
     html = Nokogiri::XML(File.read("test.html")).at("//body")
     html.xpath("//script").each(&:remove)
-    expect(strip_guid(xmlpp(html.to_xml)))
+    expect(strip_guid(Xml::C14n.format(html.to_xml)))
       .to be_equivalent_to <<~OUTPUT
         <body lang="en" xml:lang="en">
             <div class="title-section">
@@ -453,8 +453,8 @@
       INPUT
     html = Nokogiri::XML(File.read("test.html"))
       .at("//div[@id = 'toc']")
-    expect(strip_guid(xmlpp(html.to_xml)))
-      .to be_equivalent_to xmlpp(<<~OUTPUT)
+    expect(strip_guid(Xml::C14n.format(html.to_xml)))
+      .to be_equivalent_to Xml::C14n.format(<<~OUTPUT)
         <div id="toc">
           <ul>
             <li class="h1">
@@ -506,7 +506,7 @@
       .sub(/^.*<main class="main-section">/m,
            '<main xmlns:epub="epub" class="main-section">')
       .sub(%r{</main>.*$}m, "</main>")
-    expect(xmlpp(html)).to be_equivalent_to xmlpp(<<~OUTPUT)
+    expect(Xml::C14n.format(html)).to be_equivalent_to Xml::C14n.format(<<~OUTPUT)
           <main  xmlns:epub="epub" class="main-section"><button onclick="topFunction()" id="myBtn" title="Go to top">Top</button>
             <div id="A">
               <h1><a class="anchor" href="#A"/><a class="header" href="#A">Clause 4</a></h1>
@@ -567,9 +567,9 @@
       .sub(/^.*<main class="main-section">/m, '<main class="main-section">')
       .sub(%r{</main>.*$}m, "</main>")
     expect(`ls test_*_htmlimages`).to match(/\.png$/)
-    expect(xmlpp(html.gsub(/\/[0-9a-f-]+\.png/, "/_.png"))
+    expect(Xml::C14n.format(html.gsub(/\/[0-9a-f-]+\.png/, "/_.png"))
     .gsub(/test_[^_]+_htmlimages/, "test_htmlimages"))
-      .to be_equivalent_to xmlpp(<<~OUTPUT)
+      .to be_equivalent_to Xml::C14n.format(<<~OUTPUT)
                    <main class="main-section"><button onclick="topFunction()" id="myBtn" title="Go to top">Top</button>
                      <br />
                      <div>
@@ -617,9 +617,9 @@
       .sub(/^.*<main class="main-section">/m, '<main class="main-section">')
       .sub(%r{</main>.*$}m, "</main>")
     expect(`ls test_*_htmlimages`).to match(/\.png$/)
-    expect(xmlpp(html.gsub(/\/[0-9a-f-]+\.png/, "/_.png"))
+    expect(Xml::C14n.format(html.gsub(/\/[0-9a-f-]+\.png/, "/_.png"))
            .gsub(/test_[^_]+_htmlimages/, "test_htmlimages"))
-      .to be_equivalent_to xmlpp(<<~OUTPUT)
+      .to be_equivalent_to Xml::C14n.format(<<~OUTPUT)
             <main class='main-section'>
           <button onclick='topFunction()' id='myBtn' title='Go to top'>Top</button>
           <br/>
@@ -816,9 +816,9 @@
       .sub(/^.*<main class="main-section">/m, '<main class="main-section">')
       .sub(%r{</main>.*$}m, "</main>")
     expect(`ls test_*_htmlimages`).to match(/\.png$/)
-    expect(xmlpp(html.gsub(/\/[0-9a-f-]+\.png/, "/_.png"))
+    expect(Xml::C14n.format(html.gsub(/\/[0-9a-f-]+\.png/, "/_.png"))
     .gsub(/test_[^_]+_htmlimages/, "test_htmlimages"))
-      .to be_equivalent_to xmlpp(<<~OUTPUT)
+      .to be_equivalent_to Xml::C14n.format(<<~OUTPUT)
         <main class='main-section'>
              <button onclick='topFunction()' id='myBtn' title='Go to top'>Top</button>
              <br/>
@@ -858,9 +858,9 @@
       .sub(/^.*<main class="main-section">/m, '<main class="main-section">')
       .sub(%r{</main>.*$}m, "</main>")
     expect(`ls test_*_htmlimages`).to match(/\.png$/)
-    expect(xmlpp(html.gsub(/\/[0-9a-f-]+\.png/, "/_.png"))
+    expect(Xml::C14n.format(html.gsub(/\/[0-9a-f-]+\.png/, "/_.png"))
            .gsub(/test_[^_]+_htmlimages/, "test_htmlimages"))
-      .to be_equivalent_to xmlpp(<<~OUTPUT)
+      .to be_equivalent_to Xml::C14n.format(<<~OUTPUT)
                    <main class="main-section"><button onclick="topFunction()" id="myBtn" title="Go to top">Top</button>
                      <br />
                      <div>
@@ -895,9 +895,9 @@
     html = File.read("test.html")
       .sub(/^.*<main class="main-section">/m, '<main class="main-section">')
       .sub(%r{</main>.*$}m, "</main>")
-    expect(xmlpp(html
+    expect(Xml::C14n.format(html
       .gsub(%r{src="data:image/png;base64,[^"]+"}, %{src="data:image/png;base64,_"})))
-      .to be_equivalent_to xmlpp(<<~OUTPUT)
+      .to be_equivalent_to Xml::C14n.format(<<~OUTPUT)
             <main class="main-section"><button onclick="topFunction()" id="myBtn" title="Go to top">Top</button>
               <br />
               <div>
@@ -930,9 +930,9 @@
     html = File.read("spec/test.html")
       .sub(/^.*<main class="main-section">/m, '<main class="main-section">')
       .sub(%r{</main>.*$}m, "</main>")
-    expect(xmlpp(html
+    expect(Xml::C14n.format(html
       .gsub(%r{src="data:image/png;base64,[^"]+"}, %{src="data:image/png;base64,_"})))
-      .to be_equivalent_to xmlpp(<<~OUTPUT)
+      .to be_equivalent_to Xml::C14n.format(<<~OUTPUT)
             <main class="main-section"><button onclick="topFunction()" id="myBtn" title="Go to top">Top</button>
               <br />
               <div>
@@ -1020,7 +1020,7 @@
     html = File.read("test.html")
       .sub(/^.*<main class="main-section">/m, '<main class="main-section">')
       .sub(%r{</main>.*$}m, "</main>")
-    expect(xmlpp(html)).to be_equivalent_to xmlpp(<<~OUTPUT)
+    expect(Xml::C14n.format(html)).to be_equivalent_to Xml::C14n.format(<<~OUTPUT)
       <main class="main-section"><button onclick="topFunction()" id="myBtn" title="Go to top">Top</button>
         <br />
         <div>
@@ -1038,7 +1038,7 @@
     word = File.read("test.doc")
       .sub(/^.*<div class="WordSection2">/m, '<div class="WordSection2">')
       .sub(%r{<p class="MsoNormal">\s*<br clear="all" class="section"/>\s*</p>\s*<div class="WordSection3">.*$}m, "")
-    expect(xmlpp(word)).to be_equivalent_to xmlpp(<<~OUTPUT)
+    expect(Xml::C14n.format(word)).to be_equivalent_to Xml::C14n.format(<<~OUTPUT)
       <div class="WordSection2">
         <p class="MsoNormal">
           <br clear="all" style="mso-special-character:line-break;page-break-before:always"/>
@@ -1111,18 +1111,18 @@
         </body>
       </html>
     OUTPUT
-    expect(xmlpp(IsoDoc::HtmlConvert
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert
       .new(wordstylesheet: "spec/assets/word.css",
            htmlstylesheet: "spec/assets/html.scss", filename: "test")
       .html_preface(Nokogiri::XML(input)).to_xml)
       .sub(/^.*<main/m, "<main").sub(%r{</main>.*$}m, "</main>"))
-      .to be_equivalent_to xmlpp(html)
-    expect(xmlpp(IsoDoc::WordConvert
+      .to be_equivalent_to Xml::C14n.format(html)
+    expect(Xml::C14n.format(IsoDoc::WordConvert
       .new(wordstylesheet: "spec/assets/word.css",
            htmlstylesheet: "spec/assets/html.scss", filename: "test")
        .word_cleanup(Nokogiri::XML(input)).to_xml)
        .sub(/^.*<main/m, "<main").sub(%r{</main>.*$}m, "</main>"))
-      .to be_equivalent_to xmlpp(doc)
+      .to be_equivalent_to Xml::C14n.format(doc)
   end
 
   it "cleans up coverpage note" do
@@ -1184,18 +1184,18 @@
         </body>
       </html>
     OUTPUT
-    expect(xmlpp(IsoDoc::HtmlConvert
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert
   .new(wordstylesheet: "spec/assets/word.css",
        htmlstylesheet: "spec/assets/html.scss", filename: "test")
   .html_preface(Nokogiri::XML(input)).to_xml)
   .sub(/^.*<main/m, "<main").sub(%r{</main>.*$}m, "</main>"))
-      .to be_equivalent_to xmlpp(html)
-    expect(xmlpp(IsoDoc::WordConvert
+      .to be_equivalent_to Xml::C14n.format(html)
+    expect(Xml::C14n.format(IsoDoc::WordConvert
       .new(wordstylesheet: "spec/assets/word.css",
            htmlstylesheet: "spec/assets/html.scss", filename: "test")
        .word_cleanup(Nokogiri::XML(input)).to_xml)
        .sub(/^.*<main/m, "<main").sub(%r{</main>.*$}m, "</main>"))
-      .to be_equivalent_to xmlpp(doc)
+      .to be_equivalent_to Xml::C14n.format(doc)
   end
 
   it "removes coverpage note destination if unused" do
@@ -1253,18 +1253,18 @@
         </body>
       </html>
     OUTPUT
-    expect(xmlpp(IsoDoc::HtmlConvert
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert
   .new(wordstylesheet: "spec/assets/word.css",
        htmlstylesheet: "spec/assets/html.scss", filename: "test")
   .html_preface(Nokogiri::XML(input)).to_xml)
   .sub(/^.*<main/m, "<main").sub(%r{</main>.*$}m, "</main>"))
-      .to be_equivalent_to xmlpp(html)
-    expect(xmlpp(IsoDoc::WordConvert
+      .to be_equivalent_to Xml::C14n.format(html)
+    expect(Xml::C14n.format(IsoDoc::WordConvert
       .new(wordstylesheet: "spec/assets/word.css",
            htmlstylesheet: "spec/assets/html.scss", filename: "test")
        .word_cleanup(Nokogiri::XML(input)).to_xml)
        .sub(/^.*<main/m, "<main").sub(%r{</main>.*$}m, "</main>"))
-      .to be_equivalent_to xmlpp(doc)
+      .to be_equivalent_to Xml::C14n.format(doc)
   end
 
   it "generates bare HTML file" do
@@ -1313,7 +1313,7 @@
       .sub(%r{</body>.*$}m, "</body>")
       .gsub(%r{<script.+?</script>}m, "<script/>")
       .sub(%r{(<script/>\s+)+}m, "<script/>")
-    expect(xmlpp(html)).to be_equivalent_to xmlpp(output)
+    expect(Xml::C14n.format(html)).to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "cleans up lists (HTML)" do
@@ -1352,11 +1352,11 @@
         </ul>
       </main>
     OUTPUT
-    expect(xmlpp(IsoDoc::HtmlConvert
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert
   .new(htmlstylesheet: "spec/assets/html.scss", filename: "test")
   .html_cleanup(Nokogiri::XML(input)).to_xml)
   .sub(/^.*<main/m, "<main").sub(%r{</main>.*$}m, "</main>"))
-      .to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "has hex-only XML escapes" do
diff --git a/spec/isodoc/postproc_word_spec.rb b/spec/isodoc/postproc_word_spec.rb
index 399d89b4..8b67a748 100644
--- a/spec/isodoc/postproc_word_spec.rb
+++ b/spec/isodoc/postproc_word_spec.rb
@@ -26,7 +26,7 @@
     word = File.read("test.doc")
       .sub(/^.*<div class="WordSection2">/m, '<div class="WordSection2">')
       .sub(%r{<p class="MsoNormal">\s*<br clear="all" class="section"/>\s*</p>\s*<div class="WordSection3">.*$}m, "")
-    expect(xmlpp(word)).to be_equivalent_to xmlpp(<<~OUTPUT)
+    expect(Xml::C14n.format(word)).to be_equivalent_to Xml::C14n.format(<<~OUTPUT)
       <div class="WordSection2">
               <p class="MsoNormal"><br clear="all" style="mso-special-character:line-break;page-break-before:always"/></p>
               <div>
@@ -74,7 +74,7 @@
     word = File.read("test.doc")
       .sub(/^.*<div class="WordSection1">/m, '<div class="WordSection1">')
       .sub(%r{<p class="MsoNormal">\s*<br clear="all" class="section"/>\s*</p>\s*<div class="WordSection2">.*$}m, "")
-    expect(xmlpp(word)).to be_equivalent_to xmlpp(<<~OUTPUT)
+    expect(Xml::C14n.format(word)).to be_equivalent_to Xml::C14n.format(<<~OUTPUT)
       <div class="WordSection1">
       /* an empty word cover page */
 
@@ -87,7 +87,7 @@
     word = File.read("test.doc")
       .sub(/^.*<div class="WordSection1">/m, '<div class="WordSection1">')
       .sub(%r{<p class="MsoNormal">\s*<br clear="all" class="section"/>\s*</p>\s*<div class="WordSection2">.*$}m, "")
-    expect(xmlpp(word)).to be_equivalent_to xmlpp(<<~OUTPUT)
+    expect(Xml::C14n.format(word)).to be_equivalent_to Xml::C14n.format(<<~OUTPUT)
     OUTPUT
   end
 
@@ -150,9 +150,9 @@
     word = File.read("test.doc")
       .sub(/^.*<div class="WordSection2">/m, '<div class="WordSection2">')
       .sub(%r{<p class="MsoNormal">\s*<br clear="all" class="section"/>\s*</p>\s*<div class="WordSection3">.*$}m, "")
-    expect(xmlpp(word.gsub(/_Toc\d\d+/, "_Toc")
+    expect(Xml::C14n.format(word.gsub(/_Toc\d\d+/, "_Toc")
       .gsub(/<o:p>&#xA0;<\/o:p>/, "")))
-      .to be_equivalent_to xmlpp(<<~'OUTPUT')
+      .to be_equivalent_to Xml::C14n.format(<<~'OUTPUT')
           <div class="WordSection2">
         /* an empty word intro page */
 
@@ -237,9 +237,9 @@
     word = File.read("test.doc")
       .sub(/^.*<div class="WordSection2">/m, '<div class="WordSection2">')
       .sub(%r{<p class="MsoNormal">\s*<br clear="all" class="section"/>\s*</p>\s*<div class="WordSection3">.*$}m, "")
-    expect(xmlpp(word.gsub(/_Toc\d\d+/, "_Toc")
+    expect(Xml::C14n.format(word.gsub(/_Toc\d\d+/, "_Toc")
       .gsub(/<o:p>&#xA0;<\/o:p>/, "")))
-      .to be_equivalent_to xmlpp(<<~'OUTPUT')
+      .to be_equivalent_to Xml::C14n.format(<<~'OUTPUT')
            <div class="WordSection2">
          /* an empty word intro page */
         <p class="MsoNormal"><br clear="all" style="mso-special-character:line-break;page-break-before:always"/></p><div class="TOC"><p class="zzContents">Table of Contents</p><p class="MsoToc1"><span lang="EN-GB" xml:lang="EN-GB"><span style="mso-element:field-begin"/><span style="mso-spacerun:yes"> </span>TOC \o "1-2" \h \z \u <span style="mso-element:field-separator"/></span><span class="MsoHyperlink"><span lang="EN-GB" style="mso-no-proof:yes" xml:lang="EN-GB"><a href="#_Toc">Clause 4<span lang="EN-GB" class="MsoTocTextSpan" xml:lang="EN-GB"><span style="mso-tab-count:1 dotted">. </span></span><span lang="EN-GB" class="MsoTocTextSpan" xml:lang="EN-GB"><span style="mso-element:field-begin"/></span>
@@ -305,9 +305,9 @@
     word = File.read("test.doc")
       .sub(/^.*<div class="WordSection2">/m, '<div class="WordSection2">')
       .sub(%r{<p class="MsoNormal">\s*<br clear="all" class="section"/>\s*</p>\s*<div class="WordSection3">.*$}m, "")
-    expect(xmlpp(word.gsub(/_Toc\d\d+/, "_Toc")
+    expect(Xml::C14n.format(word.gsub(/_Toc\d\d+/, "_Toc")
                 .gsub(/<o:p>&#xA0;<\/o:p>/, "")))
-      .to be_equivalent_to xmlpp(<<~'OUTPUT')
+      .to be_equivalent_to Xml::C14n.format(<<~'OUTPUT')
                    <div class="WordSection2">
                /* an empty word intro page */
 
@@ -425,9 +425,9 @@
     word = File.read("test.doc")
       .sub(/^.*<div class="WordSection2">/m, '<div class="WordSection2">')
       .sub(%r{<p class="MsoNormal">\s*<br clear="all" class="section"/>\s*</p>\s*<div class="WordSection3">.*$}m, "")
-    expect(xmlpp(word.gsub(/_Toc\d\d+/, "_Toc")
+    expect(Xml::C14n.format(word.gsub(/_Toc\d\d+/, "_Toc")
                 .gsub(/<o:p>&#xA0;<\/o:p>/, "")))
-      .to be_equivalent_to xmlpp(<<~'OUTPUT')
+      .to be_equivalent_to Xml::C14n.format(<<~'OUTPUT')
         <div class="WordSection2">
          /* an empty word intro page */
 
@@ -472,9 +472,9 @@
     word = File.read("test.doc")
       .sub(/^.*<div class="WordSection2">/m, '<div class="WordSection2">')
       .sub(%r{<p class="MsoNormal">\s*<br clear="all" class="section"/>\s*</p>\s*<div class="WordSection3">.*$}m, "")
-    expect(xmlpp(word.gsub(/_Toc\d\d+/, "_Toc")
+    expect(Xml::C14n.format(word.gsub(/_Toc\d\d+/, "_Toc")
                 .gsub(/<o:p>&#xA0;<\/o:p>/, "")))
-      .to be_equivalent_to xmlpp(<<~'OUTPUT')
+      .to be_equivalent_to Xml::C14n.format(<<~'OUTPUT')
         <div class="WordSection2">
         /* an empty word intro page */
 
@@ -607,7 +607,7 @@
     word = File.read("test.doc")
       .sub(/^.*<div class="WordSection2">/m, '<div class="WordSection2" xmlns:m="m">')
       .sub(%r{<p class="MsoNormal">\s*<br clear="all" class="section"/>\s*</p>\s*<div class="WordSection3">.*$}m, "")
-    expect(xmlpp(word)).to be_equivalent_to xmlpp(<<~OUTPUT)
+    expect(Xml::C14n.format(word)).to be_equivalent_to Xml::C14n.format(<<~OUTPUT)
       <div xmlns:m="m" class="WordSection2">
           <p class="MsoNormal">
             <br clear="all" style="mso-special-character:line-break;page-break-before:always"/>
@@ -658,7 +658,7 @@
     word = File.read("test.doc")
       .sub(/^.*<div class="WordSection2">/m, '<div class="WordSection2">')
       .sub(%r{<p class="MsoNormal">\s*<br clear="all" class="section"/>\s*</p>\s*<div class="WordSection3">.*$}m, "")
-    expect(xmlpp(word)).to be_equivalent_to xmlpp(<<~OUTPUT)
+    expect(Xml::C14n.format(word)).to be_equivalent_to Xml::C14n.format(<<~OUTPUT)
       <div class="WordSection2">
                    <p class="MsoNormal">
                      <br clear="all" style="mso-special-character:line-break;page-break-before:always"/>
@@ -692,7 +692,7 @@
       .sub(/^.*<div class="WordSection2">/m, '<div class="WordSection2">')
       .sub(%r{<p class="MsoNormal">\s*<br clear="all" class="section"/>\s*</p>\s*<div class="WordSection3">.*$}m, "")
       .sub(/src="[^"]+"/, 'src="_"')
-    expect(xmlpp(word)).to be_equivalent_to xmlpp(<<~OUTPUT)
+    expect(Xml::C14n.format(word)).to be_equivalent_to Xml::C14n.format(<<~OUTPUT)
       <div class="WordSection2">
                <p class="MsoNormal">
                  <br clear="all" style="mso-special-character:line-break;page-break-before:always"/>
@@ -731,7 +731,7 @@
       .sub(/^.*<div class="WordSection2">/m, '<div class="WordSection2" xmlns:m="m">')
       .sub(%r{<p class="MsoNormal">\s*<br clear="all" class="section"/>\s*</p>\s*<div class="WordSection3">.*$}m, "")
       .sub(/src="[^"]+"/, 'src="_"')
-    expect(xmlpp(word)).to be_equivalent_to xmlpp(<<~OUTPUT)
+    expect(Xml::C14n.format(word)).to be_equivalent_to Xml::C14n.format(<<~OUTPUT)
       <div class="WordSection2" xmlns:m="m">
               <p class="MsoNormal">
                 <br clear="all" style="mso-special-character:line-break;page-break-before:always"/>
@@ -779,7 +779,7 @@
       .sub(/^.*<div class="WordSection2">/m, '<div class="WordSection2" xmlns:m="m">')
       .sub(%r{<p class="MsoNormal">\s*<br clear="all" class="section"/>\s*</p>\s*<div class="WordSection3">.*$}m, "")
       .sub(/src="[^"]+"/, 'src="_"')
-    expect(xmlpp(word)).to be_equivalent_to xmlpp(<<~OUTPUT)
+    expect(Xml::C14n.format(word)).to be_equivalent_to Xml::C14n.format(<<~OUTPUT)
       <div class='WordSection2' xmlns:m='m'>
            <p class='MsoNormal'>
              <br clear='all' style='mso-special-character:line-break;page-break-before:always'/>
@@ -883,8 +883,8 @@
     expect(html).to include "div.WordSection3_1 {page:WordSection3P;}"
     expect(html).to include "div.WordSection3_2 {page:WordSection3L;}"
 
-    expect(xmlpp(html.sub(/^.*<body /m, "<body ")
-      .sub(%r{</body>.*$}m, "</body>"))).to be_equivalent_to xmlpp(<<~OUTPUT)
+    expect(Xml::C14n.format(html.sub(/^.*<body /m, "<body ")
+      .sub(%r{</body>.*$}m, "</body>"))).to be_equivalent_to Xml::C14n.format(<<~OUTPUT)
                 <body lang='EN-US' xml:lang='EN-US' link='blue' vlink='#954F72'>
                   <div class='WordSection2'>
                   <p class='MsoNormal'>
@@ -1110,12 +1110,12 @@
         </body>
       </html>
     OUTPUT
-    expect(xmlpp(IsoDoc::WordConvert
+    expect(Xml::C14n.format(IsoDoc::WordConvert
       .new(wordstylesheet: "spec/assets/word.css",
            htmlstylesheet: "spec/assets/html.scss", filename: "test")
       .word_cleanup(Nokogiri::XML(input)).to_xml)
       .sub(/^.*<main/m, "<main").sub(%r{</main>.*$}m, "</main>"))
-      .to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "allocate widths to tables (Word)" do
@@ -1375,11 +1375,11 @@
                </body>
              </html>
     OUTPUT
-    expect(xmlpp(IsoDoc::WordConvert
+    expect(Xml::C14n.format(IsoDoc::WordConvert
       .new(wordstylesheet: "spec/assets/word.css",
            htmlstylesheet: "spec/assets/html.scss", filename: "test")
       .word_cleanup(Nokogiri::XML(input)).to_xml)
       .sub(/^.*<main/m, "<main").sub(%r{</main>.*$}m, "</main>"))
-      .to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(output)
   end
 end
diff --git a/spec/isodoc/presentation_xml_maths_spec.rb b/spec/isodoc/presentation_xml_maths_spec.rb
index 637a5647..e7a51ef2 100644
--- a/spec/isodoc/presentation_xml_maths_spec.rb
+++ b/spec/isodoc/presentation_xml_maths_spec.rb
@@ -29,10 +29,10 @@
         </preface>
       </iso-standard>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
       .convert("test", input, true))
       .sub(%r{<localized-strings>.*</localized-strings>}m, "")))
-      .to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(output)
   end
 
   context "when twitter_cldr_localiser_symbols has additional options" do
@@ -180,10 +180,10 @@
     end
 
     it "Supports twitter_cldr_localiser_symbols fraction options" do
-      expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+      expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
         .convert("test", input, true))
         .sub(%r{<localized-strings>.*</localized-strings>}m, "")))
-        .to(be_equivalent_to(xmlpp(output)))
+        .to(be_equivalent_to(Xml::C14n.format(output)))
     end
   end
 
@@ -216,10 +216,10 @@
         </preface>
       </iso-standard>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
       .convert("test", input, true))
       .sub(%r{<localized-strings>.*</localized-strings>}m, "")))
-      .to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "customises localisation of numbers" do
@@ -251,10 +251,10 @@
              </preface>
            </iso-standard>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
       .convert("test", input, true))
       .sub(%r{<localized-strings>.*</localized-strings>}m, "")))
-      .to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(output)
   end
 
   context "overrides localisation of numbers in MathML" do
@@ -288,12 +288,12 @@
          </iso-standard>
       OUTPUT
       TwitterCldr.reset_locale_fallbacks
-      expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert
+      expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert
         .new({ localizenumber: "##0;###" }
         .merge(presxml_options))
           .convert("test", input, true))
           .sub(%r{<localized-strings>.*</localized-strings>}m, "")))
-        .to be_equivalent_to xmlpp(output2)
+        .to be_equivalent_to Xml::C14n.format(output2)
     end
 
     it "with grouping of digits" do
@@ -327,12 +327,12 @@
          </iso-standard>
       OUTPUT
       TwitterCldr.reset_locale_fallbacks
-      expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert
+      expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert
     .new({ localizenumber: "#=#0;##$#" }
         .merge(presxml_options))
       .convert("test", input, true))
       .sub(%r{<localized-strings>.*</localized-strings>}m, "")))
-        .to be_equivalent_to xmlpp(output1)
+        .to be_equivalent_to Xml::C14n.format(output1)
     end
   end
 
@@ -539,12 +539,12 @@
       OUTPUT
       TwitterCldr.reset_locale_fallbacks
 
-      expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert
+      expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert
     .new({ localizenumber: "#=#0;##$#" }
         .merge(presxml_options))
       .convert("test", input, true))
       .sub(%r{<localized-strings>.*</localized-strings>}m, "")))
-        .to be_equivalent_to xmlpp(output1)
+        .to be_equivalent_to Xml::C14n.format(output1)
     end
 
     it "with data-metanorma-numberformat attributes and no default precision" do
@@ -610,12 +610,12 @@
       OUTPUT
       TwitterCldr.reset_locale_fallbacks
 
-      expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert
+      expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert
     .new({ localizenumber: "#=#0;##$#" }
         .merge(presxml_options))
       .convert("test", input, true))
       .sub(%r{<localized-strings>.*</localized-strings>}m, "")))
-        .to be_equivalent_to xmlpp(output1)
+        .to be_equivalent_to Xml::C14n.format(output1)
     end
   end
 
@@ -692,10 +692,10 @@
         </preface>
       </iso-standard>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
       .convert("test", input, true))
       .sub(%r{<localized-strings>.*</localized-strings>}m, "")))
-      .to be_equivalent_to xmlpp(presxml)
+      .to be_equivalent_to Xml::C14n.format(presxml)
   end
 
   it "processes line breaks in MathML" do
@@ -796,16 +796,16 @@
     output = IsoDoc::PresentationXMLConvert.new(presxml_options
       .merge(output_formats: { html: "html", doc: "doc" }))
       .convert("test", input, true)
-    expect(xmlpp(strip_guid(output)
+    expect(Xml::C14n.format(strip_guid(output)
       .sub(%r{<localized-strings>.*</localized-strings>}m, "")
       .gsub(%r{<metanorma-extension>.*</metanorma-extension>}m, "")))
-      .to be_equivalent_to xmlpp(presxml)
-    expect(xmlpp(strip_guid(IsoDoc::HtmlConvert.new({})
+      .to be_equivalent_to Xml::C14n.format(presxml)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::HtmlConvert.new({})
       .convert("test", output, true))))
-      .to be_equivalent_to xmlpp(html)
-    expect(xmlpp(strip_guid(IsoDoc::WordConvert.new({})
+      .to be_equivalent_to Xml::C14n.format(html)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::WordConvert.new({})
       .convert("test", output, true))))
-      .to be_equivalent_to xmlpp(word)
+      .to be_equivalent_to Xml::C14n.format(word)
   end
 
   private
diff --git a/spec/isodoc/presentation_xml_metadata_spec.rb b/spec/isodoc/presentation_xml_metadata_spec.rb
index 67d8dc9f..f6fa6a96 100644
--- a/spec/isodoc/presentation_xml_metadata_spec.rb
+++ b/spec/isodoc/presentation_xml_metadata_spec.rb
@@ -62,10 +62,10 @@
          </preface>
        </iso-standard>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert
       .new({})
       .convert("test", input, true))))
-      .to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "inserts preprocess-xslt" do
@@ -111,10 +111,10 @@
         </metanorma-extension>
       </iso-standard>
     OUTPUT
-    expect(xmlpp(IsoDoc::PresentationXMLConvert.new(presxml_options)
+    expect(Xml::C14n.format(IsoDoc::PresentationXMLConvert.new(presxml_options)
   .convert("test", input, true))
   .sub(%r{<localized-strings>.*</localized-strings>}m, ""))
-      .to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "processes user-css" do
@@ -143,10 +143,10 @@
         </metanorma-extension>
       </iso-standard>
     OUTPUT
-    expect(xmlpp(IsoDoc::PresentationXMLConvert.new(presxml_options)
+    expect(Xml::C14n.format(IsoDoc::PresentationXMLConvert.new(presxml_options)
   .convert("test", input, true))
   .sub(%r{<localized-strings>.*</localized-strings>}m, ""))
-      .to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "inserts toc metadata" do
@@ -175,14 +175,14 @@
         <sections> </sections>
       </iso-standard>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert
       .new({ tocfigures: true,
              toctables: true,
              tocrecommendations: true }
       .merge(presxml_options))
       .convert("test", input, true)))
       .sub(%r{<localized-strings>.*</localized-strings>}m, ""))
-      .to be_equivalent_to xmlpp(presxml)
+      .to be_equivalent_to Xml::C14n.format(presxml)
   end
 
   it "passes font names to Presentation XML" do
@@ -229,12 +229,12 @@
          </sections>
       </iso-standard>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert
       .new({ fonts: "font1; font2", fontlicenseagreement: "no-install-fonts" }
       .merge(presxml_options))
       .convert("test", input, true)))
       .sub(%r{<localized-strings>.*</localized-strings>}m, ""))
-      .to be_equivalent_to xmlpp(presxml)
+      .to be_equivalent_to Xml::C14n.format(presxml)
   end
 
   it "processes preprocessing XSLT" do
@@ -419,10 +419,10 @@
         </body>
       </html>
     OUTPUT
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
-      .convert("test", input, true))).to be_equivalent_to xmlpp(html)
-    expect(xmlpp(IsoDoc::WordConvert.new({})
-      .convert("test", input, true))).to be_equivalent_to xmlpp(word)
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
+      .convert("test", input, true))).to be_equivalent_to Xml::C14n.format(html)
+    expect(Xml::C14n.format(IsoDoc::WordConvert.new({})
+      .convert("test", input, true))).to be_equivalent_to Xml::C14n.format(word)
   end
 
   it "extracts attachments" do
diff --git a/spec/isodoc/presentation_xml_spec.rb b/spec/isodoc/presentation_xml_spec.rb
index 4f86f1f0..1b72bd5a 100644
--- a/spec/isodoc/presentation_xml_spec.rb
+++ b/spec/isodoc/presentation_xml_spec.rb
@@ -47,10 +47,10 @@
          </sections>
        </iso-standard>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
   .convert("test", input, true))
   .sub(%r{<localized-strings>.*</localized-strings>}m, "")))
-      .to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "resolve address components" do
@@ -110,10 +110,10 @@
         </bibdata>
       </iso-standard>
     OUTPUT
-    expect(xmlpp(IsoDoc::PresentationXMLConvert.new(presxml_options)
+    expect(Xml::C14n.format(IsoDoc::PresentationXMLConvert.new(presxml_options)
       .convert("test", input, true))
       .sub(%r{<localized-strings>.*</localized-strings>}m, ""))
-      .to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "strips variant-title" do
@@ -331,14 +331,14 @@
           </body>
         </html>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
       .convert("test", input, true))
       .sub(%r{<localized-strings>.*</localized-strings>}m, "")))
-      .to be_equivalent_to xmlpp(presxml)
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
-      .convert("test", presxml, true))).to be_equivalent_to xmlpp(html)
-    expect(xmlpp(IsoDoc::WordConvert.new({})
-      .convert("test", presxml, true))).to be_equivalent_to xmlpp(doc)
+      .to be_equivalent_to Xml::C14n.format(presxml)
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
+      .convert("test", presxml, true))).to be_equivalent_to Xml::C14n.format(html)
+    expect(Xml::C14n.format(IsoDoc::WordConvert.new({})
+      .convert("test", presxml, true))).to be_equivalent_to Xml::C14n.format(doc)
   end
 
   it "duplicates EMF and SVG files" do
@@ -394,7 +394,7 @@
          </sections>
       </iso-standard>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert
       .new(presxml_options.merge(output_formats: { html: "html", doc: "doc" }))
       .convert("test", input, true)
       .sub(%r{<localized-strings>.*</localized-strings>}m, "")
@@ -403,7 +403,7 @@
             '"data:image/emf;base64"')
       .gsub(%r{"data:application/x-msmetafile;base64,[^"]+"},
             '"data:application/x-msmetafile;base64"'))))
-      .to be_equivalent_to (xmlpp(output))
+      .to be_equivalent_to (Xml::C14n.format(output))
 
     output = <<~OUTPUT
       <iso-standard xmlns="http://riboseinc.com/isoxml" type="presentation">
@@ -452,7 +452,7 @@
          </sections>
        </iso-standard>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert
       .new(presxml_options.merge(output_formats: { html: "html" }))
       .convert("test", input, true)
       .sub(%r{<localized-strings>.*</localized-strings>}m, "")
@@ -692,7 +692,7 @@
                </sections>
             </iso-standard>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
   .convert("test", input, true)
   .sub(%r{<localized-strings>.*</localized-strings>}m, "")
       .gsub(%r{src="[^"]+?\.emf"}, 'src="_.emf"')
@@ -729,7 +729,7 @@
         </sections>
       </iso-standard>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
       .convert("test", input, true)
       .sub(%r{<localized-strings>.*</localized-strings>}m, "")
       .gsub(%r{src="[^"]+?\.svg"}, 'src="_.svg"'))))
@@ -840,10 +840,10 @@
         </sections>
       </iso-standard>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
       .convert("test", input, true))
       .sub(%r{<localized-strings>.*</localized-strings>}m, "")))
-      .to be_equivalent_to xmlpp(presxml)
+      .to be_equivalent_to Xml::C14n.format(presxml)
   end
 
   it "considers ul when adding types to ordered lists" do
@@ -895,10 +895,10 @@
         </sections>
       </iso-standard>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
       .convert("test", input, true))
       .sub(%r{<localized-strings>.*</localized-strings>}m, "")))
-      .to be_equivalent_to xmlpp(presxml)
+      .to be_equivalent_to Xml::C14n.format(presxml)
   end
 
   it "processes multiple-target xrefs in English" do
@@ -956,13 +956,13 @@
          </p>
        </foreword>
     OUTPUT
-    expect(xmlpp(Nokogiri::XML(
+    expect(Xml::C14n.format(Nokogiri::XML(
       IsoDoc::PresentationXMLConvert.new(presxml_options)
       .convert("test", input, true),
     )
       .at("//xmlns:foreword")
       .to_xml))
-      .to be_equivalent_to xmlpp(presxml)
+      .to be_equivalent_to Xml::C14n.format(presxml)
   end
 
   it "processes multiple-target xrefs in Japanese" do
@@ -1018,13 +1018,13 @@
          </p>
        </foreword>
     OUTPUT
-    expect(xmlpp(Nokogiri::XML(
+    expect(Xml::C14n.format(Nokogiri::XML(
       IsoDoc::PresentationXMLConvert.new(presxml_options)
       .convert("test", input, true),
     )
       .at("//xmlns:foreword")
       .to_xml))
-      .to be_equivalent_to xmlpp(presxml)
+      .to be_equivalent_to Xml::C14n.format(presxml)
   end
 
   it "processes erefstack" do
@@ -1097,8 +1097,8 @@
     xml.at("//xmlns:localized-strings")&.remove
     xml.at("//xmlns:bibliography")&.remove
     xml.at("//xmlns:references")&.remove
-    expect(xmlpp(strip_guid(xml.to_xml)))
-      .to be_equivalent_to xmlpp(presxml)
+    expect(Xml::C14n.format(strip_guid(xml.to_xml)))
+      .to be_equivalent_to Xml::C14n.format(presxml)
   end
 
   it "captions embedded figures" do
@@ -1162,10 +1162,10 @@
          </sections>
        </iso-standard>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
       .convert("test", input, true))
       .sub(%r{<localized-strings>.*</localized-strings>}m, "")))
-      .to be_equivalent_to xmlpp(presxml)
+      .to be_equivalent_to Xml::C14n.format(presxml)
   end
 
   it "skips numbering of hidden sections" do
@@ -1220,10 +1220,10 @@
         </bibliography>
       </standard-document>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
       .convert("test", input, true))
       .sub(%r{<localized-strings>.*</localized-strings>}m, "")))
-      .to be_equivalent_to xmlpp(presxml)
+      .to be_equivalent_to Xml::C14n.format(presxml)
   end
 
   it "processes identifier" do
@@ -1254,10 +1254,10 @@
          </sections>
        </standard-document>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
       .convert("test", input, true))
       .sub(%r{<localized-strings>.*</localized-strings>}m, "")))
-      .to be_equivalent_to xmlpp(presxml)
+      .to be_equivalent_to Xml::C14n.format(presxml)
   end
 
   it "sorts preface sections" do
@@ -1301,10 +1301,10 @@
         </preface>
       </standard-document>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
       .convert("test", input, true))
       .sub(%r{<localized-strings>.*</localized-strings>}m, "")))
-      .to be_equivalent_to xmlpp(presxml)
+      .to be_equivalent_to Xml::C14n.format(presxml)
   end
 
   it "leaves alone floating titles if preface sections already sorted" do
@@ -1348,10 +1348,10 @@
          </preface>
        </standard-document>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
       .convert("test", input, true))
        .sub(%r{<localized-strings>.*</localized-strings>}m, "")))
-      .to be_equivalent_to xmlpp(presxml)
+      .to be_equivalent_to Xml::C14n.format(presxml)
   end
 
   it "does not break up very long strings in tables by default" do
@@ -1387,10 +1387,10 @@
          </preface>
        </standard-document>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
       .convert("test", input, true))
        .sub(%r{<localized-strings>.*</localized-strings>}m, "")))
-      .to be_equivalent_to xmlpp(presxml)
+      .to be_equivalent_to Xml::C14n.format(presxml)
   end
 
   it "breaks up very long strings in tables on request" do
@@ -1661,11 +1661,11 @@
          </preface>
        </standard-document>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert
       .new(presxml_options
       .merge(output_formats: { html: "html", doc: "doc", pdf: "pdf" }))
       .convert("test", input, true))
        .sub(%r{<localized-strings>.*</localized-strings>}m, "")))
-      .to be_equivalent_to xmlpp(presxml)
+      .to be_equivalent_to Xml::C14n.format(presxml)
   end
 end
diff --git a/spec/isodoc/ref_spec.rb b/spec/isodoc/ref_spec.rb
index e33776f2..47c2e5e8 100644
--- a/spec/isodoc/ref_spec.rb
+++ b/spec/isodoc/ref_spec.rb
@@ -482,14 +482,14 @@
     OUTPUT
 
     FileUtils.rm_rf("test.doc")
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
       .convert("test", input, true))
       .sub(%r{<localized-strings>.*</localized-strings>}m, "")
       .gsub(%r{<fn reference="[^"]+"}m, "<fn reference=\"_\"")))
-      .to be_equivalent_to xmlpp(presxml)
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
+      .to be_equivalent_to Xml::C14n.format(presxml)
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
       .convert("test", presxml, true)))
-      .to be_equivalent_to xmlpp(html)
+      .to be_equivalent_to Xml::C14n.format(html)
     IsoDoc::WordConvert.new({})
       .convert("test", presxml, false)
     expect(File.exist?("test.doc")).to be true
@@ -499,8 +499,8 @@
       .gsub("epub:", "")
       .gsub(/mso-bookmark:_Ref\d+/, "mso-bookmark:_Ref")
       .gsub(/NOTEREF _Ref\d+/, "NOTEREF _Ref")
-    expect(xmlpp(html))
-      .to be_equivalent_to xmlpp(doc)
+    expect(Xml::C14n.format(html))
+      .to be_equivalent_to Xml::C14n.format(doc)
   end
 
   it "marks references sections as hidden" do
@@ -549,10 +549,10 @@
         </bibliography>
       </iso-standard>
     PRESXML
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
       .convert("test", input, true)
       .sub(%r{<localized-strings>.*</localized-strings>}m, ""))))
-      .to be_equivalent_to xmlpp(presxml)
+      .to be_equivalent_to Xml::C14n.format(presxml)
   end
 
   it "processes hidden references sections in Relaton bibliographies #1" do
@@ -873,10 +873,10 @@
         </bibliography>
       </iso-standard>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
       .convert("test", input, true)
       .sub(%r{<localized-strings>.*</localized-strings>}m, ""))))
-      .to be_equivalent_to xmlpp(presxml)
+      .to be_equivalent_to Xml::C14n.format(presxml)
   end
 
   it "processes hidden references sections in Relaton bibliographies #2" do
@@ -995,10 +995,10 @@
         </bibliography>
       </iso-standard>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
     .convert("test", input, true)
     .sub(%r{<localized-strings>.*</localized-strings>}m, ""))))
-      .to be_equivalent_to xmlpp(presxml)
+      .to be_equivalent_to Xml::C14n.format(presxml)
   end
 
   it "selects the primary identifier" do
@@ -1035,11 +1035,11 @@
         </p>
       </foreword>
     PRESXML
-    expect(xmlpp(Nokogiri::XML(
+    expect(Xml::C14n.format(Nokogiri::XML(
       IsoDoc::PresentationXMLConvert.new(presxml_options)
       .convert("test", input, true),
     ).at("//xmlns:foreword").to_xml))
-      .to be_equivalent_to xmlpp(presxml)
+      .to be_equivalent_to Xml::C14n.format(presxml)
   end
 
   it "selects multiple primary identifiers" do
@@ -1076,11 +1076,11 @@
         </p>
       </foreword>
     PRESXML
-    expect(xmlpp(Nokogiri::XML(
+    expect(Xml::C14n.format(Nokogiri::XML(
       IsoDoc::PresentationXMLConvert.new(presxml_options)
       .convert("test", input, true),
     ).at("//xmlns:foreword").to_xml))
-      .to be_equivalent_to xmlpp(presxml)
+      .to be_equivalent_to Xml::C14n.format(presxml)
   end
 
   it "enforces consistent metanorma-ordinal numbering" do
@@ -1130,11 +1130,11 @@
          </references>
        </bibliography>
     PRESXML
-    expect(xmlpp(Nokogiri::XML(
+    expect(Xml::C14n.format(Nokogiri::XML(
       IsoDoc::PresentationXMLConvert.new(presxml_options)
       .convert("test", input, true),
     ).at("//xmlns:bibliography").to_xml))
-      .to be_equivalent_to xmlpp(presxml)
+      .to be_equivalent_to Xml::C14n.format(presxml)
   end
 
   it "enforces consistent references numbering with hidden items: metanorma identifiers" do
@@ -1178,11 +1178,11 @@
         </references>
       </bibliography>
     PRESXML
-    expect(xmlpp(Nokogiri::XML(
+    expect(Xml::C14n.format(Nokogiri::XML(
       IsoDoc::PresentationXMLConvert.new(presxml_options)
       .convert("test", input, true),
     ).at("//xmlns:bibliography").to_xml))
-      .to be_equivalent_to xmlpp(presxml)
+      .to be_equivalent_to Xml::C14n.format(presxml)
   end
 
   it "enforces consistent references numbering with hidden items: metanorma-ordinal identifiers" do
@@ -1232,11 +1232,11 @@
         </references>
       </bibliography>
     PRESXML
-    expect(xmlpp(Nokogiri::XML(
+    expect(Xml::C14n.format(Nokogiri::XML(
       IsoDoc::PresentationXMLConvert.new(presxml_options)
       .convert("test", input, true),
     ).at("//xmlns:bibliography").to_xml))
-      .to be_equivalent_to xmlpp(presxml)
+      .to be_equivalent_to Xml::C14n.format(presxml)
   end
 
   it "suppresses document identifier if requested to" do
@@ -1344,12 +1344,12 @@
     OUTPUT
     doc = IsoDoc::PresentationXMLConvert.new(presxml_options)
       .convert("test", input, true)
-    expect(xmlpp(strip_guid(Nokogiri::XML(doc)
+    expect(Xml::C14n.format(strip_guid(Nokogiri::XML(doc)
     .at("//xmlns:references").to_xml)))
-      .to be_equivalent_to xmlpp(presxml)
-    expect(xmlpp(strip_guid(IsoDoc::HtmlConvert.new({})
+      .to be_equivalent_to Xml::C14n.format(presxml)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::HtmlConvert.new({})
    .convert("test", doc, true))))
-      .to be_equivalent_to xmlpp(html)
+      .to be_equivalent_to Xml::C14n.format(html)
   end
 
   it "renders footnote in metanorma docidentifier" do
@@ -1411,12 +1411,12 @@
     OUTPUT
     doc = IsoDoc::PresentationXMLConvert.new(presxml_options)
       .convert("test", input, true)
-    expect(strip_guid(xmlpp(Nokogiri::XML(doc)
+    expect(strip_guid(Xml::C14n.format(Nokogiri::XML(doc)
     .at("//xmlns:references").to_xml)))
-      .to be_equivalent_to xmlpp(presxml)
-    expect(strip_guid(xmlpp(IsoDoc::HtmlConvert.new({})
+      .to be_equivalent_to Xml::C14n.format(presxml)
+    expect(strip_guid(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
    .convert("test", doc, true))))
-      .to be_equivalent_to xmlpp(html)
+      .to be_equivalent_to Xml::C14n.format(html)
   end
 
   it "renders mixed bibitems and bibliographic subclauses" do
@@ -1610,11 +1610,11 @@
       .convert("test", input, true)
     xml = Nokogiri::XML(doc)
     xml.at("//xmlns:localized-strings").remove
-    expect(strip_guid(xmlpp(xml.to_xml)))
-      .to be_equivalent_to xmlpp(presxml)
-    expect(strip_guid(xmlpp(IsoDoc::HtmlConvert.new({})
+    expect(strip_guid(Xml::C14n.format(xml.to_xml)))
+      .to be_equivalent_to Xml::C14n.format(presxml)
+    expect(strip_guid(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
       .convert("test", doc, true))))
-      .to be_equivalent_to xmlpp(html)
+      .to be_equivalent_to Xml::C14n.format(html)
   end
 
   it "emend citeas" do
@@ -1638,8 +1638,8 @@
     xml = Nokogiri::XML(IsoDoc::PresentationXMLConvert
       .new(presxml_options)
       .convert("test", input, true))
-    expect(strip_guid(xmlpp(xml.at("//xmlns:foreword").to_xml)))
-      .to be_equivalent_to xmlpp(presxml)
+    expect(strip_guid(Xml::C14n.format(xml.at("//xmlns:foreword").to_xml)))
+      .to be_equivalent_to Xml::C14n.format(presxml)
   end
 
   it "processes clauses containing normative references" do
@@ -1724,10 +1724,10 @@
              </body>
            </html>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
-      .convert("test", input, true)))).to be_equivalent_to xmlpp(presxml)
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
-      .convert("test", presxml, true))).to be_equivalent_to xmlpp(html)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+      .convert("test", input, true)))).to be_equivalent_to Xml::C14n.format(presxml)
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
+      .convert("test", presxml, true))).to be_equivalent_to Xml::C14n.format(html)
   end
 
   it "sets NO ID to nil" do
@@ -1768,10 +1768,10 @@
        </bibliography>
       </iso-standard>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
       .convert("test", input, true))
                       .sub(%r{<localized-strings>.*</localized-strings>}m, "")))
-      .to be_equivalent_to xmlpp(presxml)
+      .to be_equivalent_to Xml::C14n.format(presxml)
 
     mock_i18n
     presxml = <<~OUTPUT
@@ -1797,10 +1797,10 @@
        </bibliography>
       </iso-standard>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
       .convert("test", input.sub(">en<", ">eo<"), true))
                       .sub(%r{<localized-strings>.*</localized-strings>}m, "")))
-      .to be_equivalent_to xmlpp(presxml)
+      .to be_equivalent_to Xml::C14n.format(presxml)
   end
 
   private
diff --git a/spec/isodoc/section_spec.rb b/spec/isodoc/section_spec.rb
index 6b168bed..77dd6aa9 100644
--- a/spec/isodoc/section_spec.rb
+++ b/spec/isodoc/section_spec.rb
@@ -20,8 +20,8 @@
        </sections>
       </iso-standard>
     INPUT
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
-      .convert("test", input, true))).to be_equivalent_to xmlpp(<<~OUTPUT)
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
+      .convert("test", input, true))).to be_equivalent_to Xml::C14n.format(<<~OUTPUT)
             <html lang='en'>
           <head/>
           <body lang='en'>
@@ -61,8 +61,8 @@
           </body>
         </html>
       OUTPUT
-    expect(xmlpp(IsoDoc::WordConvert.new({})
-      .convert("test", input, true))).to be_equivalent_to xmlpp(<<~OUTPUT)
+    expect(Xml::C14n.format(IsoDoc::WordConvert.new({})
+      .convert("test", input, true))).to be_equivalent_to Xml::C14n.format(<<~OUTPUT)
             <html xmlns:epub='http://www.idpf.org/2007/ops' lang='en'>
           <head>
             <style>
@@ -160,8 +160,8 @@
          </body>
        </html>
     OUTPUT
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
-         .convert("test", input, true))).to be_equivalent_to xmlpp(output)
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
+         .convert("test", input, true))).to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "processes annexes containing one, or more than one special sections" do
@@ -311,8 +311,8 @@
         </annex>
       </iso-standard>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
-      .convert("test", input, true)))).to be_equivalent_to xmlpp(presxml)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+      .convert("test", input, true)))).to be_equivalent_to Xml::C14n.format(presxml)
   end
 
   it "processes cross-align" do
@@ -369,7 +369,7 @@
          </body>
        </html>
     OUTPUT
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
-         .convert("test", input, true))).to be_equivalent_to xmlpp(output)
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
+         .convert("test", input, true))).to be_equivalent_to Xml::C14n.format(output)
   end
 end
diff --git a/spec/isodoc/section_title_spec.rb b/spec/isodoc/section_title_spec.rb
index b931812f..d94a76ab 100644
--- a/spec/isodoc/section_title_spec.rb
+++ b/spec/isodoc/section_title_spec.rb
@@ -570,12 +570,12 @@
         </body>
       </html>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
-      .convert("test", input, true)))).to be_equivalent_to xmlpp(presxml)
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
-      .convert("test", presxml, true))).to be_equivalent_to xmlpp(html)
-    expect(xmlpp(IsoDoc::WordConvert.new({})
-      .convert("test", presxml, true))).to be_equivalent_to xmlpp(word)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+      .convert("test", input, true)))).to be_equivalent_to Xml::C14n.format(presxml)
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
+      .convert("test", presxml, true))).to be_equivalent_to Xml::C14n.format(html)
+    expect(Xml::C14n.format(IsoDoc::WordConvert.new({})
+      .convert("test", presxml, true))).to be_equivalent_to Xml::C14n.format(word)
   end
 
   it "processes section subtitles" do
@@ -1227,10 +1227,10 @@
     OUTPUT
     presxml = IsoDoc::PresentationXMLConvert.new(presxml_options)
       .convert("test", input, true)
-    expect(xmlpp(strip_guid(IsoDoc::HtmlConvert.new({})
-      .convert("test", presxml, true)))).to be_equivalent_to xmlpp(html)
-    expect(xmlpp(strip_guid(IsoDoc::WordConvert.new({})
-      .convert("test", presxml, true)))).to be_equivalent_to xmlpp(word)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::HtmlConvert.new({})
+      .convert("test", presxml, true)))).to be_equivalent_to Xml::C14n.format(html)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::WordConvert.new({})
+      .convert("test", presxml, true)))).to be_equivalent_to Xml::C14n.format(word)
   end
 
   it "processes section names suppressing section numbering" do
@@ -1382,10 +1382,10 @@
         </bibliography>
       </iso-standard>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert
       .new({ suppressheadingnumbers: true }
       .merge(presxml_options))
-      .convert("test", input, true)))).to be_equivalent_to xmlpp(output)
+      .convert("test", input, true)))).to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "processes unnumbered section names" do
@@ -1524,9 +1524,9 @@
          </bibliography>
        </iso-standard>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert
       .new(presxml_options)
-      .convert("test", input, true)))).to be_equivalent_to xmlpp(output)
+      .convert("test", input, true)))).to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "processes floating titles" do
@@ -1683,15 +1683,15 @@
              </h1></div></div><div style="mso-element:footnote-list"/>
          </body>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
-      .convert("test", input, true)))).to be_equivalent_to xmlpp(presxml)
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
-      .convert("test", presxml, true))).to be_equivalent_to xmlpp(html)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+      .convert("test", input, true)))).to be_equivalent_to Xml::C14n.format(presxml)
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
+      .convert("test", presxml, true))).to be_equivalent_to Xml::C14n.format(html)
     IsoDoc::WordConvert.new({}).convert("test", presxml, false)
-    expect(xmlpp(File.read("test.doc")
+    expect(Xml::C14n.format(File.read("test.doc")
     .sub(/^.*<body/m, "<body")
     .sub(%r{</body>.*$}m, "")))
-      .to be_equivalent_to xmlpp(word)
+      .to be_equivalent_to Xml::C14n.format(word)
   end
 
   it "processes section titles without ID" do
@@ -1721,10 +1721,10 @@
         </preface>
       </iso-standard>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert
       .new({ suppressheadingnumbers: true }
       .merge(presxml_options))
-      .convert("test", input, true)))).to be_equivalent_to xmlpp(output)
+      .convert("test", input, true)))).to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "processes inline section headers" do
@@ -1781,10 +1781,10 @@
                </body>
            </html>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
-      .convert("test", input, true)))).to be_equivalent_to xmlpp(presxml)
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
-      .convert("test", presxml, true))).to be_equivalent_to xmlpp(output)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+      .convert("test", input, true)))).to be_equivalent_to Xml::C14n.format(presxml)
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
+      .convert("test", presxml, true))).to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "processes inline section headers with suppressed heading numbering" do
@@ -1801,11 +1801,11 @@
        </sections>
       </iso-standard>
     INPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert
       .new({ suppressheadingnumbers: true }
       .merge(presxml_options))
       .convert("test", input, true))))
-      .to be_equivalent_to xmlpp(<<~OUTPUT)
+      .to be_equivalent_to Xml::C14n.format(<<~OUTPUT)
         <iso-standard xmlns='http://riboseinc.com/isoxml' type="presentation">
           <preface> <clause type="toc" id="_" displayorder="1"> <title depth="1">Table of contents</title> </clause> </preface>
           <sections>
@@ -1867,8 +1867,8 @@
         </sections>
       </iso-standard>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
-      .convert("test", input, true)))).to be_equivalent_to xmlpp(output)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+      .convert("test", input, true)))).to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "processes disconnected titles" do
@@ -1930,7 +1930,7 @@
          </body>
        </html>
     OUTPUT
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
-         .convert("test", input, true))).to be_equivalent_to xmlpp(output)
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
+         .convert("test", input, true))).to be_equivalent_to Xml::C14n.format(output)
   end
 end
diff --git a/spec/isodoc/sourcecode_spec.rb b/spec/isodoc/sourcecode_spec.rb
index 9a44c801..2060b783 100644
--- a/spec/isodoc/sourcecode_spec.rb
+++ b/spec/isodoc/sourcecode_spec.rb
@@ -85,12 +85,12 @@
                 </body>
             </html>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
-      .convert("test", input, true)))).to be_equivalent_to xmlpp(presxml)
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
-      .convert("test", presxml, true))).to be_equivalent_to xmlpp(html)
-    expect(xmlpp(IsoDoc::WordConvert.new({})
-      .convert("test", presxml, true))).to be_equivalent_to xmlpp(doc)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+      .convert("test", input, true)))).to be_equivalent_to Xml::C14n.format(presxml)
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
+      .convert("test", presxml, true))).to be_equivalent_to Xml::C14n.format(html)
+    expect(Xml::C14n.format(IsoDoc::WordConvert.new({})
+      .convert("test", presxml, true))).to be_equivalent_to Xml::C14n.format(doc)
   end
 
   it "processes sourcecode with sourcecode highlighting" do
@@ -315,20 +315,20 @@
          <div style="mso-element:footnote-list"/>
        </body>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert
       .new({ sourcehighlighter: true }
       .merge(presxml_options))
       .convert("test", input, true)))
     .sub(%r{<localized-strings>.*</localized-strings>}m, ""))
-      .to be_equivalent_to xmlpp(presxml)
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
-      .convert("test", presxml, true))).to be_equivalent_to xmlpp(html)
+      .to be_equivalent_to Xml::C14n.format(presxml)
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
+      .convert("test", presxml, true))).to be_equivalent_to Xml::C14n.format(html)
     FileUtils.rm_f("test.doc")
     IsoDoc::WordConvert.new({}).convert("test", presxml, false)
-    expect(xmlpp(File.read("test.doc")
+    expect(Xml::C14n.format(File.read("test.doc")
       .gsub(%r{^.*<body }m, "<body ")
       .gsub(%r{</body>.*}m, "</body>")))
-      .to be_equivalent_to xmlpp(doc)
+      .to be_equivalent_to Xml::C14n.format(doc)
   end
 
   it "combines sourcecode highlighting stylesheet with user-css" do
@@ -401,8 +401,8 @@
       .merge(presxml_options))
       .convert("test", input, true))
       .at("//xmlns:metanorma-extension")
-    expect(xmlpp(xml.to_xml))
-      .to be_equivalent_to xmlpp(output)
+    expect(Xml::C14n.format(xml.to_xml))
+      .to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "processes sourcecode with escapes preserved, and XML sourcecode highlighting" do
@@ -485,15 +485,15 @@
          </body>
        </html>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert
   .new({ sourcehighlighter: true }
       .merge(presxml_options))
   .convert("test", input, true)))
   .sub(%r{<metanorma-extension>.*</metanorma-extension>}m, "")
   .sub(%r{<localized-strings>.*</localized-strings>}m, ""))
-      .to be_equivalent_to xmlpp(presxml)
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
-      .convert("test", presxml, true))).to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(presxml)
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
+      .convert("test", presxml, true))).to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "processes sourcecode with annotations" do
@@ -635,17 +635,17 @@
            </body>
          </html>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert
   .new({ sourcehighlighter: true }
       .merge(presxml_options))
   .convert("test", input, true)))
   .sub(%r{<metanorma-extension>.*</metanorma-extension>}m, "")
   .sub(%r{<localized-strings>.*</localized-strings>}m, ""))
-      .to be_equivalent_to xmlpp(presxml)
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
-      .convert("test", presxml, true))).to be_equivalent_to xmlpp(html)
-    expect(xmlpp(IsoDoc::WordConvert.new({})
-      .convert("test", presxml, true))).to be_equivalent_to xmlpp(doc)
+      .to be_equivalent_to Xml::C14n.format(presxml)
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
+      .convert("test", presxml, true))).to be_equivalent_to Xml::C14n.format(html)
+    expect(Xml::C14n.format(IsoDoc::WordConvert.new({})
+      .convert("test", presxml, true))).to be_equivalent_to Xml::C14n.format(doc)
   end
 
   it "processes sourcecode with annotations and line numbering" do
@@ -852,17 +852,17 @@
         </body>
       </html>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert
   .new({ sourcehighlighter: true }
       .merge(presxml_options))
   .convert("test", input, true)))
   .sub(%r{<metanorma-extension>.*</metanorma-extension>}m, "")
   .sub(%r{<localized-strings>.*</localized-strings>}m, ""))
-      .to be_equivalent_to xmlpp(presxml)
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
-      .convert("test", presxml, true))).to be_equivalent_to xmlpp(html)
-    expect(xmlpp(IsoDoc::WordConvert.new({})
-      .convert("test", presxml, true))).to be_equivalent_to xmlpp(doc)
+      .to be_equivalent_to Xml::C14n.format(presxml)
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
+      .convert("test", presxml, true))).to be_equivalent_to Xml::C14n.format(html)
+    expect(Xml::C14n.format(IsoDoc::WordConvert.new({})
+      .convert("test", presxml, true))).to be_equivalent_to Xml::C14n.format(doc)
   end
 
   it "processes sourcecode with xml formatting" do
@@ -974,13 +974,13 @@
          </preface>
        </iso-standard>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert
       .new({ sourcehighlighter: true }
       .merge(presxml_options))
       .convert("test", input, true)))
       .sub(%r{<metanorma-extension>.*</metanorma-extension>}m, "")
       .sub(%r{<localized-strings>.*</localized-strings>}m, ""))
-      .to be_equivalent_to xmlpp(presxml)
+      .to be_equivalent_to Xml::C14n.format(presxml)
   end
 
   it "processes pseudocode" do
@@ -1028,17 +1028,17 @@
     OUTPUT
 
     FileUtils.rm_f "test.doc"
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
       .convert("test", input, true)))
       .sub(%r{<localized-strings>.*</localized-strings>}m, ""))
-      .to be_equivalent_to xmlpp(presxml)
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
-      .convert("test", presxml, true))).to be_equivalent_to xmlpp(html)
+      .to be_equivalent_to Xml::C14n.format(presxml)
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
+      .convert("test", presxml, true))).to be_equivalent_to Xml::C14n.format(html)
     IsoDoc::WordConvert.new({}).convert("test", presxml, false)
-    expect(xmlpp(File.read("test.doc")
+    expect(Xml::C14n.format(File.read("test.doc")
       .gsub(%r{^.*<h1 class="ForewordTitle">Foreword</h1>}m, "")
       .gsub(%r{</div>.*}m, "</div>")))
-      .to be_equivalent_to xmlpp(<<~"OUTPUT")
+      .to be_equivalent_to Xml::C14n.format(<<~"OUTPUT")
              <div class="pseudocode"  style='page-break-after: avoid;page-break-inside: avoid;'><a name="_" id="_"></a><p class="pseudocode"><a name="_" id="_"></a>&#xA0;&#xA0;<b>A</b><br/>
         &#xA0;&#xA0;&#xA0;&#xA0;&#xA0;&#xA0;&#xA0;&#xA0;<span style="font-variant:small-caps;">B</span></p>
         <p class="pseudocode" style="page-break-after:avoid;"><a name="_" id="_"></a>&#xA0;&#xA0;<i>C</i></p><p class="SourceTitle" style="text-align:center;">Figure 1&#xA0;&#x2014; Label</p></div>
diff --git a/spec/isodoc/table_spec.rb b/spec/isodoc/table_spec.rb
index 95a458a4..2c124dc8 100644
--- a/spec/isodoc/table_spec.rb
+++ b/spec/isodoc/table_spec.rb
@@ -458,14 +458,14 @@
          </body>
        </html>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
-      .convert("test", input, true)))).to be_equivalent_to xmlpp(presxml)
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
-      .convert("test", presxml, true))).to be_equivalent_to xmlpp(html)
-    expect(xmlpp(IsoDoc::WordConvert.new({})
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+      .convert("test", input, true)))).to be_equivalent_to Xml::C14n.format(presxml)
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
+      .convert("test", presxml, true))).to be_equivalent_to Xml::C14n.format(html)
+    expect(Xml::C14n.format(IsoDoc::WordConvert.new({})
       .convert("test", presxml, true)
       .gsub(/mso-bookmark:_Ref\d+/, "mso-bookmark:_Ref")))
-      .to be_equivalent_to xmlpp(word)
+      .to be_equivalent_to Xml::C14n.format(word)
   end
 
   it "passes on classes of tables from Presentation XML" do
@@ -544,12 +544,12 @@
          </body>
        </html>
     OUTPUT
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
-  .convert("test", presxml, true))).to be_equivalent_to xmlpp(html)
-    expect(xmlpp(IsoDoc::WordConvert.new({})
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
+  .convert("test", presxml, true))).to be_equivalent_to Xml::C14n.format(html)
+    expect(Xml::C14n.format(IsoDoc::WordConvert.new({})
       .convert("test", presxml, true)
       .gsub(/mso-bookmark:_Ref\d+/, "mso-bookmark:_Ref")))
-      .to be_equivalent_to xmlpp(word)
+      .to be_equivalent_to Xml::C14n.format(word)
   end
 
   it "processes tables with big cells" do
@@ -738,10 +738,10 @@
            </body>
          </html>
     OUTPUT
-    expect(xmlpp(IsoDoc::WordConvert.new({})
+    expect(Xml::C14n.format(IsoDoc::WordConvert.new({})
       .convert("test", input, true)
       .gsub(/mso-bookmark:_Ref\d+/, "mso-bookmark:_Ref")))
-      .to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "processes tables with many rows" do
@@ -848,10 +848,10 @@
         </body>
       </html>
     OUTPUT
-    expect(xmlpp(IsoDoc::WordConvert.new({})
+    expect(Xml::C14n.format(IsoDoc::WordConvert.new({})
         .convert("test", input, true)
         .gsub(/mso-bookmark:_Ref\d+/, "mso-bookmark:_Ref")))
-      .to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(output)
 
     input = <<~INPUT
         <iso-standard xmlns="http://riboseinc.com/isoxml">
@@ -966,10 +966,10 @@
       </html>
 
     OUTPUT
-    expect(xmlpp(IsoDoc::WordConvert.new({})
+    expect(Xml::C14n.format(IsoDoc::WordConvert.new({})
         .convert("test", input, true)
         .gsub(/mso-bookmark:_Ref\d+/, "mso-bookmark:_Ref")))
-      .to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "processes tables with large rows" do
@@ -1077,10 +1077,10 @@
          </body>
        </html>
     OUTPUT
-    expect(xmlpp(IsoDoc::WordConvert.new({})
+    expect(Xml::C14n.format(IsoDoc::WordConvert.new({})
            .convert("test", input, true)
            .gsub(/mso-bookmark:_Ref\d+/, "mso-bookmark:_Ref")))
-      .to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(output)
 
     input = <<~INPUT
         <iso-standard xmlns="http://riboseinc.com/isoxml">
@@ -1193,9 +1193,9 @@
          </body>
        </html>
     OUTPUT
-    expect(xmlpp(IsoDoc::WordConvert.new({})
+    expect(Xml::C14n.format(IsoDoc::WordConvert.new({})
                .convert("test", input, true)
                .gsub(/mso-bookmark:_Ref\d+/, "mso-bookmark:_Ref")))
-      .to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(output)
   end
 end
diff --git a/spec/isodoc/terms_spec.rb b/spec/isodoc/terms_spec.rb
index 11862e02..b6db988e 100644
--- a/spec/isodoc/terms_spec.rb
+++ b/spec/isodoc/terms_spec.rb
@@ -43,10 +43,10 @@
                </body>
            </html>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
-      .convert("test", input, true)))).to be_equivalent_to xmlpp(presxml)
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
-      .convert("test", presxml, true))).to be_equivalent_to xmlpp(html)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+      .convert("test", input, true)))).to be_equivalent_to Xml::C14n.format(presxml)
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
+      .convert("test", presxml, true))).to be_equivalent_to Xml::C14n.format(html)
   end
 
   it "processes IsoXML terms" do
@@ -307,12 +307,12 @@
          </body>
        </html>
     WORD
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
-      .convert("test", input, true)))).to be_equivalent_to xmlpp(presxml)
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
-      .convert("test", presxml, true))).to be_equivalent_to xmlpp(html)
-    expect(xmlpp(IsoDoc::WordConvert.new({})
-      .convert("test", presxml, true))).to be_equivalent_to xmlpp(word)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+      .convert("test", input, true)))).to be_equivalent_to Xml::C14n.format(presxml)
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
+      .convert("test", presxml, true))).to be_equivalent_to Xml::C14n.format(html)
+    expect(Xml::C14n.format(IsoDoc::WordConvert.new({})
+      .convert("test", presxml, true))).to be_equivalent_to Xml::C14n.format(word)
   end
 
   it "processes IsoXML term with multiple definitions" do
@@ -415,11 +415,11 @@
         </term>
       </terms>
     PRESXML
-    expect(xmlpp(Nokogiri::XML(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(Nokogiri::XML(IsoDoc::PresentationXMLConvert
       .new(presxml_options)
        .convert("test", input, true))
       .at("//xmlns:terms").to_xml))
-      .to be_equivalent_to xmlpp(presxml)
+      .to be_equivalent_to Xml::C14n.format(presxml)
   end
 
   it "processes IsoXML term with multiple preferred terms" do
@@ -508,11 +508,11 @@
       </term>
           </terms>
     PRESXML
-    expect(xmlpp(Nokogiri::XML(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(Nokogiri::XML(IsoDoc::PresentationXMLConvert
       .new(presxml_options)
        .convert("test", input, true))
       .at("//xmlns:terms").to_xml))
-      .to be_equivalent_to xmlpp(presxml)
+      .to be_equivalent_to Xml::C14n.format(presxml)
   end
 
   it "processes IsoXML term with grammatical information" do
@@ -564,11 +564,11 @@
         </term>
       </terms>
     PRESXML
-    expect(xmlpp(Nokogiri::XML(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(Nokogiri::XML(IsoDoc::PresentationXMLConvert
       .new(presxml_options)
        .convert("test", input, true))
       .at("//xmlns:terms").to_xml))
-      .to be_equivalent_to xmlpp(presxml)
+      .to be_equivalent_to Xml::C14n.format(presxml)
   end
 
   it "processes IsoXML term with empty or graphical designations" do
@@ -606,11 +606,11 @@
         </term>
       </terms>
     PRESXML
-    expect(xmlpp(Nokogiri::XML(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(Nokogiri::XML(IsoDoc::PresentationXMLConvert
       .new(presxml_options)
        .convert("test", input, true))
       .at("//xmlns:terms").to_xml))
-      .to be_equivalent_to xmlpp(presxml)
+      .to be_equivalent_to Xml::C14n.format(presxml)
   end
 
   it "processes IsoXML term with nonverbal definitions" do
@@ -785,11 +785,11 @@
         </term>
       </terms>
     PRESXML
-    expect(xmlpp(Nokogiri::XML(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(Nokogiri::XML(IsoDoc::PresentationXMLConvert
       .new(presxml_options)
        .convert("test", input, true))
       .at("//xmlns:terms").to_xml))
-      .to be_equivalent_to xmlpp(presxml)
+      .to be_equivalent_to Xml::C14n.format(presxml)
   end
 
   it "processes related terms" do
@@ -866,11 +866,11 @@
         </term>
       </terms>
     OUTPUT
-    expect(xmlpp(Nokogiri::XML(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(Nokogiri::XML(IsoDoc::PresentationXMLConvert
       .new(presxml_options)
        .convert("test", input, true))
       .at("//xmlns:terms").to_xml))
-      .to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "processes IsoXML term with different term source statuses" do
@@ -959,11 +959,11 @@
         </term>
       </terms>
     OUTPUT
-    expect(xmlpp(Nokogiri::XML(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(Nokogiri::XML(IsoDoc::PresentationXMLConvert
           .new(presxml_options)
            .convert("test", input, true))
           .at("//xmlns:terms").to_xml))
-      .to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(output)
     output = <<~OUTPUT
       <terms id="_terms_and_definitions" obligation="normative" displayorder="2">
         <title depth="1">1.<tab/>Terms and Definitions</title>
@@ -999,12 +999,12 @@
         </term>
       </terms>
     OUTPUT
-    expect(xmlpp(Nokogiri::XML(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(Nokogiri::XML(IsoDoc::PresentationXMLConvert
           .new(presxml_options)
           .convert("test", input.sub(%r{<language>en</language>},
                                      "<language>de</language>"), true))
           .at("//xmlns:terms").to_xml))
-      .to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(output)
   end
 
   # also applies to postprocessing of indexes
@@ -1050,10 +1050,10 @@
         </term>
       </terms>
     OUTPUT
-    expect(xmlpp(Nokogiri::XML(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(Nokogiri::XML(IsoDoc::PresentationXMLConvert
       .new(presxml_options)
        .convert("test", input, true))
       .at("//xmlns:terms").to_xml))
-      .to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(output)
   end
 end
diff --git a/spec/isodoc/xref_format_spec.rb b/spec/isodoc/xref_format_spec.rb
index de5c9de2..8074747b 100644
--- a/spec/isodoc/xref_format_spec.rb
+++ b/spec/isodoc/xref_format_spec.rb
@@ -87,15 +87,15 @@
       </p>
             </div><p> </p></div>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert
       .new(presxml_options)
-      .convert("test", input, true)))).to be_equivalent_to xmlpp(presxml)
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
-      .convert("test", presxml, true))).to be_equivalent_to xmlpp(html)
-    expect(xmlpp(Nokogiri::XML(IsoDoc::WordConvert.new({})
+      .convert("test", input, true)))).to be_equivalent_to Xml::C14n.format(presxml)
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
+      .convert("test", presxml, true))).to be_equivalent_to Xml::C14n.format(html)
+    expect(Xml::C14n.format(Nokogiri::XML(IsoDoc::WordConvert.new({})
       .convert("test", presxml, true))
       .at("//div[@class = 'WordSection2']").to_xml))
-      .to be_equivalent_to xmlpp(doc)
+      .to be_equivalent_to Xml::C14n.format(doc)
   end
 
   it "droplocs xrefs" do
@@ -144,10 +144,10 @@
         </sections>
       </iso-standard>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert
       .new({ i18nyaml: "spec/assets/i18n.yaml" }
       .merge(presxml_options))
-      .convert("test", input, true)))).to be_equivalent_to xmlpp(output)
+      .convert("test", input, true)))).to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "puts custom labels on xrefs" do
@@ -191,10 +191,10 @@
         </sections>
       </iso-standard>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert
       .new({ i18nyaml: "spec/assets/i18n.yaml" }
       .merge(presxml_options))
-      .convert("test", input, true)))).to be_equivalent_to xmlpp(output)
+      .convert("test", input, true)))).to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "renders xrefs with style" do
@@ -284,8 +284,8 @@
         </sections>
       </iso-standard>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
-      .convert("test", input, true)))).to be_equivalent_to xmlpp(output)
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert.new(presxml_options)
+      .convert("test", input, true)))).to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "cases xrefs" do
@@ -401,10 +401,10 @@
           </sections>
       </iso-standard>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert
       .new({ i18nyaml: "spec/assets/i18n.yaml" }
       .merge(presxml_options))
-      .convert("test", input, true)))).to be_equivalent_to xmlpp(output)
+      .convert("test", input, true)))).to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "ignores casing of xrefs in unicameral scripts" do
@@ -468,10 +468,10 @@
         </sections>
       </iso-standard>
     OUTPUT
-    expect(xmlpp(strip_guid(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(strip_guid(IsoDoc::PresentationXMLConvert
       .new({ i18nyaml: "spec/assets/i18n.yaml", script: "Hans" }
       .merge(presxml_options))
-      .convert("test", input, true)))).to be_equivalent_to xmlpp(output)
+      .convert("test", input, true)))).to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "ignores locations in xrefs" do
@@ -498,13 +498,13 @@
           </p>
         </div>
     OUTPUT
-    expect(xmlpp(IsoDoc::HtmlConvert.new({})
+    expect(Xml::C14n.format(IsoDoc::HtmlConvert.new({})
     .convert("test", input, true))
     .sub(/^.*<h1/m, "<div><h1").sub(%r{</div>.*$}m, "</div>"))
-      .to be_equivalent_to xmlpp(html)
-    expect(xmlpp(IsoDoc::WordConvert.new({})
+      .to be_equivalent_to Xml::C14n.format(html)
+    expect(Xml::C14n.format(IsoDoc::WordConvert.new({})
       .convert("test", input, true))
       .sub(/^.*<h1/m, "<div><h1").sub(%r{</div>.*$}m, "</div>"))
-      .to be_equivalent_to xmlpp(doc)
+      .to be_equivalent_to Xml::C14n.format(doc)
   end
 end
diff --git a/spec/isodoc/xref_lists_spec.rb b/spec/isodoc/xref_lists_spec.rb
index bcf2f4d4..6b3aeb84 100644
--- a/spec/isodoc/xref_lists_spec.rb
+++ b/spec/isodoc/xref_lists_spec.rb
@@ -84,11 +84,11 @@
         </p>
       </foreword>
     OUTPUT
-    expect(xmlpp(Nokogiri::XML(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(Nokogiri::XML(IsoDoc::PresentationXMLConvert
       .new(presxml_options)
       .convert("test", input, true))
       .at("//xmlns:foreword").to_xml))
-      .to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "cross-references list items in English and Japanese" do
@@ -184,11 +184,11 @@
         </p>
       </foreword>
     OUTPUT
-    expect(xmlpp(Nokogiri::XML(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(Nokogiri::XML(IsoDoc::PresentationXMLConvert
       .new(presxml_options)
       .convert("test", input, true))
       .at("//xmlns:foreword").to_xml))
-      .to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(output)
     input1 = input.sub(%r{<language>en</language>}, "<language>ja</language>")
     output = <<~OUTPUT
       <foreword displayorder="2">
@@ -207,11 +207,11 @@
          </p>
        </foreword>
     OUTPUT
-    expect(xmlpp(Nokogiri::XML(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(Nokogiri::XML(IsoDoc::PresentationXMLConvert
       .new(presxml_options)
       .convert("test", input1, true))
       .at("//xmlns:foreword").to_xml))
-      .to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "cross-references nested list items in English and Japanese" do
@@ -297,11 +297,11 @@
         </p>
       </foreword>
     OUTPUT
-    expect(xmlpp(Nokogiri::XML(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(Nokogiri::XML(IsoDoc::PresentationXMLConvert
       .new(presxml_options)
       .convert("test", input, true))
       .at("//xmlns:foreword").to_xml))
-      .to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(output)
     input1 = input.sub(%r{<language>en</language>}, "<language>ja</language>")
     output = <<~OUTPUT
       <foreword displayorder="2">
@@ -320,11 +320,11 @@
          </p>
        </foreword>
     OUTPUT
-    expect(xmlpp(Nokogiri::XML(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(Nokogiri::XML(IsoDoc::PresentationXMLConvert
       .new(presxml_options)
       .convert("test", input1, true))
       .at("//xmlns:foreword").to_xml))
-      .to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "cross-references definition lists" do
@@ -410,11 +410,11 @@
         </p>
       </foreword>
     OUTPUT
-    expect(xmlpp(Nokogiri::XML(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(Nokogiri::XML(IsoDoc::PresentationXMLConvert
       .new(presxml_options)
       .convert("test", input, true))
       .at("//xmlns:foreword").to_xml))
-      .to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "cross-references definition list terms" do
@@ -500,11 +500,11 @@
         </p>
       </foreword>
     OUTPUT
-    expect(xmlpp(Nokogiri::XML(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(Nokogiri::XML(IsoDoc::PresentationXMLConvert
       .new(presxml_options)
       .convert("test", input, true))
       .at("//xmlns:foreword").to_xml))
-      .to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "cross-references definition list terms that are stem expressions" do
@@ -552,10 +552,10 @@
            </p>
          </foreword>
     OUTPUT
-    expect(xmlpp(Nokogiri::XML(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(Nokogiri::XML(IsoDoc::PresentationXMLConvert
       .new(presxml_options)
       .convert("test", input, true))
       .at("//xmlns:foreword").to_xml))
-      .to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(output)
   end
 end
diff --git a/spec/isodoc/xref_numbering_spec.rb b/spec/isodoc/xref_numbering_spec.rb
index 008833cb..fa04ef26 100644
--- a/spec/isodoc/xref_numbering_spec.rb
+++ b/spec/isodoc/xref_numbering_spec.rb
@@ -59,11 +59,11 @@
             </p>
           </foreword>
     OUTPUT
-    expect(xmlpp(Nokogiri::XML(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(Nokogiri::XML(IsoDoc::PresentationXMLConvert
       .new(presxml_options)
       .convert("test", input, true))
       .at("//xmlns:foreword").to_xml))
-      .to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "realises numbering overrides" do
@@ -276,11 +276,11 @@
         </p>
       </foreword>
     OUTPUT
-    expect(xmlpp(Nokogiri::XML(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(Nokogiri::XML(IsoDoc::PresentationXMLConvert
       .new(presxml_options)
       .convert("test", input, true))
       .at("//xmlns:foreword").to_xml))
-      .to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "realises branch-numbering overrides" do
@@ -407,11 +407,11 @@
          </p>
        </foreword>
     OUTPUT
-    expect(xmlpp(Nokogiri::XML(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(Nokogiri::XML(IsoDoc::PresentationXMLConvert
       .new(presxml_options)
       .convert("test", input, true))
       .at("//xmlns:foreword").to_xml))
-      .to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(output)
   end
 
 
@@ -504,10 +504,10 @@
          </note>
        </foreword>
     OUTPUT
-    expect(xmlpp(Nokogiri::XML(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(Nokogiri::XML(IsoDoc::PresentationXMLConvert
       .new(presxml_options)
       .convert("test", input, true))
       .at("//xmlns:foreword").to_xml))
-      .to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(output)
   end
 end
diff --git a/spec/isodoc/xref_spec.rb b/spec/isodoc/xref_spec.rb
index 29a04fc6..3804a40a 100644
--- a/spec/isodoc/xref_spec.rb
+++ b/spec/isodoc/xref_spec.rb
@@ -135,11 +135,11 @@
             </p>
           </foreword>
     OUTPUT
-    expect(xmlpp(Nokogiri.XML(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(Nokogiri.XML(IsoDoc::PresentationXMLConvert
       .new(presxml_options)
       .convert("test", input, true))
       .at("//xmlns:foreword").to_xml))
-      .to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "cross-references box admonitions in English and Japanese" do
@@ -233,11 +233,11 @@
         </p>
       </foreword>
     OUTPUT
-    expect(xmlpp(Nokogiri.XML(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(Nokogiri.XML(IsoDoc::PresentationXMLConvert
       .new(presxml_options)
        .convert("test", input, true))
        .at("//xmlns:foreword").to_xml))
-      .to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(output)
     input1 = input.sub(%r{<language>en</language>},
                        "<language>ja</language>")
     output = <<~OUTPUT
@@ -256,11 +256,11 @@
          </p>
        </foreword>
     OUTPUT
-    expect(xmlpp(Nokogiri::XML(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(Nokogiri::XML(IsoDoc::PresentationXMLConvert
       .new(presxml_options)
       .convert("test", input1, true))
       .at("//xmlns:foreword").to_xml))
-      .to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "cross-references figures" do
@@ -379,11 +379,11 @@
                   </p>
                 </foreword>
     OUTPUT
-    expect(xmlpp(Nokogiri.XML(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(Nokogiri.XML(IsoDoc::PresentationXMLConvert
       .new(presxml_options)
       .convert("test", input, true))
       .at("//xmlns:foreword").to_xml))
-      .to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "cross-references figure classes" do
@@ -502,11 +502,11 @@
          </p>
        </foreword>
     OUTPUT
-    expect(xmlpp(Nokogiri.XML(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(Nokogiri.XML(IsoDoc::PresentationXMLConvert
       .new(presxml_options)
       .convert("test", input, true))
       .at("//xmlns:foreword").to_xml))
-      .to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "cross-references subfigures" do
@@ -592,11 +592,11 @@
                    </p>
                  </foreword>
     OUTPUT
-    expect(xmlpp(Nokogiri.XML(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(Nokogiri.XML(IsoDoc::PresentationXMLConvert
       .new(presxml_options)
       .convert("test", input, true))
       .at("//xmlns:foreword").to_xml))
-      .to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "cross-references examples" do
@@ -685,11 +685,11 @@
             </p>
           </foreword>
     OUTPUT
-    expect(xmlpp(Nokogiri.XML(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(Nokogiri.XML(IsoDoc::PresentationXMLConvert
       .new(presxml_options)
       .convert("test", input, true))
       .at("//xmlns:foreword").to_xml))
-      .to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(output)
 
     output = <<~OUTPUT
       <clause id='widgets1'>
@@ -711,11 +711,11 @@
          </p>
        </clause>
     OUTPUT
-    expect(xmlpp(Nokogiri.XML(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(Nokogiri.XML(IsoDoc::PresentationXMLConvert
       .new(presxml_options)
       .convert("test", input, true))
       .at("//xmlns:clause[@id='widgets1']").to_xml))
-      .to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "cross-references formulae" do
@@ -803,11 +803,11 @@
             </p>
           </foreword>
     OUTPUT
-    expect(xmlpp(Nokogiri.XML(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(Nokogiri.XML(IsoDoc::PresentationXMLConvert
       .new(presxml_options)
       .convert("test", input, true))
       .at("//xmlns:foreword").to_xml))
-      .to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "cross-references requirements" do
@@ -895,11 +895,11 @@
             </p>
           </foreword>
     OUTPUT
-    expect(xmlpp(Nokogiri.XML(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(Nokogiri.XML(IsoDoc::PresentationXMLConvert
       .new(presxml_options)
       .convert("test", input, true))
       .at("//xmlns:foreword").to_xml))
-      .to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "cross-references recommendations" do
@@ -987,11 +987,11 @@
             </p>
           </foreword>
     OUTPUT
-    expect(xmlpp(Nokogiri.XML(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(Nokogiri.XML(IsoDoc::PresentationXMLConvert
       .new(presxml_options)
       .convert("test", input, true))
       .at("//xmlns:foreword").to_xml))
-      .to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "cross-references permissions" do
@@ -1079,11 +1079,11 @@
                    </p>
                  </foreword>
     OUTPUT
-    expect(xmlpp(Nokogiri.XML(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(Nokogiri.XML(IsoDoc::PresentationXMLConvert
       .new(presxml_options)
       .convert("test", input, true))
       .at("//xmlns:foreword").to_xml))
-      .to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "labels and cross-references nested requirements" do
@@ -1171,11 +1171,11 @@
                   </p>
                 </foreword>
     OUTPUT
-    expect(xmlpp(Nokogiri.XML(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(Nokogiri.XML(IsoDoc::PresentationXMLConvert
       .new(presxml_options)
       .convert("test", input, true))
       .at("//xmlns:foreword").to_xml))
-      .to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "cross-references tables" do
@@ -1326,11 +1326,11 @@
         </p>
       </foreword>
     OUTPUT
-    expect(xmlpp(Nokogiri.XML(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(Nokogiri.XML(IsoDoc::PresentationXMLConvert
       .new(presxml_options)
       .convert("test", input, true))
       .at("//xmlns:foreword").to_xml))
-      .to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "cross-references term notes" do
@@ -1376,11 +1376,11 @@
             </p>
           </foreword>
     OUTPUT
-    expect(xmlpp(Nokogiri.XML(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(Nokogiri.XML(IsoDoc::PresentationXMLConvert
       .new(presxml_options)
       .convert("test", input, true))
       .at("//xmlns:foreword").to_xml))
-      .to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "cross-references nested term notes" do
@@ -1422,11 +1422,11 @@
         </p>
       </foreword>
     OUTPUT
-    expect(xmlpp(Nokogiri.XML(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(Nokogiri.XML(IsoDoc::PresentationXMLConvert
       .new(presxml_options)
       .convert("test", input, true))
       .at("//xmlns:foreword").to_xml))
-      .to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "cross-references term examples" do
@@ -1468,11 +1468,11 @@
             </p>
           </foreword>
     OUTPUT
-    expect(xmlpp(Nokogiri.XML(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(Nokogiri.XML(IsoDoc::PresentationXMLConvert
       .new(presxml_options)
       .convert("test", input, true))
       .at("//xmlns:foreword").to_xml))
-      .to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "cross-references nested term examples" do
@@ -1514,11 +1514,11 @@
         </p>
       </foreword>
     OUTPUT
-    expect(xmlpp(Nokogiri.XML(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(Nokogiri.XML(IsoDoc::PresentationXMLConvert
       .new(presxml_options)
       .convert("test", input, true))
       .at("//xmlns:foreword").to_xml))
-      .to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "cross-references sections" do
@@ -1637,11 +1637,11 @@
         </p>
       </foreword>
     OUTPUT
-    expect(xmlpp(Nokogiri.XML(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(Nokogiri.XML(IsoDoc::PresentationXMLConvert
       .new(presxml_options)
       .convert("test", input, true))
       .at("//xmlns:foreword").to_xml))
-      .to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "cross-references unnumbered sections" do
@@ -1762,11 +1762,11 @@
           </p>
        </foreword>
     OUTPUT
-    expect(xmlpp(Nokogiri.XML(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(Nokogiri.XML(IsoDoc::PresentationXMLConvert
       .new(presxml_options)
       .convert("test", input, true))
       .at("//xmlns:foreword").to_xml))
-      .to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(output)
   end
 
   it "cross-references bookmarks" do
@@ -1853,10 +1853,10 @@
         </p>
       </foreword>
     OUTPUT
-    expect(xmlpp(Nokogiri::XML(IsoDoc::PresentationXMLConvert
+    expect(Xml::C14n.format(Nokogiri::XML(IsoDoc::PresentationXMLConvert
       .new(presxml_options)
       .convert("test", input, true))
       .at("//xmlns:foreword").to_xml))
-      .to be_equivalent_to xmlpp(output)
+      .to be_equivalent_to Xml::C14n.format(output)
   end
 end
diff --git a/spec/spec_helper.rb b/spec/spec_helper.rb
index d29ad9f9..67773780 100644
--- a/spec/spec_helper.rb
+++ b/spec/spec_helper.rb
@@ -8,6 +8,7 @@
 require "rspec/matchers"
 require "equivalent-xml"
 require "tzinfo"
+require "xml-c14n"
 
 RSpec.configure do |config|
   # Enable flags like --only-failures and --next-failure