uniword 1.0.0 → 1.0.3

data/lib/uniword/wordprocessingml/run_properties.rb

@@ -1,6 +1,11 @@
 # frozen_string_literal: true
 
-require 'lutaml/model'
+require "lutaml/model"
+
+require_relative "run_properties/yaml_transforms"
+require_relative "run_properties/predicates"
+require_relative "run_properties/accessors"
+require_relative "run_properties/conversion"
 
 module Uniword
   module Wordprocessingml
@@ -9,6 +14,11 @@ module Uniword
     # Represents w:rPr element containing character-level formatting.
     # Used in StyleSets and run elements.
     class RunProperties < Lutaml::Model::Serializable
+      include YamlTransforms
+      include Predicates
+      include Accessors
+      prepend Conversion
+
       # Pattern 0: ATTRIBUTES FIRST, then XML mappings
 
       # Simple element wrapper objects (default: nil so unset properties are nil)
@@ -49,652 +59,133 @@ module Uniword
       attribute :caps, Properties::Caps, default: nil
       attribute :hidden, Properties::Vanish, default: nil
       attribute :no_proof, Properties::NoProof, default: nil
+      attribute :web_hidden, Properties::WebHidden, default: nil
       attribute :shadow, Properties::Shadow, default: nil
       attribute :emboss, Properties::Emboss, default: nil
       attribute :imprint, Properties::Imprint, default: nil
       attribute :outline, Properties::Outline, default: nil
       attribute :outline_level, Properties::OutlineLevel, default: nil
 
+      # W14 namespace elements
+      attribute :ligatures, Uniword::Wordprocessingml2010::Ligatures,
+                default: nil
+
       # YAML mappings for flat YAML structure (StyleSet compatibility)
       yaml do
-        map 'bold', with: { from: :yaml_bold_from, to: :yaml_bold_to }
-        map 'italic', with: { from: :yaml_italic_from, to: :yaml_italic_to }
-        map 'strike', with: { from: :yaml_strike_from, to: :yaml_strike_to }
-        map 'double_strike', with: { from: :yaml_double_strike_from, to: :yaml_double_strike_to }
-        map 'small_caps', with: { from: :yaml_small_caps_from, to: :yaml_small_caps_to }
-        map 'caps', with: { from: :yaml_caps_from, to: :yaml_caps_to }
-        map 'all_caps', with: { from: :yaml_caps_from, to: :yaml_caps_to } # Alias
-        map 'hidden', with: { from: :yaml_hidden_from, to: :yaml_hidden_to }
-        map 'size', with: { from: :yaml_size_from, to: :yaml_size_to }
-        map 'spacing', with: { from: :yaml_character_spacing_from, to: :yaml_character_spacing_to }
-        map 'character_spacing',
-            with: { from: :yaml_character_spacing_from, to: :yaml_character_spacing_to }
-        map 'underline', with: { from: :yaml_underline_from, to: :yaml_underline_to }
-        map 'color', with: { from: :yaml_color_from, to: :yaml_color_to }
-        map 'highlight', with: { from: :yaml_highlight_from, to: :yaml_highlight_to }
-        map 'font', with: { from: :yaml_font_from, to: :yaml_font_to }
-        map 'font_ascii', with: { from: :yaml_font_ascii_from, to: :yaml_font_ascii_to }
-        map 'font_east_asia', with: { from: :yaml_font_east_asia_from, to: :yaml_font_east_asia_to }
-        map 'font_h_ansi', with: { from: :yaml_font_h_ansi_from, to: :yaml_font_h_ansi_to }
-        map 'font_cs', with: { from: :yaml_font_cs_from, to: :yaml_font_cs_to }
-        map 'emboss', with: { from: :yaml_emboss_from, to: :yaml_emboss_to }
-        map 'imprint', with: { from: :yaml_imprint_from, to: :yaml_imprint_to }
-        map 'shadow', with: { from: :yaml_shadow_from, to: :yaml_shadow_to }
-        map 'outline', with: { from: :yaml_outline_from, to: :yaml_outline_to }
-        map 'vertical_align', with: { from: :yaml_vertical_align_from, to: :yaml_vertical_align_to }
-      end
-
-      # YAML transform methods
-      def yaml_bold_from(instance, value)
-        instance.bold = Properties::Bold.new(value: value) unless value.nil?
-      end
-
-      def yaml_bold_to(_instance, _doc)
-        bold&.value
-      end
-
-      def yaml_italic_from(instance, value)
-        instance.italic = Properties::Italic.new(value: value) unless value.nil?
-      end
-
-      def yaml_italic_to(_instance, _doc)
-        italic&.value
-      end
-
-      def yaml_strike_from(instance, value)
-        instance.strike = Properties::Strike.new(value: value) unless value.nil?
-      end
-
-      def yaml_strike_to(_instance, _doc)
-        strike&.value
-      end
-
-      def yaml_double_strike_from(instance, value)
-        instance.double_strike = Properties::DoubleStrike.new(value: value) unless value.nil?
-      end
-
-      def yaml_double_strike_to(_instance, _doc)
-        double_strike&.value
-      end
-
-      def yaml_small_caps_from(instance, value)
-        instance.small_caps = Properties::SmallCaps.new(value: value) unless value.nil?
-      end
-
-      def yaml_small_caps_to(_instance, _doc)
-        small_caps&.value
-      end
-
-      def yaml_caps_from(instance, value)
-        instance.caps = Properties::Caps.new(value: value) unless value.nil?
-      end
-
-      def yaml_caps_to(_instance, _doc)
-        caps&.value
-      end
-
-      def yaml_hidden_from(instance, value)
-        instance.hidden = Properties::Vanish.new(value: value) unless value.nil?
-      end
-
-      def yaml_hidden_to(_instance, _doc)
-        hidden&.value
-      end
-
-      def yaml_size_from(instance, value)
-        instance.size = Properties::FontSize.new(value: value.to_i) if value
-      end
-
-      def yaml_size_to(_instance, _doc)
-        size&.value
-      end
-
-      def yaml_character_spacing_from(instance, value)
-        instance.character_spacing = Properties::CharacterSpacing.new(value: value.to_i) if value
-      end
-
-      def yaml_character_spacing_to(_instance, _doc)
-        character_spacing&.value
-      end
-
-      def yaml_underline_from(instance, value)
-        instance.underline = Properties::Underline.new(value: value) if value
-      end
-
-      def yaml_underline_to(_instance, _doc)
-        underline&.value
-      end
-
-      def yaml_color_from(instance, value)
-        instance.color = Properties::ColorValue.new(value: value) if value
-      end
-
-      def yaml_color_to(_instance, _doc)
-        color&.value
-      end
-
-      def yaml_highlight_from(instance, value)
-        instance.highlight = Properties::Highlight.new(value: value) if value
-      end
-
-      def yaml_highlight_to(_instance, _doc)
-        highlight&.value
-      end
-
-      def yaml_font_from(instance, value)
-        instance.fonts ||= Properties::RunFonts.new
-        instance.fonts.ascii = value if value
-      end
-
-      def yaml_font_to(_instance, _doc)
-        fonts&.ascii
-      end
-
-      def yaml_font_ascii_from(instance, value)
-        instance.fonts ||= Properties::RunFonts.new
-        instance.fonts.ascii = value if value
-      end
-
-      def yaml_font_ascii_to(_instance, _doc)
-        fonts&.ascii
-      end
-
-      def yaml_font_east_asia_from(instance, value)
-        instance.fonts ||= Properties::RunFonts.new
-        instance.fonts.east_asia = value if value
-      end
-
-      def yaml_font_east_asia_to(_instance, _doc)
-        fonts&.east_asia
-      end
-
-      def yaml_font_h_ansi_from(instance, value)
-        instance.fonts ||= Properties::RunFonts.new
-        instance.fonts.h_ansi = value if value
-      end
-
-      def yaml_font_h_ansi_to(_instance, _doc)
-        fonts&.h_ansi
-      end
-
-      def yaml_font_cs_from(instance, value)
-        instance.fonts ||= Properties::RunFonts.new
-        instance.fonts.cs = value if value
-      end
-
-      def yaml_font_cs_to(_instance, _doc)
-        fonts&.cs
-      end
-
-      def yaml_emboss_from(instance, value)
-        instance.emboss = Properties::Emboss.new(value: value) unless value.nil?
-      end
-
-      def yaml_emboss_to(_instance, _doc)
-        emboss&.value
-      end
-
-      def yaml_imprint_from(instance, value)
-        instance.imprint = Properties::Imprint.new(value: value) unless value.nil?
-      end
-
-      def yaml_imprint_to(_instance, _doc)
-        imprint&.value
-      end
-
-      def yaml_shadow_from(instance, value)
-        instance.shadow = Properties::Shadow.new(value: value) unless value.nil?
-      end
-
-      def yaml_shadow_to(_instance, _doc)
-        shadow&.value
-      end
-
-      def yaml_outline_from(instance, value)
-        instance.outline_level = Properties::OutlineLevel.new(value: value) unless value.nil?
-      end
-
-      def yaml_outline_to(_instance, _doc)
-        outline_level&.value
-      end
-
-      def yaml_vertical_align_from(instance, value)
-        instance.vertical_align = Properties::VerticalAlign.new(value: value) if value
-      end
-
-      def yaml_vertical_align_to(_instance, _doc)
-        vertical_align&.value
+        map "bold", with: { from: :yaml_bold_from, to: :yaml_bold_to }
+        map "italic", with: { from: :yaml_italic_from, to: :yaml_italic_to }
+        map "strike", with: { from: :yaml_strike_from, to: :yaml_strike_to }
+        map "double_strike",
+            with: { from: :yaml_double_strike_from, to: :yaml_double_strike_to }
+        map "small_caps",
+            with: { from: :yaml_small_caps_from, to: :yaml_small_caps_to }
+        map "caps", with: { from: :yaml_caps_from, to: :yaml_caps_to }
+        map "all_caps", with: { from: :yaml_caps_from, to: :yaml_caps_to } # Alias
+        map "hidden", with: { from: :yaml_hidden_from, to: :yaml_hidden_to }
+        map "size", with: { from: :yaml_size_from, to: :yaml_size_to }
+        map "spacing",
+            with: { from: :yaml_character_spacing_from,
+                    to: :yaml_character_spacing_to }
+        map "character_spacing",
+            with: { from: :yaml_character_spacing_from,
+                    to: :yaml_character_spacing_to }
+        map "underline",
+            with: { from: :yaml_underline_from, to: :yaml_underline_to }
+        map "color", with: { from: :yaml_color_from, to: :yaml_color_to }
+        map "highlight",
+            with: { from: :yaml_highlight_from, to: :yaml_highlight_to }
+        map "font", with: { from: :yaml_font_from, to: :yaml_font_to }
+        map "font_ascii",
+            with: { from: :yaml_font_ascii_from, to: :yaml_font_ascii_to }
+        map "font_east_asia",
+            with: { from: :yaml_font_east_asia_from,
+                    to: :yaml_font_east_asia_to }
+        map "font_h_ansi",
+            with: { from: :yaml_font_h_ansi_from, to: :yaml_font_h_ansi_to }
+        map "font_cs", with: { from: :yaml_font_cs_from, to: :yaml_font_cs_to }
+        map "emboss", with: { from: :yaml_emboss_from, to: :yaml_emboss_to }
+        map "imprint", with: { from: :yaml_imprint_from, to: :yaml_imprint_to }
+        map "shadow", with: { from: :yaml_shadow_from, to: :yaml_shadow_to }
+        map "outline", with: { from: :yaml_outline_from, to: :yaml_outline_to }
+        map "vertical_align",
+            with: { from: :yaml_vertical_align_from,
+                    to: :yaml_vertical_align_to }
       end
 
       # XML mappings come AFTER attributes
       xml do
-        element 'rPr'
+        element "rPr"
         namespace Uniword::Ooxml::Namespaces::WordProcessingML
         mixed_content
 
         # Style reference (wrapper object)
-        map_element 'rStyle', to: :style, render_nil: false
+        map_element "rStyle", to: :style, render_nil: false
 
         # Fonts (complex object)
-        map_element 'rFonts', to: :fonts, render_nil: false
+        map_element "rFonts", to: :fonts, render_nil: false
 
         # Font sizes (wrapper objects)
-        map_element 'sz', to: :size, render_nil: false
-        map_element 'szCs', to: :size_cs, render_nil: false
+        map_element "sz", to: :size, render_nil: false
+        map_element "szCs", to: :size_cs, render_nil: false
 
         # Boolean formatting (wrapper objects)
-        map_element 'b', to: :bold, render_nil: false
-        map_element 'bCs', to: :bold_cs, render_nil: false
-        map_element 'i', to: :italic, render_nil: false
-        map_element 'iCs', to: :italic_cs, render_nil: false
-        map_element 'strike', to: :strike, render_nil: false
-        map_element 'dstrike', to: :double_strike, render_nil: false
-        map_element 'smallCaps', to: :small_caps, render_nil: false
-        map_element 'caps', to: :caps, render_nil: false
-        map_element 'vanish', to: :hidden, render_nil: false
-        map_element 'noProof', to: :no_proof, render_nil: false
+        map_element "b", to: :bold, render_nil: false
+        map_element "bCs", to: :bold_cs, render_nil: false
+        map_element "i", to: :italic, render_nil: false
+        map_element "iCs", to: :italic_cs, render_nil: false
+        map_element "strike", to: :strike, render_nil: false
+        map_element "dstrike", to: :double_strike, render_nil: false
+        map_element "smallCaps", to: :small_caps, render_nil: false
+        map_element "caps", to: :caps, render_nil: false
+        map_element "vanish", to: :hidden, render_nil: false
+        map_element "noProof", to: :no_proof, render_nil: false
+        map_element "webHidden", to: :web_hidden, render_nil: false
 
         # Color (wrapper object)
-        map_element 'color', to: :color, render_nil: false
+        map_element "color", to: :color, render_nil: false
 
         # Underline (wrapper object)
-        map_element 'u', to: :underline, render_nil: false
+        map_element "u", to: :underline, render_nil: false
 
         # Highlight (wrapper object)
-        map_element 'highlight', to: :highlight, render_nil: false
+        map_element "highlight", to: :highlight, render_nil: false
 
         # Vertical alignment (wrapper object)
-        map_element 'vertAlign', to: :vertical_align, render_nil: false
+        map_element "vertAlign", to: :vertical_align, render_nil: false
 
         # Position (wrapper object)
-        map_element 'position', to: :position, render_nil: false
+        map_element "position", to: :position, render_nil: false
 
         # Character spacing (wrapper object)
-        map_element 'spacing', to: :character_spacing, render_nil: false
+        map_element "spacing", to: :character_spacing, render_nil: false
 
         # Kerning (wrapper object)
-        map_element 'kern', to: :kerning, render_nil: false
+        map_element "kern", to: :kerning, render_nil: false
 
         # Width scale (wrapper object)
-        map_element 'w', to: :width_scale, render_nil: false
+        map_element "w", to: :width_scale, render_nil: false
 
         # Emphasis mark (wrapper object)
-        map_element 'em', to: :emphasis_mark, render_nil: false
+        map_element "em", to: :emphasis_mark, render_nil: false
 
         # Shading (complex object)
-        map_element 'shd', to: :shading, render_nil: false
+        map_element "shd", to: :shading, render_nil: false
 
         # Language (complex object)
-        map_element 'lang', to: :language, render_nil: false
+        map_element "lang", to: :language, render_nil: false
 
         # Text effects (complex objects - basic support)
-        map_element 'textFill', to: :text_fill, render_nil: false
-        map_element 'textOutline', to: :text_outline, render_nil: false
+        map_element "textFill", to: :text_fill, render_nil: false
+        map_element "textOutline", to: :text_outline, render_nil: false
 
         # Additional boolean formatting
-        map_element 'shadow', to: :shadow, render_nil: false
-        map_element 'emboss', to: :emboss, render_nil: false
-        map_element 'imprint', to: :imprint, render_nil: false
-        map_element 'outline', to: :outline, render_nil: false
-      end
-
-      # Helper methods for boolean values (handle both wrapper and primitive)
-      def bold?
-        val = bold
-        return false if val.nil?
-
-        val = val.value if val.is_a?(Uniword::Properties::BooleanElement)
-        val == true
-      end
-
-      def italic?
-        val = italic
-        return false if val.nil?
-
-        val = val.value if val.is_a?(Uniword::Properties::BooleanElement)
-        val == true
-      end
-
-      def strike?
-        val = strike
-        return false if val.nil?
-
-        val = val.value if val.is_a?(Uniword::Properties::BooleanElement)
-        val == true
-      end
-
-      # Get all_caps - returns boolean
-      def all_caps
-        val = @all_caps || caps
-        return false if val.nil?
-
-        val = val.value if val.is_a?(Uniword::Properties::BooleanElement)
-        val == true
-      end
-
-      # Set all_caps
-      def all_caps=(value)
-        @all_caps = value
-        self.caps = value.is_a?(Properties::Caps) ? value : Properties::Caps.new(value: value)
-        value
-      end
-
-      # Get all_caps? (alias for caps?)
-      def all_caps?
-        caps?
-      end
-
-      # Get caps? predicate
-      def caps?
-        val = caps
-        return false if val.nil?
-
-        val = val.value if val.is_a?(Uniword::Properties::BooleanElement)
-        val == true
-      end
-
-      # Font convenience getters - delegate to fonts wrapper
-      def font
-        fonts&.ascii
-      end
-
-      # Set font name on ASCII slot
-      def font=(value)
-        self.fonts ||= Properties::RunFonts.new
-        fonts.ascii = value
-      end
-
-      def font_ascii
-        fonts&.ascii
-      end
-
-      def font_east_asia
-        fonts&.east_asia
-      end
-
-      def font_h_ansi
-        fonts&.h_ansi
-      end
-
-      def font_cs
-        fonts&.cs
-      end
-
-      # Language convenience getters - delegate to language wrapper
-      def language_val
-        language&.val
-      end
-
-      def language_east_asia
-        language&.east_asia
-      end
-
-      def language_bidi
-        language&.bidi
-      end
-
-      # Shading convenience getters - delegate to shading wrapper
-      def shading_fill
-        shading&.fill
-      end
-
-      def shading_type
-        shading&.pattern
-      end
-
-      # Convenience predicate methods for RunProperties
-      def small_caps?
-        val = small_caps
-        return false if val.nil?
-
-        val = val.value if val.is_a?(Properties::SmallCaps)
-        val == true
-      end
-
-      def shadow?
-        val = shadow
-        return false if val.nil?
-
-        val = val.value if val.is_a?(Properties::Shadow)
-        val == true
-      end
-
-      def imprint?
-        val = imprint
-        return false if val.nil?
-
-        val = val.value if val.is_a?(Properties::Imprint)
-        val == true
-      end
-
-      def emboss?
-        val = emboss
-        return false if val.nil?
-
-        val = val.value if val.is_a?(Properties::Emboss)
-        val == true
-      end
-
-      def hidden?
-        val = hidden
-        return false if val.nil?
-
-        val = val.value if val.is_a?(Properties::Vanish)
-        val == true
-      end
-
-      def outline?
-        val = outline
-        return false if val.nil?
-
-        val = val.val if val.is_a?(Properties::Outline)
-        val != 'false'
-      end
-
-      def shading_color
-        shading&.fill
-      end
-
-      def shading_color=(value)
-        self.shading ||= Properties::Shading.new
-        shading.fill = value
-        self
-      end
-
-      def page_break=(_value)
-        self
-      end
-
-      # Get text expansion (alias for width_scale)
-      #
-      # @return [Properties::WidthScale, nil] Width scale wrapper object
-      def text_expansion
-        width_scale
-      end
-
-      # Set text expansion
-      #
-      # @param value [Integer, Properties::WidthScale] Width scale value
-      # @return [self] For method chaining
-      def text_expansion=(value)
-        self.width_scale = if value.is_a?(Properties::WidthScale)
-                             value
-                           else
-                             Properties::WidthScale.new(value: value)
-                           end
-        self
-      end
-
-      # Initialize with defaults and handle primitive-to-wrapper conversion
-      def initialize(attrs = {})
-        # Extract flat convenience keys before super (lutaml-model ignores
-        # unknown keys). These are converted to proper wrapper objects below.
-        font_val = attrs.delete(:font) || attrs.delete('font')
-        font_ascii_val = attrs.delete(:font_ascii) || attrs.delete('font_ascii')
-        font_ea_val = attrs.delete(:font_east_asia) || attrs.delete('font_east_asia')
-        font_ha_val = attrs.delete(:font_h_ansi) || attrs.delete('font_h_ansi')
-        font_cs_val = attrs.delete(:font_cs) || attrs.delete('font_cs')
-        lang_val = attrs.delete(:language_val) || attrs.delete('language_val')
-        lang_ea = attrs.delete(:language_east_asia) || attrs.delete('language_east_asia')
-        lang_bidi = attrs.delete(:language_bidi) || attrs.delete('language_bidi')
-        # Also intercept language: 'en-US' (lutaml-model stores raw string
-        # when a primitive is passed for a typed attribute via constructor).
-        # Only extract if it's a String; leave Properties::Language objects
-        # for lutaml-model to handle normally.
-        raw_language = attrs[:language] || attrs['language']
-        if raw_language.is_a?(String)
-          attrs.delete(:language)
-          attrs.delete('language')
-        else
-          raw_language = nil
-        end
-        shading_fill_val = attrs.delete(:shading_fill) || attrs.delete('shading_fill')
-        shading_type_val = attrs.delete(:shading_type) || attrs.delete('shading_type')
-
-        super
-
-        # Convert primitive values to wrapper objects (Pattern 0: run after super)
-        # This handles cases like RunProperties.new(bold: true) where primitives
-        # are passed instead of wrapper objects
-        convert_primitive_attributes!
-
-        # Map removed flat font attributes to fonts wrapper.
-        # font_ascii takes precedence over font for the ASCII slot.
-        if font_val || font_ascii_val
-          self.fonts ||= Properties::RunFonts.new
-          fonts.ascii = font_ascii_val || font_val
-        end
-        if font_ea_val
-          self.fonts ||= Properties::RunFonts.new
-          fonts.east_asia = font_ea_val
-        end
-        if font_ha_val
-          self.fonts ||= Properties::RunFonts.new
-          fonts.h_ansi = font_ha_val
-        end
-        if font_cs_val
-          self.fonts ||= Properties::RunFonts.new
-          fonts.cs = font_cs_val
-        end
-
-        # Map removed flat language attributes to language wrapper.
-        if lang_val || lang_ea || lang_bidi || raw_language
-          self.language = Properties::Language.new
-          language.val = lang_val || raw_language if lang_val || raw_language
-          language.east_asia = lang_ea if lang_ea
-          language.bidi = lang_bidi if lang_bidi
-        end
-
-        # Map removed flat shading attributes to shading wrapper
-        return unless shading_fill_val || shading_type_val
-
-        self.shading ||= Properties::Shading.new
-        shading.fill = shading_fill_val if shading_fill_val
-        shading.pattern = shading_type_val if shading_type_val
-      end
-
-      # Convert primitive attribute values to proper wrapper objects
-      # Called after super() to handle cases where primitives were passed
-      # instead of the expected Serializable wrapper types
-      def convert_primitive_attributes!
-        # Boolean formatting properties
-        @bold = Properties::Bold.new(value: @bold) if @bold && !@bold.is_a?(Properties::Bold)
-        if @bold_cs && !@bold_cs.is_a?(Properties::BoldCs)
-          @bold_cs = Properties::BoldCs.new(value: @bold_cs)
-        end
-        if @italic && !@italic.is_a?(Properties::Italic)
-          @italic = Properties::Italic.new(value: @italic)
-        end
-        if @italic_cs && !@italic_cs.is_a?(Properties::ItalicCs)
-          @italic_cs = Properties::ItalicCs.new(value: @italic_cs)
-        end
-        if @strike && !@strike.is_a?(Properties::Strike)
-          @strike = Properties::Strike.new(value: @strike)
-        end
-        if @double_strike && !@double_strike.is_a?(Properties::DoubleStrike)
-          @double_strike = Properties::DoubleStrike.new(value: @double_strike)
-        end
-        if @small_caps && !@small_caps.is_a?(Properties::SmallCaps)
-          @small_caps = Properties::SmallCaps.new(value: @small_caps)
-        end
-        @caps = Properties::Caps.new(value: @caps) if @caps && !@caps.is_a?(Properties::Caps)
-        if @hidden && !@hidden.is_a?(Properties::Vanish)
-          @hidden = Properties::Vanish.new(value: @hidden)
-        end
-
-        # Style - convert string to RunStyleReference wrapper
-        @style = Properties::RunStyleReference.new(value: @style) if @style.is_a?(String)
-
-        # Font size (half-points)
-        if @size && !@size.is_a?(Properties::FontSize)
-          val = @size.is_a?(Numeric) ? @size : @size.to_i
-          @size = Properties::FontSize.new(value: val)
-        end
-        if @size_cs && !@size_cs.is_a?(Properties::FontSize)
-          val = @size_cs.is_a?(Numeric) ? @size_cs : @size_cs.to_i
-          @size_cs = Properties::FontSize.new(value: val)
-        end
-
-        # Color
-        if @color && !@color.is_a?(Properties::ColorValue)
-          @color = Properties::ColorValue.new(value: @color.to_s)
-        end
-
-        # Underline
-        if @underline && !@underline.is_a?(Properties::Underline)
-          @underline = if @underline == true || @underline == 'single'
-                         Properties::Underline.new(value: 'single')
-                       elsif @underline.is_a?(String)
-                         Properties::Underline.new(value: @underline)
-                       else
-                         Properties::Underline.new(value: @underline.to_s)
-                       end
-        end
-
-        # Highlight
-        if @highlight && !@highlight.is_a?(Properties::Highlight)
-          @highlight = Properties::Highlight.new(value: @highlight.to_s)
-        end
-
-        # Vertical alignment
-        if @vertical_align && !@vertical_align.is_a?(Properties::VerticalAlign)
-          @vertical_align = Properties::VerticalAlign.new(value: @vertical_align.to_s)
-        end
-
-        # Position
-        if @position && !@position.is_a?(Properties::Position)
-          @position = Properties::Position.new(value: @position)
-        end
-
-        # Character spacing
-        if @character_spacing && !@character_spacing.is_a?(Properties::CharacterSpacing)
-          @character_spacing = Properties::CharacterSpacing.new(value: @character_spacing)
-        end
-
-        # Kerning
-        if @kerning && !@kerning.is_a?(Properties::Kerning)
-          @kerning = Properties::Kerning.new(value: @kerning)
-        end
-
-        # Width scale
-        if @width_scale && !@width_scale.is_a?(Properties::WidthScale)
-          @width_scale = Properties::WidthScale.new(value: @width_scale)
-        end
-
-        # Emphasis mark
-        if @emphasis_mark && !@emphasis_mark.is_a?(Properties::EmphasisMark)
-          @emphasis_mark = Properties::EmphasisMark.new(value: @emphasis_mark.to_s)
-        end
-
-        # Text fill
-        if @text_fill && !@text_fill.is_a?(Properties::TextFill)
-          @text_fill = Properties::TextFill.new
-        end
-
-        # Text outline
-        return unless @text_outline && !@text_outline.is_a?(Properties::TextOutline)
+        map_element "shadow", to: :shadow, render_nil: false
+        map_element "emboss", to: :emboss, render_nil: false
+        map_element "imprint", to: :imprint, render_nil: false
+        map_element "outline", to: :outline, render_nil: false
 
-        @text_outline = Properties::TextOutline.new
+        # W14 namespace elements
+        map_element "ligatures", to: :ligatures, render_nil: false
       end
     end
   end