plurimath 0.8.10 → 0.8.12

data/lib/plurimath/unicode_math/parsing_rules/constants_rules.rb

@@ -7,7 +7,7 @@ module Plurimath
       module ConstantsRules
         include Helper
 
-        rule(:slash) { str("\\") }
+        rule(:slash)  { str("\\") }
         rule(:slash?) { slash.maybe }
         rule(:primes) { str("⁗") | str("‴") | str("″") | str("′") | str("'") | str("'") }
 
@@ -16,25 +16,26 @@ module Plurimath
         rule(:op_fonts) { slash >> arr_to_expression(Constants::FONTS_CLASSES, :font_class) }
         rule(:op_close) { slash >> arr_to_expression(Constants::CLOSE_SYMBOLS.keys, :close_paren) }
 
-        rule(:op_accent) { arr_to_expression(Constants::ACCENT_SYMBOLS.values, :accent_symbols) }
         rule(:op_spaces) { skip_symbols | skip_symbols_prefixed }
+        rule(:op_accent) { arr_to_expression(Constants::ACCENT_SYMBOLS.values, :accent_symbols) }
 
         rule(:op_matrixs) { arr_to_expression(Constants::MATRIXS.values, :matrixs) }
         rule(:op_negated) { arr_to_expression(Constants::NEGATABLE_SYMBOLS, :negated_operator) }
 
-        rule(:op_nary_text) { slash >> arr_to_expression(Constants::NARY_SYMBOLS.keys, :nary_class) }
+        rule(:skip_symbols) { arr_to_expression(Constants::SKIP_SYMBOLS.values, :spaces) }
         rule(:op_sub_alpha) { arr_to_expression(Constants::SUB_ALPHABETS.values, :sub_alpha) }
         rule(:op_sup_alpha) { arr_to_expression(Constants::SUP_ALPHABETS.values, :sup_alpha) }
+        rule(:op_nary_text) { slash >> arr_to_expression(Constants::NARY_SYMBOLS.keys, :nary_class) }
         rule(:op_h_bracket) { arr_to_expression(Constants::HORIZONTAL_BRACKETS.values, :hbracket_class) }
-        rule(:skip_symbols) { arr_to_expression(Constants::SKIP_SYMBOLS.values, :spaces) }
 
         rule(:op_open_paren) { arr_to_expression(Constants::OPEN_PARENTHESIS, :open_paren) }
         rule(:op_sup_digits) { arr_to_expression(Constants::SUP_DIGITS.values, :sup_digits) }
         rule(:op_sub_digits) { arr_to_expression(Constants::SUB_DIGITS.values, :sub_digits) }
 
         rule(:binary_symbols) { op_binary_symbols | op_binary_symbols_prefixed }
-        rule(:binary_negated) { binary_negated_absent_symbols? >> (op_binary_negated | op_prefixed_binary_negated) }
         rule(:op_close_paren) { arr_to_expression(Constants::CLOSE_PARENTHESIS, :close_paren) }
+        rule(:binary_negated) { binary_negated_absent_symbols? >> (op_binary_negated | op_prefixed_binary_negated) }
+        rule(:unicoded_fonts) { unicoded_fonts_to_expression(Constants::UNICODED_FONTS, :symbol) }
 
         rule(:wrapper_symbols) { arr_to_expression(Constants.wrapper_symbols, :symbol) }
         rule(:op_nary_symbols) { arr_to_expression(Constants::NARY_SYMBOLS.values, :nary_class) }
@@ -48,12 +49,12 @@ module Plurimath
         rule(:op_sup_operators) { arr_to_expression(Constants::SUP_OPERATORS.values, :sup_operators) }
 
         rule(:op_binary_symbols) { arr_to_expression(Constants::BINARY_SYMBOLS.values, :binary_symbols) }
-        rule(:op_binary_negated) { arr_to_expression(Constants::BINARY_SYMBOLS.values, :binary_negated_operator) }
         rule(:op_sub_open_paren) { arr_to_expression(Constants::SUB_PARENTHESIS[:open].values, :sub_open_paren) }
         rule(:op_sup_open_paren) { arr_to_expression(Constants::SUP_PARENTHESIS[:open].values, :sup_open_paren) }
+        rule(:op_binary_negated) { arr_to_expression(Constants::BINARY_SYMBOLS.values, :binary_negated_operator) }
 
-        rule(:op_accent_prefixed) { slash >> arr_to_expression(Constants::ACCENT_SYMBOLS.keys, :accent_symbols) }
         rule(:op_unary_functions) { arr_to_expression(Constants::UNARY_FUNCTIONS, :unary_functions) }
+        rule(:op_accent_prefixed) { slash >> arr_to_expression(Constants::ACCENT_SYMBOLS.keys, :accent_symbols) }
         rule(:op_sub_close_paren) { arr_to_expression(Constants::SUB_PARENTHESIS[:close].values, :sub_close_paren) }
         rule(:op_sup_close_paren) { arr_to_expression(Constants::SUP_PARENTHESIS[:close].values, :sup_close_paren) }
 
@@ -67,11 +68,11 @@ module Plurimath
 
         rule(:op_unicode_fractions)  { arr_to_expression(Constants::UNICODE_FRACTIONS.keys, :unicode_fractions) }
         rule(:skip_symbols_prefixed) { slash >> arr_to_expression(Constants::SKIP_SYMBOLS.keys, :spaces) }
+        rule(:op_diacritic_overlays) { arr_to_expression(Constants::DIACRITIC_OVERLAYS, :diacritic_overlays) }
+        rule(:op_relational_unicode) { arr_to_expression(Constants::RELATIONAL_SYMBOLS.values, :relational_symbols) }
         rule(:op_alphanumeric_fonts) { slash >> arr_to_expression(Constants::ALPHANUMERIC_FONTS_CLASSES, :font_class) }
         rule(:op_h_bracket_prefixed) { slash >> arr_to_expression(Constants::HORIZONTAL_BRACKETS.keys, :hbracket_class) }
         rule(:op_relational_symbols) { slash >> arr_to_expression(Constants::RELATIONAL_SYMBOLS.keys, :relational_symbols) }
-        rule(:op_diacritic_overlays) { arr_to_expression(Constants::DIACRITIC_OVERLAYS, :diacritic_overlays) }
-        rule(:op_relational_unicode) { arr_to_expression(Constants::RELATIONAL_SYMBOLS.values, :relational_symbols) }
 
         rule(:op_unary_arg_functions) { arr_to_expression(Constants::UNARY_ARG_FUNCTIONS.values, :unary_arg_functions) }
 
@@ -97,6 +98,28 @@ module Plurimath
             str(arr.first).as(name)
           end
         end
+
+        def unicoded_fonts_to_expression(hash, name = nil)
+          type = hash.first.class
+          hash.reduce do |expression, expr_hash|
+            if expression.is_a?(type)
+              expression = hash_values(expression.last, expression.first)
+            end
+            expression | hash_values(expr_hash.last, expr_hash.first)
+          end
+        end
+
+        def hash_values(expr_hash, name)
+          if expr_hash.keys.length > 1
+            type = expr_hash.first.class
+            expr_hash.reduce do |expression, (_, hex_code)|
+              expression = str(name).absent?.as(name).as(:unicoded_font_class) >> str(expression.last).as(:symbol) if expression.is_a?(type)
+              expression | str(name).absent?.as(name).as(:unicoded_font_class) >> str(hex_code).as(:symbol)
+            end
+          else
+            str(expr_hash.values.last)
+          end
+        end
       end
     end
   end

data/lib/plurimath/unicode_math/parsing_rules/sub_sup.rb

@@ -59,7 +59,7 @@ module Plurimath
           (operator.absent? >> naryand_values >> naryand_recursion.as(:naryand_recursion).maybe) |
             (slashed_operator >> naryand_recursion.as(:naryand_recursion).maybe)
         end
-        
+
         rule(:baseless_sub) do
           (invisible_space? >> base_syntax >> op_size_overrides_symbols.absent? >> (operator_symbols.maybe >> baseless_sub_values(:sub_script))) |
             (invisible_space? >> base_syntax >> op_size_overrides_symbols.absent? >> (operator_symbols >> recursive_baseless_sub_exp.maybe)) |
@@ -85,9 +85,10 @@ module Plurimath
         end
 
         rule(:naryand_values) do
-          fraction.as(:frac) |
+          binomial_fraction.absent? >> fraction.as(:frac) |
             (exp_bracket >> (subsup | subscript_value | supscript_value).maybe) |
             (exp_script >> space?) |
+            binomial_fraction.as(:frac) >> space? |
             negatable_symbols.absent? >> sub_sup_operand
         end
 
@@ -100,8 +101,8 @@ module Plurimath
         end
 
         rule(:nary_sub_sup) do
-          (power_base_script.as(:nary_sub_sup) >> invisible_space? >> naryand_recursion.as(:naryand).maybe) |
-            (op_nary >> invisible_space? >> naryand_recursion.as(:naryand).maybe)
+          (power_base_script.as(:nary_sub_sup) >> (invisible_space? >> space?) >> naryand_recursion.as(:naryand).maybe) |
+            (op_nary >> (invisible_space? >> space?) >> naryand_recursion.as(:naryand).maybe)
         end
 
         rule(:unary_sub_sup) do
@@ -219,8 +220,8 @@ module Plurimath
           (operator_symbols.as(:expr) >> (((mini_sub_sup | sub_or_sup) >> space?) >> bracketed_soperand.maybe)) |
             (operator_symbols.as(:expr) >> bracketed_soperand) |
             (((primes | prefixed_primes).as(:symbol).as(:first_value) >> repeated_accent_symbols).as(:accents) >> (sub_or_sup.maybe >> space? >> bracketed_soperand).maybe) |
-            bracketed_soperand >> operator_symbols.absent? >> sub_sup_values.as(:expr).maybe |
-            sub_sup_binary_absent >> operator_symbols.absent? >> sub_sup_values.as(:expr).maybe |
+            bracketed_soperand >> str("−").absent? >> operator_symbols.absent? >> sub_sup_values.as(:expr).maybe |
+            sub_sup_binary_absent >> str("−").absent? >> operator_symbols.absent? >> sub_sup_values.as(:expr).maybe |
             bracketed_soperand |
             prefixed_primes |
             primes |

data/lib/plurimath/unicode_math/transform.rb

@@ -37,6 +37,9 @@ module Plurimath
       rule(sub_exp: sequence(:exp)) { exp }
       rule(factor: simple(:factor)) { factor }
       rule(hbrack: simple(:hbrack)) { hbrack }
+      rule(script: simple(:script)) { :script }
+      rule(double: simple(:double)) { :double }
+      rule(mitBbb: simple(:mitBbb)) { :mitBbb }
       rule(symbol: simple(:symbol)) { Utility.symbols_class(symbol, lang: :unicodemath) }
       rule(number: simple(:number)) { Math::Number.new(number) }
 
@@ -44,6 +47,7 @@ module Plurimath
       rule(sub_paren: simple(:paren)) { paren }
       rule(factor: sequence(:factor)) { factor }
       rule(operand: simple(:operand)) { operand }
+      rule(fraktur: simple(:fraktur)) { :fraktur }
       rule(accents: subtree(:accent)) { Utility.unicode_accents(accent) }
       rule(sup_alpha: simple(:alpha)) { Math::Symbols::Symbol.new(Constants::SUP_ALPHABETS.key(alpha).to_s, mini_sup_sized: true) }
 
@@ -168,7 +172,7 @@ module Plurimath
                         else
                           (Constants::NARY_CLASSES.invert[nary_class.to_s] || Constants::NARY_SYMBOLS[nary_class.to_sym] || nary_class)
                         end
-        Utility.get_class(nary_function).new 
+        Utility.get_class(nary_function).new
       end
 
       rule(ordinary_negated_operator: simple(:operator)) do
@@ -183,6 +187,22 @@ module Plurimath
         Math::Number.new("#{decimal}#{whole.value}")
       end
 
+      rule(positive: simple(:positive),
+           infty: simple(:infty)) do
+        [
+          Utility.symbols_class(positive, lang: :unicodemath),
+          Utility.symbols_class(infty, lang: :unicodemath),
+        ]
+      end
+
+      rule(negative: simple(:negative),
+           infty: simple(:infty)) do
+        [
+          Utility.symbols_class(negative, lang: :unicodemath),
+          Utility.symbols_class(infty, lang: :unicodemath),
+        ]
+      end
+
       rule(unicode_fractions: simple(:fractions),
            expr: sequence(:expr)) do
         [Utility.unicode_fractions(fractions)] + expr
@@ -204,7 +224,7 @@ module Plurimath
           unicoded.to_sym,
           symbol.to_sym,
         )
-        Utility.symbols_class(unicode, lang: :unicodemath)
+        Utility.symbols_class((unicode || symbol), lang: :unicodemath)
       end
 
       rule(font_class: simple(:fonts),
@@ -392,6 +412,11 @@ module Plurimath
         [fonts] + expr
       end
 
+      rule(fonts: simple(:fonts),
+           expr: simple(:expr)) do
+        [fonts, expr]
+      end
+
       rule(phantom: simple(:phantom),
            expr: sequence(:expr)) do
         [phantom] + expr
@@ -493,6 +518,12 @@ module Plurimath
         [Utility.symbols_class(symbol, lang: :unicodemath), sup_script]
       end
 
+      rule(combined_symbols: simple(:combined_symbols),
+           exp: simple(:exp)) do
+        symbol = Constants::COMBINING_SYMBOLS[combined_symbols.to_sym]
+        [Utility.symbols_class(symbol, lang: :unicodemath), exp]
+      end
+
       rule(operator: simple(:operator),
            sub_script: simple(:sub_script)) do
         [Utility.symbols_class(operator, lang: :unicodemath), sub_script]
@@ -690,6 +721,11 @@ module Plurimath
         [nary, naryand_recursion]
       end
 
+      rule(nary: simple(:nary),
+           naryand_recursion: sequence(:naryand_recursion)) do
+        [nary] + naryand_recursion
+      end
+
       rule(factor: simple(:factor),
            operand: simple(:operand)) do
         [factor, operand]
@@ -705,6 +741,16 @@ module Plurimath
         [factor] + operand
       end
 
+      rule(operand: sequence(:operand),
+           expr: simple(:expr)) do
+        operand + [expr]
+      end
+
+      rule(operand: sequence(:operand),
+           expr: sequence(:expr)) do
+        operand + expr
+      end
+
       rule(factor: simple(:factor),
            unary_subsup: sequence(:subsup)) do
         [factor] + subsup
@@ -750,6 +796,11 @@ module Plurimath
         [sub_exp] + naryand
       end
 
+      rule(sup_exp: simple(:sup_exp),
+           naryand_recursion: simple(:naryand)) do
+        [sup_exp, naryand]
+      end
+
       rule(exp: simple(:exp),
            expr: simple(:expr)) do
         [exp, expr]
@@ -1123,6 +1174,16 @@ module Plurimath
         end
       end
 
+      rule(unary_sub_sup: simple(:sub_sup),
+           first_value: sequence(:first_value)) do
+        if sub_sup.is_unary?
+          sub_sup.parameter_one.parameter_one = Utility.filter_values(first_value)
+          sub_sup
+        else
+          Math::Formula.new([sub_sup] + first_value)
+        end
+      end
+
       rule(color_value: simple(:color),
            first_value: simple(:first_value)) do
         Math::Function::Color.new(
@@ -1476,17 +1537,6 @@ module Plurimath
         )
       end
 
-      rule(unary_functions: simple(:unary),
-           first_value: simple(:first_value)) do
-        if Constants::UNDEF_UNARY_FUNCTIONS.include?(unary.to_s)
-          Math::Formula.new([
-            Utility.symbols_class(unary, lang: :unicodemath),
-            first_value,
-          ])
-        else
-          Utility.get_class(unary).new(first_value)
-        end
-      end
 
       rule(unary_functions: simple(:unary),
            first_value: simple(:first_value)) do
@@ -1495,6 +1545,8 @@ module Plurimath
             Utility.symbols_class(unary, lang: :unicodemath),
             first_value,
           ])
+        elsif unary == "mod"
+          Math::Function::Mod.new(nil, first_value)
         else
           Utility.get_class(unary).new(first_value)
         end
@@ -1740,6 +1792,11 @@ module Plurimath
         [frac, exp]
       end
 
+      rule(frac: simple(:frac),
+           naryand_recursion: sequence(:naryand)) do
+        [frac] + naryand
+      end
+
       rule(expr: simple(:expr),
            func_expr: simple(:func_expr)) do
         [expr, func_expr]
@@ -1813,6 +1870,11 @@ module Plurimath
         if subsup_exp.is_ternary_function?
           subsup_exp.parameter_three = Utility.filter_values(naryand)
           subsup_exp
+        elsif subsup_exp.is_a?(Math::Function::Nary)
+          if subsup_exp.parameter_four.nil?
+            subsup_exp.parameter_four = Utility.filter_values(naryand)
+          end
+          subsup_exp
         else
           Math::Function::Nary.new(
             subsup_exp.parameter_one,
@@ -2180,6 +2242,12 @@ module Plurimath
         [factor] + operand + naryand_recursion
       end
 
+      rule(factor: simple(:factor),
+           operand: sequence(:operand),
+           naryand_recursion: simple(:naryand_recursion)) do
+        [factor] + operand + [naryand_recursion]
+      end
+
       rule(factor: sequence(:factor),
            operand: simple(:operand),
            expr: sequence(:expr)) do
@@ -2834,34 +2902,6 @@ module Plurimath
         end
       end
 
-      rule(nary_class: simple(:nary_class),
-           mask: simple(:mask),
-           sup: simple(:sup)) do
-        nary_function = if Constants::NARY_CLASSES.key?(nary_class.to_sym)
-                          nary_class
-                        else
-                          (Constants::NARY_CLASSES.invert[nary_class.to_s] || Constants::NARY_SYMBOLS[nary_class.to_sym] || nary_class)
-                        end
-        sup_value = sup.is_a?(Math::Function::Overset) ? sup.parameter_one : Utility.unfenced_value(sup, paren_specific: true)
-        options = { mask: mask.value }
-        if Constants::NARY_CLASSES.key?(nary_function.to_sym)
-          Utility.get_class(nary_function).new(
-            nil,
-            sup_value,
-            nil,
-            options
-          )
-        else
-          Math::Function::Nary.new(
-            Utility.symbols_class(nary_function, lang: :unicodemath),
-            nil,
-            sup_value,
-            nil,
-            options
-          )
-        end
-      end
-
       rule(nary_class: simple(:nary_class),
            mask: simple(:mask),
            sup: simple(:sup)) do
@@ -3083,6 +3123,17 @@ module Plurimath
         [fenced] + naryand_recursion
       end
 
+      rule(open_paren: simple(:open_paren),
+           unary_subsup: simple(:unary_subsup),
+           exp: simple(:exp),
+           close_paren: simple(:close_paren)) do
+        Math::Function::Fenced.new(
+          open_paren.is_a?(Slice) ? Utility.symbols_class(open_paren, lang: :unicodemath) : open_paren,
+          [unary_subsup, exp],
+          close_paren.is_a?(Slice) ? Utility.symbols_class(close_paren, lang: :unicodemath) : close_paren,
+        )
+      end
+
       rule(open_paren: simple(:open_paren),
            factor: simple(:factor),
            close_paren: simple(:close_paren),
@@ -3250,6 +3301,19 @@ module Plurimath
         )
       end
 
+      rule(open_paren: simple(:open_paren),
+           unicode_symbols: simple(:symbol),
+           exp: simple(:exp),
+           close_paren: simple(:close_paren),
+           sup: simple(:sup)) do
+        fenced = Math::Function::Fenced.new(
+          open_paren.is_a?(Slice) ? Utility.symbols_class(open_paren, lang: :unicodemath) : open_paren,
+          [Utility.symbols_class(symbol, lang: :unicodemath), exp],
+          close_paren.is_a?(Slice) ? Utility.symbols_class(close_paren, lang: :unicodemath) : close_paren,
+        )
+        Math::Function::Power.new(fenced, sup)
+      end
+
       rule(open_paren: simple(:open_paren),
            operator: simple(:operator),
            expr: simple(:expr),
@@ -3556,6 +3620,28 @@ module Plurimath
         )
       end
 
+      rule(open_paren: simple(:open_paren),
+           fonts: simple(:fonts),
+           expr: simple(:expr),
+           close_paren: simple(:close_paren)) do
+        Math::Function::Fenced.new(
+          open_paren.is_a?(Slice) ? Utility.symbols_class(open_paren, lang: :unicodemath) : open_paren,
+          [fonts, expr],
+          close_paren.is_a?(Slice) ? Utility.symbols_class(close_paren, lang: :unicodemath) : close_paren,
+        )
+      end
+
+      rule(open_paren: simple(:open_paren),
+           fonts: simple(:fonts),
+           exp: simple(:exp),
+           close_paren: simple(:close_paren)) do
+        Math::Function::Fenced.new(
+          open_paren.is_a?(Slice) ? Utility.symbols_class(open_paren, lang: :unicodemath) : open_paren,
+          [fonts, exp],
+          close_paren.is_a?(Slice) ? Utility.symbols_class(close_paren, lang: :unicodemath) : close_paren,
+        )
+      end
+
       rule(open_paren: simple(:open_paren),
            operator: simple(:operator),
            exp: sequence(:exp),
@@ -3709,6 +3795,18 @@ module Plurimath
         )
       end
 
+      rule(open_paren: simple(:open_paren),
+           factor: simple(:factor),
+           operand: sequence(:operand),
+           exp: sequence(:exp),
+           close_paren: simple(:close_paren)) do
+        Math::Function::Fenced.new(
+          open_paren.is_a?(Slice) ? Utility.symbols_class(open_paren, lang: :unicodemath) : open_paren,
+          ([factor] + operand + exp),
+          close_paren.is_a?(Slice) ? Utility.symbols_class(close_paren, lang: :unicodemath) : close_paren,
+        )
+      end
+
       rule(open_paren: simple(:open_paren),
            factor: simple(:factor),
            operand: simple(:operand),
@@ -3790,6 +3888,61 @@ module Plurimath
         )
       end
 
+      rule(open_paren: simple(:open_paren),
+           left_value: simple(:left_value),
+           comma: simple(:comma),
+           right_value: simple(:right_value),
+           close_paren: simple(:close_paren)) do
+        Math::Function::Fenced.new(
+          Utility.symbols_class(open_paren, lang: :unicodemath),
+          [left_value, Utility.symbols_class(comma, lang: :unicodemath), right_value],
+          Utility.symbols_class(close_paren, lang: :unicodemath),
+        )
+      end
+
+      rule(open_paren: simple(:open_paren),
+           left_value: simple(:left_value),
+           comma: simple(:comma),
+           right_value: sequence(:right_value),
+           close_paren: simple(:close_paren)) do
+        fence_value = [left_value, Utility.symbols_class(comma, lang: :unicodemath)]
+        Math::Function::Fenced.new(
+          Utility.symbols_class(open_paren, lang: :unicodemath),
+          fence_value.concat([Utility.filter_values(right_value)]),
+          Utility.symbols_class(close_paren, lang: :unicodemath),
+        )
+      end
+
+      rule(open_paren: simple(:open_paren),
+           left_value: sequence(:left_value),
+           comma: simple(:comma),
+           right_value: simple(:right_value),
+           close_paren: simple(:close_paren)) do
+        fence_value = [Utility.symbols_class(comma, lang: :unicodemath), right_value]
+        Math::Function::Fenced.new(
+          Utility.symbols_class(open_paren, lang: :unicodemath),
+          fence_value.insert(0, Utility.filter_values(left_value)),
+          Utility.symbols_class(close_paren, lang: :unicodemath),
+        )
+      end
+
+      rule(open_paren: simple(:open_paren),
+           left_value: sequence(:left_value),
+           comma: simple(:comma),
+           right_value: sequence(:right_value),
+           close_paren: simple(:close_paren)) do
+        fenced_value = [
+          Utility.filter_values(left_value),
+          Utility.symbols_class(comma, lang: :unicodemath),
+          Utility.filter_values(right_value),
+        ]
+        Math::Function::Fenced.new(
+          Utility.symbols_class(open_paren, lang: :unicodemath),
+          fenced_value,
+          Utility.symbols_class(close_paren, lang: :unicodemath),
+        )
+      end
+
       rule(open_paren: simple(:open_paren),
            pre_subscript: simple(:pre_sub),
            pre_supscript: simple(:pre_sup),
@@ -3804,6 +3957,18 @@ module Plurimath
         )
       end
 
+      rule(open_paren: simple(:open_paren),
+           factor: sequence(:factor),
+           operand: simple(:operand),
+           exp: simple(:exp),
+           close_paren: simple(:close_paren)) do
+        Math::Function::Fenced.new(
+          Utility.symbols_class(open_paren, lang: :unicodemath),
+          factor + [operand, exp],
+          Utility.symbols_class(close_paren, lang: :unicodemath),
+        )
+      end
+
       rule(open_paren: simple(:open_paren),
            pre_subscript: simple(:pre_sub),
            pre_supscript: simple(:pre_sup),