asciimath 2.0.3 → 2.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1d9ffbd1e2a3ba0ae760422ed287d430cce18f80583aa8ceb043cd5235a9805e
-  data.tar.gz: ebbf1108292b512df0b9aa76a7ee4a17e91fdebf52019dafca3d1e4c9950c4e1
+  metadata.gz: 6c38e7e41750527b0992c27f6e636cb6b670eec3008563e1a5fe19fc86458991
+  data.tar.gz: 3313df7a9524d4a4e384be1ec54f38aafe2ff70553ae65aa695c530fff5f45e9
 SHA512:
-  metadata.gz: 6d117d91868212eea9a0a5fe763fd91e0d4e2febe112c6ed92f8ed6fe745005fb27fc91c0e4dbcfe274cf3beced5d2ffcaa566f03fa2310b355eb40e93fde964
-  data.tar.gz: 49580040db7cc0f1f5941bdd5d55d2d5829c5b84503ce093faef266ef54aae5a74b8fb7992bebd62b55b92d3f3d0fc75645e82c25a2ca3e0b990b4f7147aa11e
+  metadata.gz: a7b29b1332ddb6965162a5b1e82d15c459e5a9ea4d514646b0663ea52adfe5b1999d1078e850dee228160e09b5ac052dde48b39aaa946d6587b97b2658109215
+  data.tar.gz: 6bfce3c229fea323dbfaff74ab1987802b9ae6c7b0ae32562b868bc5da2fd35bc76d0a8c9aa1e414c2765839e02065c5575d5366af89e4becadb882ee084ce08

data/AST.adoc

@@ -257,8 +257,8 @@ Empty matrix cells are represented as `AsciiMath::AST::Empty`.
 |++oo++ |:infty |++∞++ (https://codepoints.net/U+221E[U+221E]) |++\infty++
 |++infty++ |:infty |++∞++ (https://codepoints.net/U+221E[U+221E]) |++\infty++
 |++aleph++ |:aleph |++ℵ++ (https://codepoints.net/U+2135[U+2135]) |++\aleph++
-|++...++ |:ellipsis |++…++ (https://codepoints.net/U+2026[U+2026]) |++\ellipsis++
-|++ldots++ |:ellipsis |++…++ (https://codepoints.net/U+2026[U+2026]) |++\ellipsis++
+|++...++ |:ellipsis |++…++ (https://codepoints.net/U+2026[U+2026]) |++\ldots++
+|++ldots++ |:ellipsis |++…++ (https://codepoints.net/U+2026[U+2026]) |++\ldots++
 |++:.++ |:therefore |++∴++ (https://codepoints.net/U+2234[U+2234]) |++\therefore++
 |++therefore++ |:therefore |++∴++ (https://codepoints.net/U+2234[U+2234]) |++\therefore++
 |++:'++ |:because |++∵++ (https://codepoints.net/U+2235[U+2235]) |++\because++

data/CHANGELOG.adoc

@@ -1,5 +1,13 @@
 = Asciimath Changelog
 
+== 2.0.4
+
+Bug fixes::
+
+  * Issue #69: correctly render sub and superscripts as following `obrace` and `ubrace`.
+  * Issue #70: fix MathML output for `frac`.
+  * Issue #71: correctly parse row vectors.
+
 == 2.0.3
 
 Enhancements::

data/lib/asciimath/ast.rb

@@ -51,8 +51,8 @@ module AsciiMath
       Number.new(value)
     end
 
-    def symbol(symbol, text)
-      Symbol.new(symbol, text)
+    def symbol(symbol, text, type)
+      Symbol.new(symbol, text, type)
     end
 
     def identifier(value)
@@ -340,14 +340,16 @@ module AsciiMath
 
     class Symbol < ValueNode
       attr_reader :text
+      attr_reader :type
 
-      def initialize(value, text)
+      def initialize(value, text, type)
         super(value)
         @text = text.dup.freeze
+        @type = type
       end
 
       def ==(o)
-        super && o.text == text
+        super && o.text == text && o.type == type
       end
 
       def to_s

data/lib/asciimath/latex.rb

@@ -27,7 +27,9 @@ module AsciiMath
       :ne => "\\neq",
       :assign => ":=",
       :lt => ?<,
+      :mlt => "\\ll",
       :gt => ?>,
+      :mgt => "\\gg",
       :sub => "\\text{–}",
       :sup => "\\text{^}",
       :implies => "\\Rightarrow",
@@ -83,6 +85,7 @@ module AsciiMath
       :f => "f",
       :g => "g",
       :to => "\\rightarrow",
+      :ellipsis => "\\ldots",
       :bold => "\\mathbf",
       :double_struck => "\\mathbb",
       :italic => "\\mathit",
@@ -166,7 +169,12 @@ module AsciiMath
           sup = expression.sup_expression
           e = expression.base_expression
 
+          if e.is_a?(AsciiMath::AST::UnaryOp) &&
+            %i[underbrace overbrace].include?(e.operator.value)
+            append(e)
+        else
           curly(e)
+        end
 
           if sub
             @latex << "_"

data/lib/asciimath/markup.rb

@@ -38,7 +38,9 @@ module AsciiMath
       b.add(:ne, "\u2260", :operator)
       b.add(:assign, "\u2254", :operator)
       b.add(:lt, "\u003C", :operator)
+      b.add(:mlt, "\u226A", :operator)
       b.add(:gt, "\u003E", :operator)
+      b.add(:mgt, "\u226B", :operator)
       b.add(:le, "\u2264", :operator)
       b.add(:ge, "\u2265", :operator)
       b.add(:prec, "\u227A", :operator)
@@ -52,6 +54,7 @@ module AsciiMath
       b.add(:subseteq, "\u2286", :operator)
       b.add(:supseteq, "\u2287", :operator)
       b.add(:equiv, "\u2261", :operator)
+      b.add(:sim, "\u223C", :operator)
       b.add(:cong, "\u2245", :operator)
       b.add(:approx, "\u2248", :operator)
       b.add(:propto, "\u221D", :operator)
@@ -92,6 +95,7 @@ module AsciiMath
       b.add(:partial, "\u2202", :operator)
       b.add(:nabla, "\u2207", :operator)
       b.add(:pm, "\u00B1", :operator)
+      b.add(:mp, "\u2213", :operator)
       b.add(:emptyset, "\u2205", :operator)
       b.add(:infty, "\u221E", :operator)
       b.add(:aleph, "\u2135", :operator)
@@ -206,8 +210,8 @@ module AsciiMath
       b.add(:ddot, '..', :accent, :position => :over)
       b.add(:overarc, "\u23DC", :accent, :position => :over)
       b.add(:underline, '_', :accent, :position => :under)
-      b.add(:underbrace, "\u23DF", :accent, :position => :under)
-      b.add(:overbrace, "\u23DE", :accent, :position => :over)
+      b.add(:underbrace, "\u23DF", :accent, :position => :under, :underover => true)
+      b.add(:overbrace, "\u23DE", :accent, :position => :over, :underover => true)
       b.add(:bold, :bold, :font)
       b.add(:double_struck, :double_struck, :font)
       b.add(:italic, :italic, :font)
@@ -344,7 +348,7 @@ module AsciiMath
         when ::AsciiMath::AST::Paren
           append_paren(resolve_paren(node.lparen), node.expression, resolve_paren(node.rparen), opts)
         when ::AsciiMath::AST::SubSup
-          if (resolve_symbol(node.base_expression) || {})[:underover]
+          if is_underover(node.base_expression)
             append_underover(node.base_expression, node.sub_expression, node.sup_expression)
           else
             append_subsup(node.base_expression, node.sub_expression, node.sup_expression)
@@ -383,6 +387,8 @@ module AsciiMath
                 append_root(node.operand2, node.operand1)
               when :color
                 append_color(node.operand1.to_hex_rgb, node.operand2)
+              when :frac
+                append_fraction(node.operand1, node.operand2)
             end
           end
         when ::AsciiMath::AST::InfixOp
@@ -505,5 +511,16 @@ module AsciiMath
       resolved = resolve_symbol(node)
       !resolved.nil? && resolved[:type] == :accent
     end
+
+    def is_underover(node)
+      case node
+      when AsciiMath::AST::UnaryOp
+        symbol = node.operator
+      else
+        symbol = node
+      end
+
+      (resolve_symbol(symbol) || {})[:underover]
+    end
   end
 end

data/lib/asciimath/parser.rb

@@ -253,7 +253,9 @@ module AsciiMath
       b.add('!=', 'ne', :ne, :symbol)
       b.add(':=', :assign, :symbol)
       b.add('<', 'lt', :lt, :symbol)
+      b.add('mlt', :mlt, :symbol)
       b.add('>', 'gt', :gt, :symbol)
+      b.add('mgt', :mgt, :symbol)
       b.add('<=', 'le', :le, :symbol)
       b.add('>=', 'ge', :ge, :symbol)
       b.add('-<', '-lt', 'prec', :prec, :symbol)
@@ -267,6 +269,7 @@ module AsciiMath
       b.add('sube', 'subseteq', :subseteq, :symbol)
       b.add('supe', 'supseteq', :supseteq, :symbol)
       b.add('-=', 'equiv', :equiv, :symbol)
+      b.add('~', 'sim', :sim, :symbol)
       b.add('~=', 'cong', :cong, :symbol)
       b.add('~~', 'approx', :approx, :symbol)
       b.add('prop', 'propto', :propto, :symbol)
@@ -312,6 +315,7 @@ module AsciiMath
       b.add('del', 'partial', :partial, :symbol)
       b.add('grad', 'nabla', :nabla, :symbol)
       b.add('+-', 'pm', :pm, :symbol)
+      b.add('-+', 'mp', :mp, :symbol)
       b.add('O/', 'emptyset', :emptyset, :symbol)
       b.add('oo', 'infty', :infty, :symbol)
       b.add('aleph', :aleph, :symbol)
@@ -507,7 +511,7 @@ module AsciiMath
     def parse(input)
       Expression.new(
           input,
-          parse_expression(Tokenizer.new(input, @symbol_table), 0)
+          parse_expression(Tokenizer.new(input, @symbol_table), nil)
       )
     end
 
@@ -515,36 +519,36 @@ module AsciiMath
 
     include AsciiMath::AST
 
-    def parse_expression(tok, depth)
-      e = []
+    def parse_expression(tok, close_paren_type)
+      e = nil
 
-      while (s1 = parse_intermediate_expression(tok, depth))
+      while (i1 = parse_intermediate_expression(tok, close_paren_type))
         t1 = tok.next_token
 
         if t1[:type] == :infix && t1[:value] == :frac
-          s2 = parse_intermediate_expression(tok, depth)
-          if s2
-            e << infix(unwrap_paren(s1), symbol(:frac, t1[:text]), unwrap_paren(s2))
+          i2 = parse_intermediate_expression(tok, close_paren_type)
+          if i2
+            e = concat_expressions(e, infix(unwrap_paren(i1), token_to_symbol(t1), unwrap_paren(i2)))
           else
-            e << s1
+            e = concat_expressions(e, i1)
           end
         elsif t1[:type] == :eof
-          e << s1
+          e = concat_expressions(e, i1)
           break
         else
-          e << s1
+          e = concat_expressions(e, i1)
           tok.push_back(t1)
-          if (t1[:type] == :lrparen || t1[:type] == :rparen) && depth > 0
+          if t1[:type] == close_paren_type
             break
           end
         end
       end
 
-      expression(*e)
+      e
     end
 
-    def parse_intermediate_expression(tok, depth)
-      s = parse_simple_expression(tok, depth)
+    def parse_intermediate_expression(tok, close_paren_type)
+      s = parse_simple_expression(tok, close_paren_type)
       sub = nil
       sup = nil
 
@@ -553,17 +557,17 @@ module AsciiMath
         when :infix
           case t1[:value]
             when :sub
-              sub = parse_simple_expression(tok, depth)
+              sub = parse_simple_expression(tok, close_paren_type)
               if sub
                 t2 = tok.next_token
                 if t2[:type] == :infix && t2[:value] == :sup
-                  sup = parse_simple_expression(tok, depth)
+                  sup = parse_simple_expression(tok, close_paren_type)
                 else
                   tok.push_back(t2)
                 end
               end
             when :sup
-              sup = parse_simple_expression(tok, depth)
+              sup = parse_simple_expression(tok, close_paren_type)
             else
               tok.push_back(t1)
           end
@@ -582,46 +586,54 @@ module AsciiMath
       end
     end
 
-    def parse_simple_expression(tok, depth)
+    def parse_simple_expression(tok, close_paren_type)
       t1 = tok.next_token
 
       case t1[:type]
         when :lparen, :lrparen
+          if t1[:type] == :lparen
+            close_with = :rparen
+          else
+            close_with = :lrparen
+          end
+
           t2 = tok.next_token
-          case t2[:type]
-            when :rparen, :lrparen
-              paren(token_to_symbol(t1), nil, token_to_symbol(t2))
-            else
-              tok.push_back(t2)
+          if t2[:type] == close_with
+            paren(token_to_symbol(t1), nil, token_to_symbol(t2))
+          else
+            tok.push_back(t2)
 
-              e = parse_expression(tok, depth + 1)
+            e = parse_expression(tok, close_with)
 
-              t2 = tok.next_token
-              case t2[:type]
-                when :rparen, :lrparen
-                  convert_to_matrix(paren(token_to_symbol(t1), e, token_to_symbol(t2)))
-                else
-                  tok.push_back(t2)
-                  paren(token_to_symbol(t1), e, nil)
+            t2 = tok.next_token
+            if t2[:type] == close_with
+              convert_to_matrix(paren(token_to_symbol(t1), e, token_to_symbol(t2)))
+            else
+              tok.push_back(t2)
+              if t1[:type] == :lrparen
+                concat_expressions(token_to_symbol(t1), e)
+              else
+                paren(token_to_symbol(t1), e, nil)
               end
+            end
           end
         when :rparen
-          if depth > 0
+          if close_paren_type.nil?
+            token_to_symbol(t1)
+          else
             tok.push_back(t1)
             nil
-          else
-            token_to_symbol(t1)
           end
         when :unary
-          parse_simple_expression = parse_simple_expression(tok, depth)
+          parse_simple_expression = parse_simple_expression(tok, close_paren_type)
           s = unwrap_paren(parse_simple_expression)
           s = identifier('') if s.nil?
           s = convert_node(s, t1[:convert_operand])
           unary(token_to_symbol(t1), s)
         when :binary
-          s1 = unwrap_paren(parse_simple_expression(tok, depth))
+          s1 = unwrap_paren(parse_simple_expression(tok, close_paren_type))
           s1 = identifier('') if s1.nil?
-          s2 = unwrap_paren(parse_simple_expression(tok, depth))
+          s2 = unwrap_paren(parse_simple_expression(tok, close_paren_type))
           s2 = identifier('') if s2.nil?
 
           s1 = convert_node(s1, t1[:convert_operand1])
@@ -641,12 +653,37 @@ module AsciiMath
       end
     end
 
+    def concat_expressions(e1, e2)
+      case e1
+        when Sequence
+          case e2
+            when Sequence
+              expression(*(e1.to_a), *(e2.to_a))
+            when nil
+              e1
+            else
+              expression(*(e1.to_a), e2)
+          end
+        when nil
+          e2
+        else
+          case e2
+            when Sequence
+              expression(e1, *(e2.to_a))
+            when nil
+              e1
+            else
+              expression(e1, e2)
+          end
+      end
+    end
+
     def token_to_symbol(t1)
-      symbol(t1[:value], t1[:text])
+      symbol(t1[:value], t1[:text], t1[:type])
     end
 
     def unwrap_paren(node)
-      if node.is_a?(::AsciiMath::AST::Paren)
+      if node.is_a?(::AsciiMath::AST::Paren) && (node.lparen.nil? || node.lparen.type == :lparen) && (node.rparen.nil? || node.rparen.type == :rparen)
         group(node.lparen, node.expression, node.rparen)
       else
         node
@@ -654,14 +691,23 @@ module AsciiMath
     end
 
     def convert_to_matrix(node)
-      return node unless node.is_a?(::AsciiMath::AST::Paren) && node.expression.is_a?(::AsciiMath::AST::Sequence)
+      return node unless node.is_a?(::AsciiMath::AST::Paren)
+
+      case node.expression
+      when ::AsciiMath::AST::Sequence
+        rows, separators = node.expression.partition.with_index { |obj, i| i.even? }
+      when ::AsciiMath::AST::Paren
+        rows = [node.expression]
+        separators = []
+      else
+        return node
+      end
 
-      rows, separators = node.expression.partition.with_index { |obj, i| i.even? }
-      return node unless rows.length > 1 &&
+      return node unless rows.length >= 1 &&
           rows.length > separators.length &&
           separators.all? { |item| is_matrix_separator(item) } &&
-          (rows.all? { |item| item.is_a?(::AsciiMath::AST::Paren) && item.lparen == symbol(:lparen, '(') && item.rparen == symbol(:rparen, ')') } ||
-              rows.all? { |item| item.is_a?(::AsciiMath::AST::Paren) && item.lparen == symbol(:lbracket, '[') && item.rparen == symbol(:rbracket, ']') })
+          (rows.all? { |item| item.is_a?(::AsciiMath::AST::Paren) && item.lparen == symbol(:lparen, '(', :lparen) && item.rparen == symbol(:rparen, ')', :rparen) } ||
+              rows.all? { |item| item.is_a?(::AsciiMath::AST::Paren) && item.lparen == symbol(:lbracket, '[', :lparen) && item.rparen == symbol(:rbracket, ']', :rparen) })
 
       rows = rows.map do |row|
         chunks = []

data/lib/asciimath/version.rb

@@ -1,3 +1,3 @@
 module AsciiMath
-  VERSION = "2.0.3"
+  VERSION = "2.0.4"
 end

data/spec/ast.rb

@@ -90,7 +90,7 @@ module AsciiMath
     def symbol(text)
       symbol = ::AsciiMath::Parser::DEFAULT_PARSER_SYMBOL_TABLE[text]
       if symbol
-        ACTUAL_AST.symbol(symbol[:value], text)
+        ACTUAL_AST.symbol(symbol[:value], text, symbol[:type])
       else
         nil
       end

data/spec/customisation_spec.rb

@@ -14,7 +14,7 @@ describe 'AsciiMath::Parser', :variant => :ast do
     my_tokens_table.add('mysymbol', :mysymbol, :symbol)
 
     parsed = AsciiMath::parse("a + mysymbol + b", my_tokens_table.build)
-    expect(parsed.ast).to eq(seq(identifier('a'), symbol('+'), ::AsciiMath::AST::Symbol.new(:mysymbol, 'mysymbol'), symbol('+'), identifier('b')))
+    expect(parsed.ast).to eq(seq(identifier('a'), symbol('+'), ::AsciiMath::AST::Symbol.new(:mysymbol, 'mysymbol', :symbol), symbol('+'), identifier('b')))
   end
 
   it "should support replacing standard symbols" do
@@ -23,6 +23,6 @@ describe 'AsciiMath::Parser', :variant => :ast do
     my_tokens_table.add('+', :foo, :symbol)
 
     parsed = AsciiMath::parse("a + b", my_tokens_table.build)
-    expect(parsed.ast).to eq(seq(identifier('a'), ::AsciiMath::AST::Symbol.new(:foo, '+'), identifier('b')))
+    expect(parsed.ast).to eq(seq(identifier('a'), ::AsciiMath::AST::Symbol.new(:foo, '+', :symbol), identifier('b')))
   end
 end

data/spec/parser_spec.rb

@@ -328,6 +328,13 @@ RSpec.shared_examples 'AsciiMath Examples' do
       :latex => '\\left ( \\begin{matrix} 1 \\\\ 42 \\end{matrix} \\right )',
   ))
 
+  example('((1,42))', &should_generate(
+    :ast => matrix([%w[1 42]]),
+    :mathml => '<math><mrow><mo>(</mo><mtable><mtr><mtd><mn>1</mn></mtd><mtd><mn>42</mn></mtd></mtr></mtable><mo>)</mo></mrow></math>',
+    :html => '<span class="math-inline"><span class="math-row"><span class="math-brace" style="font-size: 100%;">(</span><span class="math-matrix" style="grid-template-columns:repeat(2,1fr);grid-template-rows:repeat(1,1fr);"><span class="math-row"><span class="math-number">1</span></span><span class="math-row"><span class="math-number">42</span></span></span><span class="math-brace" style="font-size: 100%;">)</span></span></span>',
+    :latex => '\\left ( \\begin{matrix} 1 & 42 \\end{matrix} \\right )',
+    ))
+
   example('((1,2,3),(4,5,6),(7,8,9))', &should_generate(
       :ast => matrix([%w[1 2 3], %w[4 5 6], %w[7 8 9]]),
       :mathml => '<math><mrow><mo>(</mo><mtable><mtr><mtd><mn>1</mn></mtd><mtd><mn>2</mn></mtd><mtd><mn>3</mn></mtd></mtr><mtr><mtd><mn>4</mn></mtd><mtd><mn>5</mn></mtd><mtd><mn>6</mn></mtd></mtr><mtr><mtd><mn>7</mn></mtd><mtd><mn>8</mn></mtd><mtd><mn>9</mn></mtd></mtr></mtable><mo>)</mo></mrow></math>',
@@ -337,7 +344,7 @@ RSpec.shared_examples 'AsciiMath Examples' do
 
   example('|(a,b),(c,d)|=ad-bc', &should_generate(
       :ast => seq(
-          matrix(symbol('|'), [%w(a b), %w(c d)], symbol('|'),),
+          matrix(symbol('|'), [%w(a b), %w(c d)], symbol('|')),
           symbol('='),
           'a', 'd',
           symbol('-'),
@@ -596,6 +603,53 @@ RSpec.shared_examples 'AsciiMath Examples' do
     :latex => '40 \% \cdot 3 !'
   ))
 
+  example('R(alpha_(K+1)|x)', &should_generate(
+    :ast => seq('R', paren(symbol('('), seq(sub('alpha', grseq('K', symbol('+'), '1')), symbol('|'), 'x'), symbol(')'))),
+    :mathml => '<math><mi>R</mi><mrow><mo>(</mo><mrow><msub><mi>&#x3B1;</mi><mrow><mi>K</mi><mo>+</mo><mn>1</mn></mrow></msub><mo>|</mo><mi>x</mi></mrow><mo>)</mo></mrow></math>',
+    :latex => 'R \\left ( \\alpha_{K + 1} | x \\right )'
+  ))
+
+  example('|(a),(b)|', &should_generate(
+    :ast => matrix(symbol('|'), [%w(a), %w(b)], symbol('|')),
+  ))
+
+  example('|a+b|', &should_generate(
+    :ast => paren(symbol('|'), seq('a', '+', 'b'), symbol('|')),
+  ))
+
+  example('|a+b|/c', &should_generate(
+    :ast => infix(paren(symbol('|'), seq('a', '+', 'b'), symbol('|')), '/', 'c'),
+  ))
+
+  example('[[a,b,|,c],[d,e,|,f]]', &should_generate(
+    :ast => matrix(symbol('['), [['a', 'b', symbol('|'), 'c'], ['d', 'e', symbol('|'), 'f']], symbol(']')),
+  ))
+
+  example('~a mlt b mgt -+c', &should_generate(
+    :ast => seq(symbol('~'), 'a', symbol('mlt'), 'b', symbol('mgt'), symbol('-+'), 'c'),
+    :latex => '\\sim a \\ll b \\gg \\mp c',
+    :mathml => '<math><mo>&#x223C;</mo><mi>a</mi><mo>&#x226A;</mo><mi>b</mi><mo>&#x226B;</mo><mo>&#x2213;</mo><mi>c</mi></math>'
+    ))
+
+  example('a+b+...+c', &should_generate(
+    :ast => seq('a', symbol('+'), 'b', symbol('+'), symbol('...'), symbol('+'), 'c'),
+    :latex => 'a + b + \ldots + c',
+    :mathml => '<math><mi>a</mi><mo>+</mo><mi>b</mi><mo>+</mo><mo>&#x2026;</mo><mo>+</mo><mi>c</mi></math>'
+    ))
+
+  example('frac{a}{b}', &should_generate(
+    :ast => binary('frac', group(symbol('{'), 'a', symbol('}')), group(symbol('{'), 'b', symbol('}'))),
+    :latex => '\frac{a}{b}',
+    :mathml => '<math><mfrac><mi>a</mi><mi>b</mi></mfrac></math>'
+  ))
+
+  example('ubrace(((1, 0),(0, 1)))_("Adjustment to texture space")', &should_generate(
+    :ast => subsup(unary(symbol('ubrace'), group(matrix([%w[1 0], %w[0 1]]))), group("Adjustment to texture space"), []),
+    :latex => '\underbrace{\left ( \begin{matrix} 1 & 0 \\\\ 0 & 1 \end{matrix} \right )}_{\text{Adjustment to texture space}}',
+    :mathml => '<math><munder><munder accentunder="true"><mrow><mo>(</mo><mtable><mtr><mtd><mn>1</mn></mtd><mtd><mn>0</mn></mtd></mtr><mtr><mtd><mn>0</mn></mtd><mtd><mn>1</mn></mtd></mtr></mtable><mo>)</mo></mrow><mo>&#x23DF;</mo></munder><mtext>Adjustment to texture space</mtext></munder></math>'
+  ))
+
+
   version = RUBY_VERSION.split('.').map { |s| s.to_i }
 
   if version[0] > 1 || version[1] > 8

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: asciimath
 version: !ruby/object:Gem::Version
-  version: 2.0.3
+  version: 2.0.4
 platform: ruby
 authors:
 - Pepijn Van Eeckhoudt
 - Gark Garcia
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-07-26 00:00:00.000000000 Z
+date: 2022-04-21 00:00:00.000000000 Z
 dependencies: []
 description: A pure Ruby AsciiMath parsing and conversion library.
 email:
@@ -85,7 +85,7 @@ homepage: ''
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -100,8 +100,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
-signing_key: 
+rubygems_version: 3.2.22
+signing_key:
 specification_version: 4
 summary: AsciiMath parser and converter
 test_files: