plurimath 0.8.14 → 0.8.15

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

@@ -12,47 +12,47 @@ module Plurimath
           third_value: "supscript",
         }.freeze
 
-        def to_asciimath
-          subscript = "_(#{parameter_two&.map(&:to_asciimath).join})" unless valid_value_exist?(parameter_two)
-          supscript = "^(#{parameter_three&.map(&:to_asciimath).join})" unless valid_value_exist?(parameter_three)
+        def to_asciimath(options:)
+          subscript = "_(#{parameter_two&.map { |param| param.to_asciimath(options: options) }.join})" unless valid_value_exist?(parameter_two)
+          supscript = "^(#{parameter_three&.map { |param| param.to_asciimath(options: options) }.join})" unless valid_value_exist?(parameter_three)
           prescript = "\\ #{subscript}#{supscript}" if subscript || supscript
-          "#{prescript}#{parameter_one&.to_asciimath}"
+          "#{prescript}#{parameter_one&.to_asciimath(options: options)}"
         end
 
-        def to_latex
-          subscript = "_{#{parameter_two&.map(&:to_latex).join}}" unless valid_value_exist?(parameter_two)
-          supscript = "^{#{parameter_three&.map(&:to_latex).join}}" unless valid_value_exist?(parameter_three)
+        def to_latex(options:)
+          subscript = "_{#{parameter_two&.map { |param| param.to_latex(options: options) }&.join}}" unless valid_value_exist?(parameter_two)
+          supscript = "^{#{parameter_three&.map { |param| param.to_latex(options: options) }&.join}}" unless valid_value_exist?(parameter_three)
           prescript = "{}#{subscript}#{supscript}" if subscript || supscript
-          "#{prescript}#{parameter_one&.to_latex}"
+          "#{prescript}#{parameter_one&.to_latex(options: options)}"
         end
 
-        def to_mathml_without_math_tag(intent)
+        def to_mathml_without_math_tag(intent, options:)
           mprescript = ox_element("mprescripts") if parameter_two || parameter_three
           Utility.update_nodes(
             ox_element("mmultiscripts"),
             [
-              parameter_one&.mmultiscript(intent),
+              parameter_one&.mmultiscript(intent, options: options),
               mprescript,
-              validate_mathml_fields(prescripts, intent),
+              validate_mathml_fields(prescripts, intent, options: options),
             ]
           )
         end
 
-        def to_omml_without_math_tag(display_style)
+        def to_omml_without_math_tag(display_style, options:)
           Utility.update_nodes(
             ox_element("sPre", namespace: "m"),
             [
-              omml_parameter(parameter_one, display_style, tag_name: "e"),
-              omml_parameter(parameter_two, display_style, tag_name: "sub"),
-              omml_parameter(parameter_three, display_style, tag_name: "sup"),
+              omml_parameter(parameter_one, display_style, tag_name: "e", options: options),
+              omml_parameter(parameter_two, display_style, tag_name: "sub", options: options),
+              omml_parameter(parameter_three, display_style, tag_name: "sup", options: options),
             ],
           )
         end
 
-        def to_unicodemath
-          first_value = sub_value if unicode_valid_value?(parameter_two)
-          second_value = sup_value if unicode_valid_value?(parameter_three)
-          "#{first_value}#{second_value} #{parameter_one&.to_unicodemath}"
+        def to_unicodemath(options:)
+          first_value = sub_value(options: options) if unicode_valid_value?(parameter_two)
+          second_value = sup_value(options: options) if unicode_valid_value?(parameter_three)
+          "#{first_value}#{second_value} #{parameter_one&.to_unicodemath(options: options)}"
         end
 
         def line_breaking(obj)
@@ -98,25 +98,27 @@ module Plurimath
           !field.empty? && !valid_value_exist?(field)
         end
 
-        def sup_value
+        def sup_value(options:)
           field = Utility.filter_values(parameter_two)
+          field_value = parameter_three.map { |param| param.to_unicodemath(options: options) }.join
           if field&.mini_sized? || prime_unicode?(field)
-            parameter_three.map(&:to_unicodemath).join
+            field_value
           elsif field.is_a?(Math::Function::Power)
-            "^#{parameter_three.map(&:to_unicodemath).join}"
+            "^#{field_value}"
           elsif parameter_three && !parameter_three.empty?
-            "^(#{parameter_three.map(&:to_unicodemath).join})"
+            "^(#{field_value})"
           end
         end
 
-        def sub_value
+        def sub_value(options:)
           field = Utility.filter_values(parameter_two)
+          field_value = parameter_two&.map { |param| param.to_unicodemath(options: options) }.join
           if field&.mini_sized?
-            parameter_two.map(&:to_unicodemath).join
+            field_value
           elsif parameter_two.is_a?(Math::Function::Base)
-            "_#{parameter_two.map(&:to_unicodemath).join}"
+            "_#{field_value}"
           elsif parameter_two && !parameter_two.empty?
-            "_(#{parameter_two.map(&:to_unicodemath).join})"
+            "_(#{field_value})"
           end
         end
       end

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

@@ -28,30 +28,30 @@ module Plurimath
             object.options == options
         end
 
-        def to_asciimath
-          first_value  = parameter_one&.to_asciimath || "int"
-          second_value = "_(#{parameter_two.to_asciimath})" if parameter_two
-          third_value  = "^(#{parameter_three.to_asciimath})" if parameter_three
-          fourth_value = " #{parameter_four.to_asciimath}" if parameter_four
+        def to_asciimath(options:)
+          first_value  = parameter_one&.to_asciimath(options: options) || "int"
+          second_value = "_(#{parameter_two.to_asciimath(options: options)})" if parameter_two
+          third_value  = "^(#{parameter_three.to_asciimath(options: options)})" if parameter_three
+          fourth_value = " #{parameter_four.to_asciimath(options: options)}" if parameter_four
           "#{first_value}#{second_value}#{third_value}#{fourth_value}"
         end
 
-        def to_latex
-          first_value  = parameter_one&.to_latex || "\\int"
-          second_value = "_{#{parameter_two.to_latex}}" if parameter_two
-          third_value  = "^{#{parameter_three.to_latex}}" if parameter_three
-          fourth_value = " #{parameter_four.to_latex}" if parameter_four
+        def to_latex(options:)
+          first_value  = parameter_one&.to_latex(options: options) || "\\int"
+          second_value = "_{#{parameter_two.to_latex(options: options)}}" if parameter_two
+          third_value  = "^{#{parameter_three.to_latex(options: options)}}" if parameter_three
+          fourth_value = " #{parameter_four.to_latex(options: options)}" if parameter_four
           "#{first_value}#{second_value}#{third_value}#{fourth_value}"
         end
 
-        def to_mathml_without_math_tag(intent)
+        def to_mathml_without_math_tag(intent, options:)
           new_arr = [
-            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),
           ]
           subsup_tag = Utility.update_nodes(ox_element(tag_name), new_arr)
-          masked_tag(subsup_tag) if options.dig(:mask)
+          masked_tag(subsup_tag) if self.options.dig(:mask)
           return subsup_tag unless parameter_four
 
           intentify(
@@ -59,7 +59,7 @@ module Plurimath
               ox_element("mrow"),
               [
                 subsup_tag,
-                wrap_mrow(validate_mathml_fields(parameter_four, intent), true),
+                wrap_mrow(validate_mathml_fields(parameter_four, intent, options: options), true),
               ],
             ),
             intent,
@@ -68,19 +68,19 @@ module Plurimath
           )
         end
 
-        def to_omml_without_math_tag(display_style)
+        def to_omml_without_math_tag(display_style, options:)
           nary_element = Utility.ox_element("nary", namespace: "m")
-          Utility.update_nodes(nary_element, omml_nary_tag(display_style))
+          Utility.update_nodes(nary_element, omml_nary_tag(display_style, options: options))
           Array(nary_element)
         end
 
-        def to_unicodemath
-          first_value = sub_value if parameter_two
-          second_value = sup_value if parameter_three
+        def to_unicodemath(options:)
+          first_value = sub_value(options: options) if parameter_two
+          second_value = sup_value(options: options) if parameter_three
           if prime_unicode?(parameter_three)
-            "#{parameter_one&.to_unicodemath}#{second_value}#{first_value}#{naryand_value(parameter_four)}"
+            "#{parameter_one&.to_unicodemath(options: options)}#{second_value}#{first_value}#{naryand_value(parameter_four, options: options)}"
           else
-            "#{parameter_one&.to_unicodemath}#{first_value}#{second_value}#{naryand_value(parameter_four)}"
+            "#{parameter_one&.to_unicodemath(options: options)}#{first_value}#{second_value}#{naryand_value(parameter_four, options: options)}"
           end
         end
 
@@ -126,11 +126,11 @@ module Plurimath
 
         protected
 
-        def chr_value(narypr)
-          first_value = Utility.html_entity_to_unicode(parameter_one&.nary_attr_value)
+        def chr_value(narypr, options:)
+          first_value = Utility.html_entity_to_unicode(parameter_one&.nary_attr_value(options: options))
           narypr << Utility.ox_element("chr", namespace: "m", attributes: { "m:val": first_value }) unless first_value == "∫"
 
-          narypr << Utility.ox_element("limLoc", namespace: "m", attributes: { "m:val": (options[:type] || "subSup").to_s })
+          narypr << Utility.ox_element("limLoc", namespace: "m", attributes: { "m:val": (self.options[:type] || "subSup").to_s })
           hide_tags(narypr, parameter_two, "sub")
           hide_tags(narypr, parameter_three, "sup")
           narypr
@@ -142,43 +142,43 @@ module Plurimath
           nar << Utility.ox_element("#{tag_prefix}Hide", namespace: "m", attributes: { "m:val": "1" })
         end
 
-        def omml_nary_tag(display_style)
+        def omml_nary_tag(display_style, options:)
           narypr = Utility.ox_element("naryPr", namespace: "m")
-          chr_value(narypr)
+          chr_value(narypr, options: options)
           [
             (narypr << Utility.pr_element("ctrl", true, namespace: "m")),
-            omml_parameter(parameter_two, display_style, tag_name: "sub"),
-            omml_parameter(parameter_three, display_style, tag_name: "sup"),
-            omml_parameter(parameter_four, display_style, tag_name: "e"),
+            omml_parameter(parameter_two, display_style, tag_name: "sub", options: options),
+            omml_parameter(parameter_three, display_style, tag_name: "sup", options: options),
+            omml_parameter(parameter_four, display_style, tag_name: "e", options: options),
           ]
         end
 
-        def sup_value
+        def sup_value(options:)
           if parameter_three.mini_sized? || prime_unicode?(parameter_three)
-            parameter_three.to_unicodemath
+            parameter_three.to_unicodemath(options: options)
           elsif parameter_three.is_a?(Math::Function::Power)
-            "^#{parameter_three.to_unicodemath}"
+            "^#{parameter_three.to_unicodemath(options: options)}"
           elsif parameter_one.is_a?(Math::Function::Power) && parameter_one&.prime_unicode?(parameter_one&.parameter_two)
-            "^#{parameter_three.to_unicodemath}"
+            "^#{parameter_three.to_unicodemath(options: options)}"
           else
-            "^#{unicodemath_parens(parameter_three)}"
+            "^#{unicodemath_parens(parameter_three, options: options)}"
           end
         end
 
-        def sub_value
+        def sub_value(options:)
           if parameter_two.mini_sized?
-            parameter_two.to_unicodemath
+            parameter_two.to_unicodemath(options: options)
           elsif parameter_two.is_a?(Math::Function::Base)
-            "_#{parameter_two.to_unicodemath}"
+            "_#{parameter_two.to_unicodemath(options: options)}"
           else
-            "_#{unicodemath_parens(parameter_two)}"
+            "_#{unicodemath_parens(parameter_two, options: options)}"
           end
         end
 
-        def naryand_value(field)
+        def naryand_value(field, options:)
           return "" unless field
 
-          field_value = field.to_unicodemath
+          field_value = field.to_unicodemath(options: options)
           field.is_a?(Math::Function::Fenced) ? "▒#{field_value}" : "▒〖#{field_value}〗"
         end
 

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

@@ -6,19 +6,19 @@ module Plurimath
   module Math
     module Function
       class None < UnaryFunction
-        def to_asciimath; end
+        def to_asciimath(**); end
 
-        def to_latex; end
+        def to_latex(**); end
 
-        def to_mathml_without_math_tag(_)
+        def to_mathml_without_math_tag(_, **)
           ox_element("none")
         end
 
-        def to_omml_without_math_tag(_)
+        def to_omml_without_math_tag(_, **)
           empty_tag
         end
 
-        def to_unicodemath; end
+        def to_unicodemath(**); end
       end
     end
   end

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

@@ -8,32 +8,32 @@ module Plurimath
       class Norm < UnaryFunction
         attr_accessor :open_paren, :close_paren
 
-        def to_asciimath
-          parameter_one.is_a?(Table) ? "norm#{parameter_one.to_asciimath}" : super
+        def to_asciimath(options:)
+          parameter_one.is_a?(Table) ? "norm#{parameter_one.to_asciimath(options: options)}" : super
         end
 
-        def to_latex
-          "{\\lVert #{parameter_one&.to_latex} \\lVert}"
+        def to_latex(options:)
+          "{\\lVert #{parameter_one&.to_latex(options: options)} \\lVert}"
         end
 
-        def to_mathml_without_math_tag(intent)
-          first_value = Array(parameter_one&.to_mathml_without_math_tag(intent))
+        def to_mathml_without_math_tag(intent, options:)
+          first_value = Array(parameter_one&.to_mathml_without_math_tag(intent, options: options))
           norm = ox_element("mo") << "&#x2225;"
           first_value = first_value.insert(0, norm) unless open_paren
           first_value = first_value << norm unless close_paren
           Utility.update_nodes(ox_element("mrow"), first_value)
         end
 
-        def to_unicodemath
+        def to_unicodemath(options:)
           first_value = "&#x2016;" unless open_paren
           second_value = "&#x2016;" unless close_paren
-          "#{first_value}#{parameter_one&.to_unicodemath}#{second_value}"
+          "#{first_value}#{parameter_one&.to_unicodemath(options: options)}#{second_value}"
         end
 
-        def to_omml_without_math_tag(display_style)
+        def to_omml_without_math_tag(display_style, options:)
           array = []
           array << r_element("∥") unless open_paren
-          array += Array(omml_value(display_style))
+          array += Array(omml_value(display_style, options: options))
           array << r_element("∥") unless close_paren
           array
         end

data/lib/plurimath/math/function/obrace.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
           "obrace#{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
           "\\overbrace#{first_value}"
         end
 
-        def to_mathml_without_math_tag(intent)
+        def to_mathml_without_math_tag(intent, options:)
           mo_tag = Utility.ox_element("mo") << "&#x23de;"
           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,
             ],
           )
@@ -42,19 +42,19 @@ 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
 
           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
 
-        def to_unicodemath
-          "⏞(#{parameter_one&.to_unicodemath})"
+        def to_unicodemath(options:)
+          "⏞(#{parameter_one&.to_unicodemath(options: options)})"
         end
 
         def line_breaking(obj)
@@ -64,7 +64,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": "⏞" }))
@@ -72,7 +72,7 @@ module Plurimath
             acc_tag,
             [
               acc_pr_tag,
-              omml_parameter(parameter_one, display_style, tag_name: "e", namespace: "m"),
+              omml_parameter(parameter_one, display_style, tag_name: "e", namespace: "m", options: options),
             ],
           )
           [acc_tag]

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

@@ -25,19 +25,19 @@ module Plurimath
           super(object) && object.options == options
         end
 
-        def to_asciimath
-          first_value = "_#{wrapped(parameter_one)}" if parameter_one
-          second_value = "^#{wrapped(parameter_two)}" if parameter_two
-          "oint#{first_value}#{second_value} #{parameter_three&.to_asciimath}".strip
+        def to_asciimath(options:)
+          first_value = "_#{wrapped(parameter_one, options: options)}" if parameter_one
+          second_value = "^#{wrapped(parameter_two, options: options)}" if parameter_two
+          "oint#{first_value}#{second_value} #{parameter_three&.to_asciimath(options: options)}".strip
         end
 
-        def to_latex
-          first_value = "_#{latex_wrapped(parameter_one)}" if parameter_one
-          second_value = "^#{latex_wrapped(parameter_two)}" if parameter_two
-          "\\#{class_name}#{first_value}#{second_value} #{parameter_three&.to_latex}".strip
+        def to_latex(options:)
+          first_value = "_#{latex_wrapped(parameter_one, options: options)}" if parameter_one
+          second_value = "^#{latex_wrapped(parameter_two, options: options)}" if parameter_two
+          "\\#{class_name}#{first_value}#{second_value} #{parameter_three&.to_latex(options: options)}".strip
         end
 
-        def to_mathml_without_math_tag(intent)
+        def to_mathml_without_math_tag(intent, options:)
           mo_tag = ox_element("mo")
           mo_tag << invert_unicode_symbols.to_s unless hide_function_name
           return mo_tag unless all_values_exist?
@@ -52,8 +52,8 @@ module Plurimath
             oint_tag,
             [
               mo_tag,
-              parameter_one&.to_mathml_without_math_tag(intent),
-              parameter_two&.to_mathml_without_math_tag(intent),
+              parameter_one&.to_mathml_without_math_tag(intent, options: options),
+              parameter_two&.to_mathml_without_math_tag(intent, options: options),
             ],
           )
           return ternary_intentify(oint_tag, intent) unless parameter_three
@@ -63,23 +63,23 @@ module Plurimath
               ox_element("mrow"),
               [
                 oint_tag,
-                wrap_mrow(parameter_three&.to_mathml_without_math_tag(intent), intent),
+                wrap_mrow(parameter_three&.to_mathml_without_math_tag(intent, options: options), intent),
               ],
             ),
             intent,
           )
         end
 
-        def to_omml_without_math_tag(display_style)
+        def to_omml_without_math_tag(display_style, options:)
           if all_values_exist?
             nary = Utility.ox_element("nary", namespace: "m")
             Utility.update_nodes(
               nary,
               [
                 narypr((hide_function_name ? "" : "∮"), function_type: "subSup"),
-                omml_parameter(parameter_one, display_style, tag_name: "sub"),
-                omml_parameter(parameter_two, display_style, tag_name: "sup"),
-                omml_parameter(parameter_three, display_style, tag_name: "e"),
+                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),
               ],
             )
             [nary]
@@ -91,11 +91,11 @@ module Plurimath
           end
         end
 
-        def to_unicodemath
-          first_value = "_#{unicodemath_parens(parameter_one)}" if parameter_one
-          second_value = "^#{unicodemath_parens(parameter_two)}" if parameter_two
-          mask = options&.dig(:mask) if options&.key?(:mask)
-          "∮#{mask}#{first_value}#{second_value}#{naryand_value(parameter_three)}"
+        def to_unicodemath(options:)
+          first_value = "_#{unicodemath_parens(parameter_one, options: options)}" if parameter_one
+          second_value = "^#{unicodemath_parens(parameter_two, 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)}"
         end
 
         def line_breaking(obj)

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

@@ -12,44 +12,44 @@ module Plurimath
           second_value: "denominator",
         }.freeze
 
-        def to_asciimath
-          first_value = wrapped(parameter_one)
-          second_value = wrapped(parameter_two)
+        def to_asciimath(options:)
+          first_value = wrapped(parameter_one, options: options)
+          second_value = wrapped(parameter_two, options: options)
           "frac#{first_value}#{second_value}"
         end
 
-        def to_mathml_without_math_tag(intent)
+        def to_mathml_without_math_tag(intent, options:)
           tag_name = hide_function_name ? "mrow" : "mfrac"
           mathml_value = [
-            parameter_one&.to_mathml_without_math_tag(intent),
-            parameter_two&.to_mathml_without_math_tag(intent),
+            parameter_one&.to_mathml_without_math_tag(intent, options: options),
+            parameter_two&.to_mathml_without_math_tag(intent, options: options),
           ]
           Utility.update_nodes(ox_element(tag_name), mathml_value)
         end
 
-        def to_latex
-          first_value = parameter_one&.to_latex
-          two_value = parameter_two&.to_latex
+        def to_latex(options:)
+          first_value = parameter_one&.to_latex(options: options)
+          two_value = parameter_two&.to_latex(options: options)
           "{#{first_value} \\over #{two_value}}"
         end
 
-        def to_omml_without_math_tag(display_style)
+        def to_omml_without_math_tag(display_style, options:)
           f_element   = Utility.ox_element("f", namespace: "m")
           fpr_element = Utility.ox_element("fPr", namespace: "m")
           Utility.update_nodes(
             f_element,
             [
               fpr_element << Utility.pr_element("ctrl", true, namespace: "m"),
-              omml_parameter(parameter_one, display_style, tag_name: "num"),
-              omml_parameter(parameter_two, display_style, tag_name: "den"),
+              omml_parameter(parameter_one, display_style, tag_name: "num", options: options),
+              omml_parameter(parameter_two, display_style, tag_name: "den", options: options),
             ],
           )
           [f_element]
         end
 
-        def to_unicodemath
-          first_value = unicodemath_parens(parameter_one) if parameter_one
-          second_value = unicodemath_parens(parameter_two) if parameter_two
+        def to_unicodemath(options:)
+          first_value = unicodemath_parens(parameter_one, options: options) if parameter_one
+          second_value = unicodemath_parens(parameter_two, options: options) if parameter_two
           "#{first_value}/#{second_value}"
         end
 

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

@@ -21,21 +21,21 @@ 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("mover", attributes: options),
+            ox_element("mover", 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
             power = Power.new(parameter_one, parameter_two)
-            return power.to_omml_without_math_tag(display_style)
+            return power.to_omml_without_math_tag(display_style, options: options)
           end
 
           limupp   = Utility.ox_element("limUpp", namespace: "m")
@@ -45,20 +45,20 @@ module Plurimath
             limupp,
             [
               limupppr,
-              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),
             ],
           )
           [limupp]
         end
 
-        def to_unicodemath
-          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)
+        def to_unicodemath(options:)
+          return "#{unicodemath_parens(parameter_two, options: options)}#{unicodemath_field_value(parameter_one)}" if unicode_accent?(parameter_one)
+          return "#{unicodemath_field_value(parameter_one)}#{parameter_two.to_unicodemath(options: options)}" if unicode_accent?(parameter_two)
+          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)
 
-          "#{unicodemath_parens(parameter_two)}┴#{unicodemath_parens(parameter_one)}" if parameter_one || parameter_two
+          "#{unicodemath_parens(parameter_two, options: options)}┴#{unicodemath_parens(parameter_one, options: options)}" if parameter_one || parameter_two
         end
 
         def line_breaking(obj)