uniword 1.2.5 → 1.3.0

data/lib/uniword/docx/reconciler/package_structure.rb

@@ -7,34 +7,35 @@ module Uniword
       #
       # Rebuilds content types and relationships for standard parts,
       # preserving non-standard entries from the source document.
+      # All part metadata (paths, content types, rel types) comes from
+      # Ooxml::PartRegistry; this module only declares which parts go
+      # where, in which order.
       module PackageStructure
         # Relationship types for parts we don't model or serialize.
+        # Exception: stylesWithEffects is a Microsoft extension never
+        # written by uniword, so it is not in Ooxml::PartRegistry.
         UNSUPPORTED_REL_TYPES = Set[
           "http://schemas.microsoft.com/office/2007/relationships/stylesWithEffects",
         ].freeze
 
         # Rel types that belong in package-level _rels/.rels, not document.xml.rels.
-        PACKAGE_LEVEL_REL_TYPES = Set[
-          "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument",
-          "http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties",
-          "http://schemas.openxmlformats.org/officeDocument/2006/relationships/extended-properties",
-          "http://schemas.openxmlformats.org/officeDocument/2006/relationships/custom-properties",
-        ].freeze
+        PACKAGE_LEVEL_REL_TYPES =
+          Ooxml::PartRegistry.package_rel_types.to_set.freeze
+
+        # Standard package-level parts, in _rels/.rels emission order.
+        PACKAGE_REL_PARTS = %i[document core_properties app_properties].freeze
 
         def reconcile_content_types
           ct = package.content_types
           return unless ct
 
-          ct.defaults = [
+          ct.defaults = %i[rels xml].map do |key|
+            defn = Ooxml::PartRegistry.find_by_key(key)
             Uniword::ContentTypes::Default.new(
-              extension: "rels",
-              content_type: "application/vnd.openxmlformats-package.relationships+xml",
-            ),
-            Uniword::ContentTypes::Default.new(
-              extension: "xml",
-              content_type: "application/xml",
-            ),
-          ]
+              extension: defn.extension,
+              content_type: defn.content_type,
+            )
+          end
 
           standard = content_type_overrides_for_present_parts
           standard_parts = standard.to_set(&:part_name)
@@ -43,202 +44,170 @@ module Uniword
           end
 
           ct.overrides = standard + non_standard
-          record_fix(FixCodes::CONTENT_TYPES_ASSEMBLED, "Rebuilt content types for standard parts")
+          record_fix(FixCodes::CONTENT_TYPES_ASSEMBLED,
+                     "Rebuilt content types for standard parts",
+                     part: "[Content_Types].xml")
         end
 
         def reconcile_package_rels
           rels = package.package_rels
           return unless rels
 
-          base = "http://schemas.openxmlformats.org"
-          standard_defs = [
-            ["rId1",
-             "#{base}/officeDocument/2006/relationships/officeDocument",
-             "word/document.xml"],
-            ["rId2",
-             "#{base}/package/2006/relationships/metadata/core-properties",
-             "docProps/core.xml"],
-            ["rId3",
-             "#{base}/officeDocument/2006/relationships/extended-properties",
-             "docProps/app.xml"],
-          ]
-
-          standard_targets = standard_defs.to_set { |_, _, t| t }
-          standard_rids = standard_defs.to_set { |rid, _, _| rid }
-          non_standard = rels.relationships.reject do |r|
-            standard_targets.include?(r.target) || standard_rids.include?(r.id)
+          # Preserve-first: existing rels keep their position and rId;
+          # only genuinely missing standard parts are appended, with
+          # rIds allocated by the allocator (seeded from these rels).
+          # A later rel whose rId duplicates an already-kept one is
+          # dropped — duplicates are impossible by construction.
+          kept = []
+          seen_ids = Set.new
+          rels.relationships.each do |rel|
+            next if rel.id && seen_ids.include?(rel.id)
+
+            kept << rel
+            seen_ids << rel.id if rel.id
           end
 
-          existing_by_target = rels.relationships.to_h { |r| [r.target, r] }
-          standard = standard_defs.map do |rid, type, target|
-            existing = existing_by_target[target]
-            build_rel(existing ? existing.id : rid, type, target)
+          PACKAGE_REL_PARTS.each do |key|
+            defn = Ooxml::PartRegistry.find_by_key(key)
+            next if kept.any? { |r| r.target == defn.target }
+
+            kept << build_rel(
+              allocator.alloc_rid(target: defn.target, type: defn.rel_type,
+                                  scope: :package),
+              defn.rel_type, defn.target,
+            )
           end
 
-          rels.relationships = standard + non_standard
-          record_fix(FixCodes::RELATIONSHIPS_ASSEMBLED, "Rebuilt package relationships for standard parts")
+          rels.relationships = kept
+          record_fix(FixCodes::RELATIONSHIPS_ASSEMBLED,
+                     "Assembled package relationships (preserve-first)",
+                     part: "_rels/.rels")
         end
 
         def reconcile_document_rels
           rels = package.document_rels
           return unless rels
 
-          base = "http://schemas.openxmlformats.org/officeDocument/2006/relationships"
-          defs = [
-            ["styles", "styles.xml", package.styles],
-            ["settings", "settings.xml", package.settings],
-            ["webSettings", "webSettings.xml", package.web_settings],
-            ["fontTable", "fontTable.xml", package.font_table],
-            ["theme", "theme/theme1.xml", package.theme],
-            ["numbering", "numbering.xml", package.numbering],
-            ["footnotes", "footnotes.xml", package.footnotes],
-            ["endnotes", "endnotes.xml", package.endnotes],
-          ]
-
-          standard_targets = defs.filter_map { |_, target, obj| target if obj }.to_set
-
-          # If allocator is present, use it to build rels — preserves existing rIds
-          alloc = allocator
-          if alloc
-            reconcile_document_rels_from_allocator(rels, base, defs, standard_targets, alloc)
-          else
-            reconcile_document_rels_legacy(rels, base, defs, standard_targets)
-          end
+          assemble_document_rels(rels, document_rel_defs)
         end
 
         private
 
-        def reconcile_document_rels_from_allocator(rels, base, defs, standard_targets, alloc)
-          # Collect standard part rels from allocator
-          all_rels = []
-          defs.each do |suffix, target, obj|
-            next unless obj
-            r_id = alloc.rid_for(target: target, type: "#{base}/#{suffix}")
-            if r_id
-              all_rels << build_rel(r_id, "#{base}/#{suffix}", target)
-            else
-              all_rels << build_rel(
-                alloc.alloc_rid(target: target, type: "#{base}/#{suffix}"),
-                "#{base}/#{suffix}", target,
-              )
-            end
-          end
-
-          # Add allocator-managed rels (images, headers, footers, hyperlinks)
-          alloc.all_rels.each do |entry|
-            next if standard_targets.include?(entry[:target])
-            next if all_rels.any? { |r| r.target == entry[:target] }
-            next if unsupported_rel_type?(entry[:type])
-            next if package_level_rel?(entry[:type])
-            next unless header_footer_target_present?(entry[:target])
-
-            all_rels << build_rel(
-              entry[:id], entry[:type], entry[:target],
-              target_mode: entry[:target_mode],
-            )
-          end
+        # [PartDefinition, package part] pairs for document-level parts
+        # that must carry a relationship when present, in emission order.
+        def document_rel_defs
+          defs = [
+            [Ooxml::PartRegistry.find_by_key(:styles), package.styles],
+            [Ooxml::PartRegistry.find_by_key(:settings), package.settings],
+            [Ooxml::PartRegistry.find_by_key(:web_settings),
+             package.web_settings],
+            [Ooxml::PartRegistry.find_by_key(:font_table),
+             package.font_table],
+            [Ooxml::PartRegistry.find_by_key(:theme), package.theme],
+            [Ooxml::PartRegistry.find_by_key(:numbering), package.numbering],
+            [Ooxml::PartRegistry.find_by_key(:footnotes), package.footnotes],
+            [Ooxml::PartRegistry.find_by_key(:endnotes), package.endnotes],
+            [Ooxml::PartRegistry.find_by_key(:comments), package.comments],
+          ]
 
-          # Preserve non-standard rels not managed by allocator
-          existing_targets = all_rels.to_set(&:target)
-          non_standard = rels.relationships.reject do |r|
-            existing_targets.include?(r.target) ||
-              standard_targets.include?(r.target) ||
-              unsupported_rel_type?(r.type) ||
-              package_level_rel?(r.type) ||
-              !header_footer_target_present?(r.target)
+          sources = package.bibliography_sources ||
+            package.document&.bibliography_sources
+          if sources
+            defs << [Ooxml::PartRegistry.find_by_key(:bibliography), sources]
           end
 
-          rels.relationships = all_rels + non_standard
-          record_fix(FixCodes::RELATIONSHIPS_ASSEMBLED, "Assembled document relationships from allocator")
+          defs
         end
 
-        def reconcile_document_rels_legacy(rels, base, defs, standard_targets)
-          non_standard = rels.relationships.reject do |r|
-            standard_targets.include?(r.target) ||
-              unsupported_rel_type?(r.type) ||
-              package_level_rel?(r.type) ||
-              !header_footer_target_present?(r.target)
-          end
-
-          all_rels = []
-          rid_mapping = {}
-
-          defs.each do |suffix, target, obj|
-            next unless obj
-            rid = "rId#{all_rels.size + 1}"
-            all_rels << build_rel(rid, "#{base}/#{suffix}", target)
-          end
+        # Preserve-first assembly: existing relationships keep their
+        # position and rId (the allocator was seeded from them), new
+        # standard parts and new allocator-registered entries (images,
+        # hyperlinks, headers/footers added at build time) are appended
+        # with freshly allocated ids. No renumbering, ever.
+        def assemble_document_rels(rels, defs)
+          alloc = allocator
+          register_auxiliary_part_rels(alloc)
+          kept = kept_existing_relationships(rels, alloc)
+          kept_targets = kept.to_set(&:target)
 
-          non_standard.each do |rel|
-            old_rid = rel.id
-            new_rid = "rId#{all_rels.size + 1}"
-            rid_mapping[old_rid] = new_rid if old_rid != new_rid
-            all_rels << build_rel(new_rid, rel.type, rel.target,
-                                  target_mode: rel.target_mode)
-          end
+          append_missing_standard_rels(kept, kept_targets, defs, alloc)
+          append_allocator_rels(kept, kept_targets, alloc)
 
-          rels.relationships = all_rels
-          update_sect_pr_rid_references(rid_mapping) unless rid_mapping.empty?
-          update_blip_embed_references(rid_mapping) unless rid_mapping.empty?
-          update_hyperlink_rid_references(rid_mapping) unless rid_mapping.empty?
-          record_fix(FixCodes::RELATIONSHIPS_ASSEMBLED, "Rebuilt document relationships with sequential rIds")
+          rels.relationships = kept
+          record_fix(FixCodes::RELATIONSHIPS_ASSEMBLED,
+                     "Assembled document relationships (preserve-first)",
+                     part: "word/_rels/document.xml.rels")
         end
 
-        def update_sect_pr_rid_references(mapping)
-          sect_pr = package.document&.body&.section_properties
-          return unless sect_pr
-
-          [sect_pr.header_references, sect_pr.footer_references].each do |refs|
-            next unless refs
-
-            refs.each do |ref|
-              new_rid = mapping[ref.r_id]
-              ref.r_id = new_rid if new_rid
-            end
+        # Existing rels that survive the assembly, in original order:
+        # drops unsupported and package-level types and stale
+        # header/footer targets; everything else keeps its rId verbatim
+        # (or the allocator's reallocated id when seeding resolved a
+        # collision for this target+type).
+        def kept_existing_relationships(rels, alloc)
+          used_ids = Set.new
+          rels.relationships.filter_map do |rel|
+            next if unsupported_rel_type?(rel.type)
+            next if package_level_rel?(rel.type)
+            next unless header_footer_target_present?(rel.target)
+
+            rid = alloc.rid_for(target: rel.target, type: rel.type)
+            rid = rel.id if rid.nil? || used_ids.include?(rid)
+            next if rid && used_ids.include?(rid)
+
+            used_ids << rid if rid
+            build_rel(rid, rel.type, rel.target,
+                      target_mode: rel.target_mode)
           end
         end
 
-        def update_blip_embed_references(mapping)
-          paragraphs = package.document&.body&.paragraphs
-          return unless paragraphs
-
-          paragraphs.each do |para|
-            next unless para.runs
+        # Register rels for package-carried parts outside the standard
+        # defs: OLE/embedded binaries and chart parts. Loaded packages
+        # seeded these already (no-op); programmatically added parts
+        # get freshly allocated ids from the allocator.
+        def register_auxiliary_part_rels(alloc)
+          ole = Ooxml::PartRegistry.find_by_key(:ole_object)
+          (package.embeddings&.keys || []).each do |target|
+            alloc.alloc_rid(target: target, type: ole.rel_type)
+          end
 
-            para.runs.each do |run|
-              next unless run.drawings
+          chart = Ooxml::PartRegistry.find_by_key(:chart)
+          (package.document&.chart_parts&.values || []).each do |data|
+            next unless data[:target]
 
-              run.drawings.each do |drawing|
-                update_drawing_blip(drawing, mapping)
-              end
-            end
+            alloc.alloc_rid(target: data[:target], type: chart.rel_type)
           end
         end
 
-        def update_drawing_blip(drawing, mapping)
-          graphic = drawing.inline&.graphic || drawing.anchor&.graphic
-          return unless graphic
-
-          picture = graphic.graphic_data&.picture
-          return unless picture
-
-          blip = picture.blip_fill&.blip
-          return unless blip&.embed
+        # Append rels for present standard parts that have no
+        # relationship yet (fresh or newly added parts).
+        def append_missing_standard_rels(kept, kept_targets, defs, alloc)
+          defs.each do |defn, obj|
+            next unless obj
+            next if kept_targets.include?(defn.target)
 
-          new_rid = mapping[blip.embed.to_s]
-          blip.embed = new_rid if new_rid
+            kept << build_rel(
+              alloc.alloc_rid(target: defn.target, type: defn.rel_type),
+              defn.rel_type, defn.target,
+            )
+            kept_targets << defn.target
+          end
         end
 
-        def update_hyperlink_rid_references(mapping)
-          body = package.document&.body
-          return unless body
+        # Append allocator-registered rels not already present —
+        # builder-added images, hyperlinks, charts, headers/footers.
+        def append_allocator_rels(kept, kept_targets, alloc)
+          alloc.all_rels(scope: :document).each do |entry|
+            next if kept_targets.include?(entry[:target])
+            next if unsupported_rel_type?(entry[:type])
+            next if package_level_rel?(entry[:type])
+            next unless header_footer_target_present?(entry[:target])
 
-          walk_body_paragraphs(body) do |para|
-            (para.hyperlinks || []).each do |hl|
-              next unless hl.id
-              new_rid = mapping[hl.id.to_s]
-              hl.id = new_rid if new_rid
-            end
+            kept << build_rel(
+              entry[:id], entry[:type], entry[:target],
+              target_mode: entry[:target_mode],
+            )
+            kept_targets << entry[:target]
           end
         end
 
@@ -250,69 +219,48 @@ module Uniword
           PACKAGE_LEVEL_REL_TYPES.include?(type.to_s)
         end
 
-        # Check if a header/footer rel target corresponds to a serialized part.
-        # Headers/footers may be in two places:
-        #   - document.headers / document.footers (single-section hash)
-        #   - document.header_footer_parts (multi-section ordered array)
-        # Headers/footers are numbered sequentially: header1.xml, header2.xml...
-        # If the model has fewer headers/footers than the target index, it's stale.
+        # Check if a header/footer rel target corresponds to a part the
+        # package will emit. All header/footer parts live in the unified
+        # store (document.header_footer_parts), whether loaded from the
+        # source package or added programmatically; a rel whose target
+        # is not in the store points at a part that will not be
+        # serialized and must be treated as stale.
         def header_footer_target_present?(target)
-          if target.start_with?("header") && target.end_with?(".xml")
-            num = target[/header(\d+)\.xml/, 1]&.to_i
-            hash_count = package.document&.headers&.size || 0
-            parts_count = count_parts_matching("header")
-            count = [hash_count, parts_count].max
-            return num && num <= count
-          end
-          if target.start_with?("footer") && target.end_with?(".xml")
-            num = target[/footer(\d+)\.xml/, 1]&.to_i
-            hash_count = package.document&.footers&.size || 0
-            parts_count = count_parts_matching("footer")
-            count = [hash_count, parts_count].max
-            return num && num <= count
+          header_like = target.start_with?("header") || target.start_with?("footer")
+          if header_like && target.end_with?(".xml")
+            parts = package.document&.header_footer_parts
+            return false unless parts
+
+            return parts.targets.include?(target)
           end
           true
         end
 
-        def count_parts_matching(prefix)
-          parts = package.document&.header_footer_parts
-          return 0 unless parts
-
-          parts.count { |p| p[:target].to_s.start_with?(prefix) }
-        end
-
+        # [registry key, package part] pairs in content-types emission
+        # order; overrides are derived from Ooxml::PartRegistry.
         def content_type_overrides_for_present_parts
           checks = [
-            [package.document, "/word/document.xml",
-             "application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml"],
-            [package.styles, "/word/styles.xml",
-             "application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml"],
-            [package.settings, "/word/settings.xml",
-             "application/vnd.openxmlformats-officedocument.wordprocessingml.settings+xml"],
-            [package.font_table, "/word/fontTable.xml",
-             "application/vnd.openxmlformats-officedocument.wordprocessingml.fontTable+xml"],
-            [package.web_settings, "/word/webSettings.xml",
-             "application/vnd.openxmlformats-officedocument.wordprocessingml.webSettings+xml"],
-            [package.theme, "/word/theme/theme1.xml",
-             "application/vnd.openxmlformats-officedocument.theme+xml"],
-            [package.core_properties, "/docProps/core.xml",
-             "application/vnd.openxmlformats-package.core-properties+xml"],
-            [package.app_properties, "/docProps/app.xml",
-             "application/vnd.openxmlformats-officedocument.extended-properties+xml"],
-            [package.footnotes, "/word/footnotes.xml",
-             "application/vnd.openxmlformats-officedocument.wordprocessingml.footnotes+xml"],
-            [package.endnotes, "/word/endnotes.xml",
-             "application/vnd.openxmlformats-officedocument.wordprocessingml.endnotes+xml"],
-            [package.numbering, "/word/numbering.xml",
-             "application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml"],
+            [:document, package.document],
+            [:styles, package.styles],
+            [:settings, package.settings],
+            [:font_table, package.font_table],
+            [:web_settings, package.web_settings],
+            [:theme, package.theme],
+            [:core_properties, package.core_properties],
+            [:app_properties, package.app_properties],
+            [:footnotes, package.footnotes],
+            [:endnotes, package.endnotes],
+            [:comments, package.comments],
+            [:numbering, package.numbering],
           ]
 
-          checks.filter_map do |obj, part_name, content_type|
+          checks.filter_map do |key, obj|
             next unless obj
 
+            defn = Ooxml::PartRegistry.find_by_key(key)
             Uniword::ContentTypes::Override.new(
-              part_name: part_name,
-              content_type: content_type,
+              part_name: defn.part_name,
+              content_type: defn.content_type,
             )
           end
         end

data/lib/uniword/docx/reconciler/parts.rb

@@ -50,11 +50,19 @@ module Uniword
             val: profile.list_separator,
           )
 
+          # w:updateFields set by the user/API: ensure it serializes —
+          # parsed settings carry a stored element_order that lacks it.
+          if settings.update_fields
+            ensure_element_in_order(settings, "updateFields",
+                                    after: "characterSpacingControl")
+          end
+
           unless settings.w14_doc_id
             settings.w14_doc_id = Wordprocessingml::W14DocId.new(
               val: hex_derive("w14_doc_id", 4),
             )
-            record_fix(FixCodes::DOC_ID_GENERATED, "Generated w14:docId")
+            record_fix(FixCodes::DOC_ID_GENERATED, "Generated w14:docId",
+                       part: "word/settings.xml")
           end
           unless settings.w15_doc_id
             raw = hex_derive("w15_doc_id", 16)
@@ -63,7 +71,9 @@ module Uniword
             settings.w15_doc_id = Wordprocessingml::W15DocId.new(
               val: "{#{formatted.upcase}}",
             )
-            record_fix(FixCodes::DOC_ID_GENERATED, "Generated w15:docId in GUID format")
+            record_fix(FixCodes::DOC_ID_GENERATED,
+                       "Generated w15:docId in GUID format",
+                       part: "word/settings.xml")
           end
 
           set_mc_ignorable(settings)
@@ -75,7 +85,8 @@ module Uniword
           font_table = package.font_table
           font_table ||= begin
             package.font_table = Wordprocessingml::FontTable.new
-            record_fix(FixCodes::FONT_TABLE_CREATED, "Created font table")
+            record_fix(FixCodes::FONT_TABLE_CREATED, "Created font table",
+                       part: "word/fontTable.xml")
             package.font_table
           end
 
@@ -114,7 +125,8 @@ module Uniword
 
           set_mc_ignorable(font_table)
           record_fix(FixCodes::FONT_TABLE_CREATED,
-                     "Populated font table with profile fonts and signatures")
+                     "Populated font table with profile fonts and signatures",
+                     part: "word/fontTable.xml")
         end
 
         def reconcile_styles
@@ -133,7 +145,8 @@ module Uniword
 
           set_mc_ignorable(styles)
           record_fix(FixCodes::STYLE_DEFAULTS_ADDED,
-                     "Ensured styles have docDefaults, latentStyles, and default styles")
+                     "Ensured styles have docDefaults, latentStyles, and default styles",
+                     part: "word/styles.xml")
         end
 
         def reconcile_numbering
@@ -149,7 +162,8 @@ module Uniword
             raw = raw - 0x100000000 if raw >= 0x80000000
             inst.durable_id = raw.to_s
             record_fix(FixCodes::NUMBERING_REFERENCED,
-                       "Generated w16cid:durableId for numId=#{inst.num_id}")
+                       "Generated w16cid:durableId for numId=#{inst.num_id}",
+                       part: "word/numbering.xml")
           end
 
           package.numbering.instances.each do |inst|
@@ -165,8 +179,10 @@ module Uniword
             end
             next if defn
 
-            record_fix(FixCodes::NUMBERING_REFERENCED, "Numbering instance numId=#{inst.num_id} references " \
-                             "missing abstractNumId=#{abs_id}")
+            record_fix(FixCodes::NUMBERING_REFERENCED,
+                       "Numbering instance numId=#{inst.num_id} references " \
+                       "missing abstractNumId=#{abs_id}",
+                       part: "word/numbering.xml")
           end
         end
 
@@ -180,7 +196,8 @@ module Uniword
           end
 
           set_mc_ignorable(ws)
-          record_fix(FixCodes::MC_IGNORABLE, "Cleared mc:Ignorable on webSettings")
+          record_fix(FixCodes::MC_IGNORABLE, "Cleared mc:Ignorable on webSettings",
+                     part: "word/webSettings.xml")
         end
 
         def reconcile_app_properties
@@ -219,7 +236,9 @@ module Uniword
           app.heading_pairs = nil
           app.titles_of_parts = nil
 
-          record_fix(FixCodes::APP_PROPERTIES_ENSURED, "Ensured app properties with statistics")
+          record_fix(FixCodes::APP_PROPERTIES_ENSURED,
+                     "Ensured app properties with statistics",
+                     part: "docProps/app.xml")
         end
 
         def reconcile_core_properties
@@ -259,7 +278,9 @@ module Uniword
           )
 
           cp.revision = "1" unless cp.revision
-          record_fix(FixCodes::CORE_PROPERTIES_REBUILT, "Rebuilt core properties with namespace declarations")
+          record_fix(FixCodes::CORE_PROPERTIES_REBUILT,
+                     "Rebuilt core properties with namespace declarations",
+                     part: "docProps/core.xml")
         end
 
         private
@@ -421,10 +442,12 @@ module Uniword
           end
 
           dpf = styles.styles.find { |s| s.id == "DefaultParagraphFont" }
-          if dpf && !dpf.semiHidden && !allocator
+          if dpf && !dpf.semiHidden && !builder_managed?
             dpf.semiHidden = Wordprocessingml::SemiHidden.new
             ensure_element_in_order(dpf, "semiHidden", after: "uiPriority")
-            record_fix(FixCodes::SEMI_HIDDEN_ADDED, "Added semiHidden to DefaultParagraphFont style")
+            record_fix(FixCodes::SEMI_HIDDEN_ADDED,
+                       "Added semiHidden to DefaultParagraphFont style",
+                       part: "word/styles.xml")
           end
 
           unless style_ids.include?("TableNormal")