isodoc 3.4.6 → 3.4.8

data/lib/isodoc/presentation_function/block.rb

@@ -107,11 +107,16 @@ module IsoDoc
       docxml.xpath(ns("//table")).each { |f| table1(f) }
     end
 
+    def table1_caption?(elem)
+      !labelled_ancestor(elem) &&
+        !(elem["unnumbered"] && !elem.at(ns("./name"))) &&
+        !%w(fmt-ol fmt-ul).include?(elem.parent.name)
+    end
+
     def table1(elem)
       table_fn(elem)
       table_css(elem)
-      labelled_ancestor(elem) and return
-      elem["unnumbered"] && !elem.at(ns("./name")) and return
+      table1_caption?(elem) or return
       n = @xrefs.anchor(elem["id"] || elem["original-id"], :label, false)
       lbl = labelled_autonum(lower2cap(@i18n.table),
                              elem["id"] || elem["original-id"], n)
@@ -153,32 +158,42 @@ module IsoDoc
                    "./classification | ./contributor | ./fmt-name | " \
                    "./fmt-xref-label")).each(&:remove)
       amend_newcontent(ret)
-      ret.xpath(ns("./newcontent")).each { |a| a.name = "quote" }
       ret.xpath(ns("./description")).each { |a| a.replace(a.children) }
       elem.next = ret
     end
 
     def amend_newcontent(elem)
-      elem.xpath(ns("./newcontent")).each do |a|
+      elem.xpath(ns(".//newcontent")).each do |a|
         a.name = "quote"
-        a.xpath(ns("./clause")).each do |c|
+        a["type"] = "newcontent"
+        a.xpath(ns("./clause")).reverse_each do |c|
           amend_subclause(c, 1)
           a.next = c
         end
       end
+      elem.xpath(ns("./quote[not(node())]")).each(&:remove)
     end
 
     def amend_subclause(clause, depth)
-      clause.xpath(ns("./title")).reverse_each do |t|
-        # t.name = "floating-title"
-        # t["depth"] ||= depth || "1"
-        t.name = "p"
-        t["type"] = "floating-title"
-      end
+      amend_subclause_title(clause, depth)
       clause.name = depth == 1 ? "quote" : "quote" # "div"
+      clause["type"] = "newcontent"
       clause.xpath(ns("./clause")).each { |c| amend_subclause(c, depth + 1) }
     end
 
+    def amend_subclause_title(clause, _depth)
+      if clause["type"] == "annex"
+        annex1(clause)
+      else
+        clause1(clause) # insert title prefix
+      end
+      clause.xpath(ns("./title | ./variant-title")).each(&:remove)
+      t = clause.at(ns("./fmt-title")) or return
+      t.name = "p"
+      t["type"] = "floating-title"
+      # t["depth"] ||= depth || "1"
+    end
+
     def quote(docxml)
       docxml.xpath(ns("//quote")).each { |f| quote1(f) }
     end

data/lib/isodoc/presentation_function/footnotes.rb

@@ -157,7 +157,7 @@ module IsoDoc
       elem.at(ns(".//dl/name"))&.next ||
         elem.at(ns(".//dl"))&.children&.first ||
         elem.add_child("<key><dl> </dl></key>")
-        .first.elements.first.children.first
+          .first.elements.first.children.first
     end
 
     def comments(docxml)

data/lib/isodoc/presentation_function/image.rb

@@ -48,7 +48,7 @@ module IsoDoc
 
       svg = Base64.strict_decode64(elem["src"]
         .sub(%r{^data:image/svg\+xml;(charset=[^;]+;)?base64,}, ""))
-      x = Nokogiri::XML.fragment(svg.sub(/<\?xml[^<>]*>/, ""), &:huge)
+      x = Nokogiri::XML.fragment(svg.sub(/\A<\?xml[^<>]*>\n?/, ""), &:huge)
       elem["src"] = ""
       elem.children = x
     end

data/lib/isodoc/presentation_function/list_to_table.rb

@@ -0,0 +1,250 @@
+module IsoDoc
+  class PresentationXMLConvert < ::IsoDoc::Convert
+    # Entry point: find all top-level (ol|ul)[@display='table'] and convert each
+    def list_to_table(docxml)
+      docxml.xpath(ns("//ol[@display='table'] | //ul[@display='table']"))
+        .each do |elem|
+        list_table_convert(elem)
+      end
+    end
+
+    # Convert a single display="table" list: build table, insert under fmt-ol
+    def list_table_convert(elem)
+      n = list_table_depth(elem)
+      table = list_table_build(elem, n)
+      elem << "<fmt-#{elem.name}></fmt-#{elem.name}>"
+      elem.elements.last << table
+    end
+
+    # Maximum depth of nested ol/ul: elem itself = depth 1
+    def list_table_depth(elem)
+      depths = [1]
+      elem.xpath(ns(".//ol | .//ul")).each do |sub|
+        d = sub.ancestors.take_while { |a| a != elem }
+          .count { |a| %w[ol ul].include?(a.name) } + 2
+        depths << d
+      end
+      depths.max
+    end
+
+    # Build the full table as a Nokogiri node
+    def list_table_build(elem, cellcount)
+      xml = "<table>"
+      xml += list_table_name(elem)
+      xml += list_table_colgroup(elem, cellcount)
+      xml += list_table_header(elem, cellcount)
+      xml += list_table_body(elem, cellcount)
+      xml += "</table>"
+      Nokogiri::XML(xml).root
+    end
+
+    # global table title if there are no nested titled in the list:
+    # move list/fmt-name to ol/fmt-ol/table/fmt-name: ol/fmt-ol is all we render
+    def list_table_name(elem)
+      list_only_one_title(elem) or return ""
+      ret = elem.at(ns("./fmt-name")) or return ""
+      to_xml(ret.remove)
+    end
+
+    def list_table_colgroup(elem, cellcount)
+      n = elem["display-directives"] or return ""
+      attrs = csv_attribute_extract(n)
+      attrs[:colgroup] or return ""
+      vals = attrs[:colgroup].split(",").map(&:to_f)
+      vals = list_table_normalise_colgroup(vals, cellcount)
+      ret = vals.map { |n| "<col width='#{n}%'/>" }.join
+      "<colgroup>#{ret}</colgroup>"
+    end
+
+    def list_table_normalise_colgroup(vals, cellcount)
+      vals.size > cellcount and vals = vals[0...cellcount]
+      if vals.size < cellcount
+        (vals.size...cellcount).each do |_i|
+          vals << 10.0
+        end
+      end
+      sum = vals.sum
+      vals.map { |i| 100 * i / sum }
+    end
+
+    # Build <thead><tr> with n <th> cells, one per depth level
+    def list_table_header(elem, cellcount)
+      list_only_one_title(elem) and return ""
+      ths = (1..cellcount).map { |i| list_table_th(elem, i) }.join
+      "<thead><tr>#{ths}</tr></thead>"
+    end
+
+    def list_only_one_title(elem)
+      (!elem.at(ns(".//ol//name")) && !elem.at(ns(".//ul//name"))) or return nil
+      elem.at(ns("./name"))
+    end
+
+    def list_table_th(elem, depth)
+      name = list_table_col_name(elem, depth)
+      name or return "<th/>"
+      add_id(name)
+      src = name["original-id"] || name["id"]
+      children = to_xml(name.children)
+      <<~XML
+        <th><fmt-name><semx element='name' source='#{src}'>#{children}</semx></fmt-name></th>
+      XML
+    end
+
+    # Find the <name> element of the first ol/ul at the given depth within elem
+    def list_table_col_name(elem, depth)
+      list_at_depth(elem, depth)&.at(ns("./name"))
+    end
+
+    # Return the first ol/ul at the given depth (depth 1 = elem itself)
+    def list_at_depth(elem, target_depth)
+      target_depth == 1 and return elem
+      elem.xpath(ns(".//ol | .//ul")).find do |sub|
+        d = sub.ancestors.take_while { |a| a != elem }
+          .count { |a| %w[ol ul].include?(a.name) } + 2
+        d == target_depth
+      end
+    end
+
+    # Build <tbody> with one <tr> per leaf (terminal sublist) path
+    def list_table_body(elem, cellcount)
+      paths = list_table_leaf_paths(elem, 1)
+      emitted = {} # li object_id => true when already emitted under a rowspan
+      rows = paths.map do |path|
+        list_table_row(path, cellcount, emitted)
+      end.join
+      "<tbody>#{rows}</tbody>"
+    end
+
+    def list_table_row(path, cellcount, emitted)
+      cells = path.map do |step|
+        if step[:terminal]
+          if step[:li]
+            # Degenerate: single li with no child sublist —
+            # render just that li with colspan
+            list_table_degen_terminal_td(step[:list], step[:li], step[:li_idx],
+                                              step[:depth], cellcount)
+          else
+            list_table_terminal_td(step[:list], step[:depth], cellcount)
+          end
+        else
+          li = step[:li]
+          emitted[li.object_id] and next
+          rowspan = list_table_count_terminals(li)
+          emitted[li.object_id] = true
+          list_table_nonterminal_td(step[:list], li, step[:li_idx], rowspan,
+                                    step[:depth])
+        end
+      end.compact.join
+      "<tr>#{cells}</tr>"
+    end
+
+    # Recursively collect all leaf paths from xl downward.
+    # Each path is an array of step hashes; the last step has terminal: true.
+    # Non-terminal step: { list:, li:, depth:, li_idx: }
+    # Terminal step:     { list:, depth:, terminal: true }
+    def list_table_leaf_paths(xl, depth)
+      paths = []
+      xl.xpath(ns("./li")).each_with_index do |li, idx|
+        li_idx = idx + 1
+        sub_xls = li.children.select { |c| %w[ol ul].include?(c.name) }
+        if sub_xls.empty?
+          # Degenerate: li with no child sublist — treat as its own terminal row
+          paths << [{ list: xl, li:, depth:, li_idx:, terminal: true }]
+        else
+          sub_xls.each do |sub_xl|
+            step = { list: xl, li: li, depth: depth, li_idx: li_idx }
+            if (sub_xl.xpath(ns(".//ol")) + sub_xl.xpath(ns(".//ul"))).empty?
+              paths << [step,
+                        { list: sub_xl, depth: depth + 1, terminal: true }]
+            else
+              list_table_leaf_paths(sub_xl, depth + 1).each do |sub_path|
+                paths << ([step] + sub_path)
+              end
+            end
+          end
+        end
+      end
+      paths
+    end
+
+    # Count terminal sublists reachable from a li element (used for rowspan)
+    def list_table_count_terminals(listitem)
+      sub_xls = listitem.children.select { |c| %w[ol ul].include?(c.name) }
+      sub_xls.empty? and return 1
+      count = 0
+      sub_xls.each do |sub_xl|
+        count += list_table_count_terminals_recurse(sub_xl)
+      end
+      [count, 1].max
+    end
+
+    def list_table_count_terminals_recurse(sub_xl)
+      ret = 0
+      (sub_xl.xpath(ns(".//ol")) + sub_xl.xpath(ns(".//ul"))).empty? and
+        return 1
+      sub_xl.xpath(ns("./li")).each do |sub_li|
+        ret += list_table_count_terminals(sub_li)
+      end
+      ret
+    end
+
+    # Build a nonterminal <td>: wraps a single li (minus nested sublists)
+    # in an ol/ul with appropriate start, type, and rowspan
+    def list_table_nonterminal_td(list, listitem, li_idx, rowspan, depth)
+      rowspan_attr = rowspan > 1 ? " rowspan='#{rowspan}'" : ""
+      li_content = list_table_li_content(listitem)
+      if list.name == "ol"
+        start = list_table_calc_start(list, li_idx)
+        type = @counter.ol_type(list, depth).to_s
+        "<td#{rowspan_attr}><ol start='#{start}' type='#{type}'>" \
+          "<li>#{li_content}</li></ol></td>"
+      else
+        "<td#{rowspan_attr}><ul><li>#{li_content}</li></ul></td>"
+      end
+    end
+
+    # Serialize a li's content, excluding any direct ol/ul children
+    def list_table_li_content(listitem)
+      listitem.children.reject { |c| %w[ol ul].include?(c.name) }
+        .map { |c| to_xml(c) }.join
+    end
+
+    # Build a terminal <td> for a degenerate li (no child sublist),
+    # wrapping just that single li with the correct colspan
+    def list_table_degen_terminal_td(list, listitem, li_idx, depth, cellcount)
+      colspan = cellcount - depth + 1
+      colspan_attr = colspan > 1 ? " colspan='#{colspan}'" : ""
+      li_content = list_table_li_content(listitem)
+      if list.name == "ol"
+        start = list_table_calc_start(list, li_idx)
+        type = @counter.ol_type(list, depth).to_s
+        "<td#{colspan_attr}><ol start='#{start}' type='#{type}'>" \
+          "<li>#{li_content}</li></ol></td>"
+      else
+        "<td#{colspan_attr}><ul><li>#{li_content}</li></ul></td>"
+      end
+    end
+
+    # Build a terminal <td>: contains the whole sublist,
+    # with colspan if depth < cellcount
+    def list_table_terminal_td(xl, depth, cellcount)
+      colspan = cellcount - depth + 1
+      colspan_attr = colspan > 1 ? " colspan='#{colspan}'" : ""
+      xl_dup = xl.dup
+      # Remove <name> from the copy (names go in thead, not in the cell body)
+      xl_dup.children.each { |c| c.name == "name" and c.remove }
+      if xl.name == "ol"
+        type = @counter.ol_type(xl, depth).to_s
+        xl_dup["type"] = type
+      end
+      "<td#{colspan_attr}>#{to_xml(xl_dup)}</td>"
+    end
+
+    # Calculate the start number for a wrapped ol cell
+    # (original ol start) + (0-based position of this li) = start
+    # for this li's number
+    def list_table_calc_start(list, li_idx)
+      (list["start"] || 1).to_i + li_idx - 1
+    end
+  end
+end

data/lib/isodoc/presentation_function/math.rb

@@ -50,32 +50,6 @@ module IsoDoc
                                   precision: num_precision(num.text))
     end
 
-    COMMA_PLACEHOLDER = "##COMMA##".freeze
-
-    # Temporarily replace commas inside quotes with a placeholder
-    def comma_placeholder(options)
-      processed = ""
-      in_quotes = false
-      options.each_char do |c|
-        c == "'" and in_quotes = !in_quotes
-        processed << if c == "," && in_quotes
-                       COMMA_PLACEHOLDER
-                     else c end
-      end
-      processed
-    end
-
-    def numberformat_extract(options)
-      options.gsub!(/([a-z_]+)='/, %('\\1=))
-      processed = comma_placeholder(options)
-      CSV.parse_line(processed,
-                     quote_char: "'").each_with_object({}) do |x, acc|
-        x.gsub!(COMMA_PLACEHOLDER, ",")
-        m = /^(.+?)=(.+)?$/.match(x) or next
-        acc[m[1].to_sym] = m[2].sub(/^(["'])(.+)\1$/, "\\2")
-      end
-    end
-
     def numberformat_type(ret)
       %i(precision significant digit_count group_digits fraction_group_digits)
         .each do |i|
@@ -88,7 +62,7 @@ module IsoDoc
     end
 
     def explicit_number_formatter(num, locale, options)
-      ret = numberformat_type(numberformat_extract(options))
+      ret = numberformat_type(csv_attribute_extract(options))
       l = ret[:locale] || locale
       precision, symbols, significant = explicit_number_formatter_cfg(num, ret)
       n = normalise_number(num.text)
@@ -137,7 +111,9 @@ module IsoDoc
       precision = nil
       /\.(?!\d+e)/.match?(num) and
         precision = twitter_cldr_localiser_symbols[:precision] ||
-          num.sub(/^.*\./, "").size
+          # [^.]* excludes the delimiter itself, preventing polynomial
+          # backtracking on strings with multiple dots.
+          num.sub(/\A[^.]*\./, "").size
       precision
     end
 
@@ -145,7 +121,9 @@ module IsoDoc
       totaldigits = nil
       /\.(?=\d+e)/.match?(num) and
         totaldigits = twitter_cldr_localiser_symbols[:significant] ||
-          num.sub(/^0\./, ".").sub(/^.*\./, "").sub(/e.*$/, "").size
+          # [^.]* and [^e]* exclude their respective delimiters,
+          # preventing polynomial backtracking.
+          num.sub(/\A0\./, ".").sub(/\A[^.]*\./, "").sub(/e[^e]*\z/, "").size
       totaldigits
     end
 
@@ -155,9 +133,9 @@ module IsoDoc
 
     def asciimath_dup(node)
       @suppressasciimathdup || node.parent.at(ns("./asciimath")) and return
-      math = node.to_xml.gsub(/ xmlns=["'][^"']+["']/, "")
-        .gsub(%r{<[^:/>]+:}, "<").gsub(%r{</[^:/>]+:}, "</")
-        .gsub(%r{ data-metanorma-numberformat="[^"]+"}, "")
+      math = node.to_xml.gsub(/ xmlns=["'][^"']*["']/, "")
+        .gsub(%r{<[^:/>]*:}, "<").gsub(%r{</[^:/>]*:}, "</")
+        .gsub(%r{ data-metanorma-numberformat="[^"]*"}, "")
       ret = Plurimath::Math.parse(math, "mathml").to_asciimath
       node.next = "<asciimath>#{@c.encode(ret, :basic)}</asciimath>"
     rescue StandardError => e

data/lib/isodoc/presentation_function/section.rb

@@ -33,15 +33,12 @@ module IsoDoc
 
     def clausedelim
       ret = super
-      ret && !ret.empty? or return ret
+      (ret && !ret.empty?) or return ret
       "<span class='fmt-autonum-delim'>#{ret}</span>"
     end
 
     def clause1(elem)
-      level = @xrefs.anchor(elem["id"], :level, false) ||
-        (elem.ancestors("clause, annex").size + 1)
-      is_unnumbered = unnumbered_clause?(elem)
-      lbl = @xrefs.anchor(elem["id"], :label, false)
+      level, is_unnumbered, lbl = clause1_prep(elem)
       if is_unnumbered || !lbl
         prefix_name(elem, {}, nil, "title")
       else
@@ -51,34 +48,12 @@ module IsoDoc
       t = elem.at(ns("./fmt-title")) and t["depth"] = level
     end
 
-    def annex(docxml)
-      docxml.xpath(ns("//annex")).each do |f|
-        @xrefs.klass.single_term_clause?(f) and single_term_clause_retitle(f)
-        annex1(f)
-        @xrefs.klass.single_term_clause?(f) and single_term_clause_unnest(f)
-      end
-      @xrefs.parse_inclusions(clauses: true).parse(docxml)
-    end
-
-    def annex1(elem)
+    def clause1_prep(elem)
+      level = @xrefs.anchor(elem["id"], :level, false) ||
+        (elem.ancestors("clause, annex").size + 1)
+      is_unnumbered = unnumbered_clause?(elem)
       lbl = @xrefs.anchor(elem["id"], :label, false)
-      # TODO: do not alter title, alter semx/@element = title
-      t = elem.at(ns("./title")) and
-        t.children = "<strong>#{to_xml(t.children)}</strong>"
-      if unnumbered_clause?(elem)
-        prefix_name(elem, {}, nil, "title")
-      else
-        prefix_name(elem, { caption: annex_delim_override(elem) }, lbl, "title")
-      end
-    end
-
-    def annex_delim_override(elem)
-      m = elem.document.root.at(ns("//presentation-metadata/annex-delim"))
-      m ? to_xml(m.children) : annex_delim(elem)
-    end
-
-    def annex_delim(_elem)
-      "<br/><br/>"
+      [level, is_unnumbered, lbl]
     end
 
     def single_term_clause_retitle(elem)

data/lib/isodoc/presentation_function/xrefs.rb

@@ -194,7 +194,7 @@ module IsoDoc
     end
 
     def capitalise_xref(node, linkend, label)
-      linktext = linkend.gsub(/<[^<>]+>/, "")
+      linktext = linkend.gsub(/<[^<>]*>/, "")
       (label && !label.empty? && /^#{Regexp.escape(label)}/.match?(linktext)) ||
         linktext[0, 1].match?(/\p{Upper}/) and return linkend
       node["case"] and

data/lib/isodoc/presentation_xml_convert.rb

@@ -1,6 +1,7 @@
 require_relative "presentation_function/block"
 require_relative "presentation_function/source"
 require_relative "presentation_function/list"
+require_relative "presentation_function/list_to_table"
 require_relative "presentation_function/reqt"
 require_relative "presentation_function/concepts"
 require_relative "presentation_function/designations"
@@ -11,6 +12,7 @@ require_relative "presentation_function/inline"
 require_relative "presentation_function/math"
 require_relative "presentation_function/section"
 require_relative "presentation_function/section_refs"
+require_relative "presentation_function/annex"
 require_relative "presentation_function/title"
 require_relative "presentation_function/refs"
 require_relative "presentation_function/docid"
@@ -60,8 +62,8 @@ module IsoDoc
     def bibitem_lookup(docxml)
       @bibitem_lookup ||= docxml.xpath(ns("//references/bibitem"))
         .each_with_object({}) do |b, m|
-          m[b["id"]] = b
-          m[b["anchor"]] = b
+        m[b["id"]] = b
+        m[b["anchor"]] = b
       end
     end
 
@@ -106,8 +108,9 @@ module IsoDoc
       note docxml
       admonition docxml
       source docxml
-      ul docxml
-      ol docxml
+      ul docxml # feeds list_to_table
+      ol docxml # feeds list_to_table
+      list_to_table docxml
       dl docxml
       quote docxml
       permission docxml

data/lib/isodoc/version.rb

@@ -1,3 +1,3 @@
 module IsoDoc
-  VERSION = "3.4.6".freeze
+  VERSION = "3.4.8".freeze
 end

data/lib/isodoc/word_function/table.rb

@@ -2,9 +2,12 @@ module IsoDoc
   module WordFunction
     module Body
       def remove_bottom_border(cell)
+        # [^;]* (not +): the preceding property name is the unambiguous
+        # delimiter, so zero-or-more is equivalent and avoids polynomial
+        # backtracking on the value portion.
         cell["style"] =
-          cell["style"].gsub(/border-bottom:[^;]+;/, "border-bottom:0pt;")
-            .gsub(/mso-border-bottom-alt:[^;]+;/, "mso-border-bottom-alt:0pt;")
+          cell["style"].gsub(/border-bottom:[^;]*;/, "border-bottom:0pt;")
+            .gsub(/mso-border-bottom-alt:[^;]*;/, "mso-border-bottom-alt:0pt;")
       end
 
       SW1 = "solid windowtext".freeze
@@ -40,7 +43,7 @@ module IsoDoc
           border-top:#{top}mso-border-top-alt:#{top}
           border-bottom:#{bottom}mso-border-bottom-alt:#{bottom}
         STYLE
-        opt[:bordered] && !cell["style"] or ret = ""
+        (opt[:bordered] && !cell["style"]) or ret = ""
         pb = keep_rows_together(cell, rowmax, totalrows, opt) ? "avoid" : "auto"
         "#{ret}page-break-after:#{pb};"
       end
@@ -76,7 +79,7 @@ module IsoDoc
         ret = { summary: node["summary"], width: node["width"],
                 class: table_class(node),
                 style: "mso-table-anchor-horizontal:column;" \
-                "mso-table-overlap:never;#{style}#{keep_style(node)}" }
+                       "mso-table-overlap:never;#{style}#{keep_style(node)}" }
         style or ret.delete(:class)
         super.merge(attr_code(ret))
       end

data/lib/isodoc/xref/xref_counter.rb

@@ -18,6 +18,7 @@ module IsoDoc
 
     class Counter
       include OlTypeProvider
+
       attr_accessor :prefix_override
 
       def initialize(num = 0, opts = { numerals: :arabic })
@@ -57,7 +58,7 @@ module IsoDoc
       end
 
       def new_subseq_increment1(node)
-        /^(?<b>.*?)(?<n>\d*)(?<a>[a-zA-Z]*)$/ =~ node["number"]
+        b, n, a = parse_number_suffix(node["number"])
         if !n.empty? || !a.empty?
           @letter_override = @letter = a unless a.empty?
           @number_override = @num = n.to_i unless n.empty?
@@ -73,7 +74,10 @@ module IsoDoc
           @prefix_override = node["branch-number"]
         elsif node["number"]
           @base = @letter_override = @number_override = ""
-          /^(?<b>.*?)(?<n>\d+)$/ =~ node["number"]
+          b, n, a = parse_number_suffix(node["number"])
+          # Original required digits at the absolute end (no trailing letters).
+          # If there are trailing letters, treat as a no-digit-at-end match.
+          n = "" unless a.empty?
           if blank?(n)
             @num = nil
             @base = node["number"][0..-2]
@@ -92,7 +96,16 @@ module IsoDoc
 
         @base = ""
         @letter_override = node["number"]
-        /^(?<b>.*?)(?<n>\d*)(?<a>[a-zA-Z])$/ =~ node["number"]
+        # Replace polynomial /^(?<b>.*?)(?<n>\d*)(?<a>[a-zA-Z])$/ with
+        # sequential parsing from the right: last char must be a single letter;
+        # before it are optional digits; before that is the base prefix b.
+        a = /[a-zA-Z]/.match?(node["number"][-1]) ? node["number"][-1] : nil
+        if a
+          rest = node["number"][..-2]
+          j = rest.rindex(/[^\d]/)
+          n = j.nil? ? rest : rest[(j + 1)..]
+          b = j.nil? ? "" : rest[..j]
+        end
         if blank?(a) then subsequence_increment_no_letter(node)
         else
           @letter_override = @letter = a
@@ -174,6 +187,26 @@ module IsoDoc
         "#{prefix}#{@base}#{out}#{@letter_override || @letter}"
       end
 
+      # Decompose a counter number string into [prefix, digits, letters]
+      # by scanning from the right. Examples:
+      #   "A1b"      => ["A",       "1",  "b"  ]
+      #   "prefix-3" => ["prefix-", "3",  ""   ]
+      #   "ABC"      => ["",        "",   "ABC" ]
+      #   "42"       => ["",        "42", ""   ]
+      # Replaces polynomial regexes like /^(?<b>.*?)(?<n>\d*)(?<a>[a-zA-Z]*)$/
+      # with O(n) rindex operations that cannot backtrack.
+      def parse_number_suffix(str)
+        # Step 1: split off all trailing letters
+        i = str.rindex(/[^a-zA-Z]/) # index of last non-letter char
+        a = i.nil? ? str : str[(i + 1)..]
+        rest = i.nil? ? "" : str[..i]
+        # Step 2: split off all trailing digits from the remaining prefix
+        j = rest.rindex(/[^\d]/) # index of last non-digit char
+        n = j.nil? ? rest : rest[(j + 1)..]
+        b = j.nil? ? "" : rest[..j]
+        [b, n, a]
+      end
+
       def listlabel(list, depth)
         case ol_type(list, depth)
         when :arabic then @num.to_s