xlsxrb 0.1.11 → 0.1.13

data/lib/xlsxrb/ooxml/writer.rb

@@ -3,11 +3,19 @@
 # rbs_inline: enabled
 
 require_relative "zip_generator"
+require_relative "writer/drawing_xml"
+require_relative "writer/features_xml"
+require_relative "writer/styles_xml"
+require_relative "../dsl_helpers"
 
 module Xlsxrb
   module Ooxml
     # Writes spreadsheet data into an XLSX file.
     class Writer
+      include DrawingXml
+      include FeaturesXml
+      include StylesXml
+
       XML_HEADER = %(<?xml version="1.0" encoding="UTF-8"?>)
       CT_NS = "http://schemas.openxmlformats.org/package/2006/content-types"
       REL_NS = "http://schemas.openxmlformats.org/package/2006/relationships"
@@ -2992,2651 +3000,6 @@ module Xlsxrb
         parts.join
       end
 
-      # : (untyped drawing_parts) -> untyped
-      def generate_drawing_xml(drawing_parts)
-        parts = [
-          XML_HEADER,
-          %(<xdr:wsDr xmlns:xdr="#{XDR_NS}" xmlns:a="#{A_NS}" xmlns:r="#{DOC_REL_NS}">)
-        ]
-
-        drawing_parts.each do |dp|
-          case dp[:kind]
-          when :pic
-            img = dp[:img]
-            rid = "rId#{dp[:rid_index]}"
-            ea = img[:edit_as] || "oneCell"
-            img_pub_attr = img[:published] ? ' fPublished="1"' : ""
-            parts << %(<xdr:twoCellAnchor editAs="#{xml_escape(ea)}"#{img_pub_attr}>)
-            parts << anchor_xml("from", img[:from_col], img[:from_row], col_off: img[:from_col_off] || 0, row_off: img[:from_row_off] || 0)
-            parts << anchor_xml("to", img[:to_col], img[:to_row], col_off: img[:to_col_off] || 0, row_off: img[:to_row_off] || 0)
-            macro_attr = img[:macro] ? %( macro="#{xml_escape(img[:macro])}") : ""
-            parts << "<xdr:pic#{macro_attr}>"
-            descr_attr = img[:description] ? %( descr="#{xml_escape(img[:description])}") : ""
-            title_attr = img[:title] ? %( title="#{xml_escape(img[:title])}") : ""
-            hidden_attr = img[:hidden] ? ' hidden="1"' : ""
-            pic_lock_attrs = +""
-            pic_lock_attrs << ' noChangeAspect="1"' if img[:no_change_aspect]
-            pic_lock_attrs << ' noCrop="1"' if img[:no_crop]
-            pic_locks = pic_lock_attrs.empty? ? "<a:picLocks/>" : "<a:picLocks#{pic_lock_attrs}/>"
-            parts << %(<xdr:nvPicPr><xdr:cNvPr id="#{dp[:rid_index] + 1}" name="#{xml_escape(img[:name])}"#{descr_attr}#{title_attr}#{hidden_attr}/><xdr:cNvPicPr>#{pic_locks}</xdr:cNvPicPr></xdr:nvPicPr>)
-            src_rect_xml = if img[:src_rect]
-                             sr = img[:src_rect]
-                             sr_attrs = +""
-                             sr_attrs << %( t="#{sr[:top]}") if sr[:top]
-                             sr_attrs << %( b="#{sr[:bottom]}") if sr[:bottom]
-                             sr_attrs << %( l="#{sr[:left]}") if sr[:left]
-                             sr_attrs << %( r="#{sr[:right]}") if sr[:right]
-                             "<a:srcRect#{sr_attrs}/>"
-                           else
-                             ""
-                           end
-            blip_xml = if img[:alpha_mod_fix]
-                         %(<a:blip r:embed="#{rid}"><a:alphaModFix amt="#{img[:alpha_mod_fix]}"/></a:blip>)
-                       else
-                         %(<a:blip r:embed="#{rid}"/>)
-                       end
-            parts << %(<xdr:blipFill>#{blip_xml}#{src_rect_xml}<a:stretch><a:fillRect/></a:stretch></xdr:blipFill>)
-            img_line_xml = if img[:line_color]
-                             ln_w_attr = img[:line_width] ? %( w="#{img[:line_width].to_i}") : ""
-                             %(<a:ln#{ln_w_attr}><a:solidFill>#{color_xml(img[:line_color])}</a:solidFill></a:ln>)
-                           else
-                             ""
-                           end
-            img_xfrm_xml = img[:rotation] ? %(<a:xfrm rot="#{img[:rotation].to_i}"><a:off x="0" y="0"/><a:ext cx="0" cy="0"/></a:xfrm>) : ""
-            parts << %(<xdr:spPr>#{img_xfrm_xml}<a:prstGeom prst="rect"><a:avLst/></a:prstGeom>#{img_line_xml}</xdr:spPr>)
-            parts << "</xdr:pic>"
-            parts << client_data_xml(img)
-            parts << "</xdr:twoCellAnchor>"
-          when :chart
-            chart = dp[:chart]
-            rid = "rId#{dp[:rid_index]}"
-            chart_ea_attr = chart[:edit_as] ? %( editAs="#{xml_escape(chart[:edit_as])}") : ""
-            chart_pub_attr = chart[:published] ? ' fPublished="1"' : ""
-            parts << "<xdr:twoCellAnchor#{chart_ea_attr}#{chart_pub_attr}>"
-            parts << anchor_xml("from", chart[:from_col], chart[:from_row], col_off: chart[:from_col_off] || 0, row_off: chart[:from_row_off] || 0)
-            parts << anchor_xml("to", chart[:to_col], chart[:to_row], col_off: chart[:to_col_off] || 0, row_off: chart[:to_row_off] || 0)
-            gf_macro = chart[:frame_macro] ? xml_escape(chart[:frame_macro]) : ""
-            parts << %(<xdr:graphicFrame macro="#{gf_macro}">)
-            chart_frame_name = chart[:name] || chart[:title] || "Chart"
-            chart_descr_attr = chart[:description] ? %( descr="#{xml_escape(chart[:description])}") : ""
-            chart_title_attr = chart[:frame_title] ? %( title="#{xml_escape(chart[:frame_title])}") : ""
-            chart_hidden_attr = chart[:frame_hidden] ? ' hidden="1"' : ""
-            cnv_gf_pr = if chart[:frame_no_grp]
-                          '<xdr:cNvGraphicFramePr><a:graphicFrameLocks noGrp="1"/></xdr:cNvGraphicFramePr>'
-                        else
-                          "<xdr:cNvGraphicFramePr/>"
-                        end
-            parts << %(<xdr:nvGraphicFramePr><xdr:cNvPr id="#{dp[:rid_index] + 1}" name="#{xml_escape(chart_frame_name)}"#{chart_descr_attr}#{chart_title_attr}#{chart_hidden_attr}/>#{cnv_gf_pr}</xdr:nvGraphicFramePr>)
-            parts << '<xdr:xfrm><a:off x="0" y="0"/><a:ext cx="5000000" cy="3000000"/></xdr:xfrm>'
-            parts << %(<a:graphic><a:graphicData uri="#{C_NS}"><c:chart xmlns:c="#{C_NS}" xmlns:r="#{DOC_REL_NS}" r:id="#{rid}"/></a:graphicData></a:graphic>)
-            parts << "</xdr:graphicFrame>"
-            parts << client_data_xml(chart)
-            parts << "</xdr:twoCellAnchor>"
-          when :sp
-            shape = dp[:shape]
-            shape_ea_attr = shape[:edit_as] ? %( editAs="#{xml_escape(shape[:edit_as])}") : ""
-            shape_pub_attr = shape[:published] ? ' fPublished="1"' : ""
-            parts << "<xdr:twoCellAnchor#{shape_ea_attr}#{shape_pub_attr}>"
-            parts << anchor_xml("from", shape[:from_col], shape[:from_row], col_off: shape[:from_col_off] || 0, row_off: shape[:from_row_off] || 0)
-            parts << anchor_xml("to", shape[:to_col], shape[:to_row], col_off: shape[:to_col_off] || 0, row_off: shape[:to_row_off] || 0)
-            sp_macro_attr = shape[:macro] ? %( macro="#{xml_escape(shape[:macro])}") : ""
-            sp_textlink_attr = shape[:textlink] ? %( textlink="#{xml_escape(shape[:textlink])}") : ""
-            parts << "<xdr:sp#{sp_macro_attr}#{sp_textlink_attr}>"
-            shape_descr_attr = shape[:description] ? %( descr="#{xml_escape(shape[:description])}") : ""
-            shape_title_attr = shape[:title] ? %( title="#{xml_escape(shape[:title])}") : ""
-            shape_hidden_attr = shape[:hidden] ? ' hidden="1"' : ""
-            sp_lock_attrs = +""
-            sp_lock_attrs << ' noGrp="1"' if shape[:no_grp]
-            sp_lock_attrs << ' noRot="1"' if shape[:no_rot]
-            sp_lock_attrs << ' fLocksText="1"' if shape[:f_locks_text]
-            cnv_sp_pr = if sp_lock_attrs.empty?
-                          "<xdr:cNvSpPr/>"
-                        else
-                          "<xdr:cNvSpPr><a:spLocks#{sp_lock_attrs}/></xdr:cNvSpPr>"
-                        end
-            parts << %(<xdr:nvSpPr><xdr:cNvPr id="#{dp[:id]}" name="#{xml_escape(shape[:name])}"#{shape_descr_attr}#{shape_title_attr}#{shape_hidden_attr}/>#{cnv_sp_pr}</xdr:nvSpPr>)
-            shape_fill_xml = if shape[:no_fill]
-                               "<a:noFill/>"
-                             elsif shape[:fill_color]
-                               "<a:solidFill>#{srgb_clr_xml(shape[:fill_color], alpha: shape[:fill_alpha], transforms: shape[:fill_color_transforms])}</a:solidFill>"
-                             elsif shape[:gradient_fill]
-                               gf = shape[:gradient_fill]
-                               gf_attrs = +""
-                               gf_attrs << %( rotWithShape="#{gf[:rot_with_shape] ? 1 : 0}") unless gf[:rot_with_shape].nil?
-                               gf_attrs << %( flip="#{xml_escape(gf[:flip])}") if gf[:flip]
-                               gs_xml = (gf[:stops] || []).map { |gs| %(<a:gs pos="#{gs[:pos]}">#{color_xml(gs[:color])}</a:gs>) }.join
-                               type_xml = if gf[:path]
-                                            %(<a:path path="#{xml_escape(gf[:path])}"/>)
-                                          elsif gf[:angle]
-                                            scaled_attr = gf[:scaled] ? %( scaled="1") : %( scaled="0")
-                                            %(<a:lin ang="#{gf[:angle]}"#{scaled_attr}/>)
-                                          else
-                                            ""
-                                          end
-                               tile_xml = gf[:tile_rect] ? %(<a:tileRect#{gf[:tile_rect].map { |k, v| %( #{k}="#{v}") }.join}/>) : ""
-                               "<a:gradFill#{gf_attrs}><a:gsLst>#{gs_xml}</a:gsLst>#{type_xml}#{tile_xml}</a:gradFill>"
-                             elsif shape[:pattern_fill]
-                               pf = shape[:pattern_fill]
-                               pf_children = +""
-                               pf_children << %(<a:fgClr>#{color_xml(pf[:fg_color])}</a:fgClr>) if pf[:fg_color]
-                               pf_children << %(<a:bgClr>#{color_xml(pf[:bg_color])}</a:bgClr>) if pf[:bg_color]
-                               %(<a:pattFill prst="#{xml_escape(pf[:preset])}">#{pf_children}</a:pattFill>)
-                             else
-                               ""
-                             end
-            shape_line_xml = if shape[:no_line]
-                               "<a:ln><a:noFill/></a:ln>"
-                             elsif shape[:line_color] || shape[:line_dash] || shape[:line_custom_dash] || shape[:head_end] || shape[:tail_end] || shape[:line_cap] || shape[:line_align] || shape[:line_compound] || shape[:line_join]
-                               ln_attrs = +(shape[:line_width] ? %( w="#{shape[:line_width].to_i}") : "")
-                               ln_attrs << %( cap="#{xml_escape(shape[:line_cap])}") if shape[:line_cap]
-                               ln_attrs << %( algn="#{xml_escape(shape[:line_align])}") if shape[:line_align]
-                               ln_attrs << %( cmpd="#{xml_escape(shape[:line_compound])}") if shape[:line_compound]
-                               fill_part = if shape[:line_color]
-                                             "<a:solidFill>#{srgb_clr_xml(shape[:line_color], alpha: shape[:line_alpha], transforms: shape[:line_color_transforms])}</a:solidFill>"
-                                           else
-                                             ""
-                                           end
-                               dash_part = if shape[:line_custom_dash]
-                                             ds_xml = shape[:line_custom_dash].map { |ds| %(<a:ds d="#{ds[:d]}" sp="#{ds[:sp]}"/>) }.join
-                                             "<a:custDash>#{ds_xml}</a:custDash>"
-                                           elsif shape[:line_dash]
-                                             %(<a:prstDash val="#{xml_escape(shape[:line_dash])}"/>)
-                                           else
-                                             ""
-                                           end
-                               head_part = build_line_end_xml("headEnd", shape[:head_end])
-                               tail_part = build_line_end_xml("tailEnd", shape[:tail_end])
-                               join_part = case shape[:line_join]
-                                           when "round" then "<a:round/>"
-                                           when "bevel" then "<a:bevel/>"
-                                           when "miter"
-                                             shape[:line_miter_limit] ? "<a:miter lim=\"#{shape[:line_miter_limit].to_i}\"/>" : "<a:miter/>"
-                                           else ""
-                                           end
-                               %(<a:ln#{ln_attrs}>#{fill_part}#{dash_part}#{head_part}#{tail_part}#{join_part}</a:ln>)
-                             else
-                               ""
-                             end
-            shape_xfrm_xml = shape[:rotation] ? %(<a:xfrm rot="#{shape[:rotation].to_i}"><a:off x="0" y="0"/><a:ext cx="0" cy="0"/></a:xfrm>) : ""
-            av_lst_xml = if shape[:adjust_values]&.any?
-                           gds = shape[:adjust_values].map { |gd| %(<a:gd name="#{xml_escape(gd[:name])}" fmla="#{xml_escape(gd[:fmla])}"/>) }
-                           "<a:avLst>#{gds.join}</a:avLst>"
-                         else
-                           "<a:avLst/>"
-                         end
-            effect_lst_xml = if shape[:outer_shadow] || shape[:inner_shadow] || shape[:glow] || shape[:soft_edge] || shape[:reflection] || shape[:blur]
-                               effect_children = +""
-                               if shape[:outer_shadow]
-                                 os = shape[:outer_shadow]
-                                 os_attrs = +""
-                                 os_attrs << %( blurRad="#{os[:blur_rad]}") if os[:blur_rad]
-                                 os_attrs << %( dist="#{os[:dist]}") if os[:dist]
-                                 os_attrs << %( dir="#{os[:dir]}") if os[:dir]
-                                 os_attrs << %( algn="#{xml_escape(os[:algn])}") if os[:algn]
-                                 os_attrs << %( rotWithShape="#{os[:rot_with_shape] ? 1 : 0}") unless os[:rot_with_shape].nil?
-                                 os_color = os[:color] ? srgb_clr_xml(os[:color], alpha: os[:alpha]) : ""
-                                 effect_children << "<a:outerShdw#{os_attrs}>#{os_color}</a:outerShdw>"
-                               end
-                               if shape[:glow]
-                                 gl = shape[:glow]
-                                 gl_attrs = +""
-                                 gl_attrs << %( rad="#{gl[:rad]}") if gl[:rad]
-                                 gl_color = gl[:color] ? srgb_clr_xml(gl[:color], alpha: gl[:alpha]) : ""
-                                 effect_children << "<a:glow#{gl_attrs}>#{gl_color}</a:glow>"
-                               end
-                               if shape[:inner_shadow]
-                                 is = shape[:inner_shadow]
-                                 is_attrs = +""
-                                 is_attrs << %( blurRad="#{is[:blur_rad]}") if is[:blur_rad]
-                                 is_attrs << %( dist="#{is[:dist]}") if is[:dist]
-                                 is_attrs << %( dir="#{is[:dir]}") if is[:dir]
-                                 is_color = is[:color] ? srgb_clr_xml(is[:color], alpha: is[:alpha]) : ""
-                                 effect_children << "<a:innerShdw#{is_attrs}>#{is_color}</a:innerShdw>"
-                               end
-                               if shape[:reflection]
-                                 rf = shape[:reflection]
-                                 rf_attrs = +""
-                                 rf_attrs << %( blurRad="#{rf[:blur_rad]}") if rf[:blur_rad]
-                                 rf_attrs << %( stA="#{rf[:st_a]}") if rf[:st_a]
-                                 rf_attrs << %( endA="#{rf[:end_a]}") if rf[:end_a]
-                                 rf_attrs << %( dist="#{rf[:dist]}") unless rf[:dist].nil?
-                                 rf_attrs << %( dir="#{rf[:dir]}") if rf[:dir]
-                                 rf_attrs << %( fadeDir="#{rf[:fade_dir]}") if rf[:fade_dir]
-                                 rf_attrs << %( sx="#{rf[:sx]}") if rf[:sx]
-                                 rf_attrs << %( sy="#{rf[:sy]}") if rf[:sy]
-                                 rf_attrs << %( kx="#{rf[:kx]}") if rf[:kx]
-                                 rf_attrs << %( ky="#{rf[:ky]}") if rf[:ky]
-                                 rf_attrs << %( algn="#{xml_escape(rf[:algn])}") if rf[:algn]
-                                 rf_attrs << %( rotWithShape="#{rf[:rot_with_shape] ? 1 : 0}") unless rf[:rot_with_shape].nil?
-                                 effect_children << "<a:reflection#{rf_attrs}/>"
-                               end
-                               if shape[:soft_edge]
-                                 se = shape[:soft_edge]
-                                 effect_children << %(<a:softEdge rad="#{se[:rad]}"/>)
-                               end
-                               if shape[:blur]
-                                 bl = shape[:blur]
-                                 bl_attrs = +""
-                                 bl_attrs << %( rad="#{bl[:rad]}") if bl[:rad]
-                                 bl_attrs << %( grow="#{bl[:grow] ? 1 : 0}") unless bl[:grow].nil?
-                                 effect_children << "<a:blur#{bl_attrs}/>"
-                               end
-                               "<a:effectLst>#{effect_children}</a:effectLst>"
-                             else
-                               ""
-                             end
-            parts << %(<xdr:spPr>#{shape_xfrm_xml}<a:prstGeom prst="#{xml_escape(shape[:preset])}">#{av_lst_xml}</a:prstGeom>#{shape_fill_xml}#{shape_line_xml}#{effect_lst_xml}</xdr:spPr>)
-            if shape[:text] || shape[:text_paragraphs]
-              body_pr_attrs = +""
-              body_pr_attrs << %( rot="#{shape[:text_rot]}") if shape[:text_rot]
-              body_pr_attrs << %( spcFirstLastPara="1") if shape[:text_spc_first_last_para]
-              body_pr_attrs << %( wrap="#{xml_escape(shape[:text_wrap])}") if shape[:text_wrap]
-              body_pr_attrs << %( anchor="#{xml_escape(shape[:text_anchor])}") if shape[:text_anchor]
-              body_pr_attrs << %( anchorCtr="1") if shape[:text_anchor_ctr]
-              body_pr_attrs << %( vertOverflow="#{xml_escape(shape[:text_vert_overflow])}") if shape[:text_vert_overflow]
-              body_pr_attrs << %( horzOverflow="#{xml_escape(shape[:text_horz_overflow])}") if shape[:text_horz_overflow]
-              body_pr_attrs << %( numCol="#{shape[:text_num_col]}") if shape[:text_num_col]
-              body_pr_attrs << %( spcCol="#{shape[:text_spc_col]}") if shape[:text_spc_col]
-              body_pr_attrs << %( rtlCol="1") if shape[:text_rtl_col]
-              body_pr_attrs << %( fromWordArt="1") if shape[:text_from_word_art]
-              body_pr_attrs << %( upright="1") if shape[:text_upright]
-              body_pr_attrs << %( compatLnSpc="1") if shape[:text_compat_ln_spc]
-              body_pr_attrs << %( forceAA="1") if shape[:text_force_aa]
-              body_pr_attrs << %( vert="#{xml_escape(shape[:text_vertical])}") if shape[:text_vertical]
-              if shape[:text_insets]
-                ins = shape[:text_insets]
-                body_pr_attrs << %( lIns="#{ins[:left]}") if ins[:left]
-                body_pr_attrs << %( tIns="#{ins[:top]}") if ins[:top]
-                body_pr_attrs << %( rIns="#{ins[:right]}") if ins[:right]
-                body_pr_attrs << %( bIns="#{ins[:bottom]}") if ins[:bottom]
-              end
-              body_pr_children = +""
-              if shape[:text_warp]
-                tw = shape[:text_warp]
-                body_pr_children << %(<a:prstTxWarp prst="#{xml_escape(tw[:preset])}"><a:avLst/></a:prstTxWarp>)
-              end
-              autofit_xml = case shape[:autofit]
-                            when "none" then "<a:noAutofit/>"
-                            when "shape" then "<a:spAutoFit/>"
-                            when "normal" then "<a:normAutofit/>"
-                            when Hash
-                              af = shape[:autofit]
-                              case af[:type]
-                              when "normal"
-                                na_attrs = +""
-                                na_attrs << %( fontScale="#{af[:font_scale]}") if af[:font_scale]
-                                na_attrs << %( lnSpcReduction="#{af[:ln_spc_reduction]}") if af[:ln_spc_reduction]
-                                "<a:normAutofit#{na_attrs}/>"
-                              when "none" then "<a:noAutofit/>"
-                              when "shape" then "<a:spAutoFit/>"
-                              else ""
-                              end
-                            else ""
-                            end
-              body_pr_children << autofit_xml
-              body_pr_xml = if body_pr_children.empty?
-                              "<a:bodyPr#{body_pr_attrs}/>"
-                            else
-                              "<a:bodyPr#{body_pr_attrs}>#{body_pr_children}</a:bodyPr>"
-                            end
-              parts << "<xdr:txBody>#{body_pr_xml}<a:lstStyle/>"
-              if shape[:text_paragraphs]
-                shape[:text_paragraphs].each { |para| parts << paragraph_xml(para) }
-              elsif shape[:text]
-                parts << paragraph_xml(
-                  text: shape[:text], font: shape[:text_font],
-                  align: shape[:text_align], font_align: shape[:text_font_align],
-                  def_tab_sz: shape[:text_def_tab_sz], rtl: shape[:text_rtl],
-                  ea_ln_brk: shape[:text_ea_ln_brk], latin_ln_brk: shape[:text_latin_ln_brk],
-                  hanging_punct: shape[:text_hanging_punct], level: shape[:text_level],
-                  indent: shape[:text_indent], spacing: shape[:text_spacing],
-                  tab_stops: shape[:text_tab_stops], bullet: shape[:text_bullet],
-                  def_rpr: shape[:text_def_rpr], end_para_rpr: shape[:text_end_para_rpr]
-                )
-              end
-              parts << "</xdr:txBody>"
-            end
-            parts << "</xdr:sp>"
-            parts << client_data_xml(shape)
-            parts << "</xdr:twoCellAnchor>"
-          end
-        end
-
-        parts << "</xdr:wsDr>"
-        parts.join
-      end
-
-      # : (untyped para) -> ::String
-      def paragraph_xml(para)
-        ppr_attrs = +""
-        ppr_attrs << %( algn="#{xml_escape(para[:align])}") if para[:align]
-        ppr_attrs << %( fontAlgn="#{xml_escape(para[:font_align])}") if para[:font_align]
-        ppr_attrs << %( defTabSz="#{para[:def_tab_sz]}") if para[:def_tab_sz]
-        ppr_attrs << %( rtl="1") if para[:rtl]
-        ppr_attrs << %( eaLnBrk="1") if para[:ea_ln_brk]
-        ppr_attrs << %( latinLnBrk="1") if para[:latin_ln_brk]
-        ppr_attrs << %( hangingPunct="1") if para[:hanging_punct]
-        ppr_attrs << %( lvl="#{para[:level]}") if para[:level]
-        if para[:indent]
-          ti = para[:indent]
-          ppr_attrs << %( marL="#{ti[:left]}") if ti[:left]
-          ppr_attrs << %( marR="#{ti[:right]}") if ti[:right]
-          ppr_attrs << %( indent="#{ti[:indent]}") if ti[:indent]
-        end
-        ppr_children = +""
-        if para[:spacing]
-          ts = para[:spacing]
-          if ts[:line]
-            ppr_children << %(<a:lnSpc><a:spcPts val="#{ts[:line]}"/></a:lnSpc>)
-          elsif ts[:line_pct]
-            ppr_children << %(<a:lnSpc><a:spcPct val="#{ts[:line_pct]}"/></a:lnSpc>)
-          end
-          if ts[:before]
-            ppr_children << %(<a:spcBef><a:spcPts val="#{ts[:before]}"/></a:spcBef>)
-          elsif ts[:before_pct]
-            ppr_children << %(<a:spcBef><a:spcPct val="#{ts[:before_pct]}"/></a:spcBef>)
-          end
-          if ts[:after]
-            ppr_children << %(<a:spcAft><a:spcPts val="#{ts[:after]}"/></a:spcAft>)
-          elsif ts[:after_pct]
-            ppr_children << %(<a:spcAft><a:spcPct val="#{ts[:after_pct]}"/></a:spcAft>)
-          end
-        end
-        if para[:tab_stops]&.any?
-          tabs = para[:tab_stops].map do |tab|
-            tab_attrs = %( pos="#{tab[:pos]}")
-            tab_attrs << %( algn="#{xml_escape(tab[:align])}") if tab[:align]
-            "<a:tab#{tab_attrs}/>"
-          end
-          ppr_children << "<a:tabLst>#{tabs.join}</a:tabLst>"
-        end
-        if para[:bullet]
-          bu = para[:bullet]
-          ppr_children << %(<a:buClr>#{color_xml(bu[:color])}</a:buClr>) if bu[:color]
-          ppr_children << %(<a:buSzPts val="#{bu[:size_pts]}"/>) if bu[:size_pts]
-          ppr_children << %(<a:buSzPct val="#{bu[:size_pct]}"/>) if bu[:size_pct]
-          ppr_children << %(<a:buFont typeface="#{xml_escape(bu[:font])}"/>) if bu[:font]
-          case bu[:type]
-          when "none"
-            ppr_children << "<a:buNone/>"
-          when "char"
-            ppr_children << %(<a:buChar char="#{xml_escape(bu[:char])}"/>)
-          when "auto"
-            auto_attrs = %( type="#{xml_escape(bu[:auto_type])}")
-            auto_attrs << %( startAt="#{bu[:start_at]}") if bu[:start_at]
-            ppr_children << "<a:buAutoNum#{auto_attrs}/>"
-          end
-        end
-        ppr_children << text_char_props_xml("a:defRPr", para[:def_rpr]) if para[:def_rpr]
-        ppr_xml = if ppr_attrs.empty? && ppr_children.empty?
-                    ""
-                  elsif ppr_children.empty?
-                    "<a:pPr#{ppr_attrs}/>"
-                  else
-                    "<a:pPr#{ppr_attrs}>#{ppr_children}</a:pPr>"
-                  end
-        end_para_rpr_xml = para[:end_para_rpr] ? text_char_props_xml("a:endParaRPr", para[:end_para_rpr]) : ""
-        runs_xml = if para[:runs]
-                     para[:runs].map do |run|
-                       run_rpr = run[:font] ? text_char_props_xml("a:rPr", run[:font]) : ""
-                       "<a:r>#{run_rpr}<a:t>#{xml_escape(run[:text] || "")}</a:t></a:r>"
-                     end.join
-                   else
-                     rpr_xml = para[:font] ? text_char_props_xml("a:rPr", para[:font]) : ""
-                     "<a:r>#{rpr_xml}<a:t>#{xml_escape(para[:text] || "")}</a:t></a:r>"
-                   end
-        "<a:p>#{ppr_xml}#{runs_xml}#{end_para_rpr_xml}</a:p>"
-      end
-
-      # : (untyped tag, untyped font) -> untyped
-      def text_char_props_xml(tag, font)
-        attrs = +""
-        attrs << %( b="1") if font[:bold]
-        attrs << %( i="1") if font[:italic]
-        attrs << %( noProof="1") if font[:no_proof]
-        attrs << %( normalizeH="1") if font[:normalize_h]
-        attrs << %( kumimoji="1") if font[:kumimoji]
-        attrs << %( sz="#{font[:size]}") if font[:size]
-        attrs << %( strike="#{xml_escape(font[:strike])}") if font[:strike]
-        attrs << %( u="#{xml_escape(font[:underline])}") if font[:underline]
-        attrs << %( baseline="#{font[:baseline]}") if font[:baseline]
-        attrs << %( spc="#{font[:spacing]}") if font[:spacing]
-        attrs << %( kern="#{font[:kern]}") if font[:kern]
-        attrs << %( cap="#{xml_escape(font[:cap])}") if font[:cap]
-        attrs << %( lang="#{xml_escape(font[:lang])}") if font[:lang]
-        attrs << %( altLang="#{xml_escape(font[:alt_lang])}") if font[:alt_lang]
-        attrs << %( dirty="1") if font[:dirty]
-        attrs << %( smtClean="1") if font[:smt_clean]
-        attrs << %( err="1") if font[:err]
-        attrs << %( bmk="#{xml_escape(font[:bmk])}") if font[:bmk]
-        children = +""
-        children << %(<a:solidFill>#{color_xml(font[:color])}</a:solidFill>) if font[:color]
-        children << %(<a:highlight>#{color_xml(font[:highlight])}</a:highlight>) if font[:highlight]
-        children << %(<a:latin typeface="#{xml_escape(font[:name])}"/>) if font[:name]
-        children << %(<a:ea typeface="#{xml_escape(font[:ea_font])}"/>) if font[:ea_font]
-        children << %(<a:cs typeface="#{xml_escape(font[:cs_font])}"/>) if font[:cs_font]
-        children << %(<a:sym typeface="#{xml_escape(font[:sym_font])}"/>) if font[:sym_font]
-        children << "<a:uFillTx/>" if font[:u_fill_tx]
-        children << "<a:uLnTx/>" if font[:u_ln_tx]
-        if font[:line_color] || font[:line_width] || font[:line_dash] || font[:line_cap] || font[:line_join]
-          ln_attrs = +(font[:line_width] ? %( w="#{font[:line_width].to_i}") : "")
-          ln_attrs << %( cap="#{xml_escape(font[:line_cap])}") if font[:line_cap]
-          ln_fill = font[:line_color] ? %(<a:solidFill>#{color_xml(font[:line_color])}</a:solidFill>) : ""
-          ln_dash = font[:line_dash] ? %(<a:prstDash val="#{xml_escape(font[:line_dash])}"/>) : ""
-          ln_join = case font[:line_join]
-                    when "round" then "<a:round/>"
-                    when "bevel" then "<a:bevel/>"
-                    when "miter"
-                      font[:line_miter_limit] ? "<a:miter lim=\"#{font[:line_miter_limit].to_i}\"/>" : "<a:miter/>"
-                    else ""
-                    end
-          children << "<a:ln#{ln_attrs}>#{ln_fill}#{ln_dash}#{ln_join}</a:ln>"
-        end
-        if font[:outer_shadow] || font[:inner_shadow] || font[:glow] || font[:soft_edge] || font[:reflection] || font[:blur]
-          eff = +""
-          if font[:outer_shadow]
-            os = font[:outer_shadow]
-            oa = +""
-            oa << %( blurRad="#{os[:blur_rad]}") if os[:blur_rad]
-            oa << %( dist="#{os[:dist]}") if os[:dist]
-            oa << %( dir="#{os[:dir]}") if os[:dir]
-            oa << %( algn="#{xml_escape(os[:algn])}") if os[:algn]
-            oa << %( rotWithShape="#{os[:rot_with_shape] ? 1 : 0}") unless os[:rot_with_shape].nil?
-            oc = os[:color] ? srgb_clr_xml(os[:color], alpha: os[:alpha]) : ""
-            eff << "<a:outerShdw#{oa}>#{oc}</a:outerShdw>"
-          end
-          if font[:glow]
-            gl = font[:glow]
-            ga = +(gl[:rad] ? %( rad="#{gl[:rad]}") : "")
-            gc = gl[:color] ? srgb_clr_xml(gl[:color], alpha: gl[:alpha]) : ""
-            eff << "<a:glow#{ga}>#{gc}</a:glow>"
-          end
-          if font[:inner_shadow]
-            is = font[:inner_shadow]
-            ia = +""
-            ia << %( blurRad="#{is[:blur_rad]}") if is[:blur_rad]
-            ia << %( dist="#{is[:dist]}") if is[:dist]
-            ia << %( dir="#{is[:dir]}") if is[:dir]
-            ic = is[:color] ? srgb_clr_xml(is[:color], alpha: is[:alpha]) : ""
-            eff << "<a:innerShdw#{ia}>#{ic}</a:innerShdw>"
-          end
-          if font[:reflection]
-            rf = font[:reflection]
-            ra = +""
-            ra << %( blurRad="#{rf[:blur_rad]}") if rf[:blur_rad]
-            ra << %( stA="#{rf[:st_a]}") if rf[:st_a]
-            ra << %( endA="#{rf[:end_a]}") if rf[:end_a]
-            ra << %( dist="#{rf[:dist]}") unless rf[:dist].nil?
-            ra << %( dir="#{rf[:dir]}") if rf[:dir]
-            ra << %( fadeDir="#{rf[:fade_dir]}") if rf[:fade_dir]
-            ra << %( sx="#{rf[:sx]}") if rf[:sx]
-            ra << %( sy="#{rf[:sy]}") if rf[:sy]
-            ra << %( kx="#{rf[:kx]}") if rf[:kx]
-            ra << %( ky="#{rf[:ky]}") if rf[:ky]
-            ra << %( algn="#{xml_escape(rf[:algn])}") if rf[:algn]
-            ra << %( rotWithShape="#{rf[:rot_with_shape] ? 1 : 0}") unless rf[:rot_with_shape].nil?
-            eff << "<a:reflection#{ra}/>"
-          end
-          if font[:soft_edge]
-            se = font[:soft_edge]
-            eff << %(<a:softEdge rad="#{se[:rad]}"/>)
-          end
-          if font[:blur]
-            bl = font[:blur]
-            ba = +(bl[:rad] ? %( rad="#{bl[:rad]}") : "")
-            ba << %( grow="#{bl[:grow] ? 1 : 0}") unless bl[:grow].nil?
-            eff << "<a:blur#{ba}/>"
-          end
-          children << "<a:effectLst>#{eff}</a:effectLst>"
-        end
-        if children.empty?
-          "<#{tag}#{attrs}/>"
-        else
-          "<#{tag}#{attrs}>#{children}</#{tag}>"
-        end
-      end
-
-      # : (untyped tag, untyped col, untyped row, ?col_off: ::Integer, ?row_off: ::Integer) -> ::String
-      def anchor_xml(tag, col, row, col_off: 0, row_off: 0)
-        "<xdr:#{tag}><xdr:col>#{col}</xdr:col><xdr:colOff>#{col_off}</xdr:colOff><xdr:row>#{row}</xdr:row><xdr:rowOff>#{row_off}</xdr:rowOff></xdr:#{tag}>"
-      end
-
-      # : (untyped obj) -> ::String
-      def client_data_xml(obj)
-        cd_attrs = +""
-        cd_attrs << ' fLocksWithSheet="0"' if obj[:locks_with_sheet] == false
-        cd_attrs << ' fLocksWithSheet="1"' if obj[:locks_with_sheet] == true
-        cd_attrs << ' fPrintsWithSheet="0"' if obj[:prints_with_sheet] == false
-        cd_attrs << ' fPrintsWithSheet="1"' if obj[:prints_with_sheet] == true
-        "<xdr:clientData#{cd_attrs}/>"
-      end
-
-      # : (untyped rels_data) -> untyped
-      def generate_drawing_rels(rels_data)
-        parts = [XML_HEADER, %(<Relationships xmlns="#{REL_NS}">)]
-        rels_data.each_with_index do |rel, i|
-          rel_type = case rel[:type]
-                     when :image then "#{DOC_REL_NS}/image"
-                     when :chart then "#{DOC_REL_NS}/chart"
-                     end
-          parts << %(<Relationship Id="rId#{i + 1}" Type="#{rel_type}" Target="#{rel[:target]}"/>)
-        end
-        parts << "</Relationships>"
-        parts.join
-      end
-
-      # : (untyped title_spec, ?overlay: bool) -> untyped
-      def build_chart_title_xml(title_spec, overlay: false)
-        overlay_val = overlay ? 1 : 0
-        if title_spec.is_a?(Hash)
-          text = xml_escape(title_spec[:text].to_s)
-          rotation = title_spec[:rotation]
-          body_pr = rotation ? %(<a:bodyPr rot="#{rotation}"/>) : "<a:bodyPr/>"
-          font = title_spec[:font] || {}
-          rpr_attrs = +""
-          rpr_attrs << %( b="1") if font[:bold]
-          rpr_attrs << %( i="1") if font[:italic]
-          rpr_attrs << %( sz="#{font[:size]}") if font[:size]
-          rpr_children = +""
-          rpr_children << %(<a:solidFill>#{color_xml(font[:color])}</a:solidFill>) if font[:color]
-          rpr_children << %(<a:latin typeface="#{xml_escape(font[:name])}"/>) if font[:name]
-          rpr_xml = if rpr_children.empty?
-                      "<a:rPr#{rpr_attrs}/>"
-                    else
-                      "<a:rPr#{rpr_attrs}>#{rpr_children}</a:rPr>"
-                    end
-          layout_xml = build_title_layout_xml(title_spec[:layout])
-          sp_xml = build_title_sp_pr(title_spec)
-          "<c:title><c:tx><c:rich>#{body_pr}<a:lstStyle/><a:p><a:r>#{rpr_xml}<a:t>#{text}</a:t></a:r></a:p></c:rich></c:tx>#{layout_xml}<c:overlay val=\"#{overlay_val}\"/>#{sp_xml}</c:title>"
-        else
-          "<c:title><c:tx><c:rich><a:bodyPr/><a:lstStyle/><a:p><a:r><a:t>#{xml_escape(title_spec)}</a:t></a:r></a:p></c:rich></c:tx><c:overlay val=\"#{overlay_val}\"/></c:title>"
-        end
-      end
-
-      # : (untyped title_spec, untyped chart, untyped prefix) -> untyped
-      def merge_flat_title_styling(title_spec, chart, prefix)
-        font_key = :"#{prefix}_font"
-        fill_key = :"#{prefix}_fill"
-        no_fill_key = :"#{prefix}_no_fill"
-        lc_key = :"#{prefix}_line_color"
-        lw_key = :"#{prefix}_line_width"
-        ld_key = :"#{prefix}_line_dash"
-        rot_key = :"#{prefix}_rotation"
-        return title_spec unless chart[font_key] || chart[fill_key] || chart[no_fill_key] ||
-                                 chart[lc_key] || chart[lw_key] || chart[ld_key] || chart[rot_key]
-
-        spec = title_spec.is_a?(Hash) ? title_spec : { text: title_spec }
-        spec[:font] ||= chart[font_key] if chart[font_key]
-        spec[:fill_color] ||= chart[fill_key] if chart[fill_key]
-        spec[:no_fill] = chart[no_fill_key] if spec[:no_fill].nil? && !chart[no_fill_key].nil?
-        spec[:line_color] ||= chart[lc_key] if chart[lc_key]
-        spec[:line_width] ||= chart[lw_key] if chart[lw_key]
-        spec[:line_dash] ||= chart[ld_key] if chart[ld_key]
-        spec[:rotation] ||= chart[rot_key] if chart[rot_key]
-        spec
-      end
-
-      # : (untyped spec) -> untyped
-      def build_title_sp_pr(spec)
-        children = +""
-        children << %(<a:solidFill>#{color_xml(spec[:fill_color])}</a:solidFill>) if spec[:fill_color]
-        children << "<a:noFill/>" if spec[:no_fill]
-        if spec[:line_color] || spec[:line_width] || spec[:line_dash]
-          lw = spec[:line_width] ? %( w="#{(spec[:line_width] * 12_700).to_i}") : ""
-          lf = spec[:line_color] ? %(<a:solidFill>#{color_xml(spec[:line_color])}</a:solidFill>) : ""
-          ld = spec[:line_dash] ? %(<a:prstDash val="#{xml_escape(spec[:line_dash])}"/>) : ""
-          children << "<a:ln#{lw}>#{lf}#{ld}</a:ln>"
-        end
-        children.empty? ? "" : "<c:spPr>#{children}</c:spPr>"
-      end
-
-      # : (untyped layout) -> ("" | untyped)
-      def build_title_layout_xml(layout)
-        return "" unless layout.is_a?(Hash)
-
-        ml = +""
-        ml << %(<c:x val="#{layout[:x]}"/>) if layout[:x]
-        ml << %(<c:y val="#{layout[:y]}"/>) if layout[:y]
-        ml << %(<c:w val="#{layout[:w]}"/>) if layout[:w]
-        ml << %(<c:h val="#{layout[:h]}"/>) if layout[:h]
-        ml.empty? ? "" : "<c:layout><c:manualLayout>#{ml}</c:manualLayout></c:layout>"
-      end
-
-      # : (untyped tag, untyped spec) -> ("" | untyped)
-      def gridlines_xml(tag, spec)
-        return "" unless spec
-
-        if spec.is_a?(Hash)
-          sp_children = +""
-          if spec[:line_color] || spec[:line_width] || spec[:line_dash]
-            lw = spec[:line_width] ? %( w="#{(spec[:line_width] * 12_700).to_i}") : ""
-            lf = spec[:line_color] ? %(<a:solidFill>#{color_xml(spec[:line_color])}</a:solidFill>) : ""
-            ld = spec[:line_dash] ? %(<a:prstDash val="#{xml_escape(spec[:line_dash])}"/>) : ""
-            sp_children << "<a:ln#{lw}>#{lf}#{ld}</a:ln>"
-          end
-          sp_children.empty? ? "<c:#{tag}/>" : "<c:#{tag}><c:spPr>#{sp_children}</c:spPr></c:#{tag}>"
-        else
-          "<c:#{tag}/>"
-        end
-      end
-
-      # Resolves a cell reference like "Sheet1!$A$1:$A$5" to an array of values from @sheets.
-      # : (untyped ref) -> (nil | untyped)
-      def resolve_sheet_ref(ref)
-        return nil unless ref
-
-        m = if ref.start_with?("'")
-              ref.match(/\A'([^']+)'!(.+)\z/)
-
-            else
-              ref.match(/\A([^!]+)!(.+)\z/)
-
-            end
-        return nil unless m
-
-        sheet_name = m[1]
-        range_part = m[2]
-        return nil unless @sheets.key?(sheet_name)
-
-        range_part = range_part.delete("$")
-        cells = if range_part.include?(":")
-                  start_cell, end_cell = range_part.split(":", 2)
-                  enumerate_cell_range(start_cell, end_cell)
-                else
-                  [range_part]
-                end
-        cells.map { |addr| @sheets[sheet_name][addr] }
-      end
-
-      # : (untyped start_cell, untyped end_cell) -> (::Array[untyped] | untyped)
-      def enumerate_cell_range(start_cell, end_cell)
-        sc = start_cell.match(/\A([A-Z]+)(\d+)\z/)
-        ec = end_cell.match(/\A([A-Z]+)(\d+)\z/)
-        return [start_cell] unless sc && ec
-
-        start_col = column_letter_to_index(sc[1])
-        start_row = sc[2].to_i
-        end_col = column_letter_to_index(ec[1])
-        end_row = ec[2].to_i
-        cells = []
-        (start_row..end_row).each do |row|
-          (start_col..end_col).each do |col|
-            cells << "#{index_to_column_letter(col)}#{row}"
-          end
-        end
-        cells
-      end
-
-      # : (untyped ref) -> ("" | ::String)
-      def num_cache_xml(ref)
-        values = resolve_sheet_ref(ref)
-        return "" unless values
-
-        pts = values.each_with_index.filter_map do |v, i|
-          next unless v
-
-          %(<c:pt idx="#{i}"><c:v>#{xml_escape(v.to_s)}</c:v></c:pt>)
-        end
-        %(<c:numCache><c:formatCode>General</c:formatCode><c:ptCount val="#{values.size}"/>#{pts.join}</c:numCache>)
-      end
-
-      # : (untyped ref) -> ("" | ::String)
-      def str_cache_xml(ref)
-        values = resolve_sheet_ref(ref)
-        return "" unless values
-
-        pts = values.each_with_index.filter_map do |v, i|
-          next unless v
-
-          %(<c:pt idx="#{i}"><c:v>#{xml_escape(v.to_s)}</c:v></c:pt>)
-        end
-        %(<c:strCache><c:ptCount val="#{values.size}"/>#{pts.join}</c:strCache>)
-      end
-
-      # : (untyped color, ?alpha: untyped?, ?transforms: untyped?) -> untyped
-      def color_xml(color, alpha: nil, transforms: nil)
-        if color.is_a?(Hash) && color[:scheme]
-          tag = "schemeClr"
-          val = xml_escape(color[:scheme])
-          transforms = color[:transforms] || transforms
-        else
-          tag = "srgbClr"
-          val = xml_escape(normalize_drawing_rgb(color))
-        end
-        children = +""
-        children << %(<a:alpha val="#{alpha}"/>) if alpha
-        (transforms || []).each do |t|
-          children << %(<a:#{xml_escape(t[:type])} val="#{t[:val]}"/>)
-        end
-        if children.empty?
-          %(<a:#{tag} val="#{val}"/>)
-        else
-          %(<a:#{tag} val="#{val}">#{children}</a:#{tag}>)
-        end
-      end
-
-      # : (untyped color) -> untyped
-      def normalize_drawing_rgb(color)
-        str = color.to_s
-        hex = str.delete_prefix("#")
-
-        # Common shorthand (e.g. #f00 -> FF0000)
-        return hex.chars.map { |c| c * 2 }.join.upcase if hex.match?(/\A[0-9A-Fa-f]{3}\z/)
-
-        # ARGB -> RGB for DrawingML srgbClr (expects RRGGBB)
-        return hex[-6, 6].upcase if hex.match?(/\A[0-9A-Fa-f]{8}\z/)
-
-        return hex.upcase if hex.match?(/\A[0-9A-Fa-f]{6}\z/)
-
-        str
-      end
-
-      alias srgb_clr_xml color_xml
-
-      # : (untyped rotation, untyped font) -> ("" | ::String)
-      def build_axis_txpr(rotation, font)
-        return "" unless rotation || font
-
-        body_attrs = rotation ? %( rot="#{rotation}") : ""
-        rpr_attrs = +""
-        rpr_children = +""
-        if font
-          rpr_attrs << %( sz="#{(font[:size] * 100).to_i}") if font[:size]
-          rpr_attrs << %( b="1") if font[:bold]
-          rpr_attrs << %( i="1") if font[:italic]
-          rpr_children << %(<a:solidFill>#{color_xml(font[:color])}</a:solidFill>) if font[:color]
-          rpr_children << %(<a:latin typeface="#{xml_escape(font[:name])}"/>) if font[:name]
-        end
-        def_rpr = if rpr_children.empty?
-                    "<a:defRPr#{rpr_attrs}/>"
-                  else
-                    "<a:defRPr#{rpr_attrs}>#{rpr_children}</a:defRPr>"
-                  end
-        %(<c:txPr><a:bodyPr#{body_attrs}/><a:lstStyle/><a:p><a:pPr>#{def_rpr}</a:pPr><a:endParaRPr/></a:p></c:txPr>)
-      end
-
-      # : (untyped chart) -> untyped
-      def generate_chart_xml(chart)
-        chart_type = CHART_TYPE_MAP[chart[:type]] || "barChart"
-        no_axes = NO_AXIS_CHARTS.include?(chart_type)
-        parts = [
-          XML_HEADER,
-          %(<c:chartSpace xmlns:c="#{C_NS}" xmlns:a="#{A_NS}" xmlns:r="#{DOC_REL_NS}">)
-        ]
-        rc = chart[:rounded_corners]
-        parts << %(<c:roundedCorners val="#{rc ? 1 : 0}"/>) unless rc.nil?
-        parts << %(<c:style val="#{chart[:style]}"/>) if chart[:style]
-        if (prot = chart[:protection])
-          parts << "<c:protection>"
-          parts << %(<c:chartObject val="#{prot[:chart_object] ? 1 : 0}"/>) unless prot[:chart_object].nil?
-          parts << %(<c:data val="#{prot[:data] ? 1 : 0}"/>) unless prot[:data].nil?
-          parts << %(<c:formatting val="#{prot[:formatting] ? 1 : 0}"/>) unless prot[:formatting].nil?
-          parts << %(<c:selection val="#{prot[:selection] ? 1 : 0}"/>) unless prot[:selection].nil?
-          parts << %(<c:userInterface val="#{prot[:user_interface] ? 1 : 0}"/>) unless prot[:user_interface].nil?
-          parts << "</c:protection>"
-        end
-        parts << "<c:chart>"
-
-        if chart[:title]
-          title_spec = chart[:title]
-          if chart[:title_font] || chart[:title_fill_color] || chart[:title_no_fill] ||
-             chart[:title_line_color] || chart[:title_line_width] || chart[:title_line_dash] ||
-             chart[:title_rotation]
-            title_spec = { text: title_spec } unless title_spec.is_a?(Hash)
-            title_spec[:font] ||= chart[:title_font] if chart[:title_font]
-            title_spec[:fill_color] ||= chart[:title_fill_color] if chart[:title_fill_color]
-            title_spec[:no_fill] = chart[:title_no_fill] if title_spec[:no_fill].nil? && !chart[:title_no_fill].nil?
-            title_spec[:line_color] ||= chart[:title_line_color] if chart[:title_line_color]
-            title_spec[:line_width] ||= chart[:title_line_width] if chart[:title_line_width]
-            title_spec[:line_dash] ||= chart[:title_line_dash] if chart[:title_line_dash]
-            title_spec[:rotation] ||= chart[:title_rotation] if chart[:title_rotation]
-          end
-          parts << build_chart_title_xml(title_spec, overlay: chart[:title_overlay])
-        end
-        atd = chart[:auto_title_deleted]
-        parts << %(<c:autoTitleDeleted val="#{atd ? 1 : 0}"/>) unless atd.nil?
-
-        if (v3d = chart[:view_3d])
-          parts << "<c:view3D>"
-          parts << %(<c:rotX val="#{v3d[:rot_x]}"/>) if v3d[:rot_x]
-          parts << %(<c:hPercent val="#{v3d[:h_percent]}"/>) if v3d[:h_percent]
-          parts << %(<c:rotY val="#{v3d[:rot_y]}"/>) if v3d[:rot_y]
-          parts << %(<c:depthPercent val="#{v3d[:depth_percent]}"/>) if v3d[:depth_percent]
-          r_ang = v3d[:r_ang_ax]
-          parts << %(<c:rAngAx val="#{r_ang ? 1 : 0}"/>) unless r_ang.nil?
-          parts << %(<c:perspective val="#{v3d[:perspective]}"/>) if v3d[:perspective]
-          parts << "</c:view3D>"
-        end
-
-        %i[floor side_wall back_wall].each do |wall_key|
-          next unless (wall = chart[wall_key])
-
-          tag = { floor: "floor", side_wall: "sideWall", back_wall: "backWall" }[wall_key]
-          parts << "<c:#{tag}><c:spPr>"
-          parts << "<a:solidFill>#{srgb_clr_xml(wall[:fill_color])}</a:solidFill>" if wall[:fill_color]
-          parts << "<a:noFill/>" if wall[:no_fill]
-          if wall[:line_color] || wall[:line_dash]
-            w_attr = wall[:line_width] ? %( w="#{wall[:line_width]}") : ""
-            w_fill = wall[:line_color] ? %(<a:solidFill>#{srgb_clr_xml(wall[:line_color])}</a:solidFill>) : ""
-            w_dash = wall[:line_dash] ? %(<a:prstDash val="#{xml_escape(wall[:line_dash])}"/>) : ""
-            parts << "<a:ln#{w_attr}>#{w_fill}#{w_dash}</a:ln>"
-          end
-          parts << "</c:spPr></c:#{tag}>"
-        end
-
-        parts << "<c:plotArea>"
-        pa_layout = chart[:plot_area_layout]
-        if pa_layout.is_a?(Hash)
-          ml_parts = +""
-          ml_parts << %(<c:layoutTarget val="#{xml_escape(pa_layout[:target])}"/>) if pa_layout[:target]
-          ml_parts << %(<c:xMode val="#{xml_escape(pa_layout[:x_mode])}"/>) if pa_layout[:x_mode]
-          ml_parts << %(<c:yMode val="#{xml_escape(pa_layout[:y_mode])}"/>) if pa_layout[:y_mode]
-          ml_parts << %(<c:wMode val="#{xml_escape(pa_layout[:w_mode])}"/>) if pa_layout[:w_mode]
-          ml_parts << %(<c:hMode val="#{xml_escape(pa_layout[:h_mode])}"/>) if pa_layout[:h_mode]
-          ml_parts << %(<c:x val="#{pa_layout[:x]}"/>) if pa_layout[:x]
-          ml_parts << %(<c:y val="#{pa_layout[:y]}"/>) if pa_layout[:y]
-          ml_parts << %(<c:w val="#{pa_layout[:w]}"/>) if pa_layout[:w]
-          ml_parts << %(<c:h val="#{pa_layout[:h]}"/>) if pa_layout[:h]
-          parts << if ml_parts.empty?
-                     "<c:layout/>"
-                   else
-                     "<c:layout><c:manualLayout>#{ml_parts}</c:manualLayout></c:layout>"
-                   end
-        else
-          parts << "<c:layout/>"
-        end
-        parts << "<c:#{chart_type}>"
-        parts << %(<c:ofPieType val="#{xml_escape(chart[:of_pie_type] || "pie")}"/>) if chart_type == "ofPieChart"
-        if %w[barChart bar3DChart].include?(chart_type)
-          bd = chart[:bar_dir] || "col"
-          gr = chart[:grouping] || "clustered"
-          parts << %(<c:barDir val="#{bd}"/><c:grouping val="#{gr}"/>)
-        elsif GROUPING_CHARTS.include?(chart_type)
-          parts << %(<c:grouping val="#{chart[:grouping] || "standard"}"/>)
-        end
-        parts << %(<c:scatterStyle val="#{chart[:scatter_style] || "lineMarker"}"/>) if chart_type == "scatterChart"
-        parts << %(<c:radarStyle val="#{chart[:radar_style] || "standard"}"/>) if chart_type == "radarChart"
-        vc = chart[:vary_colors]
-        parts << %(<c:varyColors val="#{vc ? 1 : 0}"/>) unless vc.nil?
-        wf = chart[:wireframe]
-        parts << %(<c:wireframe val="#{wf ? 1 : 0}"/>) unless wf.nil?
-
-        all_series = chart[:series] || []
-        all_series.each_with_index do |ser, idx|
-          ser_order = ser[:order] || idx
-          parts << "<c:ser><c:idx val=\"#{idx}\"/><c:order val=\"#{ser_order}\"/>"
-          parts << "<c:tx><c:strRef><c:f>#{xml_escape(ser[:name])}</c:f>#{str_cache_xml(ser[:name])}</c:strRef></c:tx>" if ser[:name]
-          iin = ser[:invert_if_negative]
-          parts << %(<c:invertIfNegative val="#{iin ? 1 : 0}"/>) unless iin.nil?
-          parts << %(<c:explosion val="#{ser[:explosion]}"/>) if ser[:explosion]
-          ser[:data_points]&.each do |dp|
-            parts << "<c:dPt><c:idx val=\"#{dp[:idx]}\"/>"
-            dp_iin = dp[:invert_if_negative]
-            parts << %(<c:invertIfNegative val="#{dp_iin ? 1 : 0}"/>) unless dp_iin.nil?
-            if dp[:marker_symbol] || dp[:marker_size] || dp[:marker_fill] || dp[:marker_no_fill] || dp[:marker_line_color] || dp[:marker_line_dash] || dp[:marker_no_line]
-              parts << "<c:marker>"
-              parts << %(<c:symbol val="#{xml_escape(dp[:marker_symbol])}"/>) if dp[:marker_symbol]
-              parts << %(<c:size val="#{dp[:marker_size]}"/>) if dp[:marker_size]
-              if dp[:marker_fill] || dp[:marker_no_fill] || dp[:marker_line_color] || dp[:marker_line_dash] || dp[:marker_no_line]
-                mk_sp = +""
-                mk_sp << "<a:noFill/>" if dp[:marker_no_fill]
-                mk_sp << %(<a:solidFill>#{color_xml(dp[:marker_fill])}</a:solidFill>) if dp[:marker_fill]
-                if dp[:marker_no_line]
-                  mk_sp << "<a:ln><a:noFill/></a:ln>"
-                elsif dp[:marker_line_color] || dp[:marker_line_dash]
-                  mk_ln_w = dp[:marker_line_width] ? %( w="#{(dp[:marker_line_width] * 12_700).to_i}") : ""
-                  mk_ln_f = dp[:marker_line_color] ? %(<a:solidFill>#{color_xml(dp[:marker_line_color])}</a:solidFill>) : ""
-                  mk_ln_d = dp[:marker_line_dash] ? %(<a:prstDash val="#{xml_escape(dp[:marker_line_dash])}"/>) : ""
-                  mk_sp << "<a:ln#{mk_ln_w}>#{mk_ln_f}#{mk_ln_d}</a:ln>"
-                end
-                parts << "<c:spPr>#{mk_sp}</c:spPr>"
-              end
-              parts << "</c:marker>"
-            end
-            dp_b3d = dp[:bubble_3d]
-            parts << %(<c:bubble3D val="#{dp_b3d ? 1 : 0}"/>) unless dp_b3d.nil?
-            parts << %(<c:explosion val="#{dp[:explosion]}"/>) if dp[:explosion]
-            dp_sp_children = +""
-            dp_sp_children << %(<a:solidFill>#{color_xml(dp[:fill_color])}</a:solidFill>) if dp[:fill_color]
-            dp_sp_children << "<a:noFill/>" if dp[:no_fill]
-            if dp[:no_line]
-              dp_sp_children << "<a:ln><a:noFill/></a:ln>"
-            elsif dp[:line_color] || dp[:line_width] || dp[:line_dash]
-              dp_ln_attrs = dp[:line_width] ? %( w="#{(dp[:line_width] * 12_700).to_i}") : ""
-              dp_ln_fill = dp[:line_color] ? %(<a:solidFill>#{color_xml(dp[:line_color])}</a:solidFill>) : ""
-              dp_ln_dash = dp[:line_dash] ? %(<a:prstDash val="#{xml_escape(dp[:line_dash])}"/>) : ""
-              dp_sp_children << "<a:ln#{dp_ln_attrs}>#{dp_ln_fill}#{dp_ln_dash}</a:ln>"
-            end
-            parts << "<c:spPr>#{dp_sp_children}</c:spPr>" unless dp_sp_children.empty?
-            parts << "</c:dPt>"
-          end
-          if ser[:fill_color] || ser[:no_fill] || ser[:line_color] || ser[:no_line] || ser[:line_width] || ser[:line_cap] || ser[:line_join] || ser[:line_dash]
-            parts << "<c:spPr>"
-            parts << %(<a:solidFill>#{color_xml(ser[:fill_color])}</a:solidFill>) if ser[:fill_color]
-            parts << "<a:noFill/>" if ser[:no_fill]
-            if ser[:line_color] || ser[:no_line] || ser[:line_width] || ser[:line_cap] || ser[:line_join] || ser[:line_dash]
-              lw = ser[:line_width] ? %( w="#{(ser[:line_width] * 12_700).to_i}") : ""
-              lc = ser[:line_cap] ? %( cap="#{xml_escape(ser[:line_cap])}") : ""
-              parts << "<a:ln#{lw}#{lc}>"
-              parts << "<a:noFill/>" if ser[:no_line]
-              parts << %(<a:solidFill>#{color_xml(ser[:line_color])}</a:solidFill>) if ser[:line_color]
-              parts << %(<a:prstDash val="#{xml_escape(ser[:line_dash])}"/>) if ser[:line_dash]
-              case ser[:line_join]
-              when "round" then parts << "<a:round/>"
-              when "bevel" then parts << "<a:bevel/>"
-              when "miter"
-                parts << (ser[:line_miter_limit] ? "<a:miter lim=\"#{ser[:line_miter_limit].to_i}\"/>" : "<a:miter/>")
-              end
-              parts << "</a:ln>"
-            end
-            parts << "</c:spPr>"
-          end
-          if ser[:marker_symbol] || ser[:marker_size] || ser[:marker_fill] || ser[:marker_no_fill] || ser[:marker_line_color] || ser[:marker_line_dash] || ser[:marker_no_line]
-            parts << "<c:marker>"
-            parts << %(<c:symbol val="#{xml_escape(ser[:marker_symbol])}"/>) if ser[:marker_symbol]
-            parts << %(<c:size val="#{ser[:marker_size]}"/>) if ser[:marker_size]
-            if ser[:marker_fill] || ser[:marker_no_fill] || ser[:marker_line_color] || ser[:marker_line_dash] || ser[:marker_no_line]
-              parts << "<c:spPr>"
-              parts << "<a:noFill/>" if ser[:marker_no_fill]
-              parts << %(<a:solidFill>#{color_xml(ser[:marker_fill])}</a:solidFill>) if ser[:marker_fill]
-              if ser[:marker_no_line]
-                parts << "<a:ln><a:noFill/></a:ln>"
-              elsif ser[:marker_line_color] || ser[:marker_line_dash]
-                mk_ln_w = ser[:marker_line_width] ? %( w="#{(ser[:marker_line_width] * 12_700).to_i}") : ""
-                mk_ln_f = ser[:marker_line_color] ? %(<a:solidFill>#{color_xml(ser[:marker_line_color])}</a:solidFill>) : ""
-                mk_ln_d = ser[:marker_line_dash] ? %(<a:prstDash val="#{xml_escape(ser[:marker_line_dash])}"/>) : ""
-                parts << "<a:ln#{mk_ln_w}>#{mk_ln_f}#{mk_ln_d}</a:ln>"
-              end
-              parts << "</c:spPr>"
-            end
-            parts << "</c:marker>"
-          end
-          if (dl = ser[:data_labels] || chart[:data_labels])
-            parts << "<c:dLbls>"
-            dl[:labels]&.each do |lbl|
-              parts << "<c:dLbl>"
-              parts << %(<c:idx val="#{lbl[:idx]}"/>)
-              if lbl[:delete]
-                parts << '<c:delete val="1"/>'
-              else
-                if (lbl_layout = lbl[:layout])
-                  ml = +""
-                  ml << %(<c:x val="#{lbl_layout[:x]}"/>) if lbl_layout[:x]
-                  ml << %(<c:y val="#{lbl_layout[:y]}"/>) if lbl_layout[:y]
-                  parts << (ml.empty? ? "<c:layout/>" : "<c:layout><c:manualLayout>#{ml}</c:manualLayout></c:layout>")
-                end
-                parts << "<c:tx><c:rich><a:bodyPr/><a:lstStyle/><a:p><a:r><a:t>#{xml_escape(lbl[:text])}</a:t></a:r></a:p></c:rich></c:tx>" if lbl[:text]
-                if lbl[:num_fmt]
-                  lnf = lbl[:num_fmt]
-                  lnf_src = lnf[:source_linked] ? ' sourceLinked="1"' : ""
-                  parts << %(<c:numFmt formatCode="#{xml_escape(lnf[:format_code])}"#{lnf_src}/>)
-                end
-                lbl_sp = +""
-                lbl_sp << %(<a:solidFill>#{color_xml(lbl[:fill_color])}</a:solidFill>) if lbl[:fill_color]
-                lbl_sp << "<a:noFill/>" if lbl[:no_fill]
-                if lbl[:line_color] || lbl[:line_width] || lbl[:line_dash]
-                  lbl_lw = lbl[:line_width] ? %( w="#{(lbl[:line_width] * 12_700).to_i}") : ""
-                  lbl_lf = lbl[:line_color] ? %(<a:solidFill>#{color_xml(lbl[:line_color])}</a:solidFill>) : ""
-                  lbl_ld = lbl[:line_dash] ? %(<a:prstDash val="#{xml_escape(lbl[:line_dash])}"/>) : ""
-                  lbl_sp << "<a:ln#{lbl_lw}>#{lbl_lf}#{lbl_ld}</a:ln>"
-                end
-                parts << "<c:spPr>#{lbl_sp}</c:spPr>" unless lbl_sp.empty?
-                parts << build_axis_txpr(nil, lbl[:font]) if lbl[:font]
-                parts << %(<c:dLblPos val="#{lbl[:position]}"/>) if lbl[:position]
-                parts << "<c:showLegendKey val=\"#{lbl[:show_legend_key] ? 1 : 0}\"/>" unless lbl[:show_legend_key].nil?
-                parts << "<c:showVal val=\"#{lbl[:show_val] ? 1 : 0}\"/>" unless lbl[:show_val].nil?
-                parts << "<c:showCatName val=\"#{lbl[:show_cat_name] ? 1 : 0}\"/>" unless lbl[:show_cat_name].nil?
-                parts << "<c:showSerName val=\"#{lbl[:show_ser_name] ? 1 : 0}\"/>" unless lbl[:show_ser_name].nil?
-                parts << "<c:showPercent val=\"#{lbl[:show_percent] ? 1 : 0}\"/>" unless lbl[:show_percent].nil?
-                parts << "<c:showBubbleSize val=\"#{lbl[:show_bubble_size] ? 1 : 0}\"/>" unless lbl[:show_bubble_size].nil?
-                parts << "<c:separator>#{xml_escape(lbl[:separator])}</c:separator>" if lbl[:separator]
-              end
-              parts << "</c:dLbl>"
-            end
-            if dl[:num_fmt]
-              nf = dl[:num_fmt]
-              nf_src = nf[:source_linked] ? ' sourceLinked="1"' : ""
-              parts << %(<c:numFmt formatCode="#{xml_escape(nf[:format_code])}"#{nf_src}/>)
-            end
-            dl_sp_children = +""
-            dl_sp_children << %(<a:solidFill>#{color_xml(dl[:fill_color])}</a:solidFill>) if dl[:fill_color]
-            dl_sp_children << "<a:noFill/>" if dl[:no_fill]
-            if dl[:line_color] || dl[:line_width] || dl[:line_dash]
-              dl_lw = dl[:line_width] ? %( w="#{(dl[:line_width] * 12_700).to_i}") : ""
-              dl_lf = dl[:line_color] ? %(<a:solidFill>#{color_xml(dl[:line_color])}</a:solidFill>) : ""
-              dl_ld = dl[:line_dash] ? %(<a:prstDash val="#{xml_escape(dl[:line_dash])}"/>) : ""
-              dl_sp_children << "<a:ln#{dl_lw}>#{dl_lf}#{dl_ld}</a:ln>"
-            end
-            parts << "<c:spPr>#{dl_sp_children}</c:spPr>" unless dl_sp_children.empty?
-            parts << build_axis_txpr(nil, dl[:font]) if dl[:font]
-            parts << %(<c:dLblPos val="#{dl[:position]}"/>) if dl[:position]
-            parts << "<c:showLegendKey val=\"#{dl[:show_legend_key] ? 1 : 0}\"/>" unless dl[:show_legend_key].nil?
-            parts << "<c:showVal val=\"#{dl[:show_val] ? 1 : 0}\"/>" unless dl[:show_val].nil?
-            parts << "<c:showCatName val=\"#{dl[:show_cat_name] ? 1 : 0}\"/>" unless dl[:show_cat_name].nil?
-            parts << "<c:showSerName val=\"#{dl[:show_ser_name] ? 1 : 0}\"/>" unless dl[:show_ser_name].nil?
-            parts << "<c:showPercent val=\"#{dl[:show_percent] ? 1 : 0}\"/>" unless dl[:show_percent].nil?
-            parts << "<c:showBubbleSize val=\"#{dl[:show_bubble_size] ? 1 : 0}\"/>" unless dl[:show_bubble_size].nil?
-            parts << "<c:separator>#{xml_escape(dl[:separator])}</c:separator>" if dl[:separator]
-            sl = dl[:show_leader_lines]
-            parts << "<c:showLeaderLines val=\"#{sl ? 1 : 0}\"/>" unless sl.nil?
-            if dl[:leader_lines]
-              ll_spec = dl[:leader_lines]
-              if ll_spec.is_a?(Hash)
-                ll_sp = +""
-                if ll_spec[:line_color] || ll_spec[:line_width] || ll_spec[:line_dash]
-                  ll_lw = ll_spec[:line_width] ? %( w="#{(ll_spec[:line_width] * 12_700).to_i}") : ""
-                  ll_lf = ll_spec[:line_color] ? %(<a:solidFill>#{color_xml(ll_spec[:line_color])}</a:solidFill>) : ""
-                  ll_ld = ll_spec[:line_dash] ? %(<a:prstDash val="#{xml_escape(ll_spec[:line_dash])}"/>) : ""
-                  ll_sp << "<a:ln#{ll_lw}>#{ll_lf}#{ll_ld}</a:ln>"
-                end
-                parts << (ll_sp.empty? ? "<c:leaderLines/>" : "<c:leaderLines><c:spPr>#{ll_sp}</c:spPr></c:leaderLines>")
-              else
-                parts << "<c:leaderLines/>"
-              end
-            end
-            parts << "</c:dLbls>"
-          end
-          trendline_list = ser[:trendlines] || (ser[:trendline] ? [ser[:trendline]] : [])
-          trendline_list.each do |tl|
-            parts << "<c:trendline>"
-            parts << "<c:name>#{xml_escape(tl[:name])}</c:name>" if tl[:name]
-            tl_sp_children = +""
-            if tl[:line_color] || tl[:line_width] || tl[:line_dash]
-              tl_ln_w = tl[:line_width] ? %( w="#{(tl[:line_width] * 12_700).to_i}") : ""
-              tl_ln_f = tl[:line_color] ? %(<a:solidFill>#{color_xml(tl[:line_color])}</a:solidFill>) : ""
-              tl_ln_d = tl[:line_dash] ? %(<a:prstDash val="#{xml_escape(tl[:line_dash])}"/>) : ""
-              tl_sp_children << "<a:ln#{tl_ln_w}>#{tl_ln_f}#{tl_ln_d}</a:ln>"
-            end
-            parts << "<c:spPr>#{tl_sp_children}</c:spPr>" unless tl_sp_children.empty?
-            parts << %(<c:trendlineType val="#{xml_escape(tl[:type] || "linear")}"/>)
-            parts << %(<c:order val="#{tl[:order]}"/>) if tl[:order]
-            parts << %(<c:period val="#{tl[:period]}"/>) if tl[:period]
-            parts << %(<c:forward val="#{tl[:forward]}"/>) if tl[:forward]
-            parts << %(<c:backward val="#{tl[:backward]}"/>) if tl[:backward]
-            parts << %(<c:intercept val="#{tl[:intercept]}"/>) if tl[:intercept]
-            parts << %(<c:dispRSqr val="#{tl[:disp_r_sqr] ? 1 : 0}"/>) unless tl[:disp_r_sqr].nil?
-            parts << %(<c:dispEq val="#{tl[:disp_eq] ? 1 : 0}"/>) unless tl[:disp_eq].nil?
-            if tl[:label]
-              lbl = tl[:label]
-              parts << "<c:trendlineLbl>"
-              parts << build_title_layout_xml(lbl[:layout])
-              parts << "<c:tx><c:rich><a:bodyPr/><a:lstStyle/><a:p><a:r><a:t>#{xml_escape(lbl[:text])}</a:t></a:r></a:p></c:rich></c:tx>" if lbl[:text]
-              if lbl[:num_fmt]
-                nf = lbl[:num_fmt]
-                nf_src = nf.is_a?(Hash) ? nf : { format_code: nf }
-                nf_linked = if nf_src.key?(:source_linked)
-                              nf_src[:source_linked] ? 1 : 0
-                            else
-                              0
-                            end
-                parts << %(<c:numFmt formatCode="#{xml_escape(nf_src[:format_code])}" sourceLinked="#{nf_linked}"/>)
-              end
-              tll_sp = +""
-              tll_sp << %(<a:solidFill>#{color_xml(lbl[:fill_color])}</a:solidFill>) if lbl[:fill_color]
-              tll_sp << "<a:noFill/>" if lbl[:no_fill]
-              if lbl[:line_color] || lbl[:line_width] || lbl[:line_dash]
-                tll_lw = lbl[:line_width] ? %( w="#{(lbl[:line_width] * 12_700).to_i}") : ""
-                tll_lf = lbl[:line_color] ? %(<a:solidFill>#{color_xml(lbl[:line_color])}</a:solidFill>) : ""
-                tll_ld = lbl[:line_dash] ? %(<a:prstDash val="#{xml_escape(lbl[:line_dash])}"/>) : ""
-                tll_sp << "<a:ln#{tll_lw}>#{tll_lf}#{tll_ld}</a:ln>"
-              end
-              parts << "<c:spPr>#{tll_sp}</c:spPr>" unless tll_sp.empty?
-              parts << build_axis_txpr(nil, lbl[:font]) if lbl[:font]
-              parts << "</c:trendlineLbl>"
-            end
-            parts << "</c:trendline>"
-          end
-          err_bars_list = ser[:error_bars_list] || (ser[:error_bars] ? [ser[:error_bars]] : [])
-          err_bars_list.each do |eb|
-            parts << "<c:errBars>"
-            parts << %(<c:errDir val="#{xml_escape(eb[:direction])}"/>) if eb[:direction]
-            parts << %(<c:errBarType val="#{xml_escape(eb[:bar_type] || "both")}"/>)
-            parts << %(<c:errValType val="#{xml_escape(eb[:val_type] || "fixedVal")}"/>)
-            parts << %(<c:noEndCap val="#{eb[:no_end_cap] ? 1 : 0}"/>) unless eb[:no_end_cap].nil?
-            parts << "<c:plus><c:numRef><c:f>#{xml_escape(eb[:plus])}</c:f></c:numRef></c:plus>" if eb[:plus]
-            parts << "<c:minus><c:numRef><c:f>#{xml_escape(eb[:minus])}</c:f></c:numRef></c:minus>" if eb[:minus]
-            parts << %(<c:val val="#{eb[:val]}"/>) if eb[:val]
-            eb_sp_children = +""
-            eb_sp_children << %(<a:solidFill>#{color_xml(eb[:fill_color])}</a:solidFill>) if eb[:fill_color]
-            eb_sp_children << "<a:noFill/>" if eb[:no_fill]
-            if eb[:line_color] || eb[:line_width] || eb[:line_dash]
-              eb_ln_w = eb[:line_width] ? %( w="#{(eb[:line_width] * 12_700).to_i}") : ""
-              eb_ln_f = eb[:line_color] ? %(<a:solidFill>#{color_xml(eb[:line_color])}</a:solidFill>) : ""
-              eb_ln_d = eb[:line_dash] ? %(<a:prstDash val="#{xml_escape(eb[:line_dash])}"/>) : ""
-              eb_sp_children << "<a:ln#{eb_ln_w}>#{eb_ln_f}#{eb_ln_d}</a:ln>"
-            end
-            parts << "<c:spPr>#{eb_sp_children}</c:spPr>" unless eb_sp_children.empty?
-            parts << "</c:errBars>"
-          end
-          uses_xy = %w[scatterChart bubbleChart].include?(chart_type)
-          cat_tag = uses_xy ? "xVal" : "cat"
-          val_tag = uses_xy ? "yVal" : "val"
-          if ser[:cat_ref]
-            parts << if uses_xy || ser[:cat_ref_type] == :num
-                       "<c:#{cat_tag}><c:numRef><c:f>#{xml_escape(ser[:cat_ref])}</c:f>#{num_cache_xml(ser[:cat_ref])}</c:numRef></c:#{cat_tag}>"
-                     else
-                       "<c:#{cat_tag}><c:strRef><c:f>#{xml_escape(ser[:cat_ref])}</c:f>#{str_cache_xml(ser[:cat_ref])}</c:strRef></c:#{cat_tag}>"
-                     end
-          end
-          parts << "<c:#{val_tag}><c:numRef><c:f>#{xml_escape(ser[:val_ref])}</c:f>#{num_cache_xml(ser[:val_ref])}</c:numRef></c:#{val_tag}>" if ser[:val_ref]
-          parts << "<c:bubbleSize><c:numRef><c:f>#{xml_escape(ser[:bubble_size_ref])}</c:f>#{num_cache_xml(ser[:bubble_size_ref])}</c:numRef></c:bubbleSize>" if ser[:bubble_size_ref]
-          parts << %(<c:smooth val="#{ser[:smooth] ? 1 : 0}"/>) unless ser[:smooth].nil?
-          parts << %(<c:shape val="#{xml_escape(ser[:shape])}"/>) if ser[:shape]
-          parts << "</c:ser>"
-        end
-
-        if chart[:band_fmts]
-          parts << "<c:bandFmts>"
-          chart[:band_fmts].each do |bf|
-            parts << "<c:bandFmt><c:idx val=\"#{bf[:idx]}\"/>"
-            bf_sp = +""
-            bf_sp << %(<a:solidFill>#{color_xml(bf[:fill_color])}</a:solidFill>) if bf[:fill_color]
-            bf_sp << "<a:noFill/>" if bf[:no_fill]
-            if bf[:line_color] || bf[:line_width] || bf[:line_dash]
-              bf_lw = bf[:line_width] ? %( w="#{(bf[:line_width] * 12_700).to_i}") : ""
-              bf_lf = bf[:line_color] ? %(<a:solidFill>#{color_xml(bf[:line_color])}</a:solidFill>) : ""
-              bf_ld = bf[:line_dash] ? %(<a:prstDash val="#{xml_escape(bf[:line_dash])}"/>) : ""
-              bf_sp << "<a:ln#{bf_lw}>#{bf_lf}#{bf_ld}</a:ln>"
-            end
-            parts << "<c:spPr>#{bf_sp}</c:spPr>" unless bf_sp.empty?
-            parts << "</c:bandFmt>"
-          end
-          parts << "</c:bandFmts>"
-        end
-
-        parts << %(<c:gapWidth val="#{chart[:gap_width]}"/>) if chart[:gap_width]
-        parts << %(<c:splitType val="#{xml_escape(chart[:split_type])}"/>) if chart[:split_type]
-        parts << %(<c:splitPos val="#{chart[:split_pos]}"/>) if chart[:split_pos]
-        if chart[:cust_split]&.any?
-          parts << "<c:custSplit>"
-          chart[:cust_split].each { |idx| parts << %(<c:secondPiePt val="#{idx}"/>) }
-          parts << "</c:custSplit>"
-        end
-        parts << %(<c:secondPieSize val="#{chart[:second_pie_size]}"/>) if chart[:second_pie_size]
-        parts << %(<c:gapDepth val="#{chart[:gap_depth]}"/>) if chart[:gap_depth]
-        parts << %(<c:overlap val="#{chart[:overlap]}"/>) if chart[:overlap]
-        parts << %(<c:shape val="#{chart[:bar_shape]}"/>) if chart[:bar_shape]
-        b3d = chart[:bubble_3d]
-        parts << %(<c:bubble3D val="#{b3d ? 1 : 0}"/>) unless b3d.nil?
-        parts << %(<c:bubbleScale val="#{chart[:bubble_scale]}"/>) if chart[:bubble_scale]
-        snb = chart[:show_neg_bubbles]
-        parts << %(<c:showNegBubbles val="#{snb ? 1 : 0}"/>) unless snb.nil?
-        parts << %(<c:sizeRepresents val="#{chart[:size_represents]}"/>) if chart[:size_represents]
-        parts << %(<c:firstSliceAng val="#{chart[:first_slice_ang]}"/>) if chart[:first_slice_ang]
-        parts << %(<c:holeSize val="#{chart[:hole_size]}"/>) if chart[:hole_size]
-        if chart[:ser_lines]
-          sl_spec = chart[:ser_lines]
-          if sl_spec.is_a?(Hash)
-            sl_sp = +""
-            if sl_spec[:line_color] || sl_spec[:line_width] || sl_spec[:line_dash]
-              sl_lw = sl_spec[:line_width] ? %( w="#{(sl_spec[:line_width] * 12_700).to_i}") : ""
-              sl_lf = sl_spec[:line_color] ? %(<a:solidFill>#{color_xml(sl_spec[:line_color])}</a:solidFill>) : ""
-              sl_ld = sl_spec[:line_dash] ? %(<a:prstDash val="#{xml_escape(sl_spec[:line_dash])}"/>) : ""
-              sl_sp << "<a:ln#{sl_lw}>#{sl_lf}#{sl_ld}</a:ln>"
-            end
-            parts << (sl_sp.empty? ? "<c:serLines/>" : "<c:serLines><c:spPr>#{sl_sp}</c:spPr></c:serLines>")
-          else
-            parts << "<c:serLines/>"
-          end
-        end
-        if chart[:drop_lines]
-          dl_spec = chart[:drop_lines]
-          if dl_spec.is_a?(Hash)
-            dl_sp = +""
-            if dl_spec[:line_color] || dl_spec[:line_width] || dl_spec[:line_dash]
-              dl_lw = dl_spec[:line_width] ? %( w="#{(dl_spec[:line_width] * 12_700).to_i}") : ""
-              dl_lf = dl_spec[:line_color] ? %(<a:solidFill>#{color_xml(dl_spec[:line_color])}</a:solidFill>) : ""
-              dl_ld = dl_spec[:line_dash] ? %(<a:prstDash val="#{xml_escape(dl_spec[:line_dash])}"/>) : ""
-              dl_sp << "<a:ln#{dl_lw}>#{dl_lf}#{dl_ld}</a:ln>"
-            end
-            parts << (dl_sp.empty? ? "<c:dropLines/>" : "<c:dropLines><c:spPr>#{dl_sp}</c:spPr></c:dropLines>")
-          else
-            parts << "<c:dropLines/>"
-          end
-        end
-        if chart[:hi_low_lines]
-          hl_spec = chart[:hi_low_lines]
-          if hl_spec.is_a?(Hash)
-            hl_sp = +""
-            if hl_spec[:line_color] || hl_spec[:line_width] || hl_spec[:line_dash]
-              hl_lw = hl_spec[:line_width] ? %( w="#{(hl_spec[:line_width] * 12_700).to_i}") : ""
-              hl_lf = hl_spec[:line_color] ? %(<a:solidFill>#{color_xml(hl_spec[:line_color])}</a:solidFill>) : ""
-              hl_ld = hl_spec[:line_dash] ? %(<a:prstDash val="#{xml_escape(hl_spec[:line_dash])}"/>) : ""
-              hl_sp << "<a:ln#{hl_lw}>#{hl_lf}#{hl_ld}</a:ln>"
-            end
-            parts << (hl_sp.empty? ? "<c:hiLowLines/>" : "<c:hiLowLines><c:spPr>#{hl_sp}</c:spPr></c:hiLowLines>")
-          else
-            parts << "<c:hiLowLines/>"
-          end
-        end
-        if chart[:up_down_bars]
-          udb = chart[:up_down_bars]
-          parts << "<c:upDownBars>"
-          parts << %(<c:gapWidth val="#{udb[:gap_width]}"/>) if udb.is_a?(Hash) && udb[:gap_width]
-          %i[up_bars down_bars].each do |bar_key|
-            tag = bar_key == :up_bars ? "upBars" : "downBars"
-            bar = udb.is_a?(Hash) ? udb[bar_key] : nil
-            if bar
-              bar_sp = +""
-              bar_sp << %(<a:solidFill>#{color_xml(bar[:fill_color])}</a:solidFill>) if bar[:fill_color]
-              bar_sp << "<a:noFill/>" if bar[:no_fill]
-              if bar[:line_color] || bar[:line_width] || bar[:line_dash]
-                b_lw = bar[:line_width] ? %( w="#{(bar[:line_width] * 12_700).to_i}") : ""
-                b_lf = bar[:line_color] ? %(<a:solidFill>#{color_xml(bar[:line_color])}</a:solidFill>) : ""
-                b_ld = bar[:line_dash] ? %(<a:prstDash val="#{xml_escape(bar[:line_dash])}"/>) : ""
-                bar_sp << "<a:ln#{b_lw}>#{b_lf}#{b_ld}</a:ln>"
-              end
-              parts << (bar_sp.empty? ? "<c:#{tag}/>" : "<c:#{tag}><c:spPr>#{bar_sp}</c:spPr></c:#{tag}>")
-            else
-              parts << "<c:#{tag}/>"
-            end
-          end
-          parts << "</c:upDownBars>"
-        end
-        mk = chart[:marker]
-        parts << %(<c:marker val="#{mk ? 1 : 0}"/>) unless mk.nil?
-        sm = chart[:smooth]
-        parts << %(<c:smooth val="#{sm ? 1 : 0}"/>) unless sm.nil?
-        three_axes = THREE_AXIS_CHARTS.include?(chart_type)
-        unless no_axes
-          parts << '<c:axId val="1"/><c:axId val="2"/>'
-          parts << '<c:axId val="3"/>' if three_axes
-        end
-        parts << "</c:#{chart_type}>"
-
-        unless no_axes
-          cat_del = chart[:cat_axis_delete] ? 1 : 0
-          cat_orient = chart[:cat_axis_orientation] || "minMax"
-          cat_ax_tag = chart[:cat_axis_type] == :date ? "dateAx" : "catAx"
-          parts << %(<c:#{cat_ax_tag}><c:axId val="1"/><c:scaling>)
-          parts << %(<c:logBase val="#{chart[:cat_axis_log_base]}"/>) if chart[:cat_axis_log_base]
-          parts << %(<c:orientation val="#{cat_orient}"/>)
-          parts << %(<c:max val="#{chart[:cat_axis_scaling_max]}"/>) if chart[:cat_axis_scaling_max]
-          parts << %(<c:min val="#{chart[:cat_axis_scaling_min]}"/>) if chart[:cat_axis_scaling_min]
-          parts << %(</c:scaling><c:delete val="#{cat_del}"/><c:axPos val="#{chart[:cat_axis_pos] || "b"}"/>)
-          parts << gridlines_xml("majorGridlines", chart[:cat_axis_major_gridlines])
-          parts << gridlines_xml("minorGridlines", chart[:cat_axis_minor_gridlines])
-          if chart[:cat_axis_title]
-            cat_title_spec = merge_flat_title_styling(chart[:cat_axis_title], chart, :cat_axis_title)
-            parts << build_chart_title_xml(cat_title_spec)
-          end
-          if (cnf = chart[:cat_axis_num_fmt])
-            sl = cnf[:source_linked] ? 1 : 0
-            parts << %(<c:numFmt formatCode="#{xml_escape(cnf[:format_code])}" sourceLinked="#{sl}"/>)
-          end
-          parts << %(<c:majorTickMark val="#{chart[:cat_axis_major_tick_mark]}"/>) if chart[:cat_axis_major_tick_mark]
-          parts << %(<c:minorTickMark val="#{chart[:cat_axis_minor_tick_mark]}"/>) if chart[:cat_axis_minor_tick_mark]
-          parts << %(<c:tickLblPos val="#{chart[:cat_axis_tick_lbl_pos]}"/>) if chart[:cat_axis_tick_lbl_pos]
-          if chart[:cat_axis_line_color] || chart[:cat_axis_fill] || chart[:cat_axis_no_fill] || chart[:cat_axis_line_dash]
-            parts << "<c:spPr>"
-            parts << "<a:noFill/>" if chart[:cat_axis_no_fill]
-            parts << %(<a:solidFill>#{color_xml(chart[:cat_axis_fill])}</a:solidFill>) if chart[:cat_axis_fill]
-            if chart[:cat_axis_line_color] || chart[:cat_axis_line_dash]
-              w_attr = chart[:cat_axis_line_width] ? %( w="#{chart[:cat_axis_line_width]}") : ""
-              ca_ln_f = chart[:cat_axis_line_color] ? %(<a:solidFill>#{srgb_clr_xml(chart[:cat_axis_line_color])}</a:solidFill>) : ""
-              ca_ln_d = chart[:cat_axis_line_dash] ? %(<a:prstDash val="#{xml_escape(chart[:cat_axis_line_dash])}"/>) : ""
-              parts << "<a:ln#{w_attr}>#{ca_ln_f}#{ca_ln_d}</a:ln>"
-            end
-            parts << "</c:spPr>"
-          end
-          parts << build_axis_txpr(chart[:cat_axis_label_rotation], chart[:cat_axis_font])
-          parts << '<c:crossAx val="2"/>'
-          parts << %(<c:crosses val="#{chart[:cat_axis_crosses]}"/>) if chart[:cat_axis_crosses]
-          parts << %(<c:crossesAt val="#{chart[:cat_axis_crosses_at]}"/>) if !chart[:cat_axis_crosses] && chart[:cat_axis_crosses_at]
-          ca_auto = chart[:cat_axis_auto]
-          parts << %(<c:auto val="#{ca_auto ? 1 : 0}"/>) unless ca_auto.nil?
-          parts << %(<c:lblAlgn val="#{xml_escape(chart[:cat_axis_lbl_algn])}"/>) if chart[:cat_axis_lbl_algn]
-          parts << %(<c:lblOffset val="#{chart[:cat_axis_lbl_offset]}"/>) if chart[:cat_axis_lbl_offset]
-          parts << %(<c:tickLblSkip val="#{chart[:cat_axis_tick_lbl_skip]}"/>) if chart[:cat_axis_tick_lbl_skip]
-          parts << %(<c:tickMarkSkip val="#{chart[:cat_axis_tick_mark_skip]}"/>) if chart[:cat_axis_tick_mark_skip]
-          nml = chart[:cat_axis_no_multi_lvl_lbl]
-          parts << %(<c:noMultiLvlLbl val="#{nml ? 1 : 0}"/>) unless nml.nil?
-          if cat_ax_tag == "dateAx"
-            parts << %(<c:baseTimeUnit val="#{chart[:cat_axis_base_time_unit]}"/>) if chart[:cat_axis_base_time_unit]
-            parts << %(<c:majorUnit val="#{chart[:cat_axis_major_unit]}"/>) if chart[:cat_axis_major_unit]
-            parts << %(<c:majorTimeUnit val="#{chart[:cat_axis_major_time_unit]}"/>) if chart[:cat_axis_major_time_unit]
-            parts << %(<c:minorUnit val="#{chart[:cat_axis_minor_unit]}"/>) if chart[:cat_axis_minor_unit]
-            parts << %(<c:minorTimeUnit val="#{chart[:cat_axis_minor_time_unit]}"/>) if chart[:cat_axis_minor_time_unit]
-          end
-          parts << "</c:#{cat_ax_tag}>"
-          val_del = chart[:val_axis_delete] ? 1 : 0
-          val_orient = chart[:val_axis_orientation] || "minMax"
-          parts << %(<c:valAx><c:axId val="2"/><c:scaling>)
-          parts << %(<c:logBase val="#{chart[:val_axis_log_base]}"/>) if chart[:val_axis_log_base]
-          parts << %(<c:orientation val="#{val_orient}"/>)
-          parts << %(<c:max val="#{chart[:val_axis_scaling_max]}"/>) if chart[:val_axis_scaling_max]
-          parts << %(<c:min val="#{chart[:val_axis_scaling_min]}"/>) if chart[:val_axis_scaling_min]
-          parts << %(</c:scaling><c:delete val="#{val_del}"/><c:axPos val="#{chart[:val_axis_pos] || "l"}"/>)
-          parts << gridlines_xml("majorGridlines", chart[:val_axis_major_gridlines])
-          parts << gridlines_xml("minorGridlines", chart[:val_axis_minor_gridlines])
-          if chart[:val_axis_title]
-            val_title_spec = merge_flat_title_styling(chart[:val_axis_title], chart, :val_axis_title)
-            parts << build_chart_title_xml(val_title_spec)
-          end
-          if (vnf = chart[:val_axis_num_fmt])
-            sl = vnf[:source_linked] ? 1 : 0
-            parts << %(<c:numFmt formatCode="#{xml_escape(vnf[:format_code])}" sourceLinked="#{sl}"/>)
-          end
-          parts << %(<c:majorTickMark val="#{chart[:val_axis_major_tick_mark]}"/>) if chart[:val_axis_major_tick_mark]
-          parts << %(<c:minorTickMark val="#{chart[:val_axis_minor_tick_mark]}"/>) if chart[:val_axis_minor_tick_mark]
-          parts << %(<c:tickLblPos val="#{chart[:val_axis_tick_lbl_pos]}"/>) if chart[:val_axis_tick_lbl_pos]
-          if chart[:val_axis_line_color] || chart[:val_axis_fill] || chart[:val_axis_no_fill] || chart[:val_axis_line_dash]
-            parts << "<c:spPr>"
-            parts << "<a:noFill/>" if chart[:val_axis_no_fill]
-            parts << %(<a:solidFill>#{color_xml(chart[:val_axis_fill])}</a:solidFill>) if chart[:val_axis_fill]
-            if chart[:val_axis_line_color] || chart[:val_axis_line_dash]
-              w_attr = chart[:val_axis_line_width] ? %( w="#{chart[:val_axis_line_width]}") : ""
-              va_ln_f = chart[:val_axis_line_color] ? %(<a:solidFill>#{srgb_clr_xml(chart[:val_axis_line_color])}</a:solidFill>) : ""
-              va_ln_d = chart[:val_axis_line_dash] ? %(<a:prstDash val="#{xml_escape(chart[:val_axis_line_dash])}"/>) : ""
-              parts << "<a:ln#{w_attr}>#{va_ln_f}#{va_ln_d}</a:ln>"
-            end
-            parts << "</c:spPr>"
-          end
-          parts << build_axis_txpr(chart[:val_axis_label_rotation], chart[:val_axis_font])
-          parts << '<c:crossAx val="1"/>'
-          parts << %(<c:crosses val="#{chart[:val_axis_crosses]}"/>) if chart[:val_axis_crosses]
-          parts << %(<c:crossesAt val="#{chart[:val_axis_crosses_at]}"/>) if !chart[:val_axis_crosses] && chart[:val_axis_crosses_at]
-          parts << %(<c:crossBetween val="#{chart[:val_axis_cross_between]}"/>) if chart[:val_axis_cross_between]
-          parts << %(<c:majorUnit val="#{chart[:val_axis_major_unit]}"/>) if chart[:val_axis_major_unit]
-          parts << %(<c:minorUnit val="#{chart[:val_axis_minor_unit]}"/>) if chart[:val_axis_minor_unit]
-          if chart[:val_axis_disp_units]
-            du = chart[:val_axis_disp_units]
-            if du.is_a?(Hash)
-              parts << "<c:dispUnits>"
-              parts << %(<c:builtInUnit val="#{xml_escape(du[:built_in_unit])}"/>) if du[:built_in_unit]
-              parts << %(<c:custUnit val="#{du[:cust_unit]}"/>) if du[:cust_unit]
-              if du[:label]
-                dul = du[:label]
-                parts << "<c:dispUnitsLbl>"
-                if dul[:num_fmt]
-                  nf = dul[:num_fmt]
-                  nf_src = nf.is_a?(Hash) ? nf : { format_code: nf }
-                  nf_linked = if nf_src.key?(:source_linked)
-                                nf_src[:source_linked] ? 1 : 0
-                              else
-                                0
-                              end
-                  parts << %(<c:numFmt formatCode="#{xml_escape(nf_src[:format_code])}" sourceLinked="#{nf_linked}"/>)
-                end
-                dul_sp = +""
-                dul_sp << %(<a:solidFill>#{color_xml(dul[:fill_color])}</a:solidFill>) if dul[:fill_color]
-                dul_sp << "<a:noFill/>" if dul[:no_fill]
-                if dul[:line_color] || dul[:line_width] || dul[:line_dash]
-                  dul_lw = dul[:line_width] ? %( w="#{(dul[:line_width] * 12_700).to_i}") : ""
-                  dul_lf = dul[:line_color] ? %(<a:solidFill>#{color_xml(dul[:line_color])}</a:solidFill>) : ""
-                  dul_ld = dul[:line_dash] ? %(<a:prstDash val="#{xml_escape(dul[:line_dash])}"/>) : ""
-                  dul_sp << "<a:ln#{dul_lw}>#{dul_lf}#{dul_ld}</a:ln>"
-                end
-                parts << "<c:spPr>#{dul_sp}</c:spPr>" unless dul_sp.empty?
-                parts << build_axis_txpr(nil, dul[:font]) if dul[:font]
-                parts << "</c:dispUnitsLbl>"
-              end
-              parts << "</c:dispUnits>"
-            else
-              parts << %(<c:dispUnits><c:builtInUnit val="#{xml_escape(du.to_s)}"/></c:dispUnits>)
-            end
-          end
-          parts << "</c:valAx>"
-
-          if three_axes
-            parts << '<c:serAx><c:axId val="3"/><c:scaling><c:orientation val="minMax"/></c:scaling>'
-            parts << '<c:delete val="0"/><c:axPos val="b"/><c:crossAx val="2"/></c:serAx>'
-          end
-        end
-
-        if chart[:data_table]
-          dt = chart[:data_table]
-          parts << "<c:dTable>"
-          parts << %(<c:showHorzBorder val="#{dt[:show_horz_border] ? 1 : 0}"/>) unless dt[:show_horz_border].nil?
-          parts << %(<c:showVertBorder val="#{dt[:show_vert_border] ? 1 : 0}"/>) unless dt[:show_vert_border].nil?
-          parts << %(<c:showOutline val="#{dt[:show_outline] ? 1 : 0}"/>) unless dt[:show_outline].nil?
-          parts << %(<c:showKeys val="#{dt[:show_keys] ? 1 : 0}"/>) unless dt[:show_keys].nil?
-          dt_sp_children = +""
-          dt_sp_children << %(<a:solidFill>#{color_xml(dt[:fill_color])}</a:solidFill>) if dt[:fill_color]
-          dt_sp_children << "<a:noFill/>" if dt[:no_fill]
-          if dt[:line_color] || dt[:line_width] || dt[:line_dash]
-            dt_ln_w = dt[:line_width] ? %( w="#{(dt[:line_width] * 12_700).to_i}") : ""
-            dt_ln_f = dt[:line_color] ? %(<a:solidFill>#{color_xml(dt[:line_color])}</a:solidFill>) : ""
-            dt_ln_d = dt[:line_dash] ? %(<a:prstDash val="#{xml_escape(dt[:line_dash])}"/>) : ""
-            dt_sp_children << "<a:ln#{dt_ln_w}>#{dt_ln_f}#{dt_ln_d}</a:ln>"
-          end
-          parts << "<c:spPr>#{dt_sp_children}</c:spPr>" unless dt_sp_children.empty?
-          parts << build_axis_txpr(nil, dt[:font]) if dt[:font]
-          parts << "</c:dTable>"
-        end
-
-        if chart[:plot_area_fill] || chart[:plot_area_no_fill] || chart[:plot_area_line_color] || chart[:plot_area_line_dash]
-          pa_sp = +""
-          pa_sp << %(<a:solidFill>#{color_xml(chart[:plot_area_fill])}</a:solidFill>) if chart[:plot_area_fill]
-          pa_sp << "<a:noFill/>" if chart[:plot_area_no_fill]
-          if chart[:plot_area_line_color] || chart[:plot_area_line_dash]
-            pa_ln_w = chart[:plot_area_line_width] ? %( w="#{chart[:plot_area_line_width].to_i}") : ""
-            pa_ln_f = chart[:plot_area_line_color] ? %(<a:solidFill>#{color_xml(chart[:plot_area_line_color])}</a:solidFill>) : ""
-            pa_ln_d = chart[:plot_area_line_dash] ? %(<a:prstDash val="#{xml_escape(chart[:plot_area_line_dash])}"/>) : ""
-            pa_sp << "<a:ln#{pa_ln_w}>#{pa_ln_f}#{pa_ln_d}</a:ln>"
-          end
-          parts << "<c:spPr>#{pa_sp}</c:spPr>"
-        end
-
-        parts << "</c:plotArea>"
-        legend_pos = chart.dig(:legend, :position) || "r"
-        legend_overlay = chart.dig(:legend, :overlay)
-        parts << %(<c:legend><c:legendPos val="#{legend_pos}"/>)
-        legend_entries = chart.dig(:legend, :entries)
-        legend_entries&.each do |entry|
-          parts << %(<c:legendEntry><c:idx val="#{entry[:idx]}"/>)
-          if !entry[:delete].nil?
-            parts << %(<c:delete val="#{entry[:delete] ? 1 : 0}"/>)
-          elsif entry[:font]
-            parts << build_axis_txpr(nil, entry[:font])
-          end
-          parts << "</c:legendEntry>"
-        end
-        legend_layout = chart.dig(:legend, :layout)
-        if legend_layout.is_a?(Hash)
-          ml_parts = +""
-          ml_parts << %(<c:layoutTarget val="#{xml_escape(legend_layout[:target])}"/>) if legend_layout[:target]
-          ml_parts << %(<c:xMode val="#{xml_escape(legend_layout[:x_mode])}"/>) if legend_layout[:x_mode]
-          ml_parts << %(<c:yMode val="#{xml_escape(legend_layout[:y_mode])}"/>) if legend_layout[:y_mode]
-          ml_parts << %(<c:wMode val="#{xml_escape(legend_layout[:w_mode])}"/>) if legend_layout[:w_mode]
-          ml_parts << %(<c:hMode val="#{xml_escape(legend_layout[:h_mode])}"/>) if legend_layout[:h_mode]
-          ml_parts << %(<c:x val="#{legend_layout[:x]}"/>) if legend_layout[:x]
-          ml_parts << %(<c:y val="#{legend_layout[:y]}"/>) if legend_layout[:y]
-          ml_parts << %(<c:w val="#{legend_layout[:w]}"/>) if legend_layout[:w]
-          ml_parts << %(<c:h val="#{legend_layout[:h]}"/>) if legend_layout[:h]
-          parts << "<c:layout><c:manualLayout>#{ml_parts}</c:manualLayout></c:layout>" unless ml_parts.empty?
-        end
-        parts << %(<c:overlay val="#{legend_overlay ? 1 : 0}"/>) unless legend_overlay.nil?
-        leg_sp_children = +""
-        leg_fill = chart.dig(:legend, :fill_color)
-        leg_sp_children << %(<a:solidFill>#{color_xml(leg_fill)}</a:solidFill>) if leg_fill
-        leg_no_fill = chart.dig(:legend, :no_fill)
-        leg_sp_children << "<a:noFill/>" if leg_no_fill
-        leg_lc = chart.dig(:legend, :line_color)
-        leg_lw = chart.dig(:legend, :line_width)
-        leg_ld = chart.dig(:legend, :line_dash)
-        if leg_lc || leg_lw || leg_ld
-          lw_attr = leg_lw ? %( w="#{(leg_lw * 12_700).to_i}") : ""
-          lf = leg_lc ? %(<a:solidFill>#{color_xml(leg_lc)}</a:solidFill>) : ""
-          ld = leg_ld ? %(<a:prstDash val="#{xml_escape(leg_ld)}"/>) : ""
-          leg_sp_children << "<a:ln#{lw_attr}>#{lf}#{ld}</a:ln>"
-        end
-        parts << "<c:spPr>#{leg_sp_children}</c:spPr>" unless leg_sp_children.empty?
-        if (lfont = chart.dig(:legend, :font))
-          parts << build_axis_txpr(nil, lfont)
-        end
-        parts << %(</c:legend>)
-        pvo = chart[:plot_vis_only]
-        parts << %(<c:plotVisOnly val="#{pvo ? 1 : 0}"/>) unless pvo.nil?
-        parts << %(<c:dispBlanksAs val="#{chart[:disp_blanks_as]}"/>) if chart[:disp_blanks_as]
-        sdom = chart[:show_d_lbls_over_max]
-        parts << %(<c:showDLblsOverMax val="#{sdom ? 1 : 0}"/>) unless sdom.nil?
-        parts << "</c:chart>"
-        if chart[:chart_fill] || chart[:chart_no_fill] || chart[:chart_line_color] || chart[:chart_line_dash]
-          cs_sp = +""
-          cs_sp << %(<a:solidFill>#{color_xml(chart[:chart_fill])}</a:solidFill>) if chart[:chart_fill]
-          cs_sp << "<a:noFill/>" if chart[:chart_no_fill]
-          if chart[:chart_line_color] || chart[:chart_line_dash]
-            cs_lw = chart[:chart_line_width] ? %( w="#{(chart[:chart_line_width] * 12_700).to_i}") : ""
-            cs_ln_f = chart[:chart_line_color] ? %(<a:solidFill>#{color_xml(chart[:chart_line_color])}</a:solidFill>) : ""
-            cs_ln_d = chart[:chart_line_dash] ? %(<a:prstDash val="#{xml_escape(chart[:chart_line_dash])}"/>) : ""
-            cs_sp << "<a:ln#{cs_lw}>#{cs_ln_f}#{cs_ln_d}</a:ln>"
-          end
-          parts << "<c:spPr>#{cs_sp}</c:spPr>"
-        end
-        parts << build_axis_txpr(nil, chart[:chart_font]) if chart[:chart_font]
-        if (ps = chart[:print_settings])
-          parts << "<c:printSettings>"
-          if (hf = ps[:header_footer])
-            parts << "<c:headerFooter>"
-            parts << "<c:oddHeader>#{xml_escape(hf[:odd_header])}</c:oddHeader>" if hf[:odd_header]
-            parts << "<c:oddFooter>#{xml_escape(hf[:odd_footer])}</c:oddFooter>" if hf[:odd_footer]
-            parts << "<c:evenHeader>#{xml_escape(hf[:even_header])}</c:evenHeader>" if hf[:even_header]
-            parts << "<c:evenFooter>#{xml_escape(hf[:even_footer])}</c:evenFooter>" if hf[:even_footer]
-            parts << "<c:firstHeader>#{xml_escape(hf[:first_header])}</c:firstHeader>" if hf[:first_header]
-            parts << "<c:firstFooter>#{xml_escape(hf[:first_footer])}</c:firstFooter>" if hf[:first_footer]
-            parts << "</c:headerFooter>"
-          end
-          if (pm = ps[:page_margins])
-            pm_attrs = %w[b l r t header footer].filter_map { |a| pm[a.to_sym] ? %( #{a}="#{pm[a.to_sym]}") : nil }.join
-            parts << "<c:pageMargins#{pm_attrs}/>"
-          end
-          if (psu = ps[:page_setup])
-            psu_parts = +""
-            psu_parts << %( paperSize="#{psu[:paper_size]}") if psu[:paper_size]
-            psu_parts << %( firstPageNumber="#{psu[:first_page_number]}") if psu[:first_page_number]
-            psu_parts << %( orientation="#{xml_escape(psu[:orientation])}") if psu[:orientation]
-            psu_parts << %( horizontalDpi="#{psu[:horizontal_dpi]}") if psu[:horizontal_dpi]
-            psu_parts << %( verticalDpi="#{psu[:vertical_dpi]}") if psu[:vertical_dpi]
-            psu_parts << %( copies="#{psu[:copies]}") if psu[:copies]
-            parts << "<c:pageSetup#{psu_parts}/>"
-          end
-          parts << "</c:printSettings>"
-        end
-        parts << "</c:chartSpace>"
-        parts.join
-      end
-
-      # : (untyped sheet_comments) -> untyped
-      def generate_comments_xml(sheet_comments)
-        authors = sheet_comments.map { |c| c[:author] }.uniq
-        parts = [
-          XML_HEADER,
-          %(<comments xmlns="#{SSML_NS}">),
-          "<authors>"
-        ]
-        authors.each { |a| parts << "<author>#{xml_escape(a)}</author>" }
-        parts << "</authors><commentList>"
-        sheet_comments.each do |c|
-          aid = authors.index(c[:author]) || 0
-          text_xml = if c[:text].is_a?(Xlsxrb::Elements::RichText)
-                       rich_text_xml(c[:text])
-                     else
-                       "<r><t>#{xml_escape(c[:text])}</t></r>"
-                     end
-          comment_attrs = %(ref="#{c[:ref]}" authorId="#{aid}")
-          comment_attrs << %( guid="#{c[:guid]}") if c[:guid]
-          comment_attrs << %( shapeId="#{c[:shape_id]}") if c[:shape_id]
-          parts << "<comment #{comment_attrs}><text>#{text_xml}</text></comment>"
-        end
-        parts << "</commentList></comments>"
-        parts.join
-      end
-
-      # : (untyped sheet_comments) -> untyped
-      def generate_vml_drawing_xml(sheet_comments)
-        parts = [
-          '<xml xmlns:v="urn:schemas-microsoft-com:vml" xmlns:o="urn:schemas-microsoft-com:office:office" xmlns:x="urn:schemas-microsoft-com:office:excel">',
-          '<o:shapelayout v:ext="edit"><o:idmap v:ext="edit" data="1"/></o:shapelayout>',
-          '<v:shapetype id="_x0000_t202" coordsize="21600,21600" o:spt="202" path="m,l,21600r21600,l21600,xe">',
-          '<v:stroke joinstyle="miter"/><v:path gradientshapeok="t" o:connecttype="rect"/>',
-          "</v:shapetype>"
-        ]
-        sheet_comments.each_with_index do |c, idx|
-          col, row = cell_to_col_row(c[:ref])
-          shape_id = 1025 + idx
-          parts << %(<v:shape id="_x0000_s#{shape_id}" type="#_x0000_t202" style="position:absolute;margin-left:59.25pt;margin-top:1.5pt;width:108pt;height:59.25pt;z-index:#{idx + 1};visibility:hidden" fillcolor="#ffffe1" o:insetmode="auto">)
-          parts << '<v:fill color2="#ffffe1"/>'
-          parts << '<v:shadow on="t" color="black" obscured="t"/>'
-          parts << '<v:path o:connecttype="none"/>'
-          parts << '<v:textbox style="mso-direction-alt:auto"><div style="text-align:left"></div></v:textbox>'
-          parts << '<x:ClientData ObjectType="Note">'
-          parts << "<x:MoveWithCells/><x:SizeWithCells/>"
-          parts << "<x:Anchor>#{col + 1}, 15, #{row}, 10, #{col + 3}, 15, #{row + 4}, 4</x:Anchor>"
-          parts << "<x:AutoFill>False</x:AutoFill>"
-          parts << "<x:Row>#{row}</x:Row>"
-          parts << "<x:Column>#{col}</x:Column>"
-          parts << "</x:ClientData></v:shape>"
-        end
-        parts << "</xml>"
-        parts.join
-      end
-
-      # : (untyped cell_ref) -> (::Array[0] | ::Array[untyped])
-      def cell_to_col_row(cell_ref)
-        m = cell_ref.match(/\A([A-Z]+)(\d+)\z/)
-        return [0, 0] unless m
-
-        col = column_letter_to_index(m[1]) - 1
-        row = m[2].to_i - 1
-        [col, row]
-      end
-
-      # : (untyped pivot_table, untyped cache_id) -> untyped
-      def generate_pivot_table_xml(pivot_table, cache_id)
-        data_caption = pivot_table[:data_caption] || (pivot_table[:data_fields].first ? pivot_table[:data_fields].first[:name] : "Values")
-        pt_attrs = %( xmlns="#{SSML_NS}" name="#{xml_escape(pivot_table[:name])}" cacheId="#{cache_id}" dataCaption="#{xml_escape(data_caption)}")
-        pt_attrs << %( grandTotalCaption="#{xml_escape(pivot_table[:grand_total_caption])}") if pivot_table[:grand_total_caption]
-        pt_attrs << %( errorCaption="#{xml_escape(pivot_table[:error_caption])}") if pivot_table[:error_caption]
-        pt_attrs << ' showError="1"' if pivot_table[:show_error]
-        pt_attrs << %( missingCaption="#{xml_escape(pivot_table[:missing_caption])}") if pivot_table[:missing_caption]
-        pt_attrs << ' showMissing="0"' if pivot_table[:show_missing] == false
-        pt_attrs << %( tag="#{xml_escape(pivot_table[:tag])}") if pivot_table[:tag]
-        pt_attrs << %( dataOnRows="1") if pivot_table[:data_on_rows]
-        pt_attrs << %( dataOnRows="0") unless pivot_table[:data_on_rows]
-        pt_attrs << %( rowGrandTotals="0") if pivot_table[:row_grand_totals] == false
-        pt_attrs << %( colGrandTotals="0") if pivot_table[:col_grand_totals] == false
-        pt_attrs << %( compact="0") if pivot_table[:compact] == false
-        pt_attrs << %( outline="0") if pivot_table[:outline] == false
-        pt_attrs << %( outlineData="1") if pivot_table[:outline_data]
-        pt_attrs << %( compactData="0") if pivot_table[:compact_data] == false
-        pt_attrs << %( showHeaders="0") if pivot_table[:show_headers] == false
-        pt_attrs << %( showMultipleLabel="0") if pivot_table[:show_multiple_label] == false
-        pt_attrs << %( showDataDropDown="0") if pivot_table[:show_data_drop_down] == false
-        pt_attrs << %( indent="#{pivot_table[:indent]}") if pivot_table[:indent]
-        pt_attrs << ' published="1"' if pivot_table[:published]
-        pt_attrs << ' editData="1"' if pivot_table[:edit_data]
-        pt_attrs << ' disableFieldList="1"' if pivot_table[:disable_field_list]
-        pt_attrs << ' visualTotals="0"' if pivot_table[:visual_totals] == false
-        pt_attrs << ' printDrill="1"' if pivot_table[:print_drill]
-        pt_attrs << %( createdVersion="#{pivot_table[:created_version]}") if pivot_table[:created_version]
-        pt_attrs << %( updatedVersion="#{pivot_table[:updated_version]}") if pivot_table[:updated_version]
-        pt_attrs << %( minRefreshableVersion="#{pivot_table[:min_refreshable_version]}") if pivot_table[:min_refreshable_version]
-        anf = pivot_table.fetch(:apply_number_formats, false)
-        abf = pivot_table.fetch(:apply_border_formats, false)
-        aff = pivot_table.fetch(:apply_font_formats, false)
-        apf = pivot_table.fetch(:apply_pattern_formats, false)
-        aaf = pivot_table.fetch(:apply_alignment_formats, false)
-        awf = pivot_table.fetch(:apply_width_height_formats, true)
-        pt_attrs << %( applyNumberFormats="#{anf ? 1 : 0}")
-        pt_attrs << %( applyBorderFormats="#{abf ? 1 : 0}")
-        pt_attrs << %( applyFontFormats="#{aff ? 1 : 0}")
-        pt_attrs << %( applyPatternFormats="#{apf ? 1 : 0}")
-        pt_attrs << %( applyAlignmentFormats="#{aaf ? 1 : 0}")
-        pt_attrs << %( applyWidthHeightFormats="#{awf ? 1 : 0}")
-        pt_attrs << ' multipleFieldFilters="0"' if pivot_table[:multiple_field_filters] == false
-        pt_attrs << ' showDrill="0"' if pivot_table[:show_drill] == false
-        pt_attrs << ' showDataTips="0"' if pivot_table[:show_data_tips] == false
-        pt_attrs << ' enableDrill="0"' if pivot_table[:enable_drill] == false
-        pt_attrs << ' showMemberPropertyTips="0"' if pivot_table[:show_member_property_tips] == false
-        pt_attrs << ' itemPrintTitles="1"' if pivot_table[:item_print_titles]
-        pt_attrs << ' fieldPrintTitles="1"' if pivot_table[:field_print_titles]
-        pt_attrs << ' preserveFormatting="0"' if pivot_table[:preserve_formatting] == false
-        pt_attrs << ' pageOverThenDown="1"' if pivot_table[:page_over_then_down]
-        pt_attrs << %( pageWrap="#{pivot_table[:page_wrap]}") if pivot_table[:page_wrap]
-        parts = [
-          XML_HEADER,
-          "<pivotTableDefinition#{pt_attrs}>"
-        ]
-
-        # Compute field count from source range or explicit field_names.
-        field_count = if pivot_table[:field_names]
-                        pivot_table[:field_names].size
-                      else
-                        (pivot_table[:row_fields].size + pivot_table[:col_fields].size + pivot_table[:data_fields].size).clamp(1, 100)
-                      end
-        loc_attrs = %(<location ref="#{pivot_table[:dest_ref]}" firstHeaderRow="1" firstDataRow="1" firstDataCol="1")
-        loc_attrs << %( rowPageCount="#{pivot_table[:row_page_count]}") if pivot_table[:row_page_count]
-        loc_attrs << %( colPageCount="#{pivot_table[:col_page_count]}") if pivot_table[:col_page_count]
-        loc_attrs << "/>"
-        parts << loc_attrs
-        parts << %(<pivotFields count="#{field_count}">)
-        field_count.times do |fi|
-          attrs = +""
-          if pivot_table[:row_fields].include?(fi)
-            attrs << ' axis="axisRow"'
-          elsif pivot_table[:col_fields].include?(fi)
-            attrs << ' axis="axisCol"'
-          end
-          attrs << ' dataField="1"' if pivot_table[:data_fields].any? { |df| df[:fld] == fi }
-          fa = pivot_table[:field_attrs] && pivot_table[:field_attrs][fi]
-          attrs << %( compact="#{fa[:compact] ? "1" : "0"}") if fa && !fa[:compact].nil?
-          attrs << %( outline="#{fa[:outline] ? "1" : "0"}") if fa && !fa[:outline].nil?
-          attrs << %( subtotalTop="#{fa[:subtotal_top] ? "1" : "0"}") if fa && !fa[:subtotal_top].nil?
-          attrs << %( showAll="#{fa && fa[:show_all] == true ? "1" : "0"}")
-          attrs << %( numFmtId="#{fa[:num_fmt_id]}") if fa && fa[:num_fmt_id]
-          attrs << %( sortType="#{xml_escape(fa[:sort_type])}") if fa && fa[:sort_type]
-          attrs << ' defaultSubtotal="0"' if fa && fa[:default_subtotal] == false
-          attrs << ' insertBlankRow="1"' if fa && fa[:insert_blank_row]
-          attrs << ' insertPageBreak="1"' if fa && fa[:insert_page_break]
-          attrs << ' includeNewItemsInFilter="1"' if fa && fa[:include_new_items_in_filter]
-
-          field_items = pivot_table[:items] && pivot_table[:items][fi]
-          if field_items
-            parts << "<pivotField#{attrs}>"
-            parts << %(<items count="#{field_items.size + 1}">)
-            field_items.size.times { |ix| parts << %(<item x="#{ix}"/>) }
-            parts << '<item t="default"/>'
-            parts << "</items>"
-            parts << "</pivotField>"
-          else
-            parts << "<pivotField#{attrs}/>"
-          end
-        end
-        parts << "</pivotFields>"
-
-        unless pivot_table[:row_fields].empty?
-          parts << %(<rowFields count="#{pivot_table[:row_fields].size}">)
-          pivot_table[:row_fields].each { |f| parts << %(<field x="#{f}"/>) }
-          parts << "</rowFields>"
-        end
-
-        unless pivot_table[:col_fields].empty?
-          parts << %(<colFields count="#{pivot_table[:col_fields].size}">)
-          pivot_table[:col_fields].each { |f| parts << %(<field x="#{f}"/>) }
-          parts << "</colFields>"
-        end
-
-        unless pivot_table[:data_fields].empty?
-          parts << %(<dataFields count="#{pivot_table[:data_fields].size}">)
-          pivot_table[:data_fields].each do |df|
-            df_attrs = %( name="#{xml_escape(df[:name])}" fld="#{df[:fld]}" subtotal="#{df[:subtotal] || "sum"}")
-            df_attrs << %( showDataAs="#{xml_escape(df[:show_data_as])}") if df[:show_data_as]
-            df_attrs << %( baseField="#{df[:base_field]}") if df[:base_field]
-            df_attrs << %( baseItem="#{df[:base_item]}") if df[:base_item]
-            df_attrs << %( numFmtId="#{df[:num_fmt_id]}") if df[:num_fmt_id]
-            parts << "<dataField#{df_attrs}/>"
-          end
-          parts << "</dataFields>"
-        end
-
-        if pivot_table[:pivot_table_style]
-          psi = pivot_table[:pivot_table_style]
-          psi_attrs = +""
-          psi_attrs << %( name="#{xml_escape(psi[:name])}") if psi[:name]
-          psi_attrs << %( showRowHeaders="#{psi[:show_row_headers] ? "1" : "0"}") unless psi[:show_row_headers].nil?
-          psi_attrs << %( showColHeaders="#{psi[:show_col_headers] ? "1" : "0"}") unless psi[:show_col_headers].nil?
-          psi_attrs << %( showRowStripes="#{psi[:show_row_stripes] ? "1" : "0"}") unless psi[:show_row_stripes].nil?
-          psi_attrs << %( showColStripes="#{psi[:show_col_stripes] ? "1" : "0"}") unless psi[:show_col_stripes].nil?
-          psi_attrs << %( showLastColumn="#{psi[:show_last_column] ? "1" : "0"}") unless psi[:show_last_column].nil?
-          parts << "<pivotTableStyleInfo#{psi_attrs}/>"
-        end
-
-        parts << "</pivotTableDefinition>"
-        parts.join
-      end
-
-      # : (untyped pivot_table, untyped _cache_id) -> untyped
-      def generate_pivot_cache_definition_xml(pivot_table, _cache_id)
-        pcd_attrs = %( xmlns="#{SSML_NS}" xmlns:r="#{DOC_REL_NS}" r:id="rId1" refreshOnLoad="1")
-        pcd_attrs << ' saveData="0"' if pivot_table[:cache_save_data] == false
-        pcd_attrs << ' enableRefresh="0"' if pivot_table[:cache_enable_refresh] == false
-        pcd_attrs << %( refreshedBy="#{xml_escape(pivot_table[:cache_refreshed_by])}") if pivot_table[:cache_refreshed_by]
-        pcd_attrs << %( refreshedVersion="#{pivot_table[:cache_refreshed_version]}") if pivot_table[:cache_refreshed_version]
-        pcd_attrs << %( createdVersion="#{pivot_table[:cache_created_version]}") if pivot_table[:cache_created_version]
-        pcd_attrs << %( recordCount="#{pivot_table[:cache_record_count]}") if pivot_table[:cache_record_count]
-        pcd_attrs << ' optimizeMemory="1"' if pivot_table[:cache_optimize_memory]
-        parts = [
-          XML_HEADER,
-          "<pivotCacheDefinition#{pcd_attrs}>"
-        ]
-
-        # Parse source ref: "Sheet1!A1:C4" => sheet name + range.
-        source = pivot_table[:source_ref]
-        ws_name_attr = pivot_table[:source_name] ? %( name="#{xml_escape(pivot_table[:source_name])}") : ""
-        if source.include?("!")
-          sname, srange = source.split("!", 2)
-          sname = sname.delete("'")
-          parts << %(<cacheSource type="worksheet"><worksheetSource ref="#{srange}" sheet="#{xml_escape(sname)}"#{ws_name_attr}/></cacheSource>)
-        else
-          parts << %(<cacheSource type="worksheet"><worksheetSource ref="#{source}"#{ws_name_attr}/></cacheSource>)
-        end
-
-        field_count = pivot_table[:field_names] ? pivot_table[:field_names].size : (pivot_table[:row_fields].size + pivot_table[:col_fields].size + pivot_table[:data_fields].size)
-        parts << %(<cacheFields count="#{field_count}">)
-        field_count.times do |fi|
-          fname = if pivot_table[:field_names] && pivot_table[:field_names][fi]
-                    pivot_table[:field_names][fi]
-                  else
-                    df = pivot_table[:data_fields].find { |d| d[:fld] == fi }
-                    df ? df[:name] : "Field#{fi + 1}"
-                  end
-          fa = pivot_table[:field_attrs] && pivot_table[:field_attrs][fi]
-          cf_num_fmt = (fa && fa[:cache_num_fmt_id]) || 0
-          cf_attrs = %( name="#{xml_escape(fname)}" numFmtId="#{cf_num_fmt}")
-          cf_attrs << %( caption="#{xml_escape(fa[:cache_caption])}") if fa && fa[:cache_caption]
-          cf_attrs << %( formula="#{xml_escape(fa[:cache_formula])}") if fa && fa[:cache_formula]
-          field_items = pivot_table[:items] && pivot_table[:items][fi]
-          if field_items
-            parts << "<cacheField#{cf_attrs}>"
-            parts << %(<sharedItems count="#{field_items.size}">)
-            field_items.each { |v| parts << %(<s v="#{xml_escape(v.to_s)}"/>) }
-            parts << "</sharedItems>"
-            parts << "</cacheField>"
-          else
-            parts << "<cacheField#{cf_attrs}><sharedItems/></cacheField>"
-          end
-        end
-        parts << "</cacheFields>"
-        parts << "</pivotCacheDefinition>"
-        parts.join
-      end
-
-      # : (untyped pivot_table) -> untyped
-      def generate_pivot_cache_records_xml(pivot_table)
-        items = pivot_table[:items]
-        if items&.values&.any? { |v| v && !v.empty? }
-          max_len = items.values.map { |v| v ? v.size : 0 }.max
-          parts = [XML_HEADER, %(<pivotCacheRecords xmlns="#{SSML_NS}" count="#{max_len}">)]
-          max_len.times do |ri|
-            parts << "<r>"
-            field_count = pivot_table[:field_names] ? pivot_table[:field_names].size : (pivot_table[:row_fields].size + pivot_table[:col_fields].size + pivot_table[:data_fields].size)
-            field_count.times do |fi|
-              field_items = items[fi]
-              parts << if field_items
-                         %(<x v="#{ri < field_items.size ? ri : 0}"/>)
-                       else
-                         %(<n v="0"/>)
-                       end
-            end
-            parts << "</r>"
-          end
-          parts << "</pivotCacheRecords>"
-          parts.join
-        else
-          [XML_HEADER, %(<pivotCacheRecords xmlns="#{SSML_NS}" count="0"/>)].join
-        end
-      end
-
-      # : (untyped cache_id) -> untyped
-      def generate_pivot_cache_rels(cache_id)
-        [
-          XML_HEADER,
-          %(<Relationships xmlns="#{REL_NS}">),
-          %(<Relationship Id="rId1" Type="#{DOC_REL_NS}/pivotCacheRecords" Target="pivotCacheRecords#{cache_id}.xml"/>),
-          "</Relationships>"
-        ].join
-      end
-
-      # : (untyped cache_id) -> untyped
-      def generate_pivot_table_rels(cache_id)
-        [
-          XML_HEADER,
-          %(<Relationships xmlns="#{REL_NS}">),
-          %(<Relationship Id="rId1" Type="#{DOC_REL_NS}/pivotCacheDefinition" Target="../pivotCache/pivotCacheDefinition#{cache_id}.xml"/>),
-          "</Relationships>"
-        ].join
-      end
-
-      # : (untyped ext_link) -> untyped
-      def generate_external_link_xml(ext_link)
-        parts = [
-          XML_HEADER,
-          %(<externalLink xmlns="#{SSML_NS}" xmlns:r="#{DOC_REL_NS}">),
-          '<externalBook r:id="rId1">'
-        ]
-        unless ext_link[:sheet_names].empty?
-          parts << "<sheetNames>"
-          ext_link[:sheet_names].each { |sn| parts << %(<sheetName val="#{xml_escape(sn)}"/>) }
-          parts << "</sheetNames>"
-        end
-        parts << "</externalBook>"
-        parts << "</externalLink>"
-        parts.join
-      end
-
-      # : (untyped ext_link) -> untyped
-      def generate_external_link_rels(ext_link)
-        [
-          XML_HEADER,
-          %(<Relationships xmlns="#{REL_NS}">),
-          %(<Relationship Id="rId1" Type="#{DOC_REL_NS}/externalLinkPath" Target="#{xml_escape(ext_link[:target])}" TargetMode="External"/>),
-          "</Relationships>"
-        ].join
-      end
-
-      # : (untyped ct_xml) -> untyped
-      def parse_extra_content_types(ct_xml)
-        ct_xml.scan(/<Default\s+Extension="([^"]+)"\s+ContentType="([^"]+)"/).each do |ext, ct|
-          @extra_ct_defaults[ext] ||= ct
-        end
-        ct_xml.scan(/<Override\s+PartName="([^"]+)"\s+ContentType="([^"]+)"/).each do |pn, ct|
-          @extra_ct_overrides[pn] ||= ct
-        end
-      end
-
-      # : (untyped element, untyped opts) -> ("" | ::String)
-      def build_line_end_xml(element, opts)
-        return "" unless opts
-
-        attrs = +""
-        attrs << %( type="#{xml_escape(opts[:type])}") if opts[:type]
-        attrs << %( w="#{xml_escape(opts[:w])}") if opts[:w]
-        attrs << %( len="#{xml_escape(opts[:len])}") if opts[:len]
-        "<a:#{element}#{attrs}/>"
-      end
-
-      # : (untyped value) -> untyped
-      def xml_escape(value)
-        value.to_s
-             .gsub(/[^\x09\x0A\x0D\x20-\uD7FF\uE000-\uFFFD\u{10000}-\u{10FFFF}]/, "")
-             .gsub("&", "&amp;")
-             .gsub("<", "&lt;")
-             .gsub(">", "&gt;")
-             .gsub('"', "&quot;")
-             .gsub("'", "&apos;")
-      end
-
-      # : (untyped rich_text) -> untyped
-      def rich_text_xml(rich_text)
-        rich_text.runs.map do |run|
-          font = run[:font]
-          if font && !font.empty?
-            rpr = +""
-            rpr << "<b/>" if font[:bold]
-            rpr << "<i/>" if font[:italic]
-            rpr << "<strike/>" if font[:strike]
-            if font[:underline]
-              rpr << if font[:underline] == true
-                       "<u/>"
-                     else
-                       %(<u val="#{font[:underline]}"/>)
-                     end
-            end
-            rpr << %(<vertAlign val="#{font[:vert_align]}"/>) if font[:vert_align]
-            rpr << %(<sz val="#{font[:sz]}"/>) if font[:sz]
-            rpr << emit_color_xml(font)
-            rpr << %(<rFont val="#{xml_escape(font[:name])}"/>) if font[:name]
-            rpr << %(<family val="#{font[:family]}"/>) if font[:family]
-            rpr << %(<scheme val="#{font[:scheme]}"/>) if font[:scheme]
-            "<r><rPr>#{rpr}</rPr><t>#{xml_escape(run[:text])}</t></r>"
-          else
-            "<r><t>#{xml_escape(run[:text])}</t></r>"
-          end
-        end.join
-      end
-
-      # : (untyped cell_ref, untyped value, untyped style_idx, ?untyped? sst, ?ph: untyped?) -> untyped
-      def cell_xml(cell_ref, value, style_idx, sst = nil, ph: nil) # rubocop:disable Naming/MethodParameterName
-        s_attr = style_idx ? %( s="#{style_idx}") : ""
-        ph_attr = ph ? ' ph="1"' : ""
-        case value
-        when Xlsxrb::Elements::CellError
-          %(<c r="#{cell_ref}" t="e"#{s_attr}#{ph_attr}><v>#{xml_escape(value.code)}</v></c>)
-        when Xlsxrb::Elements::Formula
-          f_attrs = +""
-          case value.type
-          when :shared
-            f_attrs << %( t="shared" si="#{value.shared_index}")
-            f_attrs << %( ref="#{value.ref}") if value.ref
-          when :array
-            f_attrs << %( t="array" ref="#{value.ref}") if value.ref
-          when :data_table
-            f_attrs << ' t="dataTable"'
-            f_attrs << ' dt2D="1"' if value.dt2d
-            f_attrs << ' dtr="1"' if value.dtr
-            f_attrs << %( r1="#{value.r1}") if value.r1
-            f_attrs << %( r2="#{value.r2}") if value.r2
-          end
-          f_attrs << ' ca="1"' if value.calculate_always
-          f_attrs << ' aca="1"' if value.aca
-          f_attrs << ' bx="1"' if value.bx
-          t_attr = ""
-          cached_val_str = value.cached_value.to_s
-          case value.cached_value
-          when String
-            t_attr = ' t="str"'
-          when true
-            t_attr = ' t="b"'
-            cached_val_str = "1"
-          when false
-            t_attr = ' t="b"'
-            cached_val_str = "0"
-          end
-          parts = %(<c r="#{cell_ref}"#{t_attr}#{s_attr}#{ph_attr}><f#{f_attrs}>#{xml_escape(value.expression)}</f>)
-          parts << "<v>#{xml_escape(cached_val_str)}</v>" unless value.cached_value.nil?
-          parts << "</c>"
-          parts
-        when Xlsxrb::Elements::RichText
-          if sst
-            rt_sst, = sst
-            idx = rt_sst[value]
-            %(<c r="#{cell_ref}" t="s"#{s_attr}#{ph_attr}><v>#{idx}</v></c>)
-          else
-            %(<c r="#{cell_ref}" t="inlineStr"#{s_attr}#{ph_attr}><is>#{rich_text_xml(value)}</is></c>)
-          end
-        when true, false
-          %(<c r="#{cell_ref}" t="b"#{s_attr}#{ph_attr}><v>#{value ? 1 : 0}</v></c>)
-        when Time
-          serial = Xlsxrb::Ooxml::Utils.datetime_to_serial(value)
-          dt_attr = s_attr.empty? && (dt_style = resolve_style_index(datetime_num_fmt_id)) ? %( s="#{dt_style}") : s_attr
-          %(<c r="#{cell_ref}"#{dt_attr}#{ph_attr}><v>#{serial}</v></c>)
-        when Date
-          serial = Xlsxrb::Ooxml::Utils.date_to_serial(value)
-          ds_attr = s_attr.empty? && (date_style = resolve_style_index(date_num_fmt_id)) ? %( s="#{date_style}") : s_attr
-          %(<c r="#{cell_ref}"#{ds_attr}#{ph_attr}><v>#{serial}</v></c>)
-        when Numeric
-          %(<c r="#{cell_ref}"#{s_attr}#{ph_attr}><v>#{value}</v></c>)
-        else
-          if sst
-            _, str_sst = sst
-            idx = str_sst[value.to_s]
-            %(<c r="#{cell_ref}" t="s"#{s_attr}#{ph_attr}><v>#{idx}</v></c>)
-          else
-            %(<c r="#{cell_ref}" t="inlineStr"#{s_attr}#{ph_attr}><is><t>#{xml_escape(value)}</t></is></c>)
-          end
-        end
-      end
-
-      # Returns the numFmtId for dates, registering it on first use.
-      # : () -> untyped
-      def date_num_fmt_id
-        @date_num_fmt_id ||= add_number_format(Xlsxrb::Ooxml::Utils::DEFAULT_DATE_FORMAT)
-      end
-
-      # Returns the numFmtId for datetime, registering it on first use.
-      # : () -> untyped
-      def datetime_num_fmt_id
-        @datetime_num_fmt_id ||= add_number_format(Xlsxrb::Ooxml::Utils::DEFAULT_DATETIME_FORMAT)
-      end
-
-      # Maps a numFmtId to a cellXfs index. Index 0 is the default (no format).
-      # : (untyped style_value) -> (nil | untyped)
-      def resolve_style_index(style_value)
-        return nil if style_value.nil?
-
-        # New-style: { xf_index: N } from set_cell_style.
-        return style_value[:xf_index] if style_value.is_a?(Hash) && style_value.key?(:xf_index)
-
-        # Legacy: raw num_fmt_id from set_cell_format — find or create matching xf entry.
-        num_fmt_id = style_value
-        @xf_index_map ||= begin
-          map = {}
-          @num_fmts.each_with_index do |nf, _i|
-            entry = { num_fmt_id: nf[:num_fmt_id], font_id: 0, fill_id: 0, border_id: 0 }
-            idx = @xf_entries.index(entry)
-            unless idx
-              @xf_entries << entry
-              idx = @xf_entries.size - 1
-            end
-            map[nf[:num_fmt_id]] = idx
-          end
-          map
-        end
-        @xf_index_map[num_fmt_id]
-      end
-
-      # : (untyped filter) -> untyped
-      def emit_filter_xml(filter)
-        case filter[:type]
-        when :filters
-          attrs = filter[:blank] ? +' blank="1"' : +""
-          attrs << %( calendarType="#{filter[:calendar_type]}") if filter[:calendar_type]
-          has_values = filter[:values]&.any?
-          has_date_groups = filter[:date_group_items]&.any?
-          if has_values || has_date_groups
-            parts = ["<filters#{attrs}>"]
-            filter[:values]&.each { |v| parts << %(<filter val="#{xml_escape(v)}"/>) }
-            filter[:date_group_items]&.each do |dg|
-              dg_attrs = %(dateTimeGrouping="#{dg[:date_time_grouping]}")
-              dg_attrs << %( year="#{dg[:year]}") if dg[:year]
-              dg_attrs << %( month="#{dg[:month]}") if dg[:month]
-              dg_attrs << %( day="#{dg[:day]}") if dg[:day]
-              dg_attrs << %( hour="#{dg[:hour]}") if dg[:hour]
-              dg_attrs << %( minute="#{dg[:minute]}") if dg[:minute]
-              dg_attrs << %( second="#{dg[:second]}") if dg[:second]
-              parts << "<dateGroupItem #{dg_attrs}/>"
-            end
-            parts << "</filters>"
-            parts.join
-          else
-            "<filters#{attrs}/>"
-          end
-        when :custom
-          if filter[:filters]
-            and_attr = filter[:and] ? ' and="1"' : ""
-            parts = ["<customFilters#{and_attr}>"]
-            filter[:filters].each do |cf|
-              parts << %(<customFilter operator="#{cf[:operator]}" val="#{xml_escape(cf[:val])}"/>)
-            end
-            parts << "</customFilters>"
-            parts.join
-          else
-            %(<customFilters><customFilter operator="#{filter[:operator]}" val="#{xml_escape(filter[:val])}"/></customFilters>)
-          end
-        when :dynamic
-          dyn_attrs = %( type="#{filter[:dynamic_type]}")
-          dyn_attrs << %( val="#{filter[:val]}") if filter[:val]
-          dyn_attrs << %( valIso="#{filter[:val_iso]}") if filter[:val_iso]
-          dyn_attrs << %( maxVal="#{filter[:max_val]}") if filter[:max_val]
-          dyn_attrs << %( maxValIso="#{filter[:max_val_iso]}") if filter[:max_val_iso]
-          "<dynamicFilter#{dyn_attrs}/>"
-        when :top10
-          top_attr = filter[:top] ? ' top="1"' : ""
-          pct_attr = filter[:percent] ? ' percent="1"' : ""
-          fv_attr = filter[:filter_val] ? %( filterVal="#{filter[:filter_val]}") : ""
-          %(<top10#{top_attr}#{pct_attr} val="#{filter[:val]}"#{fv_attr}/>)
-        when :color_filter
-          cf_attrs = %(dxfId="#{filter[:dxf_id]}")
-          cf_attrs << ' cellColor="0"' if filter[:cell_color] == false
-          %(<colorFilter #{cf_attrs}/>)
-        when :icon_filter
-          if_attrs = %(iconSet="#{filter[:icon_set]}")
-          if_attrs << %( iconId="#{filter[:icon_id]}") if filter[:icon_id]
-          %(<iconFilter #{if_attrs}/>)
-        else
-          ""
-        end
-      end
-
-      # : (untyped parts, untyped rule) -> untyped
-      def emit_cf_rule(parts, rule)
-        type = rule[:type]
-        if type.is_a?(String) || type.is_a?(Symbol)
-          t_str = type.to_s
-          snake = t_str.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
-                       .gsub(/([a-z\d])([A-Z])/, '\1_\2')
-                       .downcase.to_sym
-          type = snake if CF_TYPE_MAP.key?(snake)
-        end
-        rule_type = CF_TYPE_MAP[type] || type.to_s
-        rule_attrs = %(type="#{rule_type}")
-        rule_attrs << %( priority="#{rule[:priority]}") if rule[:priority]
-        rule_attrs << %( operator="#{rule[:operator]}") if rule[:operator]
-        rule_attrs << %( dxfId="#{rule[:format_id]}") if rule[:format_id]
-        rule_attrs << %( stopIfTrue="1") if rule[:stop_if_true]
-        rule_attrs << %( aboveAverage="0") if rule[:above_average] == false
-        rule_attrs << %( equalAverage="1") if rule[:equal_average]
-        rule_attrs << %( rank="#{rule[:rank]}") if rule[:rank]
-        rule_attrs << %( percent="1") if rule[:percent]
-        rule_attrs << %( bottom="1") if rule[:bottom]
-        rule_attrs << %( text="#{xml_escape(rule[:text])}") if rule[:text]
-        rule_attrs << %( timePeriod="#{rule[:time_period]}") if rule[:time_period]
-        rule_attrs << %( stdDev="#{rule[:std_dev]}") if rule[:std_dev]
-
-        case type
-        when :cell_is, :expression, :above_average, :top10, :duplicate_values, :unique_values,
-             :contains_text, :not_contains_text, :begins_with, :ends_with,
-             :contains_blanks, :not_contains_blanks, :time_period
-          formulas = rule[:formulas] || [rule[:formula]].compact
-          if formulas.empty?
-            parts << "<cfRule #{rule_attrs}/>"
-          else
-            parts << "<cfRule #{rule_attrs}>"
-            formulas.each { |f| parts << "<formula>#{xml_escape(f)}</formula>" }
-            parts << "</cfRule>"
-          end
-        when :color_scale
-          cs = rule[:color_scale]
-          parts << "<cfRule #{rule_attrs}>"
-          parts << "<colorScale>"
-          cs[:cfvo]&.each do |cfvo|
-            cfvo_attrs = %(type="#{cfvo[:type]}")
-            cfvo_attrs << %( val="#{cfvo[:val]}") if cfvo[:val]
-            cfvo_attrs << ' gte="0"' if cfvo[:gte] == false
-            parts << "<cfvo #{cfvo_attrs}/>"
-          end
-          cs[:colors]&.each { |c| parts << emit_cf_color_xml(c) }
-          parts << "</colorScale>"
-          parts << "</cfRule>"
-        when :data_bar
-          db = rule[:data_bar]
-          parts << "<cfRule #{rule_attrs}>"
-          db_attrs = +""
-          db_attrs << %( minLength="#{db[:min_length]}") if db[:min_length]
-          db_attrs << %( maxLength="#{db[:max_length]}") if db[:max_length]
-          db_attrs << %( showValue="#{db[:show_value] ? 1 : 0}") unless db[:show_value].nil?
-          parts << "<dataBar#{db_attrs}>"
-          db[:cfvo]&.each do |cfvo|
-            cfvo_attrs = %(type="#{cfvo[:type]}")
-            cfvo_attrs << %( val="#{cfvo[:val]}") if cfvo[:val]
-            cfvo_attrs << ' gte="0"' if cfvo[:gte] == false
-            parts << "<cfvo #{cfvo_attrs}/>"
-          end
-          parts << emit_cf_color_xml(db[:color]) if db[:color]
-          parts << "</dataBar>"
-          parts << "</cfRule>"
-        when :icon_set
-          is = rule[:icon_set]
-          parts << "<cfRule #{rule_attrs}>"
-          is_attrs = +""
-          is_attrs << %( iconSet="#{is[:icon_set]}") if is[:icon_set]
-          is_attrs << %( reverse="#{is[:reverse] ? 1 : 0}") unless is[:reverse].nil?
-          is_attrs << %( percent="#{is[:percent] ? 1 : 0}") unless is[:percent].nil?
-          is_attrs << %( showValue="#{is[:show_value] ? 1 : 0}") unless is[:show_value].nil?
-          parts << "<iconSet#{is_attrs}>"
-          is[:cfvo]&.each do |cfvo|
-            cfvo_attrs = %(type="#{cfvo[:type]}")
-            cfvo_attrs << %( val="#{cfvo[:val]}") if cfvo[:val]
-            cfvo_attrs << ' gte="0"' if cfvo[:gte] == false
-            parts << "<cfvo #{cfvo_attrs}/>"
-          end
-          parts << "</iconSet>"
-          parts << "</cfRule>"
-        else
-          parts << "<cfRule #{rule_attrs}/>"
-        end
-      end
-
-      # Emits a <color> element for CF rules, accepting either a plain RGB string or a hash.
-      # : (untyped color) -> (untyped | ::String)
-      def emit_cf_color_xml(color)
-        if color.is_a?(Hash)
-          emit_color_xml(color)
-        else
-          %(<color rgb="#{color}"/>)
-        end
-      end
-
-      # : (untyped sheet_cells) -> ("A1" | ::String)
-      def compute_dimension(sheet_cells)
-        return "A1" if sheet_cells.empty?
-
-        min_col = Float::INFINITY
-        max_col = 0
-        min_row = Float::INFINITY
-        max_row = 0
-        sheet_cells.each_key do |addr|
-          col_letter = extract_column_letter(addr)
-          row_num = extract_row_number(addr)
-          col_idx = column_letter_to_index(col_letter)
-          min_col = col_idx if col_idx < min_col
-          max_col = col_idx if col_idx > max_col
-          min_row = row_num if row_num < min_row
-          max_row = row_num if row_num > max_row
-        end
-        start_col = index_to_column_letter(min_col)
-        end_col = index_to_column_letter(max_col)
-        "#{start_col}#{min_row}:#{end_col}#{max_row}"
-      end
-
-      # : (untyped index) -> untyped
-      def index_to_column_letter(index)
-        result = +""
-        while index.positive?
-          index -= 1
-          result.prepend(("A".ord + (index % 26)).chr)
-          index /= 26
-        end
-        result
-      end
-
-      # : () -> untyped
-      def generate_core_properties_xml
-        parts = [
-          XML_HEADER,
-          %(<cp:coreProperties xmlns:cp="#{CP_NS}" xmlns:dc="#{DC_NS}" xmlns:dcterms="#{DCTERMS_NS}" xmlns:xsi="#{XSI_NS}">)
-        ]
-        parts << "<dc:title>#{xml_escape(@core_properties[:title])}</dc:title>" if @core_properties[:title]
-        parts << "<dc:subject>#{xml_escape(@core_properties[:subject])}</dc:subject>" if @core_properties[:subject]
-        parts << "<dc:creator>#{xml_escape(@core_properties[:creator])}</dc:creator>" if @core_properties[:creator]
-        parts << "<cp:keywords>#{xml_escape(@core_properties[:keywords])}</cp:keywords>" if @core_properties[:keywords]
-        parts << "<dc:description>#{xml_escape(@core_properties[:description])}</dc:description>" if @core_properties[:description]
-        parts << "<cp:lastModifiedBy>#{xml_escape(@core_properties[:last_modified_by])}</cp:lastModifiedBy>" if @core_properties[:last_modified_by]
-        parts << "<cp:revision>#{xml_escape(@core_properties[:revision])}</cp:revision>" if @core_properties[:revision]
-        parts << %(<dcterms:created xsi:type="dcterms:W3CDTF">#{xml_escape(@core_properties[:created])}</dcterms:created>) if @core_properties[:created]
-        parts << %(<dcterms:modified xsi:type="dcterms:W3CDTF">#{xml_escape(@core_properties[:modified])}</dcterms:modified>) if @core_properties[:modified]
-        parts << "<cp:category>#{xml_escape(@core_properties[:category])}</cp:category>" if @core_properties[:category]
-        parts << "<cp:contentStatus>#{xml_escape(@core_properties[:content_status])}</cp:contentStatus>" if @core_properties[:content_status]
-        parts << "<dc:language>#{xml_escape(@core_properties[:language])}</dc:language>" if @core_properties[:language]
-        parts << "</cp:coreProperties>"
-        parts.join
-      end
-
-      # : () -> untyped
-      def generate_app_properties_xml
-        parts = [
-          XML_HEADER,
-          %(<Properties xmlns="#{APP_NS}" xmlns:vt="#{VT_NS}">)
-        ]
-        parts << "<Application>#{xml_escape(@app_properties[:application])}</Application>" if @app_properties[:application]
-        parts << "<AppVersion>#{xml_escape(@app_properties[:app_version])}</AppVersion>" if @app_properties[:app_version]
-        if @app_properties[:heading_pairs] && @app_properties[:titles_of_parts]
-          hp = @app_properties[:heading_pairs]
-          tp = @app_properties[:titles_of_parts]
-          parts << "<HeadingPairs>"
-          parts << %(<vt:vector size="#{hp.size * 2}" baseType="variant">)
-          hp.each do |label, count|
-            parts << "<vt:variant><vt:lpstr>#{xml_escape(label)}</vt:lpstr></vt:variant>"
-            parts << "<vt:variant><vt:i4>#{count}</vt:i4></vt:variant>"
-          end
-          parts << "</vt:vector>"
-          parts << "</HeadingPairs>"
-          parts << "<TitlesOfParts>"
-          parts << %(<vt:vector size="#{tp.size}" baseType="lpstr">)
-          tp.each { |t| parts << "<vt:lpstr>#{xml_escape(t)}</vt:lpstr>" }
-          parts << "</vt:vector>"
-          parts << "</TitlesOfParts>"
-        end
-        parts << "</Properties>"
-        parts.join
-      end
-
-      # : () -> untyped
-      def generate_custom_properties_xml
-        custom_ns = "http://schemas.openxmlformats.org/officeDocument/2006/custom-properties"
-        parts = [
-          XML_HEADER,
-          %(<Properties xmlns="#{custom_ns}" xmlns:vt="#{VT_NS}">)
-        ]
-        @custom_properties.each_with_index do |prop, idx|
-          fmtid = "{D5CDD505-2E9C-101B-9397-08002B2CF9AE}"
-          pid = idx + 2 # pids start at 2
-          parts << %(<property fmtid="#{fmtid}" pid="#{pid}" name="#{xml_escape(prop[:name])}">)
-          parts << case prop[:type]
-                   when :number, :int, :i4
-                     "<vt:i4>#{prop[:value]}</vt:i4>"
-                   when :float, :r8
-                     "<vt:r8>#{prop[:value]}</vt:r8>"
-                   when :bool
-                     "<vt:bool>#{prop[:value] ? "true" : "false"}</vt:bool>"
-                   when :date, :filetime
-                     "<vt:filetime>#{prop[:value]}</vt:filetime>"
-                   else
-                     "<vt:lpwstr>#{xml_escape(prop[:value].to_s)}</vt:lpwstr>"
-                   end
-          parts << "</property>"
-        end
-        parts << "</Properties>"
-        parts.join
-      end
-
-      # : () -> untyped
-      def generate_styles_xml
-        parts = [
-          XML_HEADER,
-          %(<styleSheet xmlns="#{SSML_NS}">)
-        ]
-
-        # numFmts
-        unless @num_fmts.empty?
-          parts << %(<numFmts count="#{@num_fmts.size}">)
-          @num_fmts.each do |nf|
-            parts << %(<numFmt numFmtId="#{nf[:num_fmt_id]}" formatCode="#{xml_escape(nf[:format_code])}"/>)
-          end
-          parts << "</numFmts>"
-        end
-
-        # fonts
-        parts << %(<fonts count="#{@fonts.size}">)
-        @fonts.each { |f| parts << emit_font_xml(f) }
-        parts << "</fonts>"
-
-        # fills
-        parts << %(<fills count="#{@fills.size}">)
-        @fills.each { |f| parts << emit_fill_xml(f) }
-        parts << "</fills>"
-
-        # borders
-        parts << %(<borders count="#{@borders.size}">)
-        @borders.each { |b| parts << emit_border_xml(b) }
-        parts << "</borders>"
-
-        # cellStyleXfs
-        parts << %(<cellStyleXfs count="#{@cell_style_xfs.size}">)
-        @cell_style_xfs.each do |xf|
-          parts << %(<xf numFmtId="#{xf[:num_fmt_id]}" fontId="#{xf[:font_id]}" fillId="#{xf[:fill_id]}" borderId="#{xf[:border_id]}"/>)
-        end
-        parts << "</cellStyleXfs>"
-
-        # cellXfs
-        parts << %(<cellXfs count="#{@xf_entries.size}">)
-        @xf_entries.each do |xf|
-          apply_attrs = []
-          apply_attrs << ' applyNumberFormat="1"' if xf[:num_fmt_id].positive?
-          apply_attrs << ' applyFont="1"' if xf[:font_id].positive?
-          apply_attrs << ' applyFill="1"' if xf[:fill_id].positive?
-          apply_attrs << ' applyBorder="1"' if xf[:border_id].positive?
-          apply_attrs << ' applyAlignment="1"' if xf[:alignment]
-          apply_attrs << ' applyProtection="1"' if xf[:protection]
-          apply_attrs << ' quotePrefix="1"' if xf[:quote_prefix]
-          apply_attrs << ' pivotButton="1"' if xf[:pivot_button]
-          children = []
-          children << emit_alignment_xml(xf[:alignment]) if xf[:alignment]
-          children << emit_protection_xml(xf[:protection]) if xf[:protection]
-          xf_id = xf[:xf_id] || 0
-          parts << if children.any?
-                     %(<xf numFmtId="#{xf[:num_fmt_id]}" fontId="#{xf[:font_id]}" fillId="#{xf[:fill_id]}" borderId="#{xf[:border_id]}" xfId="#{xf_id}"#{apply_attrs.join}>#{children.join}</xf>)
-                   else
-                     %(<xf numFmtId="#{xf[:num_fmt_id]}" fontId="#{xf[:font_id]}" fillId="#{xf[:fill_id]}" borderId="#{xf[:border_id]}" xfId="#{xf_id}"#{apply_attrs.join}/>)
-                   end
-        end
-        parts << "</cellXfs>"
-
-        # cellStyles
-        parts << %(<cellStyles count="#{@cell_style_names.size}">)
-        @cell_style_names.each do |cs|
-          cs_attrs = %(name="#{xml_escape(cs[:name])}" xfId="#{cs[:xf_id]}")
-          cs_attrs << %( builtinId="#{cs[:builtin_id]}") if cs[:builtin_id]
-          cs_attrs << %( iLevel="#{cs[:i_level]}") if cs[:i_level]
-          cs_attrs << ' hidden="1"' if cs[:hidden]
-          cs_attrs << ' customBuiltin="1"' if cs[:custom_builtin]
-          parts << "<cellStyle #{cs_attrs}/>"
-        end
-        parts << "</cellStyles>"
-
-        # dxfs
-        unless @dxfs.empty?
-          parts << %(<dxfs count="#{@dxfs.size}">)
-          @dxfs.each { |d| parts << emit_dxf_xml(d) }
-          parts << "</dxfs>"
-        end
-
-        # tableStyles
-        ts_styles = @table_styles[:styles] || []
-        unless ts_styles.empty? && @table_styles[:default_table_style].nil? && @table_styles[:default_pivot_style].nil?
-          ts_attrs = [%(count="#{ts_styles.size}")]
-          ts_attrs << %(defaultTableStyle="#{xml_escape(@table_styles[:default_table_style])}") if @table_styles[:default_table_style]
-          ts_attrs << %(defaultPivotStyle="#{xml_escape(@table_styles[:default_pivot_style])}") if @table_styles[:default_pivot_style]
-          if ts_styles.empty?
-            parts << "<tableStyles #{ts_attrs.join(" ")}/>"
-          else
-            parts << "<tableStyles #{ts_attrs.join(" ")}>"
-            ts_styles.each do |ts|
-              s_attrs = [%(name="#{xml_escape(ts[:name])}")]
-              s_attrs << %(pivot="0") if ts[:pivot] == false
-              s_attrs << %(table="0") if ts[:table] == false
-              s_attrs << %(count="#{ts[:elements].size}") unless ts[:elements].empty?
-              if ts[:elements].empty?
-                parts << "<tableStyle #{s_attrs.join(" ")}/>"
-              else
-                parts << "<tableStyle #{s_attrs.join(" ")}>"
-                ts[:elements].each do |el|
-                  el_attrs = [%(type="#{el[:type]}")]
-                  el_attrs << %(size="#{el[:size]}") if el[:size] && el[:size] != 1
-                  el_attrs << %(dxfId="#{el[:dxf_id]}") if el[:dxf_id]
-                  parts << "<tableStyleElement #{el_attrs.join(" ")}/>"
-                end
-                parts << "</tableStyle>"
-              end
-            end
-            parts << "</tableStyles>"
-          end
-        end
-
-        # colors
-        unless @indexed_colors.empty? && @mru_colors.empty?
-          parts << "<colors>"
-          unless @indexed_colors.empty?
-            parts << "<indexedColors>"
-            @indexed_colors.each { |c| parts << %(<rgbColor rgb="#{c}"/>) }
-            parts << "</indexedColors>"
-          end
-          unless @mru_colors.empty?
-            parts << "<mruColors>"
-            @mru_colors.each { |c| parts << emit_color_xml(c) }
-            parts << "</mruColors>"
-          end
-          parts << "</colors>"
-        end
-
-        parts << "</styleSheet>"
-        parts.join
-      end
-
-      # : (untyped alignment) -> ::String
-      def emit_alignment_xml(alignment)
-        attrs = []
-        attrs << %(horizontal="#{alignment[:horizontal]}") if alignment[:horizontal]
-        attrs << %(vertical="#{alignment[:vertical]}") if alignment[:vertical]
-        attrs << %(wrapText="1") if alignment[:wrap_text]
-        attrs << %(textRotation="#{alignment[:text_rotation]}") if alignment[:text_rotation]
-        attrs << %(indent="#{alignment[:indent]}") if alignment[:indent]
-        attrs << %(relativeIndent="#{alignment[:relative_indent]}") if alignment[:relative_indent]
-        attrs << %(shrinkToFit="1") if alignment[:shrink_to_fit]
-        attrs << %(readingOrder="#{alignment[:reading_order]}") if alignment[:reading_order]
-        attrs << %(justifyLastLine="1") if alignment[:justify_last_line]
-        "<alignment #{attrs.join(" ")}/>"
-      end
-
-      # : (untyped protection) -> ::String
-      def emit_protection_xml(protection)
-        attrs = []
-        attrs << %(locked="#{protection[:locked] ? "1" : "0"}") unless protection[:locked].nil?
-        attrs << %(hidden="#{protection[:hidden] ? "1" : "0"}") unless protection[:hidden].nil?
-        "<protection #{attrs.join(" ")}/>"
-      end
-
-      # : (untyped source, ?tag: ::String) -> (::String | ::String | ::String | ::String | "")
-      def emit_color_xml(source, tag: "color")
-        if source[:auto]
-          %(<#{tag} auto="1"/>)
-        elsif source[:color] || source[:rgb]
-          %(<#{tag} rgb="#{source[:color] || source[:rgb]}"/>)
-        elsif source[:theme]
-          attrs = [%(theme="#{source[:theme]}")]
-          attrs << %(tint="#{source[:tint]}") if source[:tint]
-          %(<#{tag} #{attrs.join(" ")}/>)
-        elsif source[:indexed]
-          %(<#{tag} indexed="#{source[:indexed]}"/>)
-        else
-          ""
-        end
-      end
-
-      # : (untyped font) -> untyped
-      def emit_font_xml(font)
-        parts = ["<font>"]
-        parts << "<b/>" if font[:bold]
-        parts << "<i/>" if font[:italic]
-        parts << "<strike/>" if font[:strike]
-        parts << "<shadow/>" if font[:shadow]
-        parts << "<outline/>" if font[:outline]
-        parts << "<condense/>" if font[:condense]
-        parts << "<extend/>" if font[:extend]
-        if font[:underline]
-          parts << if font[:underline] == true
-                     "<u/>"
-                   else
-                     %(<u val="#{font[:underline]}"/>)
-                   end
-        end
-        parts << %(<vertAlign val="#{font[:vert_align]}"/>) if font[:vert_align]
-        parts << %(<sz val="#{font[:sz]}"/>) if font[:sz]
-        parts << emit_color_xml(font)
-        parts << %(<name val="#{xml_escape(font[:name])}"/>) if font[:name]
-        parts << %(<family val="#{font[:family]}"/>) if font[:family]
-        parts << %(<charset val="#{font[:charset]}"/>) if font[:charset]
-        parts << %(<scheme val="#{font[:scheme]}"/>) if font[:scheme]
-        parts << "</font>"
-        parts.join
-      end
-
-      # : (untyped fill) -> (untyped | ::String)
-      def emit_fill_xml(fill)
-        return emit_gradient_fill_xml(fill[:gradient]) if fill[:gradient]
-
-        has_fg = fill[:fg_color] || fill[:fg_color_theme] || fill[:fg_color_indexed] || fill[:fg_color_auto]
-        has_bg = fill[:bg_color] || fill[:bg_color_theme] || fill[:bg_color_indexed] || fill[:bg_color_auto]
-        return "<fill><patternFill patternType=\"#{fill[:pattern]}\"/></fill>" if fill[:pattern] && !has_fg && !has_bg
-
-        parts = ["<fill>"]
-        pt = fill[:pattern] || "solid"
-        parts << %(<patternFill patternType="#{pt}">)
-        parts << emit_fill_color_xml("fgColor", fill, :fg)
-        parts << emit_fill_color_xml("bgColor", fill, :bg)
-        parts << "</patternFill>"
-        parts << "</fill>"
-        parts.join
-      end
-
-      # : (untyped tag, untyped fill, untyped prefix) -> (::String | ::String | ::String | ::String | "")
-      def emit_fill_color_xml(tag, fill, prefix)
-        if fill[:"#{prefix}_color"]
-          %(<#{tag} rgb="#{fill[:"#{prefix}_color"]}"/>)
-        elsif fill[:"#{prefix}_color_theme"]
-          attrs = [%(theme="#{fill[:"#{prefix}_color_theme"]}")]
-          attrs << %(tint="#{fill[:"#{prefix}_color_tint"]}") if fill[:"#{prefix}_color_tint"]
-          %(<#{tag} #{attrs.join(" ")}/>)
-        elsif fill[:"#{prefix}_color_indexed"]
-          %(<#{tag} indexed="#{fill[:"#{prefix}_color_indexed"]}"/>)
-        elsif fill[:"#{prefix}_color_auto"]
-          %(<#{tag} auto="1"/>)
-        else
-          ""
-        end
-      end
-
-      # : (untyped gradient) -> untyped
-      def emit_gradient_fill_xml(gradient)
-        attrs = []
-        attrs << %(type="#{gradient[:type]}") if gradient[:type]
-        attrs << %(degree="#{gradient[:degree]}") if gradient[:degree]
-        attrs << %(left="#{gradient[:left]}") if gradient[:left]
-        attrs << %(right="#{gradient[:right]}") if gradient[:right]
-        attrs << %(top="#{gradient[:top]}") if gradient[:top]
-        attrs << %(bottom="#{gradient[:bottom]}") if gradient[:bottom]
-        parts = ["<fill>"]
-        parts << "<gradientFill#{" #{attrs.join(" ")}" unless attrs.empty?}"
-        if gradient[:stops]&.any?
-          parts[-1] = "#{parts[-1]}>"
-          gradient[:stops].each do |stop|
-            parts << %(<stop position="#{stop[:position]}">#{emit_color_xml(stop)}</stop>)
-          end
-          parts << "</gradientFill>"
-        else
-          parts[-1] = "#{parts[-1]}/>"
-        end
-        parts << "</fill>"
-        parts.join
-      end
-
-      # : (untyped brk, default_max: untyped) -> ::String
-      def emit_brk_xml(brk, default_max:)
-        if brk.is_a?(Hash)
-          attrs = %(id="#{brk[:id]}")
-          attrs << %( min="#{brk[:min]}") if brk[:min]
-          attrs << %( max="#{brk.fetch(:max, default_max)}")
-          attrs << ' man="1"' if brk.fetch(:man, true)
-          attrs << ' pt="1"' if brk[:pt]
-          "<brk #{attrs}/>"
-        else
-          %(<brk id="#{brk}" max="#{default_max}" man="1"/>)
-        end
-      end
-
-      # : (untyped bdr) -> untyped
-      def emit_border_xml(bdr)
-        border_attrs = []
-        border_attrs << ' diagonalUp="1"' if bdr[:diagonal_up]
-        border_attrs << ' diagonalDown="1"' if bdr[:diagonal_down]
-        border_attrs << ' outline="0"' if bdr[:outline] == false
-        parts = ["<border#{border_attrs.join}>"]
-        %i[left right top bottom diagonal vertical horizontal].each do |side|
-          s = bdr[side]
-          if s.is_a?(Hash)
-            parts << %(<#{side} style="#{s[:style]}">)
-            parts << emit_color_xml(s)
-            parts << "</#{side}>"
-          else
-            parts << "<#{side}/>"
-          end
-        end
-        parts << "</border>"
-        parts.join
-      end
-
-      # : (untyped dxf) -> untyped
-      def emit_dxf_xml(dxf)
-        parts = ["<dxf>"]
-        parts << emit_font_xml(dxf[:font]) if dxf[:font]
-        if dxf[:num_fmt]
-          nf = dxf[:num_fmt]
-          parts << %(<numFmt numFmtId="#{nf[:num_fmt_id]}" formatCode="#{xml_escape(nf[:format_code])}"/>)
-        end
-        parts << emit_fill_xml(dxf[:fill]) if dxf[:fill]
-        parts << emit_alignment_xml(dxf[:alignment]) if dxf[:alignment]
-        parts << emit_border_xml(dxf[:border]) if dxf[:border]
-        parts << emit_protection_xml(dxf[:protection]) if dxf[:protection]
-        parts << "</dxf>"
-        parts.join
-      end
-
-      # : (untyped cell_address) -> untyped
-      def validate_cell_address!(cell_address)
-        raise ArgumentError, "cell address must be a String" unless cell_address.is_a?(String)
-
-        match = cell_address.match(CELL_ADDRESS_PATTERN)
-        raise ArgumentError, "invalid cell address: #{cell_address.inspect}" unless match
-
-        row_num = match[2].to_i
-        raise ArgumentError, "row out of range: #{row_num}" unless row_num.between?(1, MAX_ROW)
-
-        col_index = column_letter_to_index(match[1])
-        raise ArgumentError, "column out of range: #{match[1]}" unless col_index.between?(1, MAX_COLUMN_INDEX)
-      end
-
-      # : (untyped letters) -> untyped
-      def column_letter_to_index(letters)
-        letters.chars.reduce(0) { |sum, char| (sum * 26) + (char.ord - "A".ord + 1) }
-      end
-
-      # Extracts the column letter(s) from a cell address, e.g. "A" from "A1".
-      # : (untyped cell_address) -> untyped
-      def extract_column_letter(cell_address)
-        cell_address.match(/^([A-Z]+)/)[1]
-      end
-
       # Extracts the row number from a cell address, e.g. 1 from "A1".
       # : (untyped cell_address) -> untyped
       def extract_row_number(cell_address)
@@ -5646,7 +3009,7 @@ module Xlsxrb
       # Converts a range like "A1:D20" to absolute "$A$1:$D$20".
       # : (untyped range) -> untyped
       def absolute_range(range)
-        range.split(":").map { |part| absolute_cell(part) }.join(":")
+        DslHelpers.absolute_range(range)
       end
 
       # Converts "A1" to "$A$1".