activemail 1.2.3 → 2.1.0

data/lib/activemail/asset_pipeline/base.rb

@@ -0,0 +1,47 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'sorbet-runtime'
+
+module ActiveMail
+  module AssetPipeline
+    class Base
+      extend T::Sig
+      extend T::Helpers
+
+      abstract!
+
+      sig { params(app: T.untyped).void }
+      def initialize(app)
+        @app = T.let(app, T.untyped)
+        @cache = T.let({}, T::Hash[String, String])
+      end
+
+      sig { params(logical_path: String).returns(T.nilable(String)) }
+      def read(logical_path)
+        return fetch(logical_path) unless cache?
+
+        cached = @cache[logical_path]
+        return cached if cached
+
+        fetch(logical_path).tap { |css| @cache[logical_path] = css if css }
+      end
+
+      sig { params(_paths: T::Array[String]).void }
+      def register_precompile(_paths); end
+
+      private
+
+      sig { abstract.params(logical_path: String).returns(T.nilable(String)) }
+      def fetch(logical_path); end
+
+      sig { returns(T.untyped) }
+      attr_reader :app
+
+      sig { returns(T::Boolean) }
+      def cache?
+        !app.config.enable_reloading
+      end
+    end
+  end
+end

data/lib/activemail/asset_pipeline/null.rb

@@ -0,0 +1,19 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module ActiveMail
+  module AssetPipeline
+    class Null < Base
+      extend T::Sig
+
+      private
+
+      sig { override.params(_logical_path: String).returns(T.nilable(String)) }
+      def fetch(_logical_path)
+        nil
+      end
+    end
+  end
+end

data/lib/activemail/asset_pipeline/propshaft.rb

@@ -0,0 +1,19 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module ActiveMail
+  module AssetPipeline
+    class Propshaft < Base
+      extend T::Sig
+
+      private
+
+      sig { override.params(logical_path: String).returns(T.nilable(String)) }
+      def fetch(logical_path)
+        app.assets.load_path.find(logical_path)&.content&.force_encoding(Encoding::UTF_8)
+      end
+    end
+  end
+end

data/lib/activemail/asset_pipeline/sprockets.rb

@@ -0,0 +1,39 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module ActiveMail
+  module AssetPipeline
+    class Sprockets < Base
+      extend T::Sig
+
+      sig { override.params(paths: T::Array[String]).void }
+      def register_precompile(paths)
+        app.config.assets.precompile += paths
+      end
+
+      private
+
+      # app.assets is the live environment (compile = true); with precompiled
+      # assets it is nil and only the manifest can resolve the logical path.
+      sig { override.params(logical_path: String).returns(T.nilable(String)) }
+      def fetch(logical_path)
+        environment = app.assets
+        return environment.find_asset(logical_path)&.to_s if environment
+
+        manifest_source(logical_path)
+      end
+
+      sig { params(logical_path: String).returns(T.nilable(String)) }
+      def manifest_source(logical_path)
+        manifest = app.assets_manifest
+        compiled = manifest&.assets&.[](logical_path)
+        return unless compiled
+
+        path = File.join(manifest.directory, compiled)
+        File.read(path) if File.file?(path)
+      end
+    end
+  end
+end

data/lib/activemail/asset_pipeline.rb

@@ -0,0 +1,35 @@
+# typed: false
+# frozen_string_literal: true
+
+require 'sorbet-runtime'
+
+require_relative 'asset_pipeline/base'
+require_relative 'asset_pipeline/sprockets'
+require_relative 'asset_pipeline/propshaft'
+require_relative 'asset_pipeline/null'
+
+module ActiveMail
+  module AssetPipeline
+    class << self
+      extend T::Sig
+
+      # Never respond_to?: Sprockets' config.assets is an OrderedOptions that
+      # answers it for any key.
+      sig { params(app: T.untyped).returns(ActiveMail::AssetPipeline::Base) }
+      def for(app)
+        if defined?(::Sprockets::Railtie)
+          Sprockets.new(app)
+        elsif defined?(::Propshaft)
+          Propshaft.new(app)
+        else
+          Null.new(app)
+        end
+      end
+
+      sig { returns(ActiveMail::AssetPipeline::Base) }
+      def current
+        @current ||= T.let(self.for(::Rails.application), T.nilable(ActiveMail::AssetPipeline::Base))
+      end
+    end
+  end
+end

data/lib/activemail/components/base.rb

@@ -21,22 +21,20 @@ module ActiveMail
       end
     end
 
-    # Public extension point: subclass, implement #transform(node, inner), then register.
+    # `inner` is an opaque slot: interpolate it exactly once; the engine moves the
+    # already transformed children there.
     class Base
       extend T::Sig
       extend T::Helpers
 
       abstract!
 
-      IGNORED_ON_PASSTHROUGH = T.let(
-        %w[class id href size large no-expander small target rel up size-sm size-lg style].freeze,
-        T::Array[String]
-      )
+      HANDLED_ATTRIBUTES = T.let(%w[class style].freeze, T::Array[String])
+      LINK_ATTRIBUTES = T.let(%w[href target rel].freeze, T::Array[String])
 
       # Layout tables: presentation role (a11y) and zeroed legacy spacing.
       TABLE_RESET = 'role="presentation" border="0" cellpadding="0" cellspacing="0"'
-
-      BUTTON_PADDING = 'padding:12px 24px;'
+      TABLE_RESET_ATTRIBUTES = T.let(%w[role border cellpadding cellspacing].freeze, T::Array[String])
 
       sig { params(core: ::ActiveMail::Core).void }
       def initialize(core)
@@ -57,19 +55,33 @@ module ActiveMail
         CGI.escapeHTML(value.to_s)
       end
 
-      # Author attributes are untrusted: "abc".to_i would silently become 0.
       sig { params(value: T.untyped).returns(T.nilable(Integer)) }
       def positive_int(value)
-        # The RBI types Integer(exception: false) as non-nilable; it does return nil.
-        int = T.let(Integer(value.to_s, exception: false), T.nilable(Integer))
-        int if int&.positive?
+        ActiveMail.parse_positive_integer(value)
       end
 
-      sig { params(node: Nokogiri::XML::Node).returns(String) }
-      def pass_through_attributes(node)
-        node.attributes.reject { |name, _| IGNORED_ON_PASSTHROUGH.include?(name.downcase) }.map do |name, value|
-          %(#{name}="#{escape_attr(value)}" )
-        end.join
+      sig { overridable.returns(T::Array[String]) }
+      def consumed_attributes
+        []
+      end
+
+      sig do
+        params(node: Nokogiri::XML::Node, classes: T.nilable(String), layout_style: String, skip: T::Array[String]).returns(String)
+      end
+      def root_attributes(node, classes:, layout_style: '', skip: [])
+        "#{class_attribute(node, classes)}#{passthrough_attributes(node, skip)}#{style_attribute(node, layout_style)}"
+      end
+
+      sig { params(node: Nokogiri::XML::Node, classes: T.nilable(String)).returns(String) }
+      def class_attribute(node, classes)
+        merged = combine_classes(node, classes)
+        merged.empty? ? '' : %( class="#{escape_attr(merged)}")
+      end
+
+      sig { params(node: Nokogiri::XML::Node, skip: T::Array[String]).returns(String) }
+      def passthrough_attributes(node, skip = [])
+        reserved = HANDLED_ATTRIBUTES + consumed_attributes + skip
+        node.attributes.except(*reserved).map { |name, attr| %( #{name}="#{escape_attr(attr.value)}") }.join
       end
 
       # Author style merged after layout (a duplicated style attribute would be
@@ -84,7 +96,7 @@ module ActiveMail
 
       sig { params(node: Nokogiri::XML::Node, klass: String).returns(T::Boolean) }
       def class?(node, klass)
-        !((node.attr('class') || '') =~ /(^|\s)#{Regexp.escape(klass)}($|\s)/).nil?
+        node['class'].to_s.split.include?(klass)
       end
 
       sig { params(node: Nokogiri::XML::Node, extra_classes: T.nilable(String)).returns(String) }
@@ -94,14 +106,6 @@ module ActiveMail
         (existing + to_add).uniq.join(' ')
       end
 
-      sig { params(node: Nokogiri::XML::Node, extra_classes: T.nilable(String)).returns(String) }
-      def combine_attributes(node, extra_classes = nil)
-        classes = combine_classes(node, extra_classes)
-        # Escape like the other attribute paths: a literal " in the class would
-        # otherwise reopen the attribute.
-        [pass_through_attributes(node), %(class="#{escape_attr(classes)}")].join
-      end
-
       sig { params(node: Nokogiri::XML::Node).returns(String) }
       def link_attributes(node)
         target = node.attributes['target']&.value
@@ -112,24 +116,16 @@ module ActiveMail
         ].join
       end
 
+      sig { params(node: Nokogiri::XML::Node, inner: String, before: String, after: String).returns(String) }
+      def anchor(node, inner, before: '', after: '')
+        %(<a#{before} href="#{escape_attr(node.attr('href'))}"#{link_attributes(node)}#{after}>#{inner}</a>)
+      end
+
       sig { params(node: Nokogiri::XML::Node, target: T.nilable(String)).returns(T.nilable(String)) }
       def resolve_rel(node, target)
         rel = node.attributes['rel']&.value
         rel = nil if rel&.strip&.empty?
-        rel || (ActiveMail.configuration.blank_link_rel if target == '_blank')
-      end
-
-      # Outlook-safe nested-table structure kept in one place for <button> and <cta>.
-      sig do
-        params(outer_classes: String, inner: String, cell_style: String, outer_extra: String).returns(String)
-      end
-      def bulletproof_button_table(outer_classes:, inner:, cell_style: '', outer_extra: '')
-        cell = cell_style.empty? ? '<td>' : %(<td style="#{cell_style}">)
-        [
-          %(<table class="#{outer_classes}" #{TABLE_RESET}><tbody><tr><td>),
-          %(<table #{TABLE_RESET}><tbody><tr>#{cell}#{inner}</td></tr></tbody></table>),
-          %(</td>#{outer_extra}</tr></tbody></table>)
-        ].join
+        rel || (core.config.blank_link_rel if target == '_blank')
       end
 
       sig { returns(Integer) }

data/lib/activemail/components/block_grid.rb

@@ -1,18 +1,25 @@
 # typed: strict
 # frozen_string_literal: true
 
-require_relative 'base'
+require_relative 'table_component'
 
 module ActiveMail
   module Components
-    class BlockGrid < Base
+    class BlockGrid < TableComponent
       extend T::Sig
 
       sig { override.params(node: Nokogiri::XML::Node, inner: String).returns(String) }
       def transform(node, inner)
         up = positive_int(node.attr('up'))
-        classes = combine_classes(node, ['block-grid', up && "up-#{up}"].compact.join(' '))
-        %(<table class="#{classes}" #{TABLE_RESET}#{style_attribute(node, 'width:100%;')}><tbody><tr>#{inner}</tr></tbody></table>)
+        classes = ['block-grid', up && "up-#{up}"].compact.join(' ')
+        %(<table#{root_attributes(node, classes: classes, layout_style: 'width:100%;')} #{TABLE_RESET}><tbody><tr>#{inner}</tr></tbody></table>)
+      end
+
+      private
+
+      sig { override.returns(T::Array[String]) }
+      def consumed_attributes
+        [*super, 'up']
       end
     end
   end

data/lib/activemail/components/button.rb

@@ -1,39 +1,16 @@
 # typed: strict
 # frozen_string_literal: true
 
-require_relative 'base'
+require_relative 'button_renderer'
 
 module ActiveMail
   module Components
-    class Button < Base
+    class Button < ButtonRenderer
       extend T::Sig
 
-      sig { override.params(node: Nokogiri::XML::Node, inner: String).returns(String) }
-      def transform(node, inner)
-        expand = class?(node, 'expand')
-        inner = anchor(node, inner, expand) if node.attr('href')
-        inner = "<center>#{inner}</center>" if expand
-
-        expander = expand ? '<td class="expander"></td>' : ''
-        # CSS-driven by design: colors come from .button rules, not inline tokens —
-        # a distinct robustness model from <cta>, which inlines its palette.
-        bulletproof_button_table(
-          outer_classes: combine_classes(node, 'button'),
-          inner: inner,
-          outer_extra: expander
-        )
-      end
-
-      private
-
-      sig { params(node: Nokogiri::XML::Node, inner: String, expand: T::Boolean).returns(String) }
-      def anchor(node, inner, expand)
-        links = link_attributes(node)
-        extra = expand ? ' align="center" class="float-center"' : ''
-        # Padding on the <a> makes the whole button a clickable target.
-        link_style = "display:inline-block;text-decoration:none;#{BUTTON_PADDING}"
-        attrs = %(#{pass_through_attributes(node)}href="#{escape_attr(node.attr('href'))}"#{links}#{extra})
-        %(<a #{attrs}#{style_attribute(node, link_style)}>#{inner}</a>)
+      sig { override.returns(String) }
+      def root_class
+        'button'
       end
     end
   end

data/lib/activemail/components/button_renderer.rb

@@ -0,0 +1,69 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module ActiveMail
+  module Components
+    # Bulletproof button shared by <button> and <cta>: styles are inlined from the
+    # tokens (read at transform time) so it survives clients that strip <style>.
+    class ButtonRenderer < Base
+      extend T::Sig
+      extend T::Helpers
+
+      abstract!
+
+      CONTROL_PADDING = 'padding:12px 24px;'
+      MSO_CELL_PADDING = 'mso-padding-alt:12px 24px;'
+      LINE_HEIGHT = '1.25'
+
+      sig { abstract.returns(String) }
+      def root_class; end
+
+      sig { override.params(node: Nokogiri::XML::Node, inner: String).returns(String) }
+      def transform(node, inner)
+        style = core.config.tokens.button_style(class?(node, 'secondary') ? :secondary : :primary)
+        expand = class?(node, 'expand')
+        width = expand ? ' style="width:100%;"' : ''
+        [
+          %(<table#{class_attribute(node, root_class)} #{TABLE_RESET}#{width}><tbody><tr><td>),
+          %(<table #{TABLE_RESET}#{width}><tbody><tr><td style="#{cell_style(style, expand)}">),
+          control(node, inner, style, expand),
+          '</td></tr></tbody></table></td></tr></tbody></table>'
+        ].join
+      end
+
+      private
+
+      sig { override.returns(T::Array[String]) }
+      def consumed_attributes
+        LINK_ATTRIBUTES
+      end
+
+      # Padding on the control makes the whole button a clickable target; Outlook Word
+      # ignores it there, so the cell repeats it as `mso-padding-alt`.
+      sig { params(node: Nokogiri::XML::Node, inner: String, style: ActiveMail::Tokens::ButtonStyle, expand: T::Boolean).returns(String) }
+      def control(node, inner, style, expand)
+        css = control_style(style, expand)
+        extra = passthrough_attributes(node)
+        return %(<span#{extra}#{style_attribute(node, css)}>#{inner}</span>) unless node.attr('href')
+
+        anchor(node, inner, before: extra, after: style_attribute(node, css))
+      end
+
+      # Fill, corners and outline live on the cell only: repeating them on the control would double them.
+      sig { params(style: ActiveMail::Tokens::ButtonStyle, expand: T::Boolean).returns(String) }
+      def cell_style(style, expand)
+        border = style.border ? "border:1px solid #{style.border};" : ''
+        "background:#{style.background};border-radius:#{style.radius};#{border}#{MSO_CELL_PADDING}#{'text-align:center;' if expand}"
+      end
+
+      sig { params(style: ActiveMail::Tokens::ButtonStyle, expand: T::Boolean).returns(String) }
+      def control_style(style, expand)
+        "display:#{expand ? 'block' : 'inline-block'};text-decoration:none;#{CONTROL_PADDING}" \
+          "font-family:#{escape_attr(core.config.tokens.font!(:body))};line-height:#{LINE_HEIGHT};" \
+          "color:#{style.color};font-weight:bold;"
+      end
+    end
+  end
+end

data/lib/activemail/components/callout.rb

@@ -1,20 +1,19 @@
 # typed: strict
 # frozen_string_literal: true
 
-require_relative 'base'
+require_relative 'table_component'
 
 module ActiveMail
   module Components
-    class Callout < Base
+    class Callout < TableComponent
       extend T::Sig
 
       sig { override.params(node: Nokogiri::XML::Node, inner: String).returns(String) }
       def transform(node, inner)
         classes = combine_classes(node, 'callout-inner')
-        attributes = pass_through_attributes(node)
         [
-          %(<table #{attributes}class="callout" #{TABLE_RESET}#{style_attribute(node, 'width:100%;')}><tbody><tr>),
-          %(<th class="#{classes}">#{inner}</th><th class="expander"></th>),
+          %(<table class="callout"#{passthrough_attributes(node)}#{style_attribute(node, 'width:100%;')} #{TABLE_RESET}><tbody><tr>),
+          %(<th class="#{escape_attr(classes)}">#{inner}</th><th class="expander"></th>),
           '</tr></tbody></table>'
         ].join
       end

data/lib/activemail/components/center.rb

@@ -8,16 +8,16 @@ module ActiveMail
     class Center < Base
       extend T::Sig
 
-      sig { override.params(node: Nokogiri::XML::Node, _inner: String).returns(String) }
-      def transform(node, _inner)
-        elements = node.elements
-        elements.each do |child|
-          child['align'] = 'center'
-          child['class'] = combine_classes(child, 'float-center')
-        end
-        items = elements.css('.menu-item').to_a.concat(elements.css('item').to_a)
-        items.each { |item| item['class'] = combine_classes(item, 'float-center') }
-        node.to_s
+      sig { override.params(node: Nokogiri::XML::Node, inner: String).returns(String) }
+      def transform(node, inner)
+        %(<center#{root_attributes(node, classes: 'float-center')} align="center">#{inner}</center>)
+      end
+
+      private
+
+      sig { override.returns(T::Array[String]) }
+      def consumed_attributes
+        ['align']
       end
     end
   end

data/lib/activemail/components/columns.rb

@@ -11,46 +11,89 @@ module ActiveMail
       sig { override.params(node: Nokogiri::XML::Node, inner: String).returns(String) }
       def transform(node, inner)
         small, large = column_sizes(node)
-        width_px = ghost_width(large)
+        width_px = ghost_width(node, large)
 
         [
-          %(<!--[if mso | IE]><td width="#{width_px}" valign="top"><![endif]-->),
+          %(<!--[if mso]><td width="#{width_px}" valign="top"><table #{TABLE_RESET} width="#{width_px}"><tr><![endif]-->),
           column_markup(node, inner, column_classes(node, small, large), width_px, expander(node, large)),
-          '<!--[if mso | IE]></td><![endif]-->'
+          '<!--[if mso]></tr></table></td><![endif]-->'
         ].join
       end
 
       private
 
+      sig { override.returns(T::Array[String]) }
+      def consumed_attributes
+        %w[small large]
+      end
+
       sig { params(node: Nokogiri::XML::Node).returns([Integer, Integer]) }
       def column_sizes(node)
         small = positive_int(node.attr('small'))
         large = positive_int(node.attr('large'))
-        siblings = node.parent ? node.parent.elements.size : 1
-        [small || column_count, large || small || [column_count / siblings, 1].max]
+        [small || column_count, large || small || [column_count / column_siblings(node).size, 1].max]
+      end
+
+      # Already transformed columns are interim <th class="columns"> elements; other siblings take no width.
+      sig { params(node: Nokogiri::XML::Node).returns(T::Array[Nokogiri::XML::Node]) }
+      def column_siblings(node)
+        return [node] unless node.parent
+
+        node.parent.elements.select { |sibling| sibling.name == node.name || column?(sibling) }
+      end
+
+      sig { params(node: Nokogiri::XML::Node).returns(T::Boolean) }
+      def column?(node)
+        return false unless node.name == ::ActiveMail::Core::INTERIM_TH_TAG
+
+        class?(node, 'columns')
       end
 
       sig { params(node: Nokogiri::XML::Node, small: Integer, large: Integer).returns(String) }
       def column_classes(node, small, large)
+        siblings = column_siblings(node)
         classes = combine_classes(node, "small-#{small} large-#{large} columns")
-        classes += ' first' unless node.previous_element
-        classes += ' last' unless node.next_element
+        classes += ' first' if siblings.first == node
+        classes += ' last' if siblings.last == node
         classes
       end
 
       sig { params(node: Nokogiri::XML::Node, large: Integer).returns(String) }
       def expander(node, large)
-        subrows = node.elements.css('.row').to_a.concat(node.elements.css('row').to_a)
-        return '' unless large == column_count && subrows.empty?
+        return '' unless large == column_count && node.at_css('.row').nil?
 
         %(<th class="expander"></th>)
       end
 
-      # Clamp: an oversized `large` would push the MSO ghost cell past the
-      # container and force a wrap in Outlook Word.
-      sig { params(large: Integer).returns(Integer) }
-      def ghost_width(large)
-        [((large.to_f / column_count) * container_width).round, container_width].min
+      # Columns are transformed leaves first, so the enclosing <columns> are still raw nodes whose
+      # sizes and positions are readable. A nested row shares the content box of its parent column.
+      sig { params(node: Nokogiri::XML::Node, large: Integer).returns(Integer) }
+      def ghost_width(node, large)
+        available = node.ancestors('columns').reverse.reduce(Rational(container_width)) do |width, ancestor|
+          share_of(width, column_sizes(ancestor).last) - horizontal_padding(ancestor)
+        end
+        share_of(available, large).round
+      end
+
+      # Clamped: an oversized `large` would push the MSO ghost cell past its parent and force a wrap in Outlook Word.
+      sig { params(width: Rational, share: Integer).returns(Rational) }
+      def share_of(width, share)
+        width * Rational([share, column_count].min, column_count)
+      end
+
+      # Mirrors _grid.scss, whose padding is inlined on each column.
+      sig { params(node: Nokogiri::XML::Node).returns(Rational) }
+      def horizontal_padding(node)
+        return Rational(0) if node.ancestors('row').any? { |row| class?(row, 'collapse') }
+
+        siblings = column_siblings(node)
+        outer_side = node.ancestors('columns').empty? ? spacing(:container_gutter) : Rational(0)
+        [siblings.first, siblings.last].sum(Rational(0)) { |edge| edge == node ? outer_side : spacing(:sm) }
+      end
+
+      sig { params(name: Symbol).returns(Rational) }
+      def spacing(name)
+        Rational(core.config.tokens.spacing!(name).delete_suffix('px'))
       end
 
       sig { params(node: Nokogiri::XML::Node, inner: String, classes: String, width_px: Integer, expander: String).returns(String) }
@@ -61,7 +104,7 @@ module ActiveMail
         # Neutralize the client default th rendering (bold, centered).
         content_style = 'font-weight:normal;text-align:left;'
         [
-          %(<#{::ActiveMail::Core::INTERIM_TH_TAG} class="#{classes}"#{style_attribute(node, style)} #{pass_through_attributes(node)}>),
+          %(<#{::ActiveMail::Core::INTERIM_TH_TAG}#{root_attributes(node, classes: classes, layout_style: style)}>),
           %(<table #{TABLE_RESET} style="width:100%;"><tbody><tr>),
           %(<th style="#{content_style}">#{inner}</th>#{expander}),
           %(</tr></tbody></table></#{::ActiveMail::Core::INTERIM_TH_TAG}>)

data/lib/activemail/components/container.rb

@@ -1,25 +1,32 @@
 # typed: strict
 # frozen_string_literal: true
 
-require_relative 'base'
+require_relative 'table_component'
 
 module ActiveMail
   module Components
-    class Container < Base
+    class Container < TableComponent
       extend T::Sig
 
       sig { override.params(node: Nokogiri::XML::Node, inner: String).returns(String) }
       def transform(node, inner)
-        attributes = combine_attributes(node, 'container')
         width = container_width
+        attributes = root_attributes(node, classes: 'container', layout_style: "width:100%;max-width:#{width}px;margin:0 auto;")
         # Outlook Word ignores max-width; the MSO ghost table pins the width.
         [
-          %(<!--[if mso | IE]><table #{TABLE_RESET} align="center" width="#{width}"><tr><td><![endif]-->),
-          %(<table #{attributes} #{TABLE_RESET} align="center"#{style_attribute(node, "width:100%;max-width:#{width}px;margin:0 auto;")}>),
+          %(<!--[if mso]><table #{TABLE_RESET} align="center" width="#{width}"><tr><td><![endif]-->),
+          %(<table#{attributes} #{TABLE_RESET} align="center">),
           %(<tbody><tr><td>#{inner}</td></tr></tbody></table>),
-          '<!--[if mso | IE]></td></tr></table><![endif]-->'
+          '<!--[if mso]></td></tr></table><![endif]-->'
         ].join
       end
+
+      private
+
+      sig { override.returns(T::Array[String]) }
+      def consumed_attributes
+        [*super, 'align']
+      end
     end
   end
 end