plurimath 0.10.2 → 0.10.3

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

@@ -15,7 +15,8 @@ module Plurimath
         autoload :Monospace, "#{__dir__}/font_style/monospace"
         autoload :Normal, "#{__dir__}/font_style/normal"
         autoload :SansSerif, "#{__dir__}/font_style/sans-serif"
-        autoload :SansSerifBoldItalic, "#{__dir__}/font_style/sans-serif-bold-italic"
+        autoload :SansSerifBoldItalic,
+                 "#{__dir__}/font_style/sans-serif-bold-italic"
         autoload :SansSerifItalic, "#{__dir__}/font_style/sans-serif-italic"
         autoload :Script, "#{__dir__}/font_style/script"
 
@@ -30,7 +31,8 @@ module Plurimath
         end
 
         def to_mathml_without_math_tag(intent, options:)
-          first_value = parameter_one&.to_mathml_without_math_tag(intent, options: options)
+          first_value = parameter_one&.to_mathml_without_math_tag(intent,
+                                                                  options: options)
           Utility.update_nodes(
             Utility.ox_element(
               "mstyle",
@@ -69,9 +71,10 @@ module Plurimath
           parameter_one.is_a?(Text)
         end
 
-        def font_styles(display_style, sty: "p", scr: nil, options:)
+        def font_styles(display_style, options:, sty: "p", scr: nil)
           children = flatten_omml_nodes(
-            Array(parameter_one&.font_style_t_tag(display_style, options: options)),
+            Array(parameter_one&.font_style_t_tag(display_style,
+                                                  options: options)),
           )
           return [empty_font_style_r_tag(sty, scr)] if children.empty?
 
@@ -117,18 +120,32 @@ module Plurimath
         def empty_font_style_r_tag(sty, scr)
           r_tag = Utility.ox_element("r", namespace: "m")
           rpr_tag = Utility.ox_element("rPr", namespace: "m")
-          rpr_tag << Utility.ox_element("scr", namespace: "m", attributes: { "m:val": scr }) if scr
-          rpr_tag << Utility.ox_element("sty", namespace: "m", attributes: { "m:val": sty }) if sty
+          if scr
+            rpr_tag << Utility.ox_element("scr", namespace: "m",
+                                                 attributes: { "m:val": scr })
+          end
+          if sty
+            rpr_tag << Utility.ox_element("sty", namespace: "m",
+                                                 attributes: { "m:val": sty })
+          end
           r_tag << rpr_tag
           r_tag
         end
 
         def inject_font_style_rpr(r_node, sty, scr)
-          return if r_node.nodes.any? { |n| n.respond_to?(:name) && n.name == "m:rPr" }
+          return if r_node.nodes.any? do |n|
+            n.respond_to?(:name) && n.name == "m:rPr"
+          end
 
           rpr_tag = Utility.ox_element("rPr", namespace: "m")
-          rpr_tag << Utility.ox_element("scr", namespace: "m", attributes: { "m:val": scr }) if scr
-          rpr_tag << Utility.ox_element("sty", namespace: "m", attributes: { "m:val": sty }) if sty
+          if scr
+            rpr_tag << Utility.ox_element("scr", namespace: "m",
+                                                 attributes: { "m:val": scr })
+          end
+          if sty
+            rpr_tag << Utility.ox_element("sty", namespace: "m",
+                                                 attributes: { "m:val": sty })
+          end
           r_node.insert_in_nodes(0, rpr_tag)
         end
 
@@ -150,7 +167,9 @@ module Plurimath
             "#{spacing}\"#{to_asciimath(options: options)}\" function apply\n",
             "#{new_spacing}|_ \"#{parameter_two}\" font family\n",
           ]
-          ascii_fields_to_print(parameter_one, { spacing: new_spacing, field_name: "argument", additional_space: "|  |_ " , array: new_arr, options: options })
+          ascii_fields_to_print(parameter_one,
+                                { spacing: new_spacing, field_name: "argument", additional_space: "|  |_ ",
+                                  array: new_arr, options: options })
           new_arr
         end
 
@@ -160,27 +179,36 @@ module Plurimath
             "#{spacing}\"#{to_latex(options: options)}\" function apply\n",
             "#{new_spacing}|_ \"#{parameter_two}\" font family\n",
           ]
-          latex_fields_to_print(parameter_one, { spacing: new_spacing, field_name: "argument", additional_space: "|  |_ " , array: new_arr, options: options })
+          latex_fields_to_print(parameter_one,
+                                { spacing: new_spacing, field_name: "argument", additional_space: "|  |_ ",
+                                  array: new_arr, options: options })
           new_arr
         end
 
         def to_mathml_math_zone(spacing, last = false, _, options:)
           new_spacing = gsub_spacing(spacing, last)
           new_arr = [
-            "#{spacing}\"#{dump_mathml(self, options: options)}\" function apply\n",
+            "#{spacing}\"#{dump_mathml(self,
+                                       options: options)}\" function apply\n",
             "#{new_spacing}|_ \"#{font_family(mathml: true)}\" font family\n",
           ]
-          mathml_fields_to_print(parameter_one, { spacing: new_spacing, field_name: "argument", additional_space: "|  |_ ", array: new_arr, options: options })
+          mathml_fields_to_print(parameter_one,
+                                 { spacing: new_spacing, field_name: "argument", additional_space: "|  |_ ",
+                                   array: new_arr, options: options })
           new_arr
         end
 
-        def to_omml_math_zone(spacing, last = false, _, display_style:, options:)
+        def to_omml_math_zone(spacing, last = false, _, display_style:,
+options:)
           new_spacing = gsub_spacing(spacing, last)
           new_arr = [
-            "#{spacing}\"#{dump_omml(self, display_style, options: options)}\" function apply\n",
+            "#{spacing}\"#{dump_omml(self, display_style,
+                                     options: options)}\" function apply\n",
             "#{new_spacing}|_ \"#{font_family(omml: true)}\" font family\n",
           ]
-          omml_fields_to_print(parameter_one, { spacing: new_spacing, field_name: "argument", additional_space: "|  |_ ", array: new_arr, display_style: display_style, options: options })
+          omml_fields_to_print(parameter_one,
+                               { spacing: new_spacing, field_name: "argument", additional_space: "|  |_ ",
+                                 array: new_arr, display_style: display_style, options: options })
           new_arr
         end
 
@@ -190,14 +218,22 @@ module Plurimath
           supported_fonts(fonts, unicode: unicode, omml: omml, mathml: mathml)
         end
 
-        def supported_fonts(fonts_array = [], unicode: false, omml: false, mathml: false)
+        def supported_fonts(fonts_array = [], unicode: false, omml: false,
+mathml: false)
           if unicode
             font = UnicodeMath::Constants::FONTS_CLASSES.find { |value| fonts_array.include?(value) }
             return "\\#{font}" if font
           end
-          return Omml::Parser::SUPPORTED_FONTS.values.find { |value| fonts_array.include?(value) } if omml
+          if omml
+            return Omml::Parser::SUPPORTED_FONTS.values.find do |value|
+              fonts_array.include?(value)
+            end
+          end
+
           if mathml
-            Mathml::Constants::SUPPORTED_FONT_STYLES.find { |string, object| fonts_array.include?(string.to_s) }&.first ||
+            Mathml::Constants::SUPPORTED_FONT_STYLES.find do |string, _object|
+              fonts_array.include?(string.to_s)
+            end&.first ||
               parameter_two
           end
         end
@@ -205,10 +241,14 @@ module Plurimath
         def to_unicodemath_math_zone(spacing, last = false, _, options:)
           new_spacing = gsub_spacing(spacing, last)
           new_arr = [
-            "#{spacing}\"#{dump_unicodemath(self, options: options)}\" function apply\n",
-            "#{new_spacing}|_ \"#{font_family(unicode: true, options: options)}\" font family\n",
+            "#{spacing}\"#{dump_unicodemath(self,
+                                            options: options)}\" function apply\n",
+            "#{new_spacing}|_ \"#{font_family(unicode: true,
+                                              options: options)}\" font family\n",
           ]
-          unicodemath_fields_to_print(parameter_one, { spacing: new_spacing, field_name: "argument", additional_space: "|  |_ ", array: new_arr, options: options })
+          unicodemath_fields_to_print(parameter_one,
+                                      { spacing: new_spacing, field_name: "argument", additional_space: "|  |_ ",
+                                        array: new_arr, options: options })
           new_arr
         end
 
@@ -219,8 +259,8 @@ module Plurimath
           obj.update(
             self.class.new(
               Utility.filter_values(obj.value),
-              self.parameter_two,
-            )
+              parameter_two,
+            ),
           )
         end
 
@@ -233,11 +273,15 @@ module Plurimath
         end
 
         def font_classes(object = self)
-          Utility::FONT_STYLES.select { |_font, font_class| font_class == object.class }.keys.map(&:to_s)
+          Utility::FONT_STYLES.select do |_font, font_class|
+            font_class == object.class
+          end.keys.map(&:to_s)
         end
 
         def parameter_to_class
-          Utility::FONT_STYLES.select { |font, _font_class| font == parameter_two.to_sym }&.values&.first&.new('')
+          Utility::FONT_STYLES.select do |font, _font_class|
+            font == parameter_two.to_sym
+          end&.values&.first&.new("")
         end
       end
     end

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

@@ -1,11 +1,9 @@
 # frozen_string_literal: true
 
-
 module Plurimath
   module Math
     module Function
       class Frac < BinaryFunction
-
         attr_accessor :options
 
         FUNCTION = {
@@ -22,7 +20,7 @@ module Plurimath
         end
 
         def ==(object)
-          super(object) &&
+          super &&
             object.options == options
         end
 
@@ -39,9 +37,16 @@ module Plurimath
             parameter_two&.to_mathml_without_math_tag(intent, options: options),
           ]
           frac_tag = ox_element(tag_name)
-          frac_tag.set_attr(self.options.reject { |opt| opt == :choose }) if tag_name == "mfrac" && self.options
+          if tag_name == "mfrac" && self.options
+            frac_tag.set_attr(self.options.reject do |opt|
+              opt == :choose
+            end)
+          end
           Utility.update_nodes(frac_tag, mathml_value)
-          update_derivative(frac_tag, mathml_value[0], mathml_value[1]) if intent
+          if intent
+            update_derivative(frac_tag, mathml_value[0],
+                              mathml_value[1])
+          end
           intentify(frac_tag, intent, func_name: :frac, options: intent_names)
         end
 
@@ -52,13 +57,15 @@ module Plurimath
         end
 
         def to_omml_without_math_tag(display_style, options:)
-          f_element   = Utility.ox_element("f", namespace: "m")
+          f_element = Utility.ox_element("f", namespace: "m")
           Utility.update_nodes(
             f_element,
             [
               fpr_element,
-              omml_parameter(parameter_one, display_style, tag_name: "num", options: options),
-              omml_parameter(parameter_two, display_style, tag_name: "den", options: options),
+              omml_parameter(parameter_one, display_style, tag_name: "num",
+                                                           options: options),
+              omml_parameter(parameter_two, display_style, tag_name: "den",
+                                                           options: options),
             ],
           )
         end
@@ -66,19 +73,27 @@ module Plurimath
         def to_unicodemath(options:)
           return unicodemath_fraction if self.options&.dig(:unicodemath_fraction)
 
-          first_value = unicodemath_parens(parameter_one, options: options) if parameter_one
-          second_value = unicodemath_parens(parameter_two, options: options) if parameter_two
+          if parameter_one
+            first_value = unicodemath_parens(parameter_one,
+                                             options: options)
+          end
+          if parameter_two
+            second_value = unicodemath_parens(parameter_two,
+                                              options: options)
+          end
           return "#{first_value}/#{second_value}" unless self.options
 
-          return "#{first_value}¦#{second_value}" if self.options && self.options.key?(:linethickness)
-          return "#{parameter_one.to_unicodemath(options: options)}⊘#{parameter_two.to_unicodemath(options: options)}" if self.options && self.options.key?(:displaystyle)
-          "#{first_value}∕#{second_value}" if self.options && self.options.key?(:ldiv)
+          return "#{first_value}¦#{second_value}" if self.options&.key?(:linethickness)
+          return "#{parameter_one.to_unicodemath(options: options)}⊘#{parameter_two.to_unicodemath(options: options)}" if self.options&.key?(:displaystyle)
+
+          "#{first_value}∕#{second_value}" if self.options&.key?(:ldiv)
         end
 
         def line_breaking(obj)
           parameter_one&.line_breaking(obj)
           if obj.value_exist?
-            frac = self.class.new(Utility.filter_values(obj.value), parameter_two)
+            frac = self.class.new(Utility.filter_values(obj.value),
+                                  parameter_two)
             frac.hide_function_name = true
             obj.update(frac)
             self.parameter_two = nil
@@ -94,8 +109,14 @@ module Plurimath
         end
 
         def choose_frac(options:)
-          first_value = unicodemath_parens(parameter_one, options: options) if parameter_one
-          second_value = unicodemath_parens(parameter_two, options: options) if parameter_two
+          if parameter_one
+            first_value = unicodemath_parens(parameter_one,
+                                             options: options)
+          end
+          if parameter_two
+            second_value = unicodemath_parens(parameter_two,
+                                              options: options)
+          end
           "#{first_value}⒞#{second_value}"
         end
 
@@ -111,8 +132,9 @@ module Plurimath
         def fpr_element
           fpr_element = Utility.ox_element("fPr", namespace: "m")
           if options
-            attributes = { "m:val":  attr_value }
-            fpr_element << Utility.ox_element("type", namespace: "m", attributes: attributes)
+            attributes = { "m:val": attr_value }
+            fpr_element << Utility.ox_element("type", namespace: "m",
+                                                      attributes: attributes)
           end
           fpr_element << Utility.pr_element("ctrl", true, namespace: "m")
         end
@@ -121,7 +143,7 @@ module Plurimath
           if options[:linethickness] == "0"
             "noBar"
           else
-            options[:bevelled] == 'true' ? 'skw' : "bar"
+            options[:bevelled] == "true" ? "skw" : "bar"
           end
         end
 
@@ -130,14 +152,16 @@ module Plurimath
           UnicodeMath::Constants::UNICODE_FRACTIONS.key(frac_array)
         end
 
-        def update_derivative(tag, num, den)
+        def update_derivative(_tag, num, den)
           return if %w[mi mo mn].include?(num&.name)
 
-          intent = num.is_a?(::Array) ? num.first["intent"] : num&.nodes&.first["intent"]
+          intent = num.is_a?(::Array) ? num.first["intent"] : num&.nodes&.first&.[]("intent")
           return unless intent
           return unless intent.start_with?(":derivative") && intent.end_with?(",)")
 
-          num.nodes.first["intent"] = num.nodes.first["intent"].gsub(/,\)$/, ",#{validate_derivative(den.nodes)})")
+          num.nodes.first["intent"] =
+            num.nodes.first["intent"].gsub(/,\)$/,
+                                           ",#{validate_derivative(den.nodes)})")
         end
 
         def validate_derivative(den_nodes)

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

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-
 module Plurimath
   module Math
     module Function

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

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-
 module Plurimath
   module Math
     module Function

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

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-
 module Plurimath
   module Math
     module Function
@@ -31,7 +30,8 @@ module Plurimath
           Utility.update_nodes(
             mover_tag,
             [
-              parameter_one&.to_mathml_without_math_tag(intent, options: options),
+              parameter_one&.to_mathml_without_math_tag(intent,
+                                                        options: options),
               mo_tag,
             ],
           )
@@ -43,13 +43,18 @@ module Plurimath
 
         def to_omml_without_math_tag(display_style, options:)
           return r_element("^", rpr_tag: false) unless parameter_one
-          return omml_value(display_style, options: options) if hide_function_name
+          if hide_function_name
+            return omml_value(display_style,
+                              options: options)
+          end
 
           if attributes && attributes[:accent]
             accent_tag(display_style, options: options)
           else
             symbol = Symbols::Symbol.new("̂") unless hide_function_name
-            Overset.new(parameter_one, symbol).to_omml_without_math_tag(display_style, options: options)
+            Overset.new(parameter_one, symbol).to_omml_without_math_tag(
+              display_style, options: options
+            )
           end
         end
 
@@ -72,12 +77,14 @@ module Plurimath
           symbol  = "̂" unless hide_function_name
           acc_tag = Utility.ox_element("acc", namespace: "m")
           acc_pr_tag = Utility.ox_element("accPr", namespace: "m")
-          acc_pr_tag << (Utility.ox_element("chr", namespace: "m", attributes: { "m:val": symbol }))
+          acc_pr_tag << Utility.ox_element("chr", namespace: "m",
+                                                  attributes: { "m:val": symbol })
           Utility.update_nodes(
             acc_tag,
             [
               acc_pr_tag,
-              omml_parameter(parameter_one, display_style, tag_name: "e", namespace: "m", options: options),
+              omml_parameter(parameter_one, display_style, tag_name: "e",
+                                                           namespace: "m", options: options),
             ],
           )
           [acc_tag]

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

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-
 module Plurimath
   module Math
     module Function

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

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-
 module Plurimath
   module Math
     module Function
@@ -31,11 +30,14 @@ module Plurimath
             inf_tag,
             [
               first_value,
-              parameter_one&.to_mathml_without_math_tag(intent, options: options),
-              parameter_two&.to_mathml_without_math_tag(intent, options: options),
+              parameter_one&.to_mathml_without_math_tag(intent,
+                                                        options: options),
+              parameter_two&.to_mathml_without_math_tag(intent,
+                                                        options: options),
             ],
           )
-          intentify(inf_tag, intent, func_name: :function, intent_name: intent_names[:name])
+          intentify(inf_tag, intent, func_name: :function,
+                                     intent_name: intent_names[:name])
         end
 
         def to_omml_without_math_tag(display_style, options:)
@@ -46,7 +48,8 @@ module Plurimath
           parameter_one.line_breaking(obj)
           if obj.value_exist?
             obj.update(
-              Underover.new(nil, Utility.filter_values(obj.value), parameter_two)
+              Underover.new(nil, Utility.filter_values(obj.value),
+                            parameter_two),
             )
             self.parameter_two = nil
           end

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

@@ -1,16 +1,16 @@
 # frozen_string_literal: true
 
-
 module Plurimath
   module Math
     module Function
       class Int < TernaryFunction
         attr_accessor :options
+
         FUNCTION = {
           name: "integral",
           first_value: "lower limit",
           second_value: "upper limit",
-          third_value: "integrand"
+          third_value: "integrand",
         }.freeze
 
         def initialize(parameter_one = nil,
@@ -22,12 +22,18 @@ module Plurimath
         end
 
         def ==(object)
-          super(object) && object.options == options
+          super && object.options == options
         end
 
         def to_asciimath(options:)
-          first_value = "_#{wrapped(parameter_one, options: options)}" if parameter_one
-          second_value = "^#{wrapped(parameter_two, options: options)}" if parameter_two
+          if parameter_one
+            first_value = "_#{wrapped(parameter_one,
+                                      options: options)}"
+          end
+          if parameter_two
+            second_value = "^#{wrapped(parameter_two,
+                                       options: options)}"
+          end
           "int#{first_value}#{second_value} #{parameter_three&.to_asciimath(options: options)}".strip
         end
 
@@ -50,7 +56,7 @@ module Plurimath
               validate_mathml_tag(parameter_two, intent, options: options),
             ],
           )
-          msubsup_tag = masked_tag(msubsup_tag) if self.options && self.options.key?(:mask)
+          msubsup_tag = masked_tag(msubsup_tag) if self.options&.key?(:mask)
           return msubsup_tag if parameter_three.nil?
 
           mrow = ox_element("mrow")
@@ -58,16 +64,21 @@ module Plurimath
             mrow,
             [
               msubsup_tag,
-              wrap_mrow(parameter_three&.to_mathml_without_math_tag(intent, options: options), intent),
+              wrap_mrow(
+                parameter_three&.to_mathml_without_math_tag(intent,
+                                                            options: options), intent
+              ),
             ].flatten.compact,
           )
-          intentify(mrow, intent, func_name: :naryand, intent_name: intent_names[:name])
+          intentify(mrow, intent, func_name: :naryand,
+                                  intent_name: intent_names[:name])
         end
 
         def to_omml_without_math_tag(display_style, options:)
           if any_value_exist?
             nary = Utility.ox_element("nary", namespace: "m")
-            Utility.update_nodes(nary, nary_array(display_style, options: options))
+            Utility.update_nodes(nary,
+                                 nary_array(display_style, options: options))
             [nary]
           else
             r_tag = Utility.ox_element("r", namespace: "m")
@@ -81,13 +92,16 @@ module Plurimath
           first_value = sub_value(options: options) if parameter_one
           second_value = sup_value(options: options) if parameter_two
           mask = self.options&.dig(:mask) if self.options&.key?(:mask)
-          "∫#{mask}#{first_value}#{second_value}#{naryand_value(parameter_three, options: options)}"
+          "∫#{mask}#{first_value}#{second_value}#{naryand_value(
+            parameter_three, options: options
+          )}"
         end
 
         def line_breaking(obj)
           parameter_one&.line_breaking(obj)
           if obj.value_exist?
-            int = Int.new(Utility.filter_values(obj.value), parameter_two, parameter_three)
+            int = Int.new(Utility.filter_values(obj.value), parameter_two,
+                          parameter_three)
             int.hide_function_name = true
             obj.update(int)
             self.parameter_two = nil
@@ -105,9 +119,12 @@ module Plurimath
           symbol = hide_function_name ? "" : "∫"
           [
             narypr(symbol, function_type: "subSup"),
-            omml_parameter(parameter_one, display_style, tag_name: "sub", options: options),
-            omml_parameter(parameter_two, display_style, tag_name: "sup", options: options),
-            omml_parameter(parameter_three, display_style, tag_name: "e", options: options),
+            omml_parameter(parameter_one, display_style, tag_name: "sub",
+                                                         options: options),
+            omml_parameter(parameter_two, display_style, tag_name: "sup",
+                                                         options: options),
+            omml_parameter(parameter_three, display_style, tag_name: "e",
+                                                           options: options),
           ]
         end
 

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

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
-
 module Plurimath
   module Math
     module Function
       class Intent < BinaryFunction
         def to_mathml_without_math_tag(intent, options:)
-          first_value = parameter_one.to_mathml_without_math_tag(intent, options: options)
+          first_value = parameter_one.to_mathml_without_math_tag(intent,
+                                                                 options: options)
           first_value.attributes["intent"] = encoded_intent(first_value)
           first_value
         end
@@ -35,7 +35,7 @@ module Plurimath
         end
 
         def encodable?
-          return unless parameter_one.is_a?(Formula)
+          return false unless parameter_one.is_a?(Formula)
 
           field = parameter_one.value[0]
           field.is_a?(Power) &&

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

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-
 module Plurimath
   module Math
     module Function

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

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-
 module Plurimath
   module Math
     module Function

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

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-
 module Plurimath
   module Math
     module Function
@@ -9,7 +8,7 @@ module Plurimath
           "left#{parameter_one}"
         end
 
-        def to_mathml_without_math_tag(intent, **)
+        def to_mathml_without_math_tag(_intent, **)
           mo = Utility.ox_element("mo")
           mo << left_paren if parameter_one
           mo
@@ -50,12 +49,12 @@ module Plurimath
 
         def to_mathml_math_zone(spacing = "", _, _, **)
           mo_tag = (Utility.ox_element("mo") << left_paren)
-          "#{spacing}\"#{dump_ox_nodes(mo_tag).gsub(/\s+/, "")}\" left\n"
+          "#{spacing}\"#{dump_ox_nodes(mo_tag).gsub(/\s+/, '')}\" left\n"
         end
 
         def to_omml_math_zone(spacing = "", _, _, display_style:, **)
           t_tag = (Utility.ox_element("t", namespace: "m") << left_paren)
-          "#{spacing}\"#{dump_ox_nodes(t_tag).gsub(/\s+/, "")}\" left\n"
+          "#{spacing}\"#{dump_ox_nodes(t_tag).gsub(/\s+/, '')}\" left\n"
         end
 
         def to_unicodemath_math_zone(spacing = "", _, _, **)

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

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-
 module Plurimath
   module Math
     module Function