plurimath 0.8.14 → 0.8.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e4917de6263422b35cc5d2c04dd466d10e1c0f50f214d0c54753fcef4df826d6
-  data.tar.gz: 8c26d6c94f2ab39735cc1011bd155af5dc74b01d714abe7050d55eeac4edebfd
+  metadata.gz: 9de48dbb937f65122d95415947e417692fc0d5a11d48e7a1caa1b54f3c4465bf
+  data.tar.gz: 2f1e748929a2569b2e7b291381624648fc11a3fc2b93d44406a9a92c2fa21068
 SHA512:
-  metadata.gz: 2e23d92d441333bee877fe164bcfd3405311a78c8e310bfbed17eaca66bcfefaa1020201b8f89c13064c7b0c32bcaec146c0667479e4b45ddedc30e93ac97055
-  data.tar.gz: ecd0a5db9719cabf0bd3256776b9874aa7c25092105430eb3fe84aff79e6b18a849ab4e41265fcfcb08eee08352886536936dc92552373068edf569baf3d3548
+  metadata.gz: c8054b884f09d830a6b7a1e98d1c5679434540f6ad018c4135654f3ea4495336aa4971e43be842def4ad0fc139664ffa477c12407cef5553c55c46f9d0f2037d
+  data.tar.gz: 852c85f6edab822fc8e880ceded6913283be3e65300069be0fd7a898b6d057bb1143fee9f1e5b182a9dee36213c564e11038cb38040b58586c5acbd16b0d063d

data/Rakefile

@@ -30,11 +30,10 @@ def write_doc_file(doc_file, type:)
   File.open(doc_file, "a") do |file|
     file.write(file_header)
 
-    Plurimath::Utility.send(:"#{type}_files").each do |symbol|
-      file_name = File.basename(symbol, ".rb")
-      klass = Plurimath::Utility.get_symbol_class(file_name)
+    Plurimath::Utility.send(:"#{type}_files").each do |klass|
       next if klass::INPUT.empty?
-
+      
+      file_name = File.basename(klass.const_source_location(:INPUT).first, ".rb")
       file.write(documentation_content(file_name, klass))
     end
 

data/lib/plurimath/formatter/numeric_formatter.rb

@@ -1,9 +1,4 @@
-require_relative "supported_locales"
-require_relative "numbers/base"
-require_relative "numbers/integer"
-require_relative "numbers/fraction"
-require_relative "numbers/significant"
-require_relative "number_formatter"
+# frozen_string_literal: true
 
 module Plurimath
   module Formatter
@@ -75,10 +70,6 @@ module Plurimath
         chars.join(" #{@times} 10^")
       end
 
-      def update_exponent_sign(str)
-        str.gsub!("e", "e+") if @exponent_sign == :plus
-      end
-
       def update_exponent_value(number_str)
         exponent_number = BigDecimal(number_str) - 1
         "#{"+" if @exponent_sign == :plus}#{exponent_number.to_i}"
@@ -88,9 +79,9 @@ module Plurimath
         notation_array = BigDecimal(num_str).to_s("e").split("e")
         notation_array[1] = update_exponent_value(notation_array[1])
         number_str = notation_array[0]
-        number_str.gsub!(/0\.(\d)/, '\1.')
-        number_str.sub!('.', '') if number_str.start_with?(".")
-        notation_array[0] = number_str[0..-2] if number_str.end_with?(".")
+        number_str = number_str.gsub(/0\.(\d)/, '\1.')
+        number_str = number_str.sub('.', '') if number_str.start_with?(".")
+        notation_array[0] = number_str.end_with?(".") ? number_str[0..-2] : number_str
         notation_array
       end
 

data/lib/plurimath/formatter/standard.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative "../number_formatter"
+module Plurimath
+  module Formatter
+    class Standard < Plurimath::NumberFormatter
+      attr_accessor :precision
+
+      DEFAULT_OPTIONS = {
+        fraction_group_digits: 3,
+        exponent_sign: "plus",
+        fraction_group: "'",
+        notation: :basic,
+        group_digits: 3,
+        significant: 0,
+        digit_count: 0,
+        precision: 0,
+        decimal: ".",
+        group: ",",
+        times: "x",
+        e: "e",
+      }.freeze
+
+      def initialize(locale: "en", string_format: nil, options: {}, precision: nil)
+        super(
+          locale,
+          localize_number: string_format,
+          localizer_symbols: set_default_options(options),
+          precision: precision,
+        )
+      end
+
+      def set_default_options(options)
+        default_options = self.class::DEFAULT_OPTIONS
+        self.precision ||= default_options[:precision]
+        options ||= default_options
+        options[:fraction_group_digits] ||= default_options[:fraction_group_digits]
+        options[:fraction_group] ||= default_options[:fraction_group]
+        options[:exponent_sign] ||= default_options[:exponent_sign]
+        options[:group_digits] ||= default_options[:group_digits]
+        options[:significant] ||= default_options[:significant]
+        options[:notation] ||= default_options[:notation]
+        options[:decimal] ||= default_options[:decimal]
+        options[:group] ||= default_options[:group]
+        options[:times] ||= default_options[:times]
+        options[:e] ||= default_options[:e]
+        options
+      end
+    end
+  end
+end

data/lib/plurimath/formatter.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "formatter/numeric_formatter"
+require_relative "formatter/supported_locales"
+require_relative "formatter/numbers/base"
+require_relative "formatter/numbers/integer"
+require_relative "formatter/numbers/fraction"
+require_relative "formatter/numbers/significant"
+require_relative "formatter/number_formatter"
+
+module Plurimath
+  module Formatter
+  end
+end

data/lib/plurimath/html/parse.rb

@@ -4,6 +4,7 @@ require "parslet"
 module Plurimath
   class Html
     class Parse < Parslet::Parser
+      rule(:space)   { match["\s"].repeat(1) }
       rule(:unary)   { array_to_expression(Constants::UNARY_CLASSES, :unary) }
       rule(:binary)  { str("lim").as(:binary) }
       rule(:sub_tag) { parse_sub_sup_tags("sub") }
@@ -74,9 +75,10 @@ module Plurimath
       rule(:symbol_text_or_tag) do
         tag_parse |
           (str("&") >> match["a-zA-Z0-9"].repeat(2) >> str(";")).as(:symbol) |
-          match["0-9"].as(:number) |
+          (match["0-9"].repeat(1) >> str(".") >> match["0-9"].repeat(1)).as(:number) |
+          match["0-9"].repeat(1).as(:number) |
           match["a-zA-Z"].as(:text) |
-          match["^0-9a-zA-Z<>/(){}\\[\\]"].as(:symbol)
+          match["^0-9a-zA-Z<>/(){}\\[\\]\s"].as(:symbol)
       end
 
       rule(:intermediate_exp) do
@@ -84,7 +86,8 @@ module Plurimath
           (symbol_text_or_tag.as(:sub_sup) >> sub_sup_tags) |
           sub_sup |
           parse_classes |
-          symbol_text_or_tag
+          symbol_text_or_tag |
+          space
       end
 
       rule(:parse_parenthesis) do

data/lib/plurimath/html/parser.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "json"
+require "cgi"
 require_relative "parse"
 require_relative "constants"
 require_relative "transform"
@@ -10,7 +11,7 @@ module Plurimath
       attr_accessor :text
 
       def initialize(text)
-        @text = CGI.unescapeHTML(text)
+        @text = ::CGI.unescapeHTML(text)
       end
 
       def parse

data/lib/plurimath/html/transform.rb

@@ -3,17 +3,19 @@
 module Plurimath
   class Html
     class Transform < Parslet::Transform
-      rule(text: simple(:text))     { Math::Function::Text.new(text) }
-      rule(unary: simple(:unary))   { Utility.get_class(unary).new }
-      rule(symbol: simple(:symbol)) { Math::Symbols::Symbol.new(symbol) }
-      rule(number: simple(:number)) { Math::Number.new(number) }
-
+      rule(text: simple(:text))      { Math::Function::Text.new(text) }
+      rule(unary: simple(:unary))    { Utility.get_class(unary).new }
+      rule(symbol: simple(:symbol))  { Utility.symbols_class(symbol, lang: :html) }
+      rule(number: simple(:number))  { Math::Number.new(number) }
+      rule(expression: simple(:exp)) { exp }
+      
+      rule(expression: sequence(:exp))    { exp }
       rule(sequence: simple(:sequence))   { sequence }
       rule(tr_value: simple(:tr_value))   { Math::Function::Tr.new([tr_value]) }
       rule(td_value: simple(:td_value))   { Math::Function::Td.new([td_value]) }
-      rule(sequence: sequence(:sequence)) { Math::Formula.new(sequence) }
+      rule(sequence: sequence(:sequence)) { sequence }
       rule(td_value: sequence(:td_value)) { Math::Function::Td.new(td_value) }
-
+      
       rule(parse_parenthesis: simple(:parse_paren)) { parse_paren }
       rule(unary_function: simple(:unary_function)) { unary_function }
 
@@ -100,14 +102,14 @@ module Plurimath
       rule(symbol: simple(:symbol),
            expression: simple(:expr)) do
         [
-          Math::Symbols::Symbol.new(symbol),
+          Utility.symbols_class(symbol, lang: :html),
           expr,
         ]
       end
 
       rule(symbol: simple(:symbol),
            expression: sequence(:expr)) do
-        [Math::Symbols::Symbol.new(symbol)] + expr
+        [Utility.symbols_class(symbol, lang: :html)] + expr
       end
 
       rule(number: simple(:number),
@@ -141,7 +143,7 @@ module Plurimath
       rule(symbol: simple(:symbol),
            parse_parenthesis: simple(:parse_paren)) do
         [
-          Math::Symbols::Symbol.new(symbol),
+          Utility.symbols_class(symbol, lang: :html),
           parse_paren,
         ]
       end
@@ -162,12 +164,12 @@ module Plurimath
       rule(sub_sup: simple(:sub_sup),
            sub_value: sequence(:sub_value)) do
         if Utility.sub_sup_method?(sub_sup)
-          sub_sup.parameter_one = Math::Formula.new(sub_value)
+          sub_sup.parameter_one = Utility.filter_values(sub_value)
           sub_sup
         else
           Math::Function::Base.new(
             sub_sup,
-            Math::Formula.new(sub_value),
+            Utility.filter_values(sub_value),
           )
         end
       end
@@ -188,12 +190,12 @@ module Plurimath
       rule(sub_sup: simple(:sub_sup),
            sup_value: sequence(:sup_value)) do
         if Utility.sub_sup_method?(sub_sup)
-          sub_sup.parameter_two = Math::Formula.new(sup_value)
+          sub_sup.parameter_two = Utility.filter_values(sup_value)
           sub_sup
         else
           Math::Function::Power.new(
             sub_sup,
-            Math::Formula.new(sup_value),
+            Utility.filter_values(sup_value),
           )
         end
       end
@@ -219,13 +221,13 @@ module Plurimath
            sup_value: sequence(:sup_value)) do
         if Utility.sub_sup_method?(sub_sup)
           sub_sup.parameter_one = sub_value
-          sub_sup.parameter_two = Math::Formula.new(sup_value)
+          sub_sup.parameter_two = Utility.filter_values(sup_value)
           sub_sup
         else
           Math::Function::PowerBase.new(
             sub_sup,
             sub_value,
-            Math::Formula.new(sup_value),
+            Utility.filter_values(sup_value),
           )
         end
       end
@@ -234,13 +236,13 @@ module Plurimath
            sub_value: sequence(:sub_value),
            sup_value: simple(:sup_value)) do
         if Utility.sub_sup_method?(sub_sup)
-          sub_sup.parameter_one = Math::Formula.new(sub_value)
+          sub_sup.parameter_one = Utility.filter_values(sub_value)
           sub_sup.parameter_two = sup_value
           sub_sup
         else
           Math::Function::PowerBase.new(
             sub_sup,
-            Math::Formula.new(sub_value),
+            Utility.filter_values(sub_value),
             sup_value,
           )
         end
@@ -250,14 +252,14 @@ module Plurimath
            sub_value: sequence(:sub_value),
            sup_value: sequence(:sup_value)) do
         if Utility.sub_sup_method?(sub_sup)
-          sub_sup.parameter_one = Math::Formula.new(sub_value)
-          sub_sup.parameter_two = Math::Formula.new(sup_value)
+          sub_sup.parameter_one = Utility.filter_values(sub_value)
+          sub_sup.parameter_two = Utility.filter_values(sup_value)
           sub_sup
         else
           Math::Function::PowerBase.new(
             sub_sup,
-            Math::Formula.new(sub_value),
-            Math::Formula.new(sup_value),
+            Utility.filter_values(sub_value),
+            Utility.filter_values(sup_value),
           )
         end
       end
@@ -267,7 +269,7 @@ module Plurimath
            expression: simple(:expression)) do
         power = Math::Function::Power.new(
           sub_sup,
-          Math::Formula.new(sup_value),
+          Utility.filter_values(sup_value),
         )
         [power, expression]
       end
@@ -276,9 +278,9 @@ module Plurimath
            text: simple(:text),
            rparen: simple(:rparen)) do
         Math::Formula.new([
-                            Math::Symbols::Symbol.new(lparen),
+                            Utility.symbols_class(lparen, lang: :html),
                             Math::Function::Text.new(text),
-                            Math::Symbols::Symbol.new(rparen),
+                            Utility.symbols_class(rparen, lang: :html),
                           ])
       end
 
@@ -286,9 +288,9 @@ module Plurimath
            sequence: simple(:sequence),
            rparen: simple(:rparen)) do
         Math::Formula.new([
-                            Math::Symbols::Symbol.new(lparen),
+                            Utility.symbols_class(lparen, lang: :html),
                             sequence,
-                            Math::Symbols::Symbol.new(rparen),
+                            Utility.symbols_class(rparen, lang: :html),
                           ])
       end
 
@@ -297,10 +299,10 @@ module Plurimath
            parse_parenthesis: simple(:parse_paren),
            rparen: simple(:rparen)) do
         Math::Formula.new([
-                            Math::Symbols::Symbol.new(lparen),
+                            Utility.symbols_class(lparen, lang: :html),
                             sequence,
                             parse_paren,
-                            Math::Symbols::Symbol.new(rparen),
+                            Utility.symbols_class(rparen, lang: :html),
                           ])
       end
 
@@ -308,9 +310,9 @@ module Plurimath
            sequence: sequence(:sequence),
            rparen: simple(:rparen)) do
         Math::Formula.new([
-                            Math::Symbols::Symbol.new(lparen),
-                            Math::Formula.new(sequence),
-                            Math::Symbols::Symbol.new(rparen),
+                            Utility.symbols_class(lparen, lang: :html),
+                            Utility.filter_values(sequence),
+                            Utility.symbols_class(rparen, lang: :html),
                           ])
       end
 
@@ -318,9 +320,9 @@ module Plurimath
            number: simple(:number),
            rparen: simple(:rparen)) do
         Math::Formula.new([
-                            Math::Symbols::Symbol.new(lparen),
+                            Utility.symbols_class(lparen, lang: :html),
                             Math::Number.new(number),
-                            Math::Symbols::Symbol.new(rparen),
+                            Utility.symbols_class(rparen, lang: :html),
                           ])
       end
 
@@ -328,9 +330,9 @@ module Plurimath
            unary_function: simple(:unary_function),
            rparen: simple(:rparen)) do
         Math::Formula.new([
-                            Math::Symbols::Symbol.new(lparen),
+                            Utility.symbols_class(lparen, lang: :html),
                             unary_function,
-                            Math::Symbols::Symbol.new(rparen),
+                            Utility.symbols_class(rparen, lang: :html),
                           ])
       end
 
@@ -340,6 +342,15 @@ module Plurimath
         Utility.get_class(binary).new(first_value, second_value)
       end
 
+      rule(first_value: sequence(:first_value),
+           binary: simple(:binary),
+           second_value: sequence(:second_value)) do
+        Utility.get_class(binary).new(
+          Utility.filter_values(first_value),
+          Utility.filter_values(second_value),
+        )
+      end
+
       rule(lparen: simple(:lparen),
            text: simple(:text),
            expression: sequence(:expression),
@@ -347,10 +358,10 @@ module Plurimath
         Math::Formula.new(
           (
             [
-              Math::Symbols::Symbol.new(lparen),
+              Utility.symbols_class(lparen, lang: :html),
               Math::Function::Text.new(text),
             ] + expression
-          ) << Math::Symbols::Symbol.new(rparen),
+          ) << Utility.symbols_class(rparen, lang: :html),
         )
       end
 
@@ -359,10 +370,10 @@ module Plurimath
            expression: simple(:expression),
            rparen: simple(:rparen)) do
         Math::Formula.new([
-                            Math::Symbols::Symbol.new(lparen),
+                            Utility.symbols_class(lparen, lang: :html),
                             Math::Function::Text.new(text),
                             expression,
-                            Math::Symbols::Symbol.new(rparen),
+                            Utility.symbols_class(rparen, lang: :html),
                           ])
       end
 
@@ -371,10 +382,10 @@ module Plurimath
            expression: simple(:expression),
            rparen: simple(:rparen)) do
         Math::Formula.new([
-                            Math::Symbols::Symbol.new(lparen),
+                            Utility.symbols_class(lparen, lang: :html),
                             Math::Number.new(number),
                             expression,
-                            Math::Symbols::Symbol.new(rparen),
+                            Utility.symbols_class(rparen, lang: :html),
                           ])
       end
 
@@ -385,11 +396,11 @@ module Plurimath
         Math::Formula.new(
           (
             [
-              Math::Symbols::Symbol.new(lparen),
+              Utility.symbols_class(lparen, lang: :html),
               Math::Number.new(number),
             ] +
             expression
-          ) << Math::Symbols::Symbol.new(rparen),
+          ) << Utility.symbols_class(rparen, lang: :html),
         )
       end
     end

data/lib/plurimath/latex/parse.rb

@@ -97,7 +97,8 @@ module Plurimath
           rparen.absent? >> symbol_class_commands |
           (slash >> math_operators_classes) |
           match["a-zA-Z"].as(:symbols) |
-          match(/\d+(\.[0-9]+)|\d/).repeat(1).as(:number) |
+          (match["0-9"].repeat(0) >> str(".").maybe >> match["0-9"].repeat(1)).as(:number) |
+          match["0-9"].repeat(1).as(:number) |
           (str("\\\\").as("\\\\") >> match(/\s/).repeat) |
           str("\\ ").as(:space) |
           (str("\\operatorname{") >> match("[^}]").repeat.as(:symbols) >> str("}"))

data/lib/plurimath/math/core.rb

@@ -8,12 +8,22 @@ module Plurimath
         /^\n/ => "",
       }.freeze
 
+      def self.inherited(subclass)
+        @descendants ||= []
+        @descendants << subclass
+        super
+      end
+
+      def self.descendants
+        @descendants
+      end
+
       def class_name
         self.class.name.split("::").last.downcase
       end
 
-      def insert_t_tag(display_style)
-        Array(to_omml_without_math_tag(display_style))
+      def insert_t_tag(display_style, options:)
+        Array(to_omml_without_math_tag(display_style, options: options))
       end
 
       def tag_name
@@ -24,7 +34,7 @@ module Plurimath
         "subSup"
       end
 
-      def nary_attr_value
+      def nary_attr_value(**)
         ""
       end
 
@@ -36,14 +46,14 @@ module Plurimath
         wrapper_tag << r_tag
       end
 
-      def omml_parameter(field, display_style, tag_name:, namespace: "m")
+      def omml_parameter(field, display_style, tag_name:, namespace: "m", options:)
         tag = ox_element(tag_name, namespace: namespace)
         return empty_tag(tag) unless field
 
         field_value = if field.is_a?(Array)
-                        field.map { |object| object.insert_t_tag(display_style) }
+                        field.map { |object| object.insert_t_tag(display_style, options: options) }
                       else
-                        field.insert_t_tag(display_style)
+                        field.insert_t_tag(display_style, options: options)
                       end
         Utility.update_nodes(tag, field_value)
       end
@@ -71,38 +81,38 @@ module Plurimath
         ""
       end
 
-      def font_style_t_tag(display_style)
-        to_omml_without_math_tag(display_style)
+      def font_style_t_tag(display_style, options:)
+        to_omml_without_math_tag(display_style, options: options)
       end
 
       def ascii_fields_to_print(field, options = {})
         return if field.nil?
 
         hashed = common_math_zone_conversion(field, options)
-        options[:array] << "#{hashed[:spacing]}|_ \"#{field&.to_asciimath}\"#{hashed[:field_name]}\n"
+        options[:array] << "#{hashed[:spacing]}|_ \"#{field&.to_asciimath(options: options[:options])}\"#{hashed[:field_name]}\n"
         return unless Utility.validate_math_zone(field, lang: :asciimath)
 
-        options[:array] << field&.to_asciimath_math_zone(hashed[:function_spacing], hashed[:last], hashed[:indent])
+        options[:array] << field&.to_asciimath_math_zone(hashed[:function_spacing], hashed[:last], hashed[:indent], options: options[:options])
       end
 
       def latex_fields_to_print(field, options = {})
         return if field.nil?
 
         hashed = common_math_zone_conversion(field, options)
-        options[:array] << "#{hashed[:spacing]}|_ \"#{field&.to_latex}\"#{hashed[:field_name]}\n"
+        options[:array] << "#{hashed[:spacing]}|_ \"#{field&.to_latex(options: options[:options])}\"#{hashed[:field_name]}\n"
         return unless Utility.validate_math_zone(field, lang: :latex)
 
-        options[:array] << field&.to_latex_math_zone(hashed[:function_spacing], hashed[:last], hashed[:indent])
+        options[:array] << field&.to_latex_math_zone(hashed[:function_spacing], hashed[:last], hashed[:indent], options: options[:options])
       end
 
       def mathml_fields_to_print(field, options = {})
         return if field.nil?
 
         hashed = common_math_zone_conversion(field, options)
-        options[:array] << "#{hashed[:spacing]}|_ \"#{dump_mathml(field)}\"#{hashed[:field_name]}\n"
-        return unless Utility.validate_math_zone(field, lang: :mathml, intent: options[:intent])
+        options[:array] << "#{hashed[:spacing]}|_ \"#{dump_mathml(field, options: options[:options])}\"#{hashed[:field_name]}\n"
+        return unless Utility.validate_math_zone(field, lang: :mathml, intent: options[:intent], options: options[:options])
 
-        options[:array] << field&.to_mathml_math_zone(hashed[:function_spacing], hashed[:last], hashed[:indent])
+        options[:array] << field&.to_mathml_math_zone(hashed[:function_spacing], hashed[:last], hashed[:indent], options: options[:options])
       end
 
       def omml_fields_to_print(field, options = {})
@@ -110,41 +120,41 @@ module Plurimath
 
         hashed = common_math_zone_conversion(field, options)
         display_style = options[:display_style]
-        options[:array] << "#{hashed[:spacing]}|_ \"#{dump_omml(field, display_style)}\"#{hashed[:field_name]}\n"
+        options[:array] << "#{hashed[:spacing]}|_ \"#{dump_omml(field, display_style, options: options[:options])}\"#{hashed[:field_name]}\n"
         return unless Utility.validate_math_zone(field, lang: :omml)
 
-        options[:array] << field&.to_omml_math_zone(hashed[:function_spacing], hashed[:last], hashed[:indent], display_style: display_style)
+        options[:array] << field&.to_omml_math_zone(hashed[:function_spacing], hashed[:last], hashed[:indent], display_style: display_style, options: options[:options])
       end
 
       def unicodemath_fields_to_print(field, options = {})
         return if field.nil?
 
         hashed = common_math_zone_conversion(field, options)
-        options[:array] << "#{hashed[:spacing]}|_ \"#{field&.to_unicodemath}\"#{hashed[:field_name]}\n"
+        options[:array] << "#{hashed[:spacing]}|_ \"#{field&.to_unicodemath(options: options[:options])}\"#{hashed[:field_name]}\n"
         return unless Utility.validate_math_zone(field, lang: :unicodemath)
 
-        options[:array] << field&.to_unicodemath_math_zone(hashed[:function_spacing], hashed[:last], hashed[:indent])
+        options[:array] << field&.to_unicodemath_math_zone(hashed[:function_spacing], hashed[:last], hashed[:indent], options: options[:options])
       end
 
-      def dump_mathml(field, intent = false)
-        dump_ox_nodes(field.to_mathml_without_math_tag(intent)).gsub(/\n\s*/, "")
+      def dump_mathml(field, intent = false, options:)
+        dump_ox_nodes(field.to_mathml_without_math_tag(intent, options: options)).gsub(/\n\s*/, "")
       end
 
-      def dump_omml(field, display_style)
+      def dump_omml(field, display_style, options:)
         return if field.nil?
 
-        dump_ox_nodes(field.omml_nodes(display_style)).gsub(/\n\s*/, "")
+        dump_ox_nodes(field.omml_nodes(display_style, options: options)).gsub(/\n\s*/, "")
       end
 
-      def omml_nodes(display_style)
-        to_omml_without_math_tag(display_style)
+      def omml_nodes(display_style, options:)
+        to_omml_without_math_tag(display_style, options: options)
       end
 
-      def validate_mathml_fields(field, intent)
+      def validate_mathml_fields(field, intent, options:)
         if field.is_a?(Array)
-          field&.map { |object| object.to_mathml_without_math_tag(intent) }
+          field&.map { |object| object.to_mathml_without_math_tag(intent, options: options) }
         else
-          field&.to_mathml_without_math_tag(intent)
+          field&.to_mathml_without_math_tag(intent, options: options)
         end
       end
 
@@ -158,8 +168,8 @@ module Plurimath
         }
       end
 
-      def filtered_values(value, lang:)
-        @values = Utility.filter_math_zone_values(value, lang: lang)
+      def filtered_values(value, lang:, options: {})
+        @values = Utility.filter_math_zone_values(value, lang: lang, options: options)
       end
 
       def dump_ox_nodes(nodes)
@@ -175,7 +185,7 @@ module Plurimath
       end
 
       def replacable_values(string)
-        REPLACABLES.each { |regex, str| string.gsub!(regex, str) }
+        REPLACABLES.each { |regex, str| string = string.gsub(regex, str) }
         string
       end
 
@@ -299,10 +309,11 @@ module Plurimath
         false
       end
 
-      def unicodemath_parens(field)
-        return field.to_unicodemath if field.is_a?(Math::Function::Fenced)
+      def unicodemath_parens(field, options:)
+        paren = field.to_unicodemath(options: options)
+        return paren if field.is_a?(Math::Function::Fenced)
 
-        "(#{field.to_unicodemath})" if field
+        "(#{paren})" if field
       end
 
       def prime_unicode?(field)