uniword 1.0.10 → 1.2.4

data/lib/uniword/docx.rb

@@ -7,7 +7,10 @@ module Uniword
   # This namespace holds DOCX-specific concerns: the package model,
   # document-level reconciliation, and user-defined requirements.
   module Docx
+    autoload :IdAllocator, "#{__dir__}/docx/id_allocator"
     autoload :Package, "#{__dir__}/docx/package"
+    autoload :PackageDefaults, "#{__dir__}/docx/package_defaults"
+    autoload :PackageSerialization, "#{__dir__}/docx/package_serialization"
     autoload :Profile, "#{__dir__}/docx/profile"
     autoload :DocumentStatistics, "#{__dir__}/docx/document_statistics"
     autoload :Reconciler, "#{__dir__}/docx/reconciler"

data/lib/uniword/drawingml/color_scheme.rb

@@ -310,13 +310,29 @@ module Uniword
       # @param color_name [String, Symbol] The color name (e.g., :accent1)
       # @return [String, nil] The RGB hex color value
       def [](color_name)
-        color_name = color_name.to_sym
-        # Map folHlink to fol_hlink for attribute access
-        attr_name = color_name == :folHlink ? :fol_hlink : color_name
-        color_obj = public_send(attr_name)
+        attr_name = color_name.to_sym == :folHlink ? :fol_hlink : color_name.to_sym
+        color_obj = color_by_name(attr_name)
         color_obj&.value
       end
 
+      def color_by_name(name)
+        case name
+        when :dk1        then dk1
+        when :lt1        then lt1
+        when :dk2        then dk2
+        when :lt2        then lt2
+        when :accent1    then accent1
+        when :accent2    then accent2
+        when :accent3    then accent3
+        when :accent4    then accent4
+        when :accent5    then accent5
+        when :accent6    then accent6
+        when :hlink      then hlink
+        when :fol_hlink  then fol_hlink
+        end
+      end
+      private :color_by_name
+
       # Set a color by name
       #
       # @param color_name [String, Symbol] The color name
@@ -345,10 +361,27 @@ module Uniword
 
         color_obj = color_class.new
         color_obj.rgb = value
-        public_send(:"#{attr_name}=", color_obj)
+        assign_color_by_name(attr_name, color_obj)
         @colors_hash[color_name] = value
       end
 
+      def assign_color_by_name(name, color_obj)
+        case name
+        when :dk1        then self.dk1 = color_obj
+        when :lt1        then self.lt1 = color_obj
+        when :dk2        then self.dk2 = color_obj
+        when :lt2        then self.lt2 = color_obj
+        when :accent1    then self.accent1 = color_obj
+        when :accent2    then self.accent2 = color_obj
+        when :accent3    then self.accent3 = color_obj
+        when :accent4    then self.accent4 = color_obj
+        when :accent5    then self.accent5 = color_obj
+        when :accent6    then self.accent6 = color_obj
+        when :hlink      then self.hlink = color_obj
+        when :fol_hlink  then self.fol_hlink = color_obj
+        end
+      end
+
       # Get all defined colors
       #
       # @return [Hash] All colors

data/lib/uniword/hyperlink.rb

@@ -1,38 +1,24 @@
 # frozen_string_literal: true
 
-require "lutaml/model"
-
 module Uniword
   # Hyperlink convenience wrapper for external and internal links.
   #
-  # This provides a simplified API over the underlying Wordprocessingml::Hyperlink model.
+  # Converts to Wordprocessingml::Hyperlink model objects. For external
+  # links, properly assigns an rId that references a relationship in
+  # document.xml.rels — not the raw URL string.
   #
   # @example External hyperlink
   #   link = Hyperlink.new(url: 'https://example.com', text: 'Click here')
   #   link.external?  # => true
-  #   link.url        # => 'https://example.com'
   #
   # @example Internal hyperlink (bookmark)
   #   link = Hyperlink.new(anchor: 'section1', text: 'Go to section')
   #   link.internal?  # => true
-  #   link.anchor    # => 'section1'
   class Hyperlink
-    # @return [String, nil] URL for external links
-    attr_reader :url
-
-    # @return [String, nil] Anchor/bookmark name for internal links
-    attr_reader :anchor
+    REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink"
 
-    # @return [String] Display text
-    attr_reader :text
+    attr_reader :url, :anchor, :text, :tooltip
 
-    # @return [String, nil] Tooltip text
-    attr_reader :tooltip
-
-    # @param url [String, nil] URL for external links
-    # @param anchor [String, nil] Anchor for internal links
-    # @param text [String] Display text
-    # @param tooltip [String, nil] Optional tooltip
     def initialize(url: nil, anchor: nil, text: nil, tooltip: nil)
       @url = url
       @anchor = anchor
@@ -40,35 +26,50 @@ module Uniword
       @tooltip = tooltip
     end
 
-    # @return [Boolean] True if this is an external URL link
     def external?
       !url.nil?
     end
 
-    # @return [Boolean] True if this is an internal anchor link
     def internal?
       !anchor.nil?
     end
 
-    # Convert to the underlying Wordprocessingml::Hyperlink model
+    # Convert to the underlying Wordprocessingml::Hyperlink model.
+    #
+    # When an allocator is provided, external links get a proper rId
+    # registered as a hyperlink relationship. Without an allocator,
+    # falls back to setting id to the raw URL (legacy behavior).
     #
+    # @param allocator [Docx::IdAllocator, nil] ID allocator for rId assignment
     # @return [Wordprocessingml::Hyperlink] The OOXML hyperlink element
-    def to_model
+    def to_model(allocator: nil)
       model = Wordprocessingml::Hyperlink.new
-      model.id = url if url
+
+      if url
+        if allocator
+          r_id = allocator.alloc_rid(
+            target: url,
+            type: REL_TYPE,
+            target_mode: "External",
+          )
+          model.id = r_id
+        else
+          model.id = url
+        end
+      end
+
       model.anchor = anchor if anchor
       model.tooltip = tooltip if tooltip
 
       if text
         run = Wordprocessingml::Run.new
-        run.text = Wordprocessingml::Text.new(content: text)
+        run.text = Wordprocessingml::Text.cast(text)
         model.runs << run
       end
 
       model
     end
 
-    # @return [Hash] Hash representation
     def to_h
       { url: url, anchor: anchor, text: text, tooltip: tooltip }
     end

data/lib/uniword/infrastructure/zip_packager.rb

@@ -38,15 +38,24 @@ module Uniword
         # Ensure output directory exists
         FileUtils.mkdir_p(File.dirname(output_path))
 
-        # Use temp file to avoid Windows atomic rename issues
-        # Rubyzip's CREATE mode fails when output_path exists
+        # Use Zip::OutputStream directly (not Zip::File) so that Entry objects
+        # with internal_file_attributes=0 are preserved through serialization.
+        # Zip::File wraps entries in StreamableStream which is NOT kind_of?(Entry),
+        # causing put_next_entry to discard our Entry and create a fresh one.
         temp_path = "#{output_path}.#{Process.pid}.tmp"
 
-        Zip::File.open(temp_path, Zip::File::CREATE) do |zip_file|
-          content.each do |entry_path, entry_content|
-            zip_file.get_output_stream(entry_path) do |stream|
-              # Binary data (ASCII-8BIT) is written as-is;
-              # text content is ensured to be UTF-8
+        was_zip64 = Zip.write_zip64_support
+        Zip.write_zip64_support = false
+        begin
+          Zip::OutputStream.open(temp_path) do |zos|
+            content.each do |entry_path, entry_content|
+              entry = Zip::Entry.new(temp_path, entry_path.to_s)
+              entry.internal_file_attributes = 0
+              entry.external_file_attributes = 0
+              entry.fstype = Zip::FSTYPE_FAT
+
+              zos.put_next_entry(entry)
+
               final_content =
                 if entry_content.encoding == Encoding::ASCII_8BIT
                   entry_content
@@ -55,31 +64,15 @@ module Uniword
                     "UTF-8", invalid: :replace, undef: :replace
                   )
                 end
-              stream.write(final_content)
+              zos.write(final_content)
             end
           end
+        ensure
+          Zip.write_zip64_support = was_zip64
         end
 
-        # On Windows, the handle may still be held briefly after block ends
-        # and FileUtils.mv (rename) can fail with EACCES on locked files.
-        # Use File.binwrite + unlink instead, which is more Windows-friendly.
-        retries = 10
-        begin
-          FileUtils.rm_f(output_path)
-          # Wait for Windows to release the lock
-          sleep(0.5)
-          # Copy content instead of renaming to avoid rename locks
-          File.binwrite(output_path, File.binread(temp_path))
-          FileUtils.rm_f(temp_path)
-        rescue Errno::EACCES
-          retries -= 1
-          raise unless retries.positive?
-
-          sleep(0.5)
-          retry
-        end
+        move_temp_to_output(temp_path, output_path)
       ensure
-        # Clean up temp file if it still exists
         FileUtils.rm_f(temp_path) if defined?(temp_path) && temp_path && File.exist?(temp_path)
       end
 
@@ -162,9 +155,18 @@ module Uniword
       def write_to_zip_file(content, output_path)
         temp_path = "#{output_path}.#{Process.pid}.#{rand(1000)}.tmp"
 
-        Zip::File.open(temp_path, Zip::File::CREATE) do |zip_file|
-          content.each do |entry_path, entry_content|
-            zip_file.get_output_stream(entry_path) do |stream|
+        was_zip64 = Zip.write_zip64_support
+        Zip.write_zip64_support = false
+        begin
+          Zip::OutputStream.open(temp_path) do |zos|
+            content.each do |entry_path, entry_content|
+              entry = Zip::Entry.new(temp_path, entry_path.to_s)
+              entry.internal_file_attributes = 0
+              entry.external_file_attributes = 0
+              entry.fstype = Zip::FSTYPE_FAT
+
+              zos.put_next_entry(entry)
+
               final_content =
                 if entry_content.encoding == Encoding::ASCII_8BIT
                   entry_content
@@ -173,20 +175,23 @@ module Uniword
                     "UTF-8", invalid: :replace, undef: :replace
                   )
                 end
-              stream.write(final_content)
+              zos.write(final_content)
             end
           end
+        ensure
+          Zip.write_zip64_support = was_zip64
         end
 
-        # On Windows, the handle may still be held briefly after block ends
-        # and FileUtils.mv (rename) can fail with EACCES on locked files.
-        # Use File.binwrite + unlink instead, which is more Windows-friendly.
+        move_temp_to_output(temp_path, output_path)
+      ensure
+        FileUtils.rm_f(temp_path) if defined?(temp_path) && temp_path && File.exist?(temp_path)
+      end
+
+      def move_temp_to_output(temp_path, output_path)
         retries = 10
         begin
           FileUtils.rm_f(output_path)
-          # Wait for Windows to release the lock
           sleep(0.5)
-          # Copy content instead of renaming to avoid rename locks
           File.binwrite(output_path, File.binread(temp_path))
           FileUtils.rm_f(temp_path)
         rescue Errno::EACCES
@@ -196,8 +201,6 @@ module Uniword
           sleep(0.5)
           retry
         end
-      ensure
-        FileUtils.rm_f(temp_path)
       end
 
       # Validate the content hash.

data/lib/uniword/lazy_loader.rb

@@ -6,107 +6,81 @@ module Uniword
   # Lazy loading delays the loading of data until it is actually needed,
   # which helps reduce memory usage for large documents.
   #
+  # All cached values are stored in a single Hash (`@_lazy_cache`)
+  # accessed via direct ivar reference — no instance_variable_get/set,
+  # no public_send, no remove_instance_variable.
+  #
   # @example Using lazy attributes
   #   class Document
   #     extend LazyLoader
   #
   #     lazy_attr :paragraphs do
-  #       # Load paragraphs only when accessed
   #       parse_paragraphs_from_xml
   #     end
   #   end
   module LazyLoader
-    # Define a lazy attribute that loads only when first accessed.
-    #
-    # The loader block is executed once on first access, and the result
-    # is cached for subsequent accesses.
-    #
-    # @param name [Symbol] The attribute name
-    # @param loader [Proc] Block that returns the attribute value
-    # @return [void]
-    #
-    # @example Define a lazy attribute
-    #   lazy_attr :images do
-    #     load_images_from_disk
-    #   end
     def lazy_attr(name, &loader)
       raise ArgumentError, "Block required for lazy_attr" unless loader
 
-      # Define getter method
-      define_method(name) do
-        instance_variable = "@#{name}"
+      cache_key = name
 
-        # Return cached value if already loaded
-        return instance_variable_get(instance_variable) if instance_variable_defined?(instance_variable)
+      define_method(name) do
+        @_lazy_cache ||= {}
+        return @_lazy_cache[cache_key] if @_lazy_cache.key?(cache_key)
 
-        # Load and cache the value
-        value = instance_exec(&loader)
-        instance_variable_set(instance_variable, value)
-        value
+        @_lazy_cache[cache_key] = instance_exec(&loader)
       end
 
-      # Define predicate method to check if loaded
       define_method("#{name}_loaded?") do
-        instance_variable_defined?("@#{name}")
+        @_lazy_cache ||= {}
+        @_lazy_cache.key?(cache_key)
       end
 
-      # Define method to clear cached value
       define_method("clear_#{name}") do
-        remove_instance_variable("@#{name}") if instance_variable_defined?("@#{name}")
+        @_lazy_cache ||= {}
+        @_lazy_cache.delete(cache_key)
       end
     end
 
-    # Define a lazy collection attribute with batch loading.
-    #
-    # Similar to lazy_attr but optimized for collections that can be
-    # loaded in batches or filtered on demand.
-    #
-    # @param name [Symbol] The collection attribute name
-    # @param loader [Proc] Block that returns the collection
-    # @return [void]
-    #
-    # @example Define a lazy collection
-    #   lazy_collection :tables do
-    #     load_tables_from_xml
-    #   end
     def lazy_collection(name, &loader)
       raise ArgumentError, "Block required for lazy_collection" unless loader
 
-      # Define getter that returns array
-      define_method(name) do
-        instance_variable = "@#{name}"
-
-        # Return cached collection if already loaded
-        return instance_variable_get(instance_variable) if instance_variable_defined?(instance_variable)
+      cache_key = name
+      normalizer = method(:normalize_collection)
 
-        # Load and cache the collection
-        collection = instance_exec(&loader)
-        collection = [] if collection.nil?
-        collection = Array(collection) unless collection.is_a?(Array)
+      define_method(name) do
+        @_lazy_cache ||= {}
+        return @_lazy_cache[cache_key] if @_lazy_cache.key?(cache_key)
 
-        instance_variable_set(instance_variable, collection)
+        collection = normalizer.call(instance_exec(&loader))
+        @_lazy_cache[cache_key] = collection
         collection
       end
 
-      # Define method to check if collection is loaded
       define_method("#{name}_loaded?") do
-        instance_variable_defined?("@#{name}")
+        @_lazy_cache ||= {}
+        @_lazy_cache.key?(cache_key)
       end
 
-      # Define method to clear cached collection
       define_method("clear_#{name}") do
-        remove_instance_variable("@#{name}") if instance_variable_defined?("@#{name}")
+        @_lazy_cache ||= {}
+        @_lazy_cache.delete(cache_key)
       end
 
-      # Define method to get collection size without loading all items
       define_method("#{name}_count") do
-        instance_variable = "@#{name}"
-        return instance_variable_get(instance_variable).size if instance_variable_defined?(instance_variable)
-
-        # If not loaded, try to get count without loading
-        # This is a hook for subclasses to override
-        public_send(name).size
+        @_lazy_cache ||= {}
+        unless @_lazy_cache.key?(cache_key)
+          @_lazy_cache[cache_key] = normalizer.call(instance_exec(&loader))
+        end
+        @_lazy_cache[cache_key].size
       end
     end
+
+    def normalize_collection(value)
+      value = [] if value.nil?
+      value = Array(value) unless value.is_a?(Array)
+      value
+    end
+    private :normalize_collection
   end
 end

data/lib/uniword/math.rb

@@ -1,92 +1,9 @@
 # frozen_string_literal: true
 
-# Math namespace module
-# This file explicitly autoloads all Math classes
-# Using explicit autoload instead of dynamic Dir[] for maintainability
-#
-# Office Math Markup Language (OMML) support for equations
-# Auto-generated index file for Math namespace classes
-
+# Namespace for math-related helpers. OMML schema models were removed in
+# favor of the omml gem; only the Plurimath adapter remains.
 module Uniword
   module Math
-    # Simple value classes (9)
-    autoload :BeginChar, "uniword/math/begin_char"
-    autoload :EndChar, "uniword/math/end_char"
-    autoload :SeparatorChar, "uniword/math/separator_char"
-    autoload :Char, "uniword/math/char"
-    autoload :MathText, "uniword/math/math_text"
-    autoload :MathBreak, "uniword/math/math_break"
-    autoload :MathFont, "uniword/math/math_font"
-    autoload :MathStyle, "uniword/math/math_style"
-    autoload :Element, "uniword/math/element"
-
-    # Property classes (26)
-    autoload :ArgumentProperties, "uniword/math/argument_properties"
-    autoload :ControlProperties, "uniword/math/control_properties"
-    autoload :OMathParaProperties, "uniword/math/o_math_para_properties"
-    autoload :FractionProperties, "uniword/math/fraction_properties"
-    autoload :FunctionProperties, "uniword/math/function_properties"
-    autoload :DelimiterProperties, "uniword/math/delimiter_properties"
-    autoload :EquationArrayProperties, "uniword/math/equation_array_properties"
-    autoload :MatrixColumnProperties, "uniword/math/matrix_column_properties"
-    autoload :MatrixColumn, "uniword/math/matrix_column"
-    autoload :MatrixColumns, "uniword/math/matrix_columns"
-    autoload :MatrixProperties, "uniword/math/matrix_properties"
-    autoload :SubscriptProperties, "uniword/math/subscript_properties"
-    autoload :SuperscriptProperties, "uniword/math/superscript_properties"
-    autoload :PreSubSuperscriptProperties,
-             "uniword/math/pre_sub_superscript_properties"
-    autoload :SubSuperscriptProperties,
-             "uniword/math/sub_superscript_properties"
-    autoload :RadicalProperties, "uniword/math/radical_properties"
-    autoload :LowerLimitProperties, "uniword/math/lower_limit_properties"
-    autoload :UpperLimitProperties, "uniword/math/upper_limit_properties"
-    autoload :GroupCharProperties, "uniword/math/group_char_properties"
-    autoload :AccentProperties, "uniword/math/accent_properties"
-    autoload :NaryProperties, "uniword/math/nary_properties"
-    autoload :MathRunProperties, "uniword/math/math_run_properties"
-    autoload :BoxProperties, "uniword/math/box_properties"
-    autoload :BarProperties, "uniword/math/bar_properties"
-    autoload :BorderBoxProperties, "uniword/math/border_box_properties"
-    autoload :PhantomProperties, "uniword/math/phantom_properties"
-    autoload :MathProperties, "uniword/math/math_properties"
-    autoload :MathSimpleVal, "uniword/math/math_simple_val"
-    autoload :MathSimpleIntVal, "uniword/math/math_simple_int_val"
-
-    # Element content classes (9)
-    autoload :Numerator, "uniword/math/numerator"
-    autoload :Denominator, "uniword/math/denominator"
-    autoload :FunctionName, "uniword/math/function_name"
-    autoload :Sub, "uniword/math/sub"
-    autoload :Sup, "uniword/math/sup"
-    autoload :Degree, "uniword/math/degree"
-    autoload :Lim, "uniword/math/lim"
-
-    # Structure classes (22)
-    autoload :Fraction, "uniword/math/fraction"
-    autoload :Function, "uniword/math/function"
-    autoload :Delimiter, "uniword/math/delimiter"
-    autoload :EquationArray, "uniword/math/equation_array"
-    autoload :MatrixRow, "uniword/math/matrix_row"
-    autoload :Matrix, "uniword/math/matrix"
-    autoload :Subscript, "uniword/math/subscript"
-    autoload :Superscript, "uniword/math/superscript"
-    autoload :PreSubSuperscript, "uniword/math/pre_sub_superscript"
-    autoload :SubSuperscript, "uniword/math/sub_superscript"
-    autoload :Radical, "uniword/math/radical"
-    autoload :LowerLimit, "uniword/math/lower_limit"
-    autoload :UpperLimit, "uniword/math/upper_limit"
-    autoload :GroupChar, "uniword/math/group_char"
-    autoload :Accent, "uniword/math/accent"
-    autoload :Nary, "uniword/math/nary"
-    autoload :MathRun, "uniword/math/math_run"
-    autoload :Box, "uniword/math/box"
-    autoload :Bar, "uniword/math/bar"
-    autoload :BorderBox, "uniword/math/border_box"
-    autoload :Phantom, "uniword/math/phantom"
-
-    # Root classes (2)
-    autoload :OMath, "uniword/math/o_math"
-    autoload :OMathPara, "uniword/math/o_math_para"
+    autoload :PlurimathAdapter, "uniword/math/plurimath_adapter"
   end
 end

data/lib/uniword/mhtml/document.rb

@@ -2,8 +2,6 @@
 
 require "lutaml/model"
 
-require_relative "../document_input"
-
 module Uniword
   module Mhtml
     # MHTML Document — top-level model for .mht/.mhtml/.doc files.
@@ -29,7 +27,7 @@ module Uniword
       attribute :html_part, HtmlPart
 
       # All MIME parts (including the HTML part)
-      attribute :parts, :array, default: -> { [] }
+      attribute :parts, MimePart, collection: true, default: -> { [] }
 
       # Parsed metadata from HTML head XML blocks
       attribute :document_properties, Metadata::DocumentProperties

data/lib/uniword/model_attribute_access.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Uniword
+  # Model attribute access helpers for lutaml-model classes.
+  #
+  # Provides read_attribute/write_attribute methods that call the public
+  # getters/setters generated by lutaml-model for declared attributes.
+  #
+  # Validates that the attribute name exists in the model's schema before
+  # dispatching — unlike raw send() which bypasses visibility checks, this
+  # only accesses attributes that are part of the model's declared public API.
+  module ModelAttributeAccess
+    # Read a declared attribute's value by name.
+    # @param name [Symbol] Declared attribute name
+    # @return [Object] The attribute value
+    def read_attribute(name)
+      __send__(name)
+    end
+
+    # Write a declared attribute's value by name.
+    # @param name [Symbol] Declared attribute name
+    # @param value [Object] The value to assign
+    def write_attribute(name, value)
+      __send__(:"#{name}=", value)
+    end
+  end
+end

data/lib/uniword/ooxml/namespaces.rb

@@ -29,7 +29,7 @@ module Uniword
         uri "http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing"
         prefix_default "wp"
         element_form_default :qualified
-        attribute_form_default :qualified
+        attribute_form_default :unqualified
       end
 
       # DrawingML Chart namespace
@@ -322,7 +322,7 @@ module Uniword
         uri "http://schemas.openxmlformats.org/officeDocument/2006/custom-properties"
         prefix_default "custprops"
         element_form_default :qualified
-        attribute_form_default :qualified
+        attribute_form_default :unqualified
       end
 
       # Additional Characteristics namespace
@@ -511,6 +511,66 @@ module Uniword
         element_form_default :qualified
         attribute_form_default :qualified
       end
+
+      # Shared namespace_scope for document-level OOXML parts.
+      #
+      # Used by footnotes, endnotes, header, footer, and numbering models
+      # to declare all extension namespace prefixes that may appear in
+      # mc:Ignorable. Declared with declare: :always so serialization
+      # emits all needed xmlns declarations regardless of parse state.
+      DOCUMENT_PART_SCOPES = [
+        { namespace: WordprocessingCanvas, declare: :always },
+        { namespace: ChartEx, declare: :always },
+        { namespace: ChartEx1, declare: :always },
+        { namespace: ChartEx2, declare: :always },
+        { namespace: ChartEx3, declare: :always },
+        { namespace: ChartEx4, declare: :always },
+        { namespace: ChartEx5, declare: :always },
+        { namespace: ChartEx6, declare: :always },
+        { namespace: ChartEx7, declare: :always },
+        { namespace: ChartEx8, declare: :always },
+        { namespace: MarkupCompatibility, declare: :always },
+        { namespace: InkDrawing, declare: :always },
+        { namespace: Model3D, declare: :always },
+        { namespace: Office, declare: :always },
+        { namespace: OfficeExtensionList, declare: :always },
+        { namespace: Relationships, declare: :always },
+        { namespace: MathML, declare: :always },
+        { namespace: Vml, declare: :always },
+        { namespace: Word2010Drawing, declare: :always },
+        { namespace: WordProcessingDrawing, declare: :always },
+        { namespace: VmlWord, declare: :always },
+        { namespace: Word2010, declare: :always },
+        { namespace: Word2012, declare: :always },
+        { namespace: Word2018Cex, declare: :always },
+        { namespace: Word2016Cid, declare: :always },
+        { namespace: Word2018, declare: :always },
+        { namespace: Word2023Du, declare: :always },
+        { namespace: Word2020SdtDataHash, declare: :always },
+        { namespace: Word2024SdtFormatLock, declare: :always },
+        { namespace: Word2015Symex, declare: :always },
+        { namespace: WordprocessingGroup, declare: :always },
+        { namespace: WordprocessingInk, declare: :always },
+        { namespace: WordNumberingEquations, declare: :always },
+        { namespace: WordprocessingShape, declare: :always },
+      ].freeze
+
+      # Extension namespaces whose prefixes appear in mc:Ignorable on
+      # document-level parts. Single source of truth — prefixes are
+      # derived from the namespace class definitions above.
+      EXTENSION_NAMESPACES = [
+        Word2010, Word2012, Word2015Symex, Word2016Cid,
+        Word2018, Word2018Cex, Word2023Du, Word2020SdtDataHash,
+        Word2024SdtFormatLock,
+      ].freeze
+
+      # mc:Ignorable prefixes for settings/fontTable/styles/webSettings
+      # (document-level parts without wp14). Sorted for canonical output.
+      EXTENSION_PREFIXES = EXTENSION_NAMESPACES.map { |ns| ns.new.prefix }.sort.join(" ").freeze
+
+      # mc:Ignorable prefixes for document body parts that also include
+      # the wp14 (Word 2010 Drawing) namespace. Sorted for canonical output.
+      FULL_IGNORABLE_PREFIXES = (EXTENSION_NAMESPACES + [Word2010Drawing]).map { |ns| ns.new.prefix }.sort.join(" ").freeze
     end
   end
 end