mjml-rb 0.4.4 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 750fc042cf9ff6273cebd5907a096e6fc304d28a49b0872cf6eec93f9818e148
-  data.tar.gz: 138a44a38b430267f646cd771b4a9fa01e3c0e9609083291de5270280db36650
+  metadata.gz: 5b2c747b6f5afbc288db3ddc0afec65b3f0ff5a208bb2958abf8c9869a76790c
+  data.tar.gz: edd5d4b07c99bfd971bafadf42b11a66c0ace207cdfe835fa2643c64fc4297f9
 SHA512:
-  metadata.gz: 5d83da073643a75183303c6a14a6b0cbd2e06d864875c80a4bbfc65ef5c857b5a4ffb2971a0465cc58e46b400efe8a1d760994f643a420da0d549837799f8bf5
-  data.tar.gz: 1bd7d0c899cb6de244ab534d0b598b12f437c53ef556cb7fd5c56880ec4d6fc164dedb493ad49e45e60b52e5bd9180dd725b7f91790eb2952440df5d5219bb3a
+  metadata.gz: 8989b98cecdb8b63d843f87dd980c409581fe11220cbb439d183768259027a04536799e1d9bc43f5f8760aef216c208ff4e0d74d01e13008f65c749f190fc99c
+  data.tar.gz: 83d310d5e9f5f92bf97da53086c56bca1baed0e9bd7495f7c8595f888b6343621e76b6dc98292db801a28c169a85720be6e8afcd674928ec9a3a4a5947d727fd

data/lib/mjml-rb/dependencies.rb

@@ -4,7 +4,7 @@ module MjmlRb
   module Dependencies
     # Components whose content is treated as raw HTML in NPM (endingTag = true).
     # The parser preserves their inner markup as-is; the validator skips child
-    # element checks because REXML structurally parses what NPM treats as text.
+    # element checks because the XML parser structurally parses what NPM treats as text.
     ENDING_TAGS = Set.new(%w[
       mj-accordion-text
       mj-accordion-title

data/lib/mjml-rb/parser.rb

@@ -1,11 +1,9 @@
-require "rexml/document"
-require "rexml/xpath"
+require "nokogiri"
 
 require_relative "ast_node"
 
 module MjmlRb
   class Parser
-    include REXML
     HTML_VOID_TAGS = %w[area base br col embed hr img input link meta param source track wbr].freeze
 
     # Ending-tag components whose inner HTML is preserved as raw content via CDATA
@@ -23,7 +21,6 @@ module MjmlRb
     VOID_TAG_CLOSING_BR_RE = %r{</br\s*>}i.freeze
     VOID_TAG_CLOSING_OTHER_RE = /<\/(#{(HTML_VOID_TAGS - ["br"]).join("|")})\s*>/i.freeze
     VOID_TAG_OPEN_RE = /<(#{HTML_VOID_TAGS.join("|")})(\s[^<>]*?)?>/i.freeze
-    LINE_ANNOTATION_RE = /(\n)|(<!\[CDATA\[.*?\]\]>)|(<(?:mj-[\w-]+|mjml)(?=[\s\/>]))/m.freeze
     BARE_AMPERSAND_RE = /&(?!(?:#[0-9]+|#x[0-9a-fA-F]+|[a-zA-Z][a-zA-Z0-9]*);)/.freeze
     ROOT_LEVEL_HEAD_TAGS = %w[
       mj-attributes
@@ -56,11 +53,12 @@ module MjmlRb
       xml = normalize_html_void_tags(xml)
       xml = expand_includes(xml, opts) unless opts[:ignore_includes]
 
-      xml = annotate_line_numbers(sanitize_bare_ampersands(xml))
-      doc = Document.new(xml)
+      xml = sanitize_bare_ampersands(xml)
+      xml = replace_html_entities(xml)
+      doc = Nokogiri::XML(xml) { |config| config.strict }
       normalize_root_head_elements(doc)
       element_to_ast(doc.root, keep_comments: opts[:keep_comments])
-    rescue ParseException => e
+    rescue Nokogiri::XML::SyntaxError => e
       raise ParseError.new("XML parse error: #{e.message}")
     end
 
@@ -85,18 +83,18 @@ module MjmlRb
     def expand_includes(xml, options, included_in = [])
       xml = wrap_ending_tags_in_cdata(xml)
       xml = normalize_html_void_tags(xml)
-      doc = Document.new(sanitize_bare_ampersands(xml))
-      includes = XPath.match(doc, "//mj-include")
+      doc = parse_xml(sanitize_bare_ampersands(xml))
+      includes = doc.xpath("//mj-include")
       return xml if includes.empty?
 
       css_includes = []
       head_includes = []
 
       includes.reverse_each do |include_node|
-        path_attr = include_node.attributes["path"]
+        path_attr = include_node["path"]
         raise ParseError, "mj-include path is required" if path_attr.to_s.empty?
 
-        include_type = include_node.attributes["type"].to_s
+        include_type = include_node["type"].to_s
         parent = include_node.parent
 
         resolved_path = begin
@@ -114,7 +112,7 @@ module MjmlRb
             tag_name: "mj-include",
             file: display_path
           }
-          parent.delete(include_node)
+          include_node.remove
           next
         end
 
@@ -125,9 +123,9 @@ module MjmlRb
 
         if include_type == "css"
           # CSS includes get collected and added to mj-head later
-          css_inline = include_node.attributes["css-inline"].to_s
+          css_inline = include_node["css-inline"].to_s
           css_includes << { content: include_content, inline: css_inline == "inline" }
-          parent.delete(include_node)
+          include_node.remove
           next
         end
 
@@ -145,19 +143,20 @@ module MjmlRb
                         body_children
                       end
 
-        insert_before = include_node
-        replacement_nodes = if replacement.is_a?(Array)
-                              replacement
-                            else
-                              fragment = Document.new(sanitize_bare_ampersands("<include-root>#{replacement}</include-root>"))
-                              fragment.root.children.map { |child| deep_clone(child) }
-                            end
-
-        replacement_nodes.each do |child|
-          annotate_include_source(child, resolved_path) if child.is_a?(Element)
-          parent.insert_before(insert_before, child)
+        if replacement.is_a?(Array)
+          replacement.each do |child|
+            annotate_include_source(child, resolved_path) if child.element?
+            include_node.add_previous_sibling(child)
+          end
+        else
+          fragment = parse_xml("<include-root>#{sanitize_bare_ampersands(replacement)}</include-root>").root
+          fragment.children.each do |child|
+            cloned = child.dup(1)
+            annotate_include_source(cloned, resolved_path) if cloned.element?
+            include_node.add_previous_sibling(cloned)
+          end
         end
-        parent.delete(include_node)
+        include_node.remove
       end
 
       inject_head_includes(doc, head_includes) unless head_includes.empty?
@@ -167,11 +166,7 @@ module MjmlRb
         inject_css_includes(doc, css_includes)
       end
 
-      output = +""
-      doc.write(output)
-      output
-    rescue ParseException => e
-      raise ParseError, "Failed to parse included content: #{e.message}"
+      doc.root.to_xml(save_with: Nokogiri::XML::Node::SaveOptions::AS_XML | Nokogiri::XML::Node::SaveOptions::NO_DECLARATION)
     end
 
     def prepare_mjml_include_document(content)
@@ -182,23 +177,23 @@ module MjmlRb
     end
 
     def extract_mjml_include_children(xml)
-      include_doc = Document.new(sanitize_bare_ampersands(xml))
+      include_doc = parse_xml(sanitize_bare_ampersands(xml))
       normalize_root_head_elements(include_doc)
       mjml_root = include_doc.root
       return [[], []] unless mjml_root&.name == "mjml"
 
-      body = XPath.first(mjml_root, "mj-body")
-      head = XPath.first(mjml_root, "mj-head")
+      body = mjml_root.at_xpath("mj-body")
+      head = mjml_root.at_xpath("mj-head")
 
       [
-        body ? body.children.map { |child| deep_clone(child) } : [],
-        head ? head.children.map { |child| deep_clone(child) } : []
+        body ? body.children.map { |child| child.dup(1) } : [],
+        head ? head.children.map { |child| child.dup(1) } : []
       ]
     end
 
     def inject_head_includes(doc, head_includes)
       head = ensure_head(doc)
-      head_includes.each { |child| head.add(child) }
+      head_includes.each { |child| head.add_child(child) }
     end
 
     def inject_css_includes(doc, css_includes)
@@ -206,10 +201,10 @@ module MjmlRb
 
       # Add each CSS include as an mj-style element
       css_includes.each do |css_include|
-        style_node = Element.new("mj-style")
-        style_node.add_attribute("inline", "inline") if css_include[:inline]
-        style_node.add(CData.new(css_include[:content]))
-        head.add(style_node)
+        style_node = Nokogiri::XML::Node.new("mj-style", doc)
+        style_node["inline"] = "inline" if css_include[:inline]
+        style_node.add_child(Nokogiri::XML::CDATA.new(doc, css_include[:content]))
+        head.add_child(style_node)
       end
     end
 
@@ -217,15 +212,15 @@ module MjmlRb
       mjml_root = doc.root
       return unless mjml_root
 
-      head = XPath.first(mjml_root, "mj-head")
+      head = mjml_root.at_xpath("mj-head")
       return head if head
 
-      head = Element.new("mj-head")
-      body = XPath.first(mjml_root, "mj-body")
+      head = Nokogiri::XML::Node.new("mj-head", doc)
+      body = mjml_root.at_xpath("mj-body")
       if body
-        mjml_root.insert_before(body, head)
+        body.add_previous_sibling(head)
       else
-        mjml_root.add(head)
+        mjml_root.add_child(head)
       end
       head
     end
@@ -239,14 +234,14 @@ module MjmlRb
       root_head_elements = []
 
       mjml_root.children.each do |child|
-        next unless child.is_a?(Element)
+        next unless child.element?
 
         if child.name == "mj-head"
           head_nodes << child
-          child.children.each { |head_child| normalized_head_children << deep_clone(head_child) }
+          child.children.each { |head_child| normalized_head_children << head_child.dup(1) }
         elsif ROOT_LEVEL_HEAD_TAGS.include?(child.name)
           root_head_elements << child
-          normalized_head_children << deep_clone(child)
+          normalized_head_children << child.dup(1)
         end
       end
 
@@ -255,11 +250,11 @@ module MjmlRb
       head = head_nodes.first || ensure_head(doc)
       return unless head
 
-      head.children.to_a.each { |child| head.delete(child) }
-      normalized_head_children.each { |child| head.add(child) }
+      head.children.each(&:remove)
+      normalized_head_children.each { |child| head.add_child(child) }
 
-      root_head_elements.each { |child| mjml_root.delete(child) }
-      head_nodes.drop(1).each { |extra_head| mjml_root.delete(extra_head) }
+      root_head_elements.each(&:remove)
+      head_nodes.drop(1).each(&:remove)
     end
 
     def strip_xml_declaration(content)
@@ -357,40 +352,39 @@ module MjmlRb
     end
 
     # Escape bare "&" that are not part of a valid XML entity reference
-    # (e.g. &amp; &#123; &#x1F;).  This lets REXML parse HTML-ish content
-    # such as "Terms & Conditions" which is common in email templates.
+    # (e.g. &amp; &#123; &#x1F;).  This lets the XML parser handle HTML-ish
+    # content such as "Terms & Conditions" which is common in email templates.
     def sanitize_bare_ampersands(content)
       content.gsub(BARE_AMPERSAND_RE, "&amp;")
     end
 
-    # Adds data-mjml-line attributes to MJML tags so line numbers survive
-    # REXML parsing (which doesn't expose source positions).
-    # Skips content inside CDATA sections to avoid modifying raw HTML.
-    def annotate_line_numbers(xml)
-      line = 1
-      xml.gsub(LINE_ANNOTATION_RE) do
-        if Regexp.last_match(1) # newline
-          line += 1
-          "\n"
-        elsif Regexp.last_match(2) # CDATA section — count newlines, pass through
-          line += Regexp.last_match(2).count("\n")
-          Regexp.last_match(2)
-        else # opening MJML tag
-          "#{Regexp.last_match(3)} data-mjml-line=\"#{line}\""
-        end
+    # Replace HTML named entities (e.g. &nbsp;, &copy;) with their numeric
+    # XML equivalents (e.g. &#160;, &#169;).  XML only defines five named
+    # entities (amp, lt, gt, quot, apos); all other named references from
+    # HTML must be converted to numeric form for the XML parser to accept them.
+    # Uses Nokogiri's built-in HTML entity lookup table.
+    def replace_html_entities(content)
+      content.gsub(/&([a-zA-Z][a-zA-Z0-9]*);/) do |match|
+        name = ::Regexp.last_match(1)
+        next match if XML_PREDEFINED_ENTITIES.include?(name)
+
+        codepoint = Nokogiri::HTML::NamedCharacters[name]
+        codepoint ? "&##{codepoint};" : match
       end
     end
 
-    # Recursively marks REXML elements from included files with data-mjml-file.
+    XML_PREDEFINED_ENTITIES = %w[amp lt gt quot apos].freeze
+
+    # Recursively marks Nokogiri elements from included files with data-mjml-file.
     # Only sets the attribute on elements that don't already have it (preserving
     # deeper include annotations from recursive expansion).
     def annotate_include_source(element, file_path)
-      return unless element.is_a?(Element)
+      return unless element.element?
 
-      if (element.name.start_with?("mj-") || element.name == "mjml") && !element.attributes["data-mjml-file"]
-        element.add_attribute("data-mjml-file", file_path)
+      if (element.name.start_with?("mj-") || element.name == "mjml") && !element["data-mjml-file"]
+        element["data-mjml-file"] = file_path
       end
-      element.each_element { |child| annotate_include_source(child, file_path) }
+      element.element_children.each { |child| annotate_include_source(child, file_path) }
     end
 
     def resolve_include_path(include_path, actual_path, file_path)
@@ -408,38 +402,24 @@ module MjmlRb
       raise Errno::ENOENT, include_path
     end
 
-    def deep_clone(node)
-      case node
-      when Element
-        clone = Element.new(node.name)
-        node.attributes.each_attribute { |attr| clone.add_attribute(attr.expanded_name, attr.value) }
-        node.children.each { |child| clone.add(deep_clone(child)) }
-        clone
-      when Text
-        Text.new(node.value)
-      when Comment
-        Comment.new(node.string)
-      else
-        node
-      end
-    end
-
     def element_to_ast(element, keep_comments:)
       raise ParseError, "Missing XML root element" unless element
 
-      # Extract metadata annotations (added by annotate_line_numbers / annotate_include_source)
+      # Extract metadata annotations (added by annotate_include_source)
       # and strip them from the public attributes hash.
-      meta_line = element.attributes["data-mjml-line"]&.to_i
-      meta_file = element.attributes["data-mjml-file"]
-      attrs = element.attributes.each_with_object({}) do |(name, val), h|
-        h[name] = val unless name.start_with?("data-mjml-")
+      # Line numbers come from Nokogiri's native node.line.
+      meta_line = element.line
+      meta_file = element["data-mjml-file"]
+      attrs = {}
+      element.attributes.each do |name, attr|
+        attrs[name] = attr.value unless name.start_with?("data-mjml-")
       end
       attrs["data-mjml-raw"] = "true" unless element.name.start_with?("mj-") || element.name == "mjml"
 
       # For ending-tag elements whose content was wrapped in CDATA, store
       # the raw HTML directly as content instead of parsing structurally.
       if ENDING_TAGS_FOR_CDATA.include?(element.name)
-        raw_content = element.children.select { |c| c.is_a?(Text) }.map(&:value).join
+        raw_content = element.children.select { |c| c.cdata? || c.text? }.map(&:content).join
         return AstNode.new(
           tag_name: element.name,
           attributes: attrs,
@@ -451,17 +431,16 @@ module MjmlRb
       end
 
       children = element.children.each_with_object([]) do |child, memo|
-        case child
-        when Element
+        if child.element?
           memo << element_to_ast(child, keep_comments: keep_comments)
-        when Text
-          text = child.value
+        elsif child.text? || child.cdata?
+          text = child.content
           next if text.empty?
           next if text.strip.empty? && ignorable_whitespace_text?(text, parent_element_name: element.name)
 
           memo << AstNode.new(tag_name: "#text", content: text)
-        when Comment
-          memo << AstNode.new(tag_name: "#comment", content: child.string) if keep_comments
+        elsif child.comment?
+          memo << AstNode.new(tag_name: "#comment", content: child.content) if keep_comments
         end
       end
 
@@ -474,6 +453,13 @@ module MjmlRb
       )
     end
 
+    # Lenient XML parse used during include expansion and intermediate steps.
+    # Errors are collected but do not raise; the final strict parse in #parse
+    # will surface any real issues.
+    def parse_xml(xml)
+      Nokogiri::XML(replace_html_entities(xml))
+    end
+
     def ignorable_whitespace_text?(text, parent_element_name:)
       return true if parent_element_name.start_with?("mj-") || parent_element_name == "mjml"
 

data/lib/mjml-rb/renderer.rb

@@ -1,4 +1,5 @@
 require "cgi"
+require "css_parser"
 require "nokogiri"
 require "set"
 require_relative "components/accordion"
@@ -417,115 +418,53 @@ module MjmlRb
     end
 
     def parse_inline_css_rules(css)
-      stripped_css = strip_css_comments(css.to_s)
-      plain_css, at_rules_css = extract_css_at_rules(stripped_css)
-
-      rules = plain_css.scan(/([^{}]+)\{([^{}]+)\}/m).flat_map do |selector_group, declarations|
-        selectors = selector_group.split(",").map(&:strip).reject(&:empty?)
-        declaration_map = parse_css_declarations(declarations)
-        selectors.map { |selector| [selector, declaration_map] }
+      parser = CssParser::Parser.new
+      parser.add_block!(css.to_s)
+
+      rules = []
+      parser.each_rule_set do |rule_set, media_types|
+        # Only inline rules not inside @media blocks; css_parser stores
+        # top-level rules under the :all media type.
+        next unless media_types == [:all]
+
+        rule_set.each_selector do |selector, declarations_str, specificity|
+          selector = selector.strip
+          # Skip @-rules like @font-face that css_parser yields as selectors
+          next if selector.start_with?("@")
+
+          declaration_map = parse_css_declarations(declarations_str)
+          rules << [selector, declaration_map, specificity]
+        end
       end
 
       # Sort rules by specificity (ascending). With the "last wins" merge
       # strategy, higher-specificity rules applied later correctly override
       # lower-specificity ones — matching CSS cascade behavior.
-      sorted = rules.each_with_index
-                    .sort_by { |(selector, _), idx| [css_specificity(selector), idx] }
-                    .map(&:first)
-
-      [sorted, at_rules_css]
-    end
+      sorted = rules.sort_by.with_index { |(_, _, spec), idx| [spec, idx] }
+                    .map { |sel, decl, _| [sel, decl] }
 
-    def strip_css_comments(css)
-      css.gsub(%r{/\*.*?\*/}m, "")
+      [sorted, ""]
     end
 
-    # Separates @-rules (@media, @font-face, etc.) from plain CSS selectors.
-    # Returns [plain_css, at_rules_css]. The at_rules_css can be injected as a
-    # <style> block since @-rules cannot be inlined into style attributes.
-    def extract_css_at_rules(css)
-      plain = +""
-      at_rules = +""
-      index = 0
-
-      while index < css.length
-        if css[index] == "@"
-          brace_index = css.index("{", index)
-          semicolon_index = css.index(";", index)
-
-          # Simple @-rules like @import or @charset end with semicolon
-          if semicolon_index && (brace_index.nil? || semicolon_index < brace_index)
-            at_rules << css[index..semicolon_index] << "\n"
-            index = semicolon_index + 1
-            next
-          end
-
-          # Block @-rules like @media, @font-face have nested braces
-          if brace_index
-            depth = 1
-            cursor = brace_index + 1
-            while cursor < css.length && depth.positive?
-              depth += 1 if css[cursor] == "{"
-              depth -= 1 if css[cursor] == "}"
-              cursor += 1
-            end
-            at_rules << css[index...cursor] << "\n"
-            index = cursor
-            next
-          end
-        end
-
-        plain << css[index]
-        index += 1
-      end
-
-      [plain, at_rules]
-    end
-
-    # Calculates CSS specificity as a comparable [a, b, c] tuple:
-    #   a = number of ID selectors (#id)
-    #   b = number of class selectors (.class), attribute selectors ([attr]),
-    #       and pseudo-classes (:hover, :lang())
-    #   c = number of type selectors (div, p) and pseudo-elements (::before)
     def css_specificity(selector)
-      s = selector.to_s
-
-      # a: ID selectors
-      a = s.scan(/#[\w-]+/).length
-
-      # b: class selectors + attribute selectors + pseudo-classes
-      b = s.scan(/\.[\w-]+/).length +
-          s.scan(/\[[^\]]*\]/).length +
-          s.scan(/:(?!:)[\w-]+/).length
-
-      # c: type selectors + pseudo-elements
-      # Strip everything except element names and combinators
-      cleaned = s
-        .gsub(/#[\w-]+/, "")                           # remove IDs
-        .gsub(/\.[\w-]+/, "")                           # remove classes
-        .gsub(/\[[^\]]*\]/, "")                         # remove attribute selectors
-        .gsub(/:[\w-]+(?:\([^)]*\))?/, "")              # remove pseudo-classes
-        .gsub(/::[\w-]+/, "")                           # remove pseudo-elements (counted separately)
-        .gsub(/[>+~]/, " ")                             # combinators → spaces
-        .gsub(/\*/, "")                                 # universal selector has no specificity
-      c = cleaned.split.reject(&:empty?).length +
-          s.scan(/::[\w-]+/).length
-
-      [a, b, c]
+      CssParser.calculate_specificity(selector.to_s)
     end
 
     def parse_css_declarations(declarations, source: :css)
-      declarations.split(";").each_with_object({}) do |entry, memo|
-        property, value = entry.split(":", 2).map { |part| part&.strip }
+      return {} if declarations.nil? || declarations.to_s.strip.empty?
+
+      rule_set = CssParser::RuleSet.new(block: declarations.to_s)
+      result = {}
+      rule_set.each_declaration do |property, value, important|
         next if property.nil? || property.empty? || value.nil? || value.empty?
 
-        important = value.match?(/\s*!important\s*\z/)
-        memo[property] = {
-          value: value.sub(/\s*!important\s*\z/, "").strip,
+        result[property] = {
+          value: value,
           important: important,
           source: source
         }
       end
+      result
     end
 
     def merge_inline_declarations!(existing, declarations, touched_properties)

data/lib/mjml-rb/validator.rb

@@ -77,8 +77,8 @@ module MjmlRb
     end
 
     def validate_allowed_children(node, errors)
-      # Ending-tag components treat content as raw HTML; REXML still parses
-      # children structurally, so skip child validation for those tags.
+      # Ending-tag components treat content as raw HTML; the XML parser still
+      # parses children structurally, so skip child validation for those tags.
       return if MjmlRb.component_registry.ending_tags.include?(node.tag_name)
 
       allowed = MjmlRb.component_registry.dependency_rules[node.tag_name]

data/lib/mjml-rb/version.rb

@@ -1,3 +1,3 @@
 module MjmlRb
-  VERSION = "0.4.4".freeze
+  VERSION = "0.5.0".freeze
 end

data/mjml-rb.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |spec|
   spec.summary = "Ruby implementation of the MJML toolchain"
   spec.description = "Ruby-first MJML compiler API and CLI with compatibility-focused behavior."
   spec.license = "MIT"
-  spec.required_ruby_version = ">= 3.0"
+  spec.required_ruby_version = ">= 3.3"
 
   spec.homepage = "https://github.com/faraquet/mjml-rb"
   spec.files = Dir.chdir(__dir__) do
@@ -18,6 +18,6 @@ Gem::Specification.new do |spec|
   spec.bindir = "bin"
   spec.executables = ["mjml"]
   spec.require_paths = ["lib"]
+  spec.add_dependency "css_parser", ">= 1.17"
   spec.add_dependency "nokogiri", ">= 1.13"
-  spec.add_dependency "rexml", ">= 3.2.5"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mjml-rb
 version: !ruby/object:Gem::Version
-  version: 0.4.4
+  version: 0.5.0
 platform: ruby
 authors:
 - Andrei Andriichuk
@@ -10,33 +10,33 @@ cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: nokogiri
+  name: css_parser
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '1.13'
+        version: '1.17'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '1.13'
+        version: '1.17'
 - !ruby/object:Gem::Dependency
-  name: rexml
+  name: nokogiri
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.2.5
+        version: '1.13'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.2.5
+        version: '1.13'
 description: Ruby-first MJML compiler API and CLI with compatibility-focused behavior.
 email:
 - andreiandriichuk@gmail.com
@@ -99,7 +99,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.0'
+      version: '3.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="