plurimath 0.8.13 → 0.8.15

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

@@ -26,28 +26,28 @@ module Plurimath
             object.close_paren == close_paren
         end
 
-        def to_asciimath
-          return parentheless_table if SIMPLE_TABLES.include?(class_name)
+        def to_asciimath(options:)
+          return parentheless_table(options: options) if SIMPLE_TABLES.include?(class_name)
 
           parenthesis = Asciimath::Constants::TABLE_PARENTHESIS
-          first_value = value.map(&:to_asciimath).join(", ")
-          lparen = open_paren.nil? ? "[" : open_paren.to_asciimath
-          rparen = close_paren.nil? ? parenthesis[lparen.to_sym] : close_paren.to_asciimath
+          first_value = value&.map { |val| val&.to_asciimath(options: options) }&.join(", ")
+          lparen = open_paren.nil? ? "[" : open_paren.to_asciimath(options: options)
+          rparen = close_paren.nil? ? parenthesis[lparen.to_sym] : close_paren.to_asciimath(options: options)
           "#{lparen}#{first_value}#{rparen}"
         end
 
-        def to_mathml_without_math_tag(intent)
+        def to_mathml_without_math_tag(intent, options:)
           table_tag = ox_element("mtable", attributes: table_attribute)
           table_tag["intent"] = ":matrix(#{value.length},#{td_count})" if intent
           Utility.update_nodes(
             table_tag,
-            value&.map { |object| object&.to_mathml_without_math_tag(intent) },
+            value&.map { |object| object&.to_mathml_without_math_tag(intent, options: options) },
           )
           return norm_table(table_tag) if open_paren.is_a?(Math::Symbols::Paren::Norm)
 
-          if mathml_paren_present?(open_paren, intent) || mathml_paren_present?(close_paren, intent)
-            first_paren = mo_element(mathml_parenthesis(open_paren, intent))
-            second_paren = mo_element(mathml_parenthesis(close_paren, intent))
+          if mathml_paren_present?(open_paren, intent, options: options) || mathml_paren_present?(close_paren, intent, options: options)
+            first_paren = mo_element(mathml_parenthesis(open_paren, intent, options: options))
+            second_paren = mo_element(mathml_parenthesis(close_paren, intent, options: options))
             attributes = { intent: ":fenced" } if intent
             mrow = ox_element("mrow", attributes: attributes)
             return Utility.update_nodes(mrow, [first_paren, table_tag, second_paren])
@@ -56,80 +56,81 @@ module Plurimath
           table_tag
         end
 
-        def to_latex
-          return "\\begin{Vmatrix}#{latex_content}\\end{Vmatrix}" if open_paren.is_a?(Math::Symbols::Paren::Norm)
+        def to_latex(options:)
+          return "\\begin{Vmatrix}#{latex_content(options: options)}\\end{Vmatrix}" if open_paren.is_a?(Math::Symbols::Paren::Norm)
 
           separator = "{#{table_attribute(:latex)}}" if environment&.include?("array")
-          left_paren = open_paren&.to_latex || "."
-          right_paren = close_paren&.to_latex || "."
+          left_paren = open_paren&.to_latex(options: options) || "."
+          right_paren = close_paren&.to_latex(options: options) || "."
           left = "\\left #{left_paren}\\begin{matrix}"
           right = "\\end{matrix}\\right #{right_paren.delete_prefix("\\right")}"
-          "#{left}#{separator}#{latex_content}#{right}"
+          "#{left}#{separator}#{latex_content(options: options)}#{right}"
         end
 
-        def to_html
-          first_value = value.map(&:to_html).join
+        def to_html(options:)
+          first_value = value.map { |val| val.to_html(options: options) }.join
           "<table>#{first_value}</table>"
         end
 
-        def to_omml_without_math_tag(display_style)
+        def to_omml_without_math_tag(display_style, options:)
           ox_table = if single_table?
-                       single_td_table(display_style)
+                       single_td_table(display_style, options: options)
                      else
-                       multiple_td_table(display_style)
+                       multiple_td_table(display_style, options: options)
                      end
           fenced_table(ox_table)
         end
 
-        def to_unicodemath
+        def to_unicodemath(options:)
+          table_values = value&.map { |val| val&.to_unicodemath(options: options) }&.join("@")
           if unicodemath_table_class?
-            "#{unicodemath_class_name}(#{value.map(&:to_unicodemath).join("@")})"
+            "#{unicodemath_class_name}(#{table_values})"
           else
-            "#{open_paren&.to_unicodemath}■(#{value.map(&:to_unicodemath).join("@")})#{close_paren&.to_unicodemath}"
+            "#{open_paren&.to_unicodemath(options: options)}■(#{table_values})#{close_paren&.to_unicodemath(options: options)}"
           end
         end
 
-        def to_asciimath_math_zone(spacing, last = false, indent = true)
+        def to_asciimath_math_zone(spacing, last = false, indent = true, options:)
           [
             "#{spacing}\"table\" function apply\n",
-            Formula.new(value).to_asciimath_math_zone(gsub_spacing(spacing, last), last, indent),
+            Formula.new(value).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}\"table\" function apply\n",
-            Formula.new(value).to_latex_math_zone(gsub_spacing(spacing, last), last, indent),
+            Formula.new(value).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}\"table\" function apply\n",
-            Formula.new(value).to_mathml_math_zone(gsub_spacing(spacing, last), last, indent),
+            Formula.new(value).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}\"table\" function apply\n",
-            Formula.new(value).to_omml_math_zone(gsub_spacing(spacing, last), last, indent, display_style: display_style),
+            Formula.new(value).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}\"table\" function apply\n",
-            Formula.new(value).to_unicodemath_math_zone(gsub_spacing(spacing, last), last, indent),
+            Formula.new(value).to_unicodemath_math_zone(gsub_spacing(spacing, last), last, indent, options: options),
           ]
         end
 
         protected
 
-        def mathml_parenthesis(field, intent)
+        def mathml_parenthesis(field, intent, options:)
           return "" unless field
           if field&.class_name == "symbol"
-            paren = field&.to_mathml_without_math_tag(intent)&.nodes&.first
+            paren = field&.to_mathml_without_math_tag(intent, options: options)&.nodes&.first
             return invisible_paren?(paren) ? "" : paren.to_s
           end
 
@@ -167,8 +168,8 @@ module Plurimath
           args
         end
 
-        def latex_content
-          value&.map(&:to_latex)&.join(" \\\\ ")
+        def latex_content(options:)
+          value&.map { |val| val&.to_latex(options: options) }&.join(" \\\\ ")
         end
 
         def matrix_class
@@ -200,17 +201,17 @@ module Plurimath
           matrices_hash.invert[open_paren].to_s if matric_value
         end
 
-        def single_td_table(display_style)
+        def single_td_table(display_style, options:)
           eqarr    = Utility.ox_element("eqArr", namespace: "m")
           eqarrpr  = Utility.ox_element("eqArrPr", namespace: "m")
           eqarrpr  << Utility.pr_element("ctrl", true, namespace: "m")
           eqarr    << eqarrpr
-          tr_value = value.map { |object| object.to_omml_without_math_tag(display_style) }.flatten
+          tr_value = value.map { |object| object.to_omml_without_math_tag(display_style, options: options) }.flatten
           Utility.update_nodes(eqarr, tr_value.compact)
           [eqarr]
         end
 
-        def multiple_td_table(display_style)
+        def multiple_td_table(display_style, options:)
           count  = { "m:val": value&.first&.parameter_one&.count }
           mcjc   = { "m:val": "center" }
           mm     = Utility.ox_element("m", namespace: "m")
@@ -234,7 +235,7 @@ module Plurimath
           mcs << mc
           mpr << mcs
           mpr << ctrlpr
-          mm_value = value&.map { |object| object.to_omml_without_math_tag(display_style) }
+          mm_value = value&.map { |object| object.to_omml_without_math_tag(display_style, options: options) }
           Utility.update_nodes(
             mm,
             mm_value.insert(0, mpr).flatten,
@@ -286,8 +287,8 @@ module Plurimath
           parenthesis.to_omml_without_math_tag(true)
         end
 
-        def parentheless_table
-          "{:#{value.map(&:to_asciimath).join(", ")}:}"
+        def parentheless_table(options:)
+          "{:#{value.map { |val| val&.to_asciimath(options: options) }&.join(", ")}:}"
         end
 
         def single_table?
@@ -334,10 +335,10 @@ module Plurimath
           UnicodeMath::Constants::MATRIXS[matrix_name]
         end
 
-        def mathml_paren_present?(paren, intent)
+        def mathml_paren_present?(paren, intent, options:)
           return unless paren || paren&.class_name == "symbol"
 
-          !paren&.to_mathml_without_math_tag(intent)&.nodes&.first&.empty?
+          !paren&.to_mathml_without_math_tag(intent, options: options)&.nodes&.first&.empty?
         end
 
         def td_count

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

@@ -11,87 +11,87 @@ module Plurimath
           super(parameter_one, parameter_two)
         end
 
-        def to_asciimath
-          parameter_one.map(&:to_asciimath).join(" ")
+        def to_asciimath(options:)
+          parameter_one.map { |val| val&.to_asciimath(options: options) }.join(" ")
         end
 
-        def to_mathml_without_math_tag(intent)
+        def to_mathml_without_math_tag(intent, options:)
           return "" if Utility.symbol_value(parameter_one.first, "|")
 
           td_attribute = parameter_two if parameter_two&.any?
           Utility.update_nodes(
             ox_element("mtd", attributes: td_attribute),
-            parameter_one.map { |object| object&.to_mathml_without_math_tag(intent) },
+            parameter_one.map { |object| object&.to_mathml_without_math_tag(intent, options: options) },
           )
         end
 
-        def to_latex
+        def to_latex(options:)
           return "" if Utility.symbol_value(parameter_one.first, "|")
 
-          parameter_one.map(&:to_latex).join(" ")
+          parameter_one.map { |val| val&.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
           "<td>#{first_value}</td>"
         end
 
-        def to_omml_without_math_tag(display_style)
+        def to_omml_without_math_tag(display_style, options:)
           me = Utility.ox_element("e", namespace: "m")
           return [me] if parameter_one&.empty?
 
-          Utility.update_nodes(me, omml_content(display_style))
+          Utility.update_nodes(me, omml_content(display_style, options: options))
           [me]
         end
 
-        def to_unicodemath
-          parameter_one&.map(&:to_unicodemath)&.join
+        def to_unicodemath(options:)
+          parameter_one&.map { |val| val&.to_unicodemath(options: options) }&.join
         end
 
-        def to_asciimath_math_zone(spacing, last = false, _)
+        def to_asciimath_math_zone(spacing, last = false, _, options:)
           [
             "#{spacing}\"td\" function apply\n",
-            Formula.new(parameter_one).to_asciimath_math_zone(gsub_spacing(spacing, last), last),
+            Formula.new(parameter_one).to_asciimath_math_zone(gsub_spacing(spacing, last), last, 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}\"td\" 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}\"td\" 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}\"td\" 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, _)
+        def to_unicodemath_math_zone(spacing, last = false, _, options:)
           [
             "#{spacing}\"td\" function apply\n",
-            Formula.new(parameter_one).to_unicodemath_math_zone(gsub_spacing(spacing, last), last),
+            Formula.new(parameter_one).to_unicodemath_math_zone(gsub_spacing(spacing, last), last, options: options),
           ]
         end
 
-        def to_unicodemath_math_zone(spacing, last = false, _)
+        def to_unicodemath_math_zone(spacing, last = false, _, options:)
           [
             "#{spacing}\"td\" function apply\n",
-            Formula.new(parameter_one).to_unicodemath_math_zone(gsub_spacing(spacing, last), last),
+            Formula.new(parameter_one).to_unicodemath_math_zone(gsub_spacing(spacing, last), last, options: options),
           ]
         end
-        
-        def omml_content(display_style)
-          parameter_one&.map { |val| val.insert_t_tag(display_style) }
+
+        def omml_content(display_style, options:)
+          parameter_one&.map { |val| val.insert_t_tag(display_style, options: options) }
         end
 
         def line_breaking(obj)

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

@@ -15,13 +15,6 @@ module Plurimath
           Utility.validate_left_right(variables.map { |var| get(var) })
         end
 
-        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
-          "#{first_value}#{second_value}#{third_value}"
-        end
-
         def ==(object)
           self.class == object.class &&
             object.parameter_one == parameter_one &&
@@ -29,27 +22,34 @@ module Plurimath
             object.parameter_three == parameter_three
         end
 
-        def to_mathml_without_math_tag(intent)
+        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_mathml_without_math_tag(intent, options:)
           value_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),
           ]
           class_tag = ox_element("m#{class_name}")
           Utility.update_nodes(class_tag, value_arr)
         end
 
-        def to_latex
-          first_value  = parameter_one&.to_latex
-          second_value = parameter_two&.to_latex
-          third_value  = parameter_three&.to_latex
+        def to_latex(options:)
+          first_value  = parameter_one&.to_latex(options: options)
+          second_value = parameter_two&.to_latex(options: options)
+          third_value  = parameter_three&.to_latex(options: options)
           "#{first_value}#{second_value}#{third_value}"
         end
 
-        def to_html
-          first_value  = "<i>#{parameter_one.to_html}</i>" if parameter_one
-          second_value = "<i>#{parameter_two.to_html}</i>" if parameter_two
-          third_value = "<i>#{parameter_three.to_html}</i>" if parameter_three
+        def to_html(options:)
+          first_value  = "<i>#{parameter_one.to_html(options: options)}</i>" if parameter_one
+          second_value = "<i>#{parameter_two.to_html(options: options)}</i>" if parameter_two
+          third_value = "<i>#{parameter_three.to_html(options: options)}</i>" if parameter_three
           "#{first_value}#{second_value}#{third_value}"
         end
 
@@ -61,80 +61,81 @@ module Plurimath
           !(parameter_one.nil? && parameter_two.nil? && parameter_three.nil?)
         end
 
-        def to_asciimath_math_zone(spacing, last = false, _)
+        def to_asciimath_math_zone(spacing, last = false, _, options:)
           parameters = self.class::FUNCTION
           new_spacing = gsub_spacing(spacing, last)
-          new_arr = ["#{spacing}\"#{to_asciimath}\" #{parameters[:name]}\n"]
-          ascii_fields_to_print(parameter_one, { spacing: new_spacing, field_name: parameters[:first_value], additional_space: "|  |_ ", array: new_arr })
-          ascii_fields_to_print(parameter_two, { spacing: new_spacing, field_name: parameters[:second_value], additional_space: "  |_ ", array: new_arr })
-          ascii_fields_to_print(parameter_three, { spacing: new_spacing, field_name: parameters[:third_value], additional_space: "   |_ ", array: new_arr })
+          new_arr = ["#{spacing}\"#{to_asciimath(options: options)}\" #{parameters[:name]}\n"]
+          ascii_fields_to_print(parameter_one, { spacing: new_spacing, field_name: parameters[:first_value], additional_space: "|  |_ ", array: new_arr, options: options })
+          ascii_fields_to_print(parameter_two, { spacing: new_spacing, field_name: parameters[:second_value], additional_space: "  |_ ", array: new_arr, options: options })
+          ascii_fields_to_print(parameter_three, { spacing: new_spacing, field_name: parameters[:third_value], 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:)
           parameters = self.class::FUNCTION
           new_spacing = gsub_spacing(spacing, last)
-          new_arr = ["#{spacing}\"#{to_latex}\" #{parameters[:name]}\n"]
-          latex_fields_to_print(parameter_one, { spacing: new_spacing, field_name: parameters[:first_value], additional_space: "|  |_ ", array: new_arr })
-          latex_fields_to_print(parameter_two, { spacing: new_spacing, field_name: parameters[:second_value], additional_space: "  |_ ", array: new_arr })
-          latex_fields_to_print(parameter_three, { spacing: new_spacing, field_name: parameters[:third_value], additional_space: "   |_ ", array: new_arr })
+          new_arr = ["#{spacing}\"#{to_latex(options: options)}\" #{parameters[:name]}\n"]
+          latex_fields_to_print(parameter_one, { spacing: new_spacing, field_name: parameters[:first_value], additional_space: "|  |_ ", array: new_arr, options: options })
+          latex_fields_to_print(parameter_two, { spacing: new_spacing, field_name: parameters[:second_value], additional_space: "  |_ ", array: new_arr, options: options })
+          latex_fields_to_print(parameter_three, { spacing: new_spacing, field_name: parameters[:third_value], 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:)
           parameters = self.class::FUNCTION
           new_spacing = gsub_spacing(spacing, last)
-          new_arr = ["#{spacing}\"#{dump_mathml(self)}\" #{parameters[:name]}\n"]
-          mathml_fields_to_print(parameter_one, { spacing: new_spacing, field_name: parameters[:first_value], additional_space: "|  |_ ", array: new_arr })
-          mathml_fields_to_print(parameter_two, { spacing: new_spacing, field_name: parameters[:second_value], additional_space: "  |_ ", array: new_arr })
-          mathml_fields_to_print(parameter_three, { spacing: new_spacing, field_name: parameters[:third_value], additional_space: "   |_ ", array: new_arr })
+          new_arr = ["#{spacing}\"#{dump_mathml(self, options: options)}\" #{parameters[:name]}\n"]
+          mathml_fields_to_print(parameter_one, { spacing: new_spacing, field_name: parameters[:first_value], additional_space: "|  |_ ", array: new_arr, options: options })
+          mathml_fields_to_print(parameter_two, { spacing: new_spacing, field_name: parameters[:second_value], additional_space: "  |_ ", array: new_arr, options: options })
+          mathml_fields_to_print(parameter_three, { spacing: new_spacing, field_name: parameters[:third_value], 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:)
           parameters = self.class::FUNCTION
           new_spacing = gsub_spacing(spacing, last)
-          new_arr = ["#{spacing}\"#{dump_omml(self, display_style)}\" #{parameters[:name]}\n"]
-          omml_fields_to_print(parameter_one, { spacing: new_spacing, field_name: parameters[:first_value], additional_space: "|  |_ ", array: new_arr, display_style: display_style })
-          omml_fields_to_print(parameter_two, { spacing: new_spacing, field_name: parameters[:second_value], additional_space: "  |_ ", array: new_arr, display_style: display_style })
-          omml_fields_to_print(parameter_three, { spacing: new_spacing, field_name: parameters[:third_value], additional_space: "   |_ ", array: new_arr, display_style: display_style })
+          new_arr = ["#{spacing}\"#{dump_omml(self, display_style, options: options)}\" #{parameters[:name]}\n"]
+          omml_fields_to_print(parameter_one, { spacing: new_spacing, field_name: parameters[:first_value], additional_space: "|  |_ ", array: new_arr, display_style: display_style, options: options })
+          omml_fields_to_print(parameter_two, { spacing: new_spacing, field_name: parameters[:second_value], additional_space: "  |_ ", array: new_arr, display_style: display_style, options: options })
+          omml_fields_to_print(parameter_three, { spacing: new_spacing, field_name: parameters[:third_value], 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:)
           parameters = self.class::FUNCTION
           new_spacing = gsub_spacing(spacing, last)
-          new_arr = ["#{spacing}\"#{to_unicodemath}\" #{parameters[:name]}\n"]
-          unicodemath_fields_to_print(parameter_one, { spacing: new_spacing, field_name: parameters[:first_value], additional_space: "|  |_ ", array: new_arr })
-          unicodemath_fields_to_print(parameter_two, { spacing: new_spacing, field_name: parameters[:second_value], additional_space: "  |_ ", array: new_arr })
-          unicodemath_fields_to_print(parameter_three, { spacing: new_spacing, field_name: parameters[:third_value], additional_space: "   |_ ", array: new_arr })
+          new_arr = ["#{spacing}\"#{to_unicodemath(options: options)}\" #{parameters[:name]}\n"]
+          unicodemath_fields_to_print(parameter_one, { spacing: new_spacing, field_name: parameters[:first_value], additional_space: "|  |_ ", array: new_arr, options: options })
+          unicodemath_fields_to_print(parameter_two, { spacing: new_spacing, field_name: parameters[:second_value], additional_space: "  |_ ", array: new_arr, options: options })
+          unicodemath_fields_to_print(parameter_three, { spacing: new_spacing, field_name: parameters[:third_value], additional_space: "   |_ ", array: new_arr, options: options })
           new_arr
         end
 
         protected
 
-        def latex_wrapped(field)
+        def latex_wrapped(field, options:)
+          field_value = field.to_latex(options: options)
           if field.validate_function_formula
-            "{ \\left ( #{field.to_latex} \\right ) }"
+            "{ \\left ( #{field_value} \\right ) }"
           else
-            "{#{field.to_latex}}"
+            "{#{field_value}}"
           end
         end
 
-        def wrapped(field, type: "ascii")
+        def wrapped(field, type: "ascii", options:)
           return "" unless field
 
-          type == "ascii" ? "(#{field.to_asciimath})" : "{#{field.to_latex}}"
+          type == "ascii" ? "(#{field.to_asciimath(options: options)})" : "{#{field.to_latex(options: options)}}"
         end
 
-        def first_field_wrap(field, type: "ascii")
+        def first_field_wrap(field, type: "ascii", options:)
           return "" unless field
 
-          type == "ascii" ? ascii_wrap(field) : latex_wrap(field)
+          type == "ascii" ? ascii_wrap(field, options: options) : latex_wrap(field, options: options)
         end
 
-        def ascii_wrap(field)
-          asciimath = field.to_asciimath
+        def ascii_wrap(field, options:)
+          asciimath = field.to_asciimath(options: options)
           return asciimath if ["obrace", "ubrace"].include?(field.class_name)
 
           case field
@@ -145,8 +146,8 @@ module Plurimath
           end
         end
 
-        def latex_wrap(field)
-          latex = field.to_latex
+        def latex_wrap(field, options:)
+          latex = field.to_latex(options: options)
           return latex if ["obrace", "ubrace"].include?(field.class_name)
 
           case field
@@ -178,23 +179,23 @@ module Plurimath
           )
         end
 
-        def validate_mathml_tag(parameter, intent)
+        def validate_mathml_tag(parameter, intent, options:)
           return Array(Utility.ox_element("mrow")) unless parameter
 
-          Array(parameter.to_mathml_without_math_tag(intent))
+          Array(parameter.to_mathml_without_math_tag(intent, options: options))
         end
 
-        def underover(display_style)
+        def underover(display_style, options:)
           overset = Overset.new(parameter_one, parameter_three)
-          return overset.to_omml_without_math_tag(display_style) unless parameter_two
+          return overset.to_omml_without_math_tag(display_style, options: options) unless parameter_two
 
-          Underset.new(overset, parameter_two)&.to_omml_without_math_tag(display_style)
+          Underset.new(overset, parameter_two)&.to_omml_without_math_tag(display_style, options: options)
         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
       end

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

@@ -9,41 +9,41 @@ module Plurimath
       class Text < UnaryFunction
         PARSER_REGEX = %r{unicode\[:(?<unicode>\w{1,})\]}.freeze
 
-        def to_asciimath
+        def to_asciimath(**)
           "\"#{parse_text('asciimath') || parameter_one}\""
         end
 
-        def to_mathml_without_math_tag(intent)
+        def to_mathml_without_math_tag(intent, **)
           text = ox_element("mtext")
           return text unless parameter_one
 
           text << (parse_text("mathml") || parameter_one)
         end
 
-        def to_latex
+        def to_latex(**)
           text_value = parse_text("latex") || parameter_one
           "\\text{#{text_value}}"
         end
 
-        def to_html
+        def to_html(**)
           parse_text("html") || parameter_one
         end
 
-        def to_omml_without_math_tag(_)
+        def to_omml_without_math_tag(_, **)
           text = Utility.ox_element("t", namespace: "m")
           text << (parse_text("omml") || parameter_one)
           [text]
         end
 
-        def to_unicodemath
+        def to_unicodemath(**)
           return unless value
 
           value&.start_with?("\\") ? value : "\"#{(Utility.html_entity_to_unicode(value))}\""
         end
 
-        def insert_t_tag(display_style)
+        def insert_t_tag(display_style, options:)
           r_tag = Utility.ox_element("r", namespace: "m")
-          Utility.update_nodes(r_tag, to_omml_without_math_tag(display_style))
+          Utility.update_nodes(r_tag, to_omml_without_math_tag(display_style, options: options))
           [r_tag]
         end
 
@@ -51,30 +51,30 @@ module Plurimath
           false
         end
 
-        def to_asciimath_math_zone(spacing, _, _)
-          "#{spacing}#{to_asciimath} text\n"
+        def to_asciimath_math_zone(spacing, _, _, options:)
+          "#{spacing}#{to_asciimath(options: options)} text\n"
         end
 
-        def to_latex_math_zone(spacing, _, _)
-          "#{spacing}#{to_asciimath} text\n"
+        def to_latex_math_zone(spacing, _, _, options:)
+          "#{spacing}#{to_asciimath(options: options)} text\n"
         end
 
-        def to_mathml_math_zone(spacing, _, _)
-          "#{spacing}\"#{dump_mathml(self)}\" text\n"
+        def to_mathml_math_zone(spacing, _, _, options:)
+          "#{spacing}\"#{dump_mathml(self, options: options)}\" text\n"
         end
 
-        def to_omml_math_zone(spacing, _, _, display_style:)
-          "#{spacing}\"#{dump_omml(self, display_style)}\" text\n"
+        def to_omml_math_zone(spacing, _, _, display_style:, options:)
+          "#{spacing}\"#{dump_omml(self, display_style, options: options)}\" text\n"
         end
 
         def value
           parameter_one
         end
 
-        def to_unicodemath_math_zone(spacing, _, _)
-          "#{spacing}#{to_unicodemath} text\n"
+        def to_unicodemath_math_zone(spacing, _, _, options:)
+          "#{spacing}#{to_unicodemath(options: options)} text\n"
         end
-        
+
         protected
 
         def symbol_value(unicode)