plurimath 0.8.3 → 0.8.4

data/lib/plurimath/math/function/fenced.rb

@@ -39,16 +39,16 @@ module Plurimath
         end
 
         def to_html
-          first_value  = "<i>#{parameter_one.value}</i>" if parameter_one
+          first_value  = "<i>#{symbol_or_paren(parameter_one, lang: :html)}</i>" if parameter_one
           second_value = parameter_two.map(&:to_html).join if parameter_two
-          third_value  = "<i>#{parameter_three.value}</i>" if parameter_three
+          third_value  = "<i>#{symbol_or_paren(parameter_three, lang: :html)}</i>" if parameter_three
           "#{first_value}#{second_value}#{third_value}"
         end
 
         def to_latex
           fenced_value = parameter_two&.map(&:to_latex)&.join(" ")
-          first_value  = latex_paren(parameter_one&.value)
-          second_value = latex_paren(parameter_three&.value)
+          first_value  = latex_paren(symbol_or_paren(parameter_one, lang: :latex))
+          second_value = latex_paren(symbol_or_paren(parameter_three, lang: :latex))
           "#{first_value} #{fenced_value} #{second_value}"
         end
 
@@ -83,34 +83,34 @@ module Plurimath
           end&.join(" ")
           return fenced_value if choose_frac?(parameter_two.first)
 
-          fenced_value = "(#{fenced_value})" if parameter_one&.value&.include?("|")
+          fenced_value = "(#{fenced_value})" if vert_paren?
 
           "#{unicode_open_paren}#{fenced_value}#{unicode_close_paren}"
         end
 
         def to_asciimath_math_zone(spacing, last = false, indent = true)
-          filtered_values(parameter_two).map.with_index(1) do |object, index|
+          filtered_values(parameter_two, lang: :asciimath).map.with_index(1) do |object, index|
             last = index == @values.length
             object.to_asciimath_math_zone(spacing, last, indent)
           end
         end
 
         def to_latex_math_zone(spacing, last = false, indent = true)
-          filtered_values(parameter_two).map.with_index(1) do |object, index|
+          filtered_values(parameter_two, lang: :latex).map.with_index(1) do |object, index|
             last = index == @values.length
             object.to_latex_math_zone(spacing, last, indent)
           end
         end
 
         def to_mathml_math_zone(spacing, last = false, indent = true)
-          filtered_values(parameter_two).map.with_index(1) do |object, index|
+          filtered_values(parameter_two, lang: :mathml).map.with_index(1) do |object, index|
             last = index == @values.length
             object.to_mathml_math_zone(spacing, last, indent)
           end
         end
 
         def to_omml_math_zone(spacing, last = false, indent = true, display_style:)
-          filtered_values(parameter_two).map do |object|
+          filtered_values(parameter_two, lang: :omml).map do |object|
             object.to_omml_math_zone(spacing, last, !indent, display_style: display_style)
           end
         end
@@ -136,10 +136,10 @@ module Plurimath
         protected
 
         def open_paren(dpr)
-          first_value = parameter_one&.value
-          return dpr if first_value.nil? || first_value.empty?
+          first_value = symbol_or_paren(parameter_one, lang: :omml)
+          return dpr if first_value.nil?
 
-          attributes = { "m:val": first_value }
+          attributes = { "m:val": Utility.html_entity_to_unicode(first_value) }
           dpr << Utility.ox_element(
             "begChr",
             namespace: "m",
@@ -148,10 +148,10 @@ module Plurimath
         end
 
         def close_paren(dpr)
-          third_value = parameter_three&.value
-          return dpr if third_value.nil? || third_value.empty?
+          third_value = symbol_or_paren(parameter_three, lang: :omml)
+          return dpr if third_value.nil?
 
-          attributes = { "m:val": third_value }
+          attributes = { "m:val": Utility.html_entity_to_unicode(third_value) }
           dpr << Utility.ox_element(
             "endChr",
             namespace: "m",
@@ -160,19 +160,16 @@ module Plurimath
         end
 
         def latex_paren(paren)
-          return "" if paren.nil? || paren.empty?
+          return "" if paren.nil?
           return paren.gsub(":", "") if paren.include?(":") && ["{:", ":}"].include?(paren)
 
-          paren = %w[{ }].include?(paren) ? "\\#{paren}" : paren
-          paren = "\\#{Latex::Constants::UNICODE_SYMBOLS.invert[paren]}" if paren&.to_s&.match?(/&#x.{0,4};/)
-          paren&.to_s
+          paren
         end
 
         def mathml_paren(field)
           unicodemath_syntax = ["&#x3016;", "&#x3017;", "&#x2524;", "&#x251c;"]
-          return "" if field&.value&.include?(":") || unicodemath_syntax.include?(field&.value&.to_s)
-
-          field&.value
+          paren = symbol_or_paren(field, lang: :mathml)
+          (paren&.include?(":") || unicodemath_syntax.include?(paren)) ? "" : paren
         end
 
         def value_split(obj, field_value)
@@ -223,6 +220,25 @@ module Plurimath
             parameter_three&.value&.include?("&#x3017;") ||
             parameter_three&.value&.include?(":}")
         end
+
+        def vert_paren?
+          return parameter_one&.value&.include?("|") if parameter_one.class_name == "symbol"
+
+          parameter_one.is_a?(Math::Symbols::Paren::Vert)
+        end
+
+        def symbol_or_paren(field, lang:)
+          return field&.value unless field.is_a?(Math::Symbols::Paren)
+
+          case lang
+          when :mathml, :html
+            field.to_mathml_without_math_tag.nodes.first
+          when :latex
+            field.to_latex
+          when :omml
+            field.to_omml_without_math_tag(true)
+          end
+        end
       end
     end
   end

data/lib/plurimath/math/function/frac.rb

@@ -38,7 +38,7 @@ module Plurimath
             parameter_two&.to_mathml_without_math_tag,
           ]
           frac_tag = ox_element(tag_name)
-          frac_tag.attributes.merge!(options) if tag_name == "mfrac" && options
+          frac_tag.set_attr(options) if tag_name == "mfrac" && options
           Utility.update_nodes(frac_tag, mathml_value)
         end
 

data/lib/plurimath/math/function/hat.rb

@@ -28,7 +28,7 @@ module Plurimath
           return mo_tag unless parameter_one
 
           mover_tag = Utility.ox_element("mover")
-          mover_tag.attributes.merge!(attributes) if attributes && !attributes.empty?
+          mover_tag.set_attr(attributes) if attributes && !attributes.empty?
           Utility.update_nodes(
             mover_tag,
             [
@@ -49,7 +49,7 @@ module Plurimath
           if attributes && attributes[:accent]
             accent_tag(display_style)
           else
-            symbol = Symbol.new("̂") unless hide_function_name
+            symbol = Symbols::Symbol.new("̂") unless hide_function_name
             Overset.new(parameter_one, symbol).to_omml_without_math_tag(display_style)
           end
         end

data/lib/plurimath/math/function/linebreak.rb

@@ -49,7 +49,7 @@ module Plurimath
 
           mo_node = parameter_one.to_mathml_without_math_tag
           mo_node.name = "mo" unless mo_node.name == "mo"
-          mo_node.attributes.merge!(attributes) unless attributes.empty?
+          mo_node.set_attr(attributes) unless attributes.empty?
           mo_node
         end
 

data/lib/plurimath/math/function/nary.rb

@@ -168,13 +168,6 @@ module Plurimath
           end
         end
 
-        def prime_unicode?(field)
-          return unless field.is_a?(Math::Symbol)
-          return true if field.value.include?("'")
-
-          UnicodeMath::Constants::PREFIXED_PRIMES.any? { |prefix, prime| field.value.include?(prime) }
-        end
-
         def naryand_value(field)
           return "" unless field
 

data/lib/plurimath/math/function/obrace.rb

@@ -28,7 +28,7 @@ module Plurimath
           return mo_tag unless parameter_one
 
           over_tag = Utility.ox_element("mover")
-          over_tag.attributes.merge!(attributes) if attributes && !attributes.empty?
+          over_tag.set_attr(attributes) if attributes && !attributes.empty?
           Utility.update_nodes(
             over_tag,
             [
@@ -48,7 +48,7 @@ module Plurimath
           if attributes && attributes[:accent]
             acc_tag(display_style)
           else
-            symbol = Symbol.new("⏞")
+            symbol = Symbols::Symbol.new("⏞")
             Overset.new(parameter_one, symbol).to_omml_without_math_tag(true)
           end
         end

data/lib/plurimath/math/function/overset.rb

@@ -50,8 +50,8 @@ module Plurimath
         end
 
         def to_unicodemath
-          return "#{unicodemath_parens(parameter_two)}#{parameter_one.value}" if unicode_accent?(parameter_one)
-          return "#{parameter_one.value}#{parameter_two.to_unicodemath}" if unicode_accent?(parameter_two)
+          return "#{unicodemath_parens(parameter_two)}#{unicodemath_field_value(parameter_one)}" if unicode_accent?(parameter_one)
+          return "#{unicodemath_field_value(parameter_one)}#{parameter_two.to_unicodemath}" if unicode_accent?(parameter_two)
           return "#{parameter_one.to_unicodemath}#{unicodemath_parens(parameter_two)}" if horizontal_brackets?
           return "#{parameter_two.to_unicodemath}^#{unicodemath_parens(parameter_one)}" if unicode_classes_accent?(parameter_two)
 
@@ -77,20 +77,25 @@ module Plurimath
         protected
 
         def unicode_accent?(field)
-          field.is_a?(Math::Symbol) &&
-            (
-              UnicodeMath::Constants::DIACRITIC_OVERLAYS.include?(field.value) ||
-                UnicodeMath::Constants::ACCENT_SYMBOLS.has_value?(field.value)
-            )
+          return unless field.is_a?(Math::Symbols::Symbol)
+
+          match_unicode?(unicodemath_field_value(field))
         end
 
         def unicode_classes_accent?(field)
-          (field.is_a?(Math::Function::Obrace) || field.is_a?(Math::Function::Ubrace))
+          field.is_a?(Math::Function::Obrace) ||
+            field.is_a?(Math::Function::Ubrace)
         end
 
         def horizontal_brackets?
-          parameter_one.is_a?(Math::Symbol) &&
-            UnicodeMath::Constants::HORIZONTAL_BRACKETS.value?(parameter_one.value)
+          return unless parameter_one.is_a?(Math::Symbols::Symbol)
+
+          UnicodeMath::Constants::HORIZONTAL_BRACKETS.value?(unicodemath_field_value(parameter_one))
+        end
+
+        def match_unicode?(unicode)
+          UnicodeMath::Constants::DIACRITIC_OVERLAYS.include?(unicode) ||
+            UnicodeMath::Constants::ACCENT_SYMBOLS.has_value?(unicode)
         end
       end
     end

data/lib/plurimath/math/function/power.rb

@@ -55,7 +55,7 @@ module Plurimath
 
         def to_unicodemath
           if accented?(parameter_two)
-            "#{parameter_one.to_unicodemath}#{parameter_two.to_unicodemath}"
+            "#{parameter_one.to_unicodemath}#{parameter_two.to_unicodemath.gsub(/\s+/, "")}"
           elsif parameter_two.mini_sized?
             "#{parameter_one.to_unicodemath}#{parameter_two.to_unicodemath}"
           else
@@ -85,16 +85,11 @@ module Plurimath
           parameter_one.is_nary_function? || parameter_one.is_nary_symbol?
         end
 
-        def prime_unicode?(field)
-          return unless field.is_a?(Math::Symbol)
-
-          UnicodeMath::Constants::PREFIXED_PRIMES.any? { |prefix, prime| field.value.include?(prime) || field.value.include?("'") }
-        end
-
         protected
 
         def accented?(field)
-          (field.is_a?(Math::Symbol) && prime_unicode?(field)) ||
+          (field.is_a?(Math::Symbols::Symbol) && prime_unicode?(field)) ||
+            (field.is_a?(Math::Formula) && prime_unicode?(field.value.first)) ||
             (field.is_a?(Math::Function::Power) && prime_unicode?(field.parameter_one))
         end
       end

data/lib/plurimath/math/function/table/array.rb

@@ -18,6 +18,15 @@ module Plurimath
             "\\begin{array}#{array_args || '.'}#{latex_content}\\end{array}"
           end
 
+          def to_mathml_without_math_tag
+            Utility.update_nodes(
+              ox_element("mtable", attributes: table_attribute),
+              value&.map(&:to_mathml_without_math_tag),
+            )
+          end
+
+          private
+
           def array_args
             args = []
             value.first.parameter_one.each do |td|
@@ -29,14 +38,6 @@ module Plurimath
             end
             "{#{args.join}}" unless args.compact.empty?
           end
-
-          def to_mathml_without_math_tag
-            table_tag = Utility.ox_element("mtable", attributes: table_attribute)
-            Utility.update_nodes(
-              table_tag,
-              value&.map(&:to_mathml_without_math_tag),
-            )
-          end
         end
       end
     end

data/lib/plurimath/math/function/table/bmatrix.rb

@@ -41,7 +41,7 @@ module Plurimath
           private
 
           def matrix_symbol
-            open_paren == "{" ? "Ⓢ" : "ⓢ"
+            open_paren.is_a?(Math::Symbols::Paren::Lcurly) ? "Ⓢ" : "ⓢ"
           end
         end
       end

data/lib/plurimath/math/function/table/eqarray.rb

@@ -15,7 +15,7 @@ module Plurimath
           end
 
           def to_unicodemath
-            "#{open_paren}█(#{value&.map(&:to_unicodemath).join("@")})#{close_paren}"
+            "#{open_paren&.to_unicodemath}█(#{value&.map(&:to_unicodemath).join("@")})#{close_paren&.to_unicodemath}"
           end
         end
       end

data/lib/plurimath/math/function/table/matrix.rb

@@ -37,7 +37,7 @@ module Plurimath
 
           def to_unicodemath
             first_value = value.map(&:to_unicodemath).join("@")
-            "#{open_paren}■(#{first_value})#{close_paren}"
+            "#{open_paren&.to_unicodemath}■(#{first_value})#{close_paren&.to_unicodemath}"
           end
 
           protected
@@ -47,7 +47,8 @@ module Plurimath
           end
 
           def table_tag_only?
-            (open_paren&.include?("(") && close_paren&.include?(")")) || !(open_paren && close_paren)
+            (open_paren&.class_name == "lround" && close_paren&.class_name == "rround") ||
+              !(open_paren && close_paren)
           end
         end
       end

data/lib/plurimath/math/function/table/vmatrix.rb

@@ -25,7 +25,7 @@ module Plurimath
           private
 
           def matrix_symbol
-            open_paren == "norm[" ? "⒩" : "⒱"
+            open_paren&.class_name == "norm" ? "⒩" : "⒱"
           end
         end
       end

data/lib/plurimath/math/function/table.rb

@@ -13,8 +13,8 @@ module Plurimath
                        close_paren = nil,
                        options = {})
           @value = value
-          @open_paren = open_paren
-          @close_paren = close_paren
+          @open_paren = Utility.symbols_class(open_paren, lang: :unicodemath)
+          @close_paren = Utility.symbols_class(close_paren, lang: :unicodemath)
           @options = options
         end
 
@@ -31,9 +31,8 @@ module Plurimath
 
           parenthesis = Asciimath::Constants::TABLE_PARENTHESIS
           first_value = value.map(&:to_asciimath).join(", ")
-          third_value = close_paren.is_a?(::Array) || close_paren.nil?
-          lparen = open_paren.nil? ? "[" : open_paren
-          rparen = third_value ? parenthesis[lparen.to_sym] : close_paren
+          lparen = open_paren.nil? ? "[" : open_paren.to_asciimath
+          rparen = close_paren.nil? ? parenthesis[lparen.to_sym] : close_paren.to_asciimath
           "#{lparen}#{first_value}#{rparen}"
         end
 
@@ -43,9 +42,9 @@ module Plurimath
             table_tag,
             value&.map(&:to_mathml_without_math_tag),
           )
-          return norm_table(table_tag) if open_paren == "norm["
+          return norm_table(table_tag) if open_paren.is_a?(Math::Symbols::Paren::Norm)
 
-          if present?(open_paren) || present?(close_paren)
+          if mathml_paren_present?(open_paren) || mathml_paren_present?(close_paren)
             first_paren = mo_element(mathml_parenthesis(open_paren))
             second_paren = mo_element(mathml_parenthesis(close_paren))
             mrow_tag = Utility.ox_element("mrow")
@@ -56,13 +55,13 @@ module Plurimath
         end
 
         def to_latex
-          return "\\begin{Vmatrix}#{latex_content}\\end{Vmatrix}" if open_paren == "norm["
+          return "\\begin{Vmatrix}#{latex_content}\\end{Vmatrix}" if open_paren.is_a?(Math::Symbols::Paren::Norm)
 
           separator = "{#{table_attribute(:latex)}}" if environment&.include?("array")
-          left_paren = latex_parenthesis(open_paren)
-          right_paren = latex_parenthesis(close_paren)
+          left_paren = open_paren&.to_latex || "."
+          right_paren = close_paren&.to_latex || "."
           left = "\\left #{left_paren}\\begin{matrix}"
-          right = "\\end{matrix}\\right #{right_paren}"
+          right = "\\end{matrix}\\right #{right_paren.delete_prefix("\\right")}"
           "#{left}#{separator}#{latex_content}#{right}"
         end
 
@@ -84,7 +83,7 @@ module Plurimath
           if unicodemath_table_class?
             "#{unicodemath_class_name}(#{value.map(&:to_unicodemath).join("@")})"
           else
-            "#{open_paren}■(#{value.map(&:to_unicodemath).join("@")})#{close_paren}"
+            "#{open_paren&.to_unicodemath}■(#{value.map(&:to_unicodemath).join("@")})#{close_paren&.to_unicodemath}"
           end
         end
 
@@ -118,23 +117,12 @@ module Plurimath
 
         protected
 
-        def present?(field)
-          !(field.nil? || field.empty?)
-        end
-
         def mathml_parenthesis(field)
-          return "" if field&.include?(":") || validate_paren(field)
-
-          present?(field) ? field : ""
-        end
-
-        def latex_parenthesis(field)
-          return "." unless field
-          return " ." if field&.include?(":")
+          return "" unless field
+          return field&.to_mathml_without_math_tag&.nodes&.first if field&.class_name == "symbol"
 
-          return "\\#{field}" if ["{", "}"].include?(field)
-
-          field
+          paren = field&.respond_to?(:encoded) ? field&.encoded : field&.paren_value
+          invisible_paren?(paren) ? "" : paren
         end
 
         def table_attribute(type = :mathml)
@@ -144,7 +132,7 @@ module Plurimath
             mathml_attrs(column_string)
           when :latex
             column_string.insert(0, "none") if column_string.include?("solid")
-            column_string&.map { |d| d == "solid" ? "|" : "a" }&.join
+            column_string&.map { |str| str == "solid" ? "|" : "a" }&.join
           end
         end
 
@@ -163,7 +151,7 @@ module Plurimath
         def mathml_attrs(column_strings)
           args = options&.dup&.reject { |arg| arg.to_s == "asterisk" }
           args[:columnlines] = column_strings.join(" ") if column_strings.include?("solid")
-          args[:columnalign] = "left" if close_paren&.include?(":}")
+          args[:columnalign] = "left" if close_paren.is_a?(Math::Symbols::Paren::CloseParen)
           args
         end
 
@@ -173,7 +161,7 @@ module Plurimath
 
         def matrix_class
           matrix = if open_paren
-                     Latex::Constants::MATRICES.invert[open_paren]
+                     Latex::Constants::MATRICES.invert[open_paren.to_matrices]
                    else
                      class_name
                    end
@@ -283,9 +271,7 @@ module Plurimath
         end
 
         def paren(parenthesis)
-          return "" if ["{:", ":}"].include?(parenthesis)
-
-          parenthesis
+          parenthesis.to_omml_without_math_tag(true)
         end
 
         def parentheless_table
@@ -305,7 +291,7 @@ module Plurimath
             options[option] == "none"
         end
 
-        def validate_paren(paren)
+        def invisible_paren?(paren)
           ["〖", "〗"].include?(paren)
         end
 
@@ -317,24 +303,30 @@ module Plurimath
           return unless class_name == "table"
           return if open_paren.nil? && close_paren.nil?
 
-          (!(open_paren.nil? || open_paren.empty?) && !(close_paren.nil? || close_paren.empty?)) ||
-            Utility::PARENTHESIS[open_paren&.to_sym] == close_paren ||
-            (open_paren.include?("|") && close_paren.include?("|"))
+          (!open_paren.nil? && !close_paren.nil?) ||
+            Utility::PARENTHESIS[unicodemath_field_value(open_paren)] == close_paren ||
+            [open_paren, close_paren].all?(Math::Symbols::Paren::Vert)
         end
 
         def unicodemath_class_name
-          return matrices_functions(:Vmatrix) if class_name == "vmatrix" && open_paren == "norm["
-          return matrices_functions(:vmatrix) if open_paren == "|" && close_paren == "|"
-          return matrices_functions(:matrix) if class_name == "Bmatrix" && open_paren == "{"
+          return matrices_functions(:Vmatrix) if class_name == "vmatrix" && open_paren&.class_name&.is_a?(Math::Symbols::Paren::Norm)
+          return matrices_functions(:vmatrix) if [open_paren, close_paren].all?(Math::Symbols::Paren::Vert)
+          return matrices_functions(:matrix) if class_name == "Bmatrix" && open_paren == Math::Symbols::Paren::Lcurly
           return unless unicodemath_table_class?
 
-          matrix_name = UnicodeMath::Constants::PARENTHESIS_MATRICES.key(open_paren)
+          matrix_name = UnicodeMath::Constants::PARENTHESIS_MATRICES.key(open_paren.to_unicodemath)
           matrices_functions(matrix_name)
         end
 
         def matrices_functions(matrix_name)
           UnicodeMath::Constants::MATRIXS[matrix_name]
         end
+
+        def mathml_paren_present?(paren)
+          return unless paren || paren&.class_name == "symbol"
+
+          !paren&.to_mathml_without_math_tag&.nodes&.first&.empty?
+        end
       end
     end
   end

data/lib/plurimath/math/function/ternary_function.rb

@@ -187,12 +187,6 @@ module Plurimath
           field_value = field.to_unicodemath
           field.is_a?(Math::Function::Fenced) ? "▒#{field_value}" : "▒〖#{field_value}〗"
         end
-
-        def prime_unicode?(field)
-          return unless field.is_a?(Math::Symbol)
-
-          UnicodeMath::Constants::PREFIXED_PRIMES.any? { |prefix, prime| field.value.include?(prime) || field.value.include?("'") }
-        end
       end
     end
   end

data/lib/plurimath/math/function/tilde.rb

@@ -15,7 +15,7 @@ module Plurimath
 
         def to_mathml_without_math_tag
           mover = Utility.ox_element("mover")
-          mover.attributes.merge!({ accent: attributes[:accent]}) if attributes && attributes[:accent]
+          mover[:accent] = attributes[:accent] if attributes && attributes[:accent]
           first_value = (Utility.ox_element("mo") << "~")
           second_value = parameter_one.to_mathml_without_math_tag if parameter_one
           Utility.update_nodes(mover, [second_value, first_value])
@@ -27,7 +27,7 @@ module Plurimath
           if attributes && attributes[:accent]
             acc_tag(display_style)
           else
-            symbol = Symbol.new("~")
+            symbol = Symbols::Symbol.new("~")
             Overset.new(parameter_one, symbol).to_omml_without_math_tag(true)
           end
         end

data/lib/plurimath/math/function/tr.rb

@@ -16,9 +16,7 @@ module Plurimath
         end
 
         def to_mathml_without_math_tag
-          first_value = parameter_one.dup
-          row_lines = first_value.first.parameter_one
-          row_lines.shift if Utility.symbol_value(row_lines.first, "⎯")
+          first_value = remove_hline(cloned_objects.parameter_one)
           Utility.update_nodes(
             Utility.ox_element("mtr"),
             first_value.map(&:to_mathml_without_math_tag).compact,
@@ -81,6 +79,12 @@ module Plurimath
             Formula.new(parameter_one).to_omml_math_zone(gsub_spacing(spacing, last), last, indent, display_style: display_style),
           ]
         end
+
+        def remove_hline(first_value)
+          row_lines = first_value.first.parameter_one
+          row_lines.shift if row_lines.first.is_a?(Math::Symbols::Hline)
+          first_value
+        end
       end
     end
   end

data/lib/plurimath/math/function/ubrace.rb

@@ -28,7 +28,7 @@ module Plurimath
           return mo_tag unless parameter_one
 
           over_tag = Utility.ox_element("munder")
-          over_tag.attributes.merge!(attributes) if attributes && !attributes.empty?
+          over_tag.set_attr(attributes) if attributes && !attributes.empty?
           Utility.update_nodes(
             over_tag,
             [
@@ -53,7 +53,7 @@ module Plurimath
         def to_omml_without_math_tag(display_style)
           return r_element("⏟", rpr_tag: false) unless parameter_one
 
-          symbol = Symbol.new("⏟")
+          symbol = Symbols::Symbol.new("⏟")
           Underset.new(parameter_one, symbol).to_omml_without_math_tag(true)
         end
 

data/lib/plurimath/math/function/ul.rb

@@ -28,7 +28,7 @@ module Plurimath
           return mo_tag unless parameter_one
 
           munder_tag = Utility.ox_element("munder")
-          munder_tag.attributes.merge!(attributes) if attributes && !attributes.empty?
+          munder_tag.set_attr(attributes) if attributes && !attributes.empty?
           Utility.update_nodes(
             munder_tag,
             [
@@ -44,7 +44,7 @@ module Plurimath
           if attributes && attributes[:accentunder]
             groupchr_tag(display_style)
           else
-            symbol = Symbol.new("̲")
+            symbol = Symbols::Symbol.new("̲")
             Underset.new(parameter_one, symbol).to_omml_without_math_tag(true)
           end
         end