plurimath 0.8.13 → 0.8.15

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

@@ -13,21 +13,21 @@ module Plurimath
           @attributes = attributes
         end
 
-        def to_mathml_without_math_tag(intent)
+        def to_mathml_without_math_tag(intent, options:)
           mover = ox_element("mover")
           mover[:accent] = attributes[:accent] if attributes&.dig(:accent)
-          second_value = parameter_one.to_mathml_without_math_tag(intent) if parameter_one
+          second_value = parameter_one.to_mathml_without_math_tag(intent, options: options) if parameter_one
           Utility.update_nodes(mover, [second_value, ox_element("mo") << "~"])
         end
 
-        def to_omml_without_math_tag(display_style)
+        def to_omml_without_math_tag(display_style, options:)
           return r_element("~", rpr_tag: false) unless parameter_one
 
           if attributes && attributes[:accent]
-            acc_tag(display_style)
+            acc_tag(display_style, options: options)
           else
             symbol = Symbols::Symbol.new("~")
-            Overset.new(parameter_one, symbol).to_omml_without_math_tag(true)
+            Overset.new(parameter_one, symbol).to_omml_without_math_tag(true, options: options)
           end
         end
 
@@ -35,8 +35,8 @@ module Plurimath
           false
         end
 
-        def to_unicodemath
-          "#{unicodemath_parens(parameter_one)}̃"
+        def to_unicodemath(options:)
+          "#{unicodemath_parens(parameter_one, options: options)}̃"
         end
 
         def line_breaking(obj)
@@ -46,7 +46,7 @@ module Plurimath
 
         protected
 
-        def acc_tag(display_style)
+        def acc_tag(display_style, options:)
           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": "˜" }))
@@ -54,7 +54,7 @@ module Plurimath
             acc_tag,
             [
               acc_pr_tag,
-              omml_parameter(parameter_one, display_style, tag_name: "e"),
+              omml_parameter(parameter_one, display_style, tag_name: "e", options: options),
             ],
           )
           [acc_tag]

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

@@ -11,31 +11,32 @@ module Plurimath
           super(parameter_one)
         end
 
-        def to_asciimath
-          "[#{parameter_one.map(&:to_asciimath).join(', ')}]"
+        def to_asciimath(options:)
+          tr_value = parameter_one.map { |param| param.to_asciimath(options: options) }.join(', ')
+          "[#{tr_value}]"
         end
 
-        def to_mathml_without_math_tag(intent)
+        def to_mathml_without_math_tag(intent, options:)
           first_value = remove_hline(cloned_objects.parameter_one)
           Utility.update_nodes(
             Utility.ox_element("mtr"),
-            first_value.map { |obj| obj&.to_mathml_without_math_tag(intent) }.compact,
+            first_value.map { |obj| obj&.to_mathml_without_math_tag(intent, options: options) }.compact,
           )
         end
 
-        def to_latex
+        def to_latex(options:)
           parameter_one.reject do |td|
             td if Utility.symbol_value(td, "|") || Utility.symbol_value(td.parameter_one.first, "|")
-          end.map(&:to_latex).join(" & ")
+          end.map { |td| td.to_latex(options: options) }.join(" & ")
         end
 
-        def to_html
-          first_value = parameter_one.map(&:to_html).join
+        def to_html(options:)
+          first_value = parameter_one.map { |val| val.to_html(options: options) }.join
           "<tr>#{first_value}</tr>"
         end
 
-        def to_omml_without_math_tag(display_style)
-          omml_content = parameter_one&.map { |object| object.to_omml_without_math_tag(display_style) }
+        def to_omml_without_math_tag(display_style, options:)
+          omml_content = parameter_one&.map { |object| object.to_omml_without_math_tag(display_style, options: options) }
           if parameter_one.count.eql?(1)
             omml_content
           else
@@ -48,42 +49,42 @@ module Plurimath
           end
         end
 
-        def to_unicodemath
-          parameter_one&.map(&:to_unicodemath)&.join("&")
+        def to_unicodemath(options:)
+          parameter_one&.map { |param| param.to_unicodemath(options: options) }&.join("&")
         end
 
-        def to_asciimath_math_zone(spacing, last = false, indent = true)
+        def to_asciimath_math_zone(spacing, last = false, indent = true, options:)
           [
             "#{spacing}\"tr\" function apply\n",
-            Formula.new(parameter_one).to_asciimath_math_zone(gsub_spacing(spacing, last), last, indent),
+            Formula.new(parameter_one).to_asciimath_math_zone(gsub_spacing(spacing, last), last, indent, options: options),
           ]
         end
 
-        def to_latex_math_zone(spacing, last = false, indent = true)
+        def to_latex_math_zone(spacing, last = false, indent = true, options:)
           [
             "#{spacing}\"tr\" function apply\n",
-            Formula.new(parameter_one).to_latex_math_zone(gsub_spacing(spacing, last), last, indent),
+            Formula.new(parameter_one).to_latex_math_zone(gsub_spacing(spacing, last), last, indent, options: options),
           ]
         end
 
-        def to_mathml_math_zone(spacing, last = false, indent = true)
+        def to_mathml_math_zone(spacing, last = false, indent = true, options:)
           [
             "#{spacing}\"tr\" function apply\n",
-            Formula.new(parameter_one).to_mathml_math_zone(gsub_spacing(spacing, last), last, indent),
+            Formula.new(parameter_one).to_mathml_math_zone(gsub_spacing(spacing, last), last, indent, options: options),
           ]
         end
 
-        def to_omml_math_zone(spacing, last = false, indent = true, display_style:)
+        def to_omml_math_zone(spacing, last = false, indent = true, display_style:, options:)
           [
             "#{spacing}\"tr\" function apply\n",
-            Formula.new(parameter_one).to_omml_math_zone(gsub_spacing(spacing, last), last, indent, display_style: display_style),
+            Formula.new(parameter_one).to_omml_math_zone(gsub_spacing(spacing, last), last, indent, display_style: display_style, options: options),
           ]
         end
 
-        def to_unicodemath_math_zone(spacing, last = false, indent = true)
+        def to_unicodemath_math_zone(spacing, last = false, indent = true, options:)
           [
             "#{spacing}\"tr\" function apply\n",
-            Formula.new(parameter_one).to_unicodemath_math_zone(gsub_spacing(spacing, last), last, indent),
+            Formula.new(parameter_one).to_unicodemath_math_zone(gsub_spacing(spacing, last), last, indent, options: options),
           ]
         end
 

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

@@ -13,17 +13,17 @@ module Plurimath
           @attributes = attributes
         end
 
-        def to_asciimath
-          first_value = "(#{parameter_one.to_asciimath})" if parameter_one
+        def to_asciimath(options:)
+          first_value = "(#{parameter_one.to_asciimath(options: options)})" if parameter_one
           "ubrace#{first_value}"
         end
 
-        def to_latex
-          first_value = "{#{parameter_one.to_latex}}" if parameter_one
+        def to_latex(options:)
+          first_value = "{#{parameter_one.to_latex(options: options)}}" if parameter_one
           "\\underbrace#{first_value}"
         end
 
-        def to_mathml_without_math_tag(intent)
+        def to_mathml_without_math_tag(intent, options:)
           mo_tag = ox_element("mo") << "&#x23df;"
           return mo_tag unless parameter_one
 
@@ -32,7 +32,7 @@ module Plurimath
           Utility.update_nodes(
             over_tag,
             [
-              parameter_one.to_mathml_without_math_tag(intent),
+              parameter_one.to_mathml_without_math_tag(intent, options: options),
               mo_tag,
             ],
           )
@@ -50,15 +50,15 @@ module Plurimath
           false
         end
 
-        def to_omml_without_math_tag(display_style)
+        def to_omml_without_math_tag(display_style, options:)
           return r_element("⏟", rpr_tag: false) unless parameter_one
 
           symbol = Symbols::Symbol.new("⏟")
-          Underset.new(parameter_one, symbol).to_omml_without_math_tag(true)
+          Underset.new(parameter_one, symbol).to_omml_without_math_tag(true, options: options)
         end
 
-        def to_unicodemath
-          first_value = "(#{parameter_one&.to_unicodemath})" if parameter_one
+        def to_unicodemath(options:)
+          first_value = "(#{parameter_one&.to_unicodemath(options: options)})" if parameter_one
           "⏟#{first_value}"
         end
 

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

@@ -13,17 +13,17 @@ module Plurimath
           @attributes = attributes
         end
 
-        def to_asciimath
-          first_value = "(#{parameter_one.to_asciimath})" if parameter_one
+        def to_asciimath(options:)
+          first_value = "(#{parameter_one.to_asciimath(options: options)})" if parameter_one
           "underline#{first_value}"
         end
 
-        def to_latex
-          first_value = "{#{parameter_one.to_latex}}" if parameter_one
+        def to_latex(options:)
+          first_value = "{#{parameter_one.to_latex(options: options)}}" if parameter_one
           "\\underline#{first_value}"
         end
 
-        def to_mathml_without_math_tag(intent)
+        def to_mathml_without_math_tag(intent, options:)
           mo_tag = ox_element("mo") << "&#x332;"
           return mo_tag unless parameter_one
 
@@ -32,25 +32,25 @@ module Plurimath
           Utility.update_nodes(
             munder_tag,
             [
-              parameter_one&.to_mathml_without_math_tag(intent),
+              parameter_one&.to_mathml_without_math_tag(intent, options: options),
               mo_tag,
             ],
           )
         end
 
-        def to_omml_without_math_tag(display_style)
+        def to_omml_without_math_tag(display_style, options:)
           return r_element("&#x332;", rpr_tag: false) unless parameter_one
 
           if attributes && attributes[:accentunder]
-            groupchr_tag(display_style)
+            groupchr_tag(display_style, options: options)
           else
             symbol = Symbols::Symbol.new("&#x332;")
-            Underset.new(parameter_one, symbol).to_omml_without_math_tag(true)
+            Underset.new(parameter_one, symbol).to_omml_without_math_tag(true, options: options)
           end
         end
 
-        def to_unicodemath
-          "▁#{unicodemath_parens(parameter_one)}"
+        def to_unicodemath(options:)
+          "▁#{unicodemath_parens(parameter_one, options: options)}"
         end
 
         def class_name
@@ -63,7 +63,7 @@ module Plurimath
 
         protected
 
-        def groupchr_tag(display_style)
+        def groupchr_tag(display_style, options:)
           groupchr = Utility.ox_element("groupChr", namespace: "m")
           groupchrpr = Utility.ox_element("groupChrPR", namespace: "m")
           chr = Utility.ox_element("chr", namespace: "m", attributes: { "m:val": "_" })
@@ -73,7 +73,7 @@ module Plurimath
             groupchr,
             [
               groupchrpr,
-              omml_parameter(parameter_one, display_style, tag_name: "e", namespace: "m"),
+              omml_parameter(parameter_one, display_style, tag_name: "e", namespace: "m", options: options),
             ],
           )
         end

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

@@ -18,21 +18,21 @@ module Plurimath
             object.parameter_one == parameter_one
         end
 
-        def to_asciimath
+        def to_asciimath(options:)
           value = if Utility::UNARY_CLASSES.any?(class_name)
-                    asciimath_value
+                    asciimath_value(options: options)
                   elsif parameter_one
-                    "(#{asciimath_value})"
+                    "(#{asciimath_value(options: options)})"
                   end
           "#{class_name}#{value}"
         end
 
-        def to_mathml_without_math_tag(intent)
+        def to_mathml_without_math_tag(intent, options:)
           tag_name = Utility::UNARY_CLASSES.include?(class_name) ? "mi" : "mo"
           new_arr = []
           new_arr << (ox_element(tag_name) << class_name) unless hide_function_name
           if parameter_one
-            new_arr += mathml_value(intent)
+            new_arr += mathml_value(intent, options: options)
             mrow = ox_element("mrow")
             Utility.update_nodes(mrow, new_arr)
             intentify(mrow, intent, func_name: :function, intent_name: :function)
@@ -41,82 +41,82 @@ module Plurimath
           end
         end
 
-        def to_latex
-          "\\#{class_name}{#{latex_value}}"
+        def to_latex(options:)
+          "\\#{class_name}{#{latex_value(options: options)}}"
         end
 
-        def to_html
+        def to_html(options:)
           first_value = if parameter_one.is_a?(Array)
-                          "<i>#{parameter_one.map(&:to_html).join}</i>"
+                          "<i>#{parameter_one.map { |val| val.to_html(options: options) }.join}</i>"
                         elsif parameter_one
-                          "<i>#{parameter_one.to_html}</i>"
+                          "<i>#{parameter_one.to_html(options: options)}</i>"
                         end
-        "<i>#{invert_unicode_symbols}</i>#{first_value}"
+          "<i>#{invert_unicode_symbols}</i>#{first_value}"
         end
 
-        def to_omml_without_math_tag(display_style)
+        def to_omml_without_math_tag(display_style, options: {})
           return r_element(class_name, rpr_tag: false) unless parameter_one
 
           if @hide_function_name
-            value = omml_value(display_style)
+            value = omml_value(display_style, options: options)
           else
             func = Utility.ox_element("func", namespace: "m")
-            value = Utility.update_nodes(func, function_values(display_style))
+            value = Utility.update_nodes(func, function_values(display_style, options: options))
           end
           Array(value)
         end
 
-        def to_unicodemath
-          "#{class_name}⁡#{parameter_one&.to_unicodemath}"
+        def to_unicodemath(options:)
+          "#{class_name}⁡#{parameter_one&.to_unicodemath(options: options)}"
         end
 
-        def to_asciimath_math_zone(spacing, last = false, _)
+        def to_asciimath_math_zone(spacing, last = false, _, options:)
           new_spacing = gsub_spacing(spacing, last)
           new_arr = [
-            "#{spacing}\"#{to_asciimath}\" function apply\n",
+            "#{spacing}\"#{to_asciimath(options: options)}\" function apply\n",
             "#{new_spacing}|_ \"#{class_name}\" function name\n",
           ]
-          ascii_fields_to_print(parameter_one, { spacing: new_spacing, field_name: "argument", additional_space: "   |_ " , array: new_arr })
+          ascii_fields_to_print(parameter_one, { spacing: new_spacing, field_name: "argument", additional_space: "   |_ " , array: new_arr, options: options })
           new_arr
         end
 
-        def to_latex_math_zone(spacing, last = false, _)
+        def to_latex_math_zone(spacing, last = false, _, options:)
           new_spacing = gsub_spacing(spacing, last)
           new_arr = [
-            "#{spacing}\"#{to_latex}\" function apply\n",
+            "#{spacing}\"#{to_latex(options: options)}\" function apply\n",
             "#{new_spacing}|_ \"#{class_name}\" function name\n",
           ]
-          latex_fields_to_print(parameter_one, { spacing: new_spacing, field_name: "argument", additional_space: "   |_ " , array: new_arr })
+          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, _)
+        def to_mathml_math_zone(spacing, last = false, _, options:)
           new_spacing = gsub_spacing(spacing, last)
           new_arr = [
-            "#{spacing}\"#{dump_mathml(self)}\" function apply\n",
+            "#{spacing}\"#{dump_mathml(self, options: options)}\" function apply\n",
             "#{new_spacing}|_ \"#{class_name}\" function name\n",
           ]
-          mathml_fields_to_print(parameter_one, { spacing: new_spacing, field_name: "argument", additional_space: "   |_ ", array: new_arr })
+          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:)
+        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)}\" function apply\n",
+            "#{spacing}\"#{dump_omml(self, display_style, options: options)}\" function apply\n",
             "#{new_spacing}|_ \"#{class_name}\" function name\n",
           ]
-          omml_fields_to_print(parameter_one, { spacing: new_spacing, field_name: "argument", additional_space: "   |_ ", array: new_arr, display_style: display_style })
+          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
 
-        def to_unicodemath_math_zone(spacing, last = false, _)
+        def to_unicodemath_math_zone(spacing, last = false, _, options:)
           new_spacing = gsub_spacing(spacing, last)
           new_arr = [
-            "#{spacing}\"#{to_unicodemath}\" function apply\n",
+            "#{spacing}\"#{to_unicodemath(options: options)}\" function apply\n",
             "#{new_spacing}|_ \"#{class_name}\" function name\n",
           ]
-          unicodemath_fields_to_print(parameter_one, { spacing: new_spacing, field_name: "argument", additional_space: "   |_ " , array: new_arr })
+          unicodemath_fields_to_print(parameter_one, { spacing: new_spacing, field_name: "argument", additional_space: "   |_ " , array: new_arr, options: options })
           new_arr
         end
 
@@ -155,44 +155,44 @@ module Plurimath
 
         protected
 
-        def asciimath_value
+        def asciimath_value(options:)
           return "" unless parameter_one
 
           case parameter_one
           when Array
-            parameter_one.compact.map(&:to_asciimath).join
+            parameter_one.compact.map { |object| object&.to_asciimath(options: options) }.join
           else
-            parameter_one.to_asciimath
+            parameter_one.to_asciimath(options: options)
           end
         end
 
-        def mathml_value(intent)
+        def mathml_value(intent, options:)
           case parameter_one
           when Array
-            parameter_one.compact.map { |object| object&.to_mathml_without_math_tag(intent) }
+            parameter_one.compact.map { |object| object&.to_mathml_without_math_tag(intent, options: options) }
           else
-            Array(parameter_one&.to_mathml_without_math_tag(intent))
+            Array(parameter_one&.to_mathml_without_math_tag(intent, options: options))
           end
         end
 
-        def latex_value
+        def latex_value(options:)
           if parameter_one.is_a?(Array)
-            return parameter_one&.compact&.map(&:to_latex)&.join(" ")
+            return parameter_one&.compact&.map { |object| object&.to_latex(options: options) }&.join(" ")
           end
 
-          parameter_one&.to_latex
+          parameter_one&.to_latex(options: options)
         end
 
-        def omml_value(display_style)
+        def omml_value(display_style, options:)
           if parameter_one.is_a?(Array)
-            return parameter_one&.compact&.map { |object| formula_to_nodes(object, display_style) }
+            return parameter_one&.compact&.map { |object| formula_to_nodes(object, display_style, options: options) }
           end
 
-          Array(formula_to_nodes(parameter_one, display_style))
+          Array(formula_to_nodes(parameter_one, display_style, options: options))
         end
 
-        def formula_to_nodes(object, display_style)
-          object&.insert_t_tag(display_style)
+        def formula_to_nodes(object, display_style, options:)
+          object&.insert_t_tag(display_style, options: options)
         end
 
         def latex_paren
@@ -203,7 +203,7 @@ module Plurimath
           !(parameter_one.is_a?(Array) ? parameter_one.empty? : parameter_one.nil?)
         end
 
-        def function_values(display_style)
+        def function_values(display_style, options:)
           funcpr = Utility.ox_element("funcPr", namespace: "m")
           funcpr << Utility.pr_element("ctrl", true, namespace: "m")
           fname  = Utility.ox_element("fName", namespace: "m")
@@ -215,7 +215,7 @@ module Plurimath
             ],
           )
           me = Utility.ox_element("e", namespace: "m")
-          Utility.update_nodes(me, omml_value(display_style)) if parameter_one
+          Utility.update_nodes(me, omml_value(display_style, options: options)) if parameter_one
           [funcpr, fname, me]
         end
       end

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

@@ -13,44 +13,44 @@ module Plurimath
           third_value: "Over",
         }.freeze
 
-        def to_asciimath
-          first_value = first_field_wrap(parameter_one) if parameter_one
-          second_value = "_#{wrapped(parameter_two)}" if parameter_two
-          third_value = "^#{wrapped(parameter_three)}" if parameter_three
+        def to_asciimath(options:)
+          first_value = first_field_wrap(parameter_one, options: options) if parameter_one
+          second_value = "_#{wrapped(parameter_two, options: options)}" if parameter_two
+          third_value = "^#{wrapped(parameter_three, options: options)}" if parameter_three
           "#{first_value}#{second_value}#{third_value}"
         end
 
-        def to_latex
-          first_value = first_field_wrap(parameter_one, type: "latex") if parameter_one
-          second_value = "_#{wrapped(parameter_two, type: 'latex')}" if parameter_two
-          third_value = "^#{wrapped(parameter_three, type: 'latex')}" if parameter_three
+        def to_latex(options:)
+          first_value = first_field_wrap(parameter_one, type: "latex", options: options) if parameter_one
+          second_value = "_#{wrapped(parameter_two, type: 'latex', options: options)}" if parameter_two
+          third_value = "^#{wrapped(parameter_three, type: 'latex', options: options)}" if parameter_three
           "#{first_value}#{second_value}#{third_value}"
         end
 
-        def to_mathml_without_math_tag(intent)
+        def to_mathml_without_math_tag(intent, options:)
           Utility.update_nodes(
             ox_element("m#{class_name}"),
             [
-              validate_mathml_fields(parameter_one, intent),
-              validate_mathml_fields(parameter_two, intent),
-              validate_mathml_fields(parameter_three, intent),
+              validate_mathml_fields(parameter_one, intent, options: options),
+              validate_mathml_fields(parameter_two, intent, options: options),
+              validate_mathml_fields(parameter_three, intent, options: options),
             ],
           )
         end
 
-        def to_omml_without_math_tag(display_style)
+        def to_omml_without_math_tag(display_style, options:)
           if !display_style
             power_base = PowerBase.new(parameter_one, parameter_two, parameter_three)
-            return power_base.to_omml_without_math_tag(display_style)
+            return power_base.to_omml_without_math_tag(display_style, options: options)
           end
 
-          underover(display_style)
+          underover(display_style, options: options)
         end
 
-        def to_unicodemath
-          sub_value = "┬#{unicodemath_parens(parameter_two)}" if parameter_two
-          sup_value = "┴#{unicodemath_parens(parameter_three)}" if parameter_three
-          "#{parameter_one&.to_unicodemath}#{sub_value}#{sup_value}"
+        def to_unicodemath(options:)
+          sub_value = "┬#{unicodemath_parens(parameter_two, options: options)}" if parameter_two
+          sup_value = "┴#{unicodemath_parens(parameter_three, options: options)}" if parameter_three
+          "#{parameter_one&.to_unicodemath(options: options)}#{sub_value}#{sup_value}"
         end
 
         def line_breaking(obj)

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

@@ -21,18 +21,18 @@ module Plurimath
           @options = options unless options.empty?
         end
 
-        def to_mathml_without_math_tag(intent)
+        def to_mathml_without_math_tag(intent, options:)
           value_array = [
-            validate_mathml_fields(parameter_two, intent),
-            validate_mathml_fields(parameter_one, intent),
+            validate_mathml_fields(parameter_two, intent, options: options),
+            validate_mathml_fields(parameter_one, intent, options: options),
           ]
-          Utility.update_nodes(ox_element("munder", attributes: options), value_array)
+          Utility.update_nodes(ox_element("munder", attributes: self.options), value_array)
         end
 
-        def to_omml_without_math_tag(display_style)
+        def to_omml_without_math_tag(display_style, options:)
           if !display_style
             base = Base.new(parameter_one, parameter_two)
-            return base.to_omml_without_math_tag(display_style)
+            return base.to_omml_without_math_tag(display_style, options: options)
           end
 
           limlow   = Utility.ox_element("limLow", namespace: "m")
@@ -42,19 +42,19 @@ module Plurimath
             limlow,
             [
               limlowpr,
-              omml_parameter(parameter_one, display_style, tag_name: "e"),
-              omml_parameter(parameter_two, display_style, tag_name: "lim"),
+              omml_parameter(parameter_one, display_style, tag_name: "e", options: options),
+              omml_parameter(parameter_two, display_style, tag_name: "lim", options: options),
             ],
           )
           [limlow]
         end
 
-        def to_unicodemath
-          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)
-          return "#{unicodemath_parens(parameter_two)}#{unicodemath_field_value(parameter_one)}" if unicode_accent?(parameter_one)
+        def to_unicodemath(options:)
+          return "#{parameter_one.to_unicodemath(options: options)}#{unicodemath_parens(parameter_two, options: options)}" if horizontal_brackets?
+          return "#{parameter_two.to_unicodemath(options: options)}_#{unicodemath_parens(parameter_one, options: options)}" if unicode_classes_accent?(parameter_two)
+          return "#{unicodemath_parens(parameter_two, options: options)}#{unicodemath_field_value(parameter_one)}" if unicode_accent?(parameter_one)
 
-          "#{unicodemath_parens(parameter_two)}┬#{parameter_one.to_unicodemath}"
+          "#{unicodemath_parens(parameter_two, options: options)}┬#{parameter_one.to_unicodemath(options: options)}"
         end
 
         def line_breaking(obj)