asciimath 1.0.6 → 2.0.1

data/lib/asciimath/mathml.rb

@@ -1,8 +1,20 @@
+require_relative 'markup'
+require_relative 'symbol_table'
+
 module AsciiMath
-  class MathMLBuilder
-    def initialize(prefix)
-      @prefix = prefix
+  class MathMLBuilder < ::AsciiMath::MarkupBuilder
+
+    def initialize(opts = {})
+      super(opts[:symbol_table] || DEFAULT_DISPLAY_SYMBOL_TABLE)
+      @prefix = opts[:prefix] || ''
       @mathml = ''
+      if opts[:msword]
+        @row_mode = :force
+        @fence_mode = :fenced
+      else
+        @row_mode = :avoid
+        @fence_mode = :row
+      end
     end
 
     def to_s
@@ -11,89 +23,150 @@ module AsciiMath
 
     def append_expression(expression, attrs = {})
       math('', attrs) do
-        append(expression, :single_child => true)
+        append(expression, :row => :omit)
       end
     end
 
     private
 
-    def append(expression, opts = {})
-      case expression
-        when Array
-          if expression.length <= 1 || opts[:single_child]
-            expression.each { |e| append(e) }
-          else
-            mrow do
-              expression.each { |e| append(e) }
-            end
-          end
-        when Hash
-          case expression[:type]
-            when :operator
-              mo(expression[:c])
-            when :identifier
-              mi(expression[:c])
-            when :number
-              mn(expression[:c])
-            when :text
-              mtext(expression[:c])
-            when :paren
-              paren = !opts[:strip_paren]
-              if paren
-                if opts[:single_child]
-                  mo(expression[:lparen]) if expression[:lparen]
-                  append(expression[:e], :single_child => true)
-                  mo(expression[:rparen]) if expression[:rparen]
-                else
-                  mrow do
-                    mo(expression[:lparen]) if expression[:lparen]
-                    append(expression[:e], :single_child => true)
-                    mo(expression[:rparen]) if expression[:rparen]
-                  end
-                end
-              else
-                append(expression[:e])
-              end
-            when :font
-              style = expression[:operator]
-              tag("mstyle", :mathvariant => style.to_s.gsub('_', '-')) do
-                append(expression[:s], :single_child => true, :strip_paren => true)
-              end
-            when :unary
-              operator = expression[:operator]
-              tag("m#{operator}") do
-                append(expression[:s], :single_child => true, :strip_paren => true)
-              end
-            when :binary
-              operator = expression[:operator]
-              tag("m#{operator}") do
-                append(expression[:s1], :strip_paren => (operator != :sub && operator != :sup))
-                append(expression[:s2], :strip_paren => true)
-              end
-            when :ternary
-              operator = expression[:operator]
-              tag("m#{operator}") do
-                append(expression[:s1])
-                append(expression[:s2], :strip_paren => true)
-                append(expression[:s3], :strip_paren => true)
-              end
-            when :matrix
-              mrow do
-                mo(expression[:lparen]) if expression[:lparen]
-                mtable do
-                  expression[:rows].each do |row|
-                    mtr do
-                      row.each do |col|
-                        mtd do
-                          append(col)
-                        end
-                      end
-                    end
-                  end
+    def append_row(expressions)
+      mrow do
+        expressions.each { |e| append(e) }
+      end
+    end
+
+    def append_operator(operator)
+      mo(operator)
+    end
+
+    def append_identifier(identifier)
+      mi(identifier)
+    end
+
+    def append_text(text)
+      mtext(text)
+    end
+
+    def append_number(number)
+      mn(number)
+    end
+
+    def append_sqrt(expression)
+      tag("m#{"sqrt"}") do
+        append(expression, :row => @row_mode)
+      end
+    end
+
+    def append_cancel(expression)
+      tag("menclose", :notation => "updiagonalstrike") do
+        append(expression, :row => :omit)
+      end
+    end
+
+    def append_root(base, index)
+      tag("m#{"root"}") do
+        append(base, :row => @row_mode)
+        append(index, :row => @row_mode)
+      end
+    end
+
+    def append_fraction(numerator, denominator)
+      tag("m#{"frac"}") do
+        append(numerator, :row => @row_mode)
+        append(denominator, :row => @row_mode)
+      end
+    end
+
+
+    def append_font(style, e)
+      tag("mstyle", :mathvariant => style.to_s.gsub('_', '-')) do
+        append(e)
+      end
+    end
+
+    def append_color(color, e)
+      tag("mstyle", :mathcolor => color) do
+        append(e)
+      end
+    end
+
+    def append_matrix(lparen, rows, rparen)
+      fenced(lparen, rparen) do
+        mtable do
+          rows.each do |row|
+            mtr do
+              row.each do |col|
+                mtd do
+                  append(col)
                 end
-                mo(expression[:rparen]) if expression[:rparen]
               end
+            end
           end
+        end
+      end
+    end
+
+    def append_operator_unary(operator, expression)
+      mrow do
+        mo(operator)
+        append(expression, :row => @row_mode)
+      end
+    end
+
+    def append_identifier_unary(identifier, expression)
+      mrow do
+        mi(identifier)
+        append(expression, :row => @row_mode)
+      end
+    end
+
+    def append_paren(lparen, e, rparen, opts = {})
+      fenced(lparen, rparen) do
+        append(e, :row => @row_mode)
+      end
+    end
+
+    def append_subsup(base, sub, sup)
+      if sub && sup
+        msubsup do
+          append(base, :row => @row_mode)
+          append(sub, :row => @row_mode)
+          append(sup, :row => @row_mode)
+        end
+      elsif sub
+        msub do
+          append(base, :row => @row_mode)
+          append(sub, :row => @row_mode)
+        end
+      elsif sup
+        msup do
+          append(base, :row => @row_mode)
+          append(sup, :row => @row_mode)
+        end
+      else
+        append(base)
+      end
+    end
+
+    def append_underover(base, sub, sup)
+      if sub && sup
+        munderover do
+          append(base, :row => @row_mode)
+          append(sub, :row => @row_mode)
+          append(sup, :row => @row_mode)
+        end
+      elsif sub
+        munder do
+          append(base, :row => @row_mode)
+          append(sub, :row => @row_mode)
+        end
+      elsif sup
+        mover do
+          append(base, :row => @row_mode)
+          append(sup, :row => @row_mode)
+        end
+      else
+        append(base)
       end
     end
 
@@ -101,31 +174,71 @@ module AsciiMath
       tag(meth, *args, &block)
     end
 
+    def fenced(lparen, rparen)
+      if lparen || rparen
+        if @fence_mode == :fenced
+          mfenced(:open => lparen || '', :close => rparen || '') do
+            yield self
+          end
+        else
+          mrow do
+            mo(lparen) if lparen
+            yield self
+            mo(rparen) if rparen
+          end
+        end
+      else
+        yield self
+      end
+    end
+
     def tag(tag, *args)
       attrs = args.last.is_a?(Hash) ? args.pop : {}
-      text = args.last.is_a?(String) ? args.pop : ''
+      text = args.last.is_a?(String) || args.last.is_a?(Symbol) ? args.pop.to_s : ''
 
       @mathml << '<' << @prefix << tag.to_s
 
       attrs.each_pair do |key, value|
-        @mathml << ' ' << key.to_s << '="' << value.to_s << '"'
+        @mathml << ' ' << key.to_s << '="'
+        append_escaped(value.to_s)
+        @mathml << '"'
       end
 
 
       if block_given? || text
         @mathml << '>'
-        @mathml << text
+        append_escaped(text)
         yield self if block_given?
         @mathml << '</' << @prefix << tag.to_s << '>'
       else
         @mathml << '/>'
       end
     end
+
+    def append_escaped(text)
+      text.each_codepoint do |cp|
+        if cp == 38
+          @mathml << "&amp;"
+        elsif cp == 60
+          @mathml << "&lt;"
+        elsif cp == 62
+          @mathml << "&gt;"
+        elsif cp > 127
+          @mathml << "&#x#{cp.to_s(16).upcase};"
+        else
+          @mathml << cp
+        end
+      end
+    end
   end
 
   class Expression
     def to_mathml(prefix = "", attrs = {})
-      MathMLBuilder.new(prefix).append_expression(@parsed_expression, attrs).to_s
+      if prefix.is_a? Hash
+        attrs = prefix
+        prefix = ""
+      end
+      MathMLBuilder.new(:prefix => prefix).append_expression(ast, attrs).to_s
     end
   end
-end
+end

data/lib/asciimath/parser.rb

@@ -1,4 +1,7 @@
 require 'strscan'
+require_relative 'ast'
+require_relative 'color_table'
+require_relative 'symbol_table'
 
 # Parser for ASCIIMath expressions.
 #
@@ -33,29 +36,20 @@ module AsciiMath
   # The :type key indicates the semantics of the token. The value for :type will be one
   # of the following symbols:
   #
-  # - :identifier a symbolic name or a bit of text without any further semantics
+  # - :symbol a symbolic name or a bit of text without any further semantics
   # - :text a bit of arbitrary text
   # - :number a number
   # - :operator a mathematical operator symbol
   # - :unary a unary operator (e.g., sqrt, text, ...)
-  # - :font a unary font command (e.g., bb, cc, ...)
   # - :infix an infix operator (e.g, /, _, ^, ...)
   # - :binary a binary operator (e.g., frac, root, ...)
-  # - :accent an accent character
   # - :eof indicates no more tokens are available
   #
-  # Each token type may also have an :underover modifier. When present and set to true
-  # sub- and superscript expressions associated with the token will be rendered as
-  # under- and overscriptabove and below rather than as sub- or superscript.
-  #
-  # :accent tokens additionally have a :postion value which is set to either :over or :under.
-  # This determines if the accent should be rendered over or under the expression to which
-  # it applies.
-  #
   class Tokenizer
-    WHITESPACE = /^\s+/
-    NUMBER = /-?[0-9]+(?:\.[0-9]+)?/
-    TEXT = /"[^"]+"/
+    WHITESPACE = /\s+/
+    NUMBER = /[0-9]+(?:\.[0-9]+)?/
+    QUOTED_TEXT = /"[^"]*"/
+    TEX_TEXT = /text\([^)]*\)/
 
     # Public: Initializes an ASCIIMath tokenizer.
     #
@@ -65,7 +59,7 @@ module AsciiMath
       @string = StringScanner.new(string)
       @symbols = symbols
       lookahead = @symbols.keys.map { |k| k.length }.max
-      @symbol_regexp = /([^\s0-9]{1,#{lookahead}})/
+      @symbol_regexp = /((?:\\[\s0-9]|[^\s0-9]){1,#{lookahead}})/
       @push_back = nil
     end
 
@@ -86,11 +80,18 @@ module AsciiMath
 
       case @string.peek(1)
         when '"'
-          read_text
+          read_quoted_text
+        when 't'
+          case @string.peek(5)
+            when 'text('
+              read_tex_text
+            else
+              read_symbol
+          end
         when '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9'
-          read_number() || read_symbol
+          read_number || read_symbol
         else
-          read_symbol()
+          read_symbol
       end
     end
 
@@ -109,12 +110,22 @@ module AsciiMath
     #
     # Returns the text token or nil if a text token could not be matched at
     # the current position
-    def read_text
-      read_value(TEXT) do |text|
+    def read_quoted_text
+      read_value(QUOTED_TEXT) do |text|
         {:value => text[1..-2], :type => :text}
       end
     end
 
+    # Private: Reads a text token from the input string
+    #
+    # Returns the text token or nil if a text token could not be matched at
+    # the current position
+    def read_tex_text
+      read_value(TEX_TEXT) do |text|
+        {:value => text[5..-2], :type => :text}
+      end
+    end
+
     # Private: Reads a number token from the input string
     #
     # Returns the number token or nil if a number token could not be matched at
@@ -155,7 +166,12 @@ module AsciiMath
           s.chop!
         end
         @string.pos = position + bytesize(s)
-        @symbols[s] || {:value => s, :type => :identifier}
+        symbol = @symbols[s]
+        if symbol
+          symbol.merge({:text => s})
+        else
+          {:value => s, :type => :identifier}
+        end
       end
     end
 
@@ -167,7 +183,7 @@ module AsciiMath
     # Returns the matched String or the value returned by the block if one was given
     def read_value(regexp)
       s = @string.scan(regexp)
-      if s
+      if s && block_given?
         yield s
       else
         s
@@ -182,277 +198,334 @@ module AsciiMath
   end
 
   class Parser
-    SYMBOLS = {
-        # Operation symbols
-        '+' => {:value => '+', :type => :operator},
-        '-' => {:value => '−', :type => :operator},
-        '*' => {:value => '⋅', :type => :operator},
-        '**' => {:value => '⋆', :type => :operator},
-        '//' => {:value => '/', :type => :operator},
-        '\\\\' => {:value => '\\', :type => :operator},
-        'xx' => {:value => '×', :type => :operator},
-        '-:' => {:value => '÷', :type => :operator},
-        '@' => {:value => '⚬', :type => :operator},
-        'o+' => {:value => '⊕', :type => :operator},
-        'ox' => {:value => '⊗', :type => :operator},
-        'o.' => {:value => '⊙', :type => :operator},
-        'sum' => {:value => '∑', :type => :operator, :underover => true},
-        'prod' => {:value => '∏', :type => :operator, :underover => true},
-        '^^' => {:value => '∧', :type => :operator},
-        '^^^' => {:value => '⋀', :type => :operator, :underover => true},
-        'vv' => {:value => '∨', :type => :operator},
-        'vvv' => {:value => '⋁', :type => :operator, :underover => true},
-        'nn' => {:value => '∩', :type => :operator},
-        'nnn' => {:value => '⋂', :type => :operator, :underover => true},
-        'uu' => {:value => '∪', :type => :operator},
-        'uuu' => {:value => '⋃', :type => :operator, :underover => true},
-
-        # Relation symbols
-        '=' => {:value => '=', :type => :operator},
-        '!=' => {:value => '≠', :type => :operator},
-        ':=' => {:value => ':=', :type => :operator},
-        '<' => {:value => '&#x003C;', :type => :operator},
-        'lt' => {:value => '&#x003C;', :type => :operator},
-        '>' => {:value => '&#x003E;', :type => :operator},
-        'gt' => {:value => '&#x003E;', :type => :operator},
-        '<=' => {:value => '&#x2264;', :type => :operator},
-        'lt=' => {:value => '&#x2264;', :type => :operator},
-        '>=' => {:value => '&#x2265;', :type => :operator},
-        'geq' => {:value => '&#x2265;', :type => :operator},
-        '-<' => {:value => '&#x227A;', :type => :operator},
-        '-lt' => {:value => '&#x227A;', :type => :operator},
-        '>-' => {:value => '&#x227B;', :type => :operator},
-        '-<=' => {:value => '&#x2AAF;', :type => :operator},
-        '>-=' => {:value => '&#x2AB0;', :type => :operator},
-        'in' => {:value => '&#x2208;', :type => :operator},
-        '!in' => {:value => '&#x2209;', :type => :operator},
-        'sub' => {:value => '&#x2282;', :type => :operator},
-        'sup' => {:value => '&#x2283;', :type => :operator},
-        'sube' => {:value => '&#x2286;', :type => :operator},
-        'supe' => {:value => '&#x2287;', :type => :operator},
-        '-=' => {:value => '&#x2261;', :type => :operator},
-        '~=' => {:value => '&#x2245;', :type => :operator},
-        '~~' => {:value => '&#x2248;', :type => :operator},
-        'prop' => {:value => '&#x221D;', :type => :operator},
-
-        # Logical symbols
-        'and' => {:value => 'and', :type => :text},
-        'or' => {:value => 'or', :type => :text},
-        'not' => {:value => '&#x00AC;', :type => :operator},
-        '=>' => {:value => '&#x21D2;', :type => :operator},
-        'if' => {:value => 'if', :type => :operator},
-        '<=>' => {:value => '&#x21D4;', :type => :operator},
-        'AA' => {:value => '&#x2200;', :type => :operator},
-        'EE' => {:value => '&#x2203;', :type => :operator},
-        '_|_' => {:value => '&#x22A5;', :type => :operator},
-        'TT' => {:value => '&#x22A4;', :type => :operator},
-        '|--' => {:value => '&#x22A2;', :type => :operator},
-        '|==' => {:value => '&#x22A8;', :type => :operator},
-
-        # Grouping brackets
-        '(' => {:value => '(', :type => :lparen},
-        ')' => {:value => ')', :type => :rparen},
-        '[' => {:value => '[', :type => :lparen},
-        ']' => {:value => ']', :type => :rparen},
-        '{' => {:value => '{', :type => :lparen},
-        '}' => {:value => '}', :type => :rparen},
-        '|' => {:value => '|', :type => :lrparen},
-        '||' => {:value => '||', :type => :lrparen},
-        '(:' => {:value => '&#x2329;', :type => :lparen},
-        ':)' => {:value => '&#x232A;', :type => :rparen},
-        '<<' => {:value => '&#x2329;', :type => :lparen},
-        '>>' => {:value => '&#x232A;', :type => :rparen},
-        '{:' => {:value => nil, :type => :lparen},
-        ':}' => {:value => nil, :type => :rparen},
-
-        # Miscellaneous symbols
-        'int' => {:value => '&#x222B;', :type => :operator},
-        'dx' => {:value => 'dx', :type => :identifier},
-        'dy' => {:value => 'dy', :type => :identifier},
-        'dz' => {:value => 'dz', :type => :identifier},
-        'dt' => {:value => 'dt', :type => :identifier},
-        'oint' => {:value => '&#x222E;', :type => :operator},
-        'del' => {:value => '&#x2202;', :type => :operator},
-        'grad' => {:value => '&#x2207;', :type => :operator},
-        '+-' => {:value => '&#x00B1;', :type => :operator},
-        'O/' => {:value => '&#x2205;', :type => :operator},
-        'oo' => {:value => '&#x221E;', :type => :operator},
-        'aleph' => {:value => '&#x2135;', :type => :operator},
-        '...' => {:value => '...', :type => :operator},
-        ':.' => {:value => '&#x2234;', :type => :operator},
-        '/_' => {:value => '&#x2220;', :type => :operator},
-        '\\ ' => {:value => '&#x00A0;', :type => :operator},
-        'quad' => {:value => '\u00A0\u00A0', :type => :operator},
-        'qquad' => {:value => '\u00A0\u00A0\u00A0\u00A0', :type => :operator},
-        'cdots' => {:value => '&#x22EF;', :type => :operator},
-        'vdots' => {:value => '&#x22EE;', :type => :operator},
-        'ddots' => {:value => '&#x22F1;', :type => :operator},
-        'diamond' => {:value => '&#x22C4;', :type => :operator},
-        'square' => {:value => '&#x25A1;', :type => :operator},
-        '|__' => {:value => '&#x230A;', :type => :operator},
-        '__|' => {:value => '&#x230B;', :type => :operator},
-        '|~' => {:value => '&#x2308;', :type => :operator},
-        '~|' => {:value => '&#x2309;', :type => :operator},
-        'CC' => {:value => '&#x2102;', :type => :operator},
-        'NN' => {:value => '&#x2115;', :type => :operator},
-        'QQ' => {:value => '&#x211A;', :type => :operator},
-        'RR' => {:value => '&#x211D;', :type => :operator},
-        'ZZ' => {:value => '&#x2124;', :type => :operator},
-        'f' => {:value => 'f', :type => :identifier},
-        'g' => {:value => 'g', :type => :identifier},
-
-        # Standard functions
-        'lim' => {:value => 'lim', :type => :operator, :underover => true},
-        'Lim' => {:value => 'Lim', :type => :operator, :underover => true},
-        'sin' => {:value => 'sin', :type => :operator},
-        'cos' => {:value => 'cos', :type => :operator},
-        'tan' => {:value => 'tan', :type => :operator},
-        'sinh' => {:value => 'sinh', :type => :operator},
-        'cosh' => {:value => 'cosh', :type => :operator},
-        'tanh' => {:value => 'tanh', :type => :operator},
-        'cot' => {:value => 'cot', :type => :operator},
-        'sec' => {:value => 'sec', :type => :operator},
-        'csc' => {:value => 'csc', :type => :operator},
-        'log' => {:value => 'log', :type => :operator},
-        'ln' => {:value => 'ln', :type => :operator},
-        'det' => {:value => 'det', :type => :operator},
-        'dim' => {:value => 'dim', :type => :operator},
-        'mod' => {:value => 'mod', :type => :operator},
-        'gcd' => {:value => 'gcd', :type => :operator},
-        'lcm' => {:value => 'lcm', :type => :operator},
-        'lub' => {:value => 'lub', :type => :operator},
-        'glb' => {:value => 'glb', :type => :operator},
-        'min' => {:value => 'min', :type => :operator, :underover => true},
-        'max' => {:value => 'max', :type => :operator, :underover => true},
-
-        # Accents
-        'hat' => {:value => '&#x005E;', :type => :accent, :position => :over},
-        'bar' => {:value => '&#x00AF;', :type => :accent, :position => :over},
-        'ul' => {:value => '_', :type => :accent, :position => :under},
-        'vec' => {:value => '&#x2192;', :type => :accent, :position => :over},
-        'dot' => {:value => '.', :type => :accent, :position => :over},
-        'ddot' => {:value => '..', :type => :accent, :position => :over},
-
-        # Arrows
-        'uarr' => {:value => '&#x2191;', :type => :operator},
-        'darr' => {:value => '&#x2193;', :type => :operator},
-        'rarr' => {:value => '&#x2192;', :type => :operator},
-        '->' => {:value => '&#x2192;', :type => :operator},
-        '>->' => {:value => '&#x21A3;', :type => :operator},
-        '->>' => {:value => '&#x21A0;', :type => :operator},
-        '>->>' => {:value => '&#x2916;', :type => :operator},
-        '|->' => {:value => '&#x21A6;', :type => :operator},
-        'larr' => {:value => '&#x2190;', :type => :operator},
-        'harr' => {:value => '&#x2194;', :type => :operator},
-        'rArr' => {:value => '&#x21D2;', :type => :operator},
-        'lArr' => {:value => '&#x21D0;', :type => :operator},
-        'hArr' => {:value => '&#x21D4;', :type => :operator},
-
-        # Other
-        'sqrt' => {:value => :sqrt, :type => :unary},
-        'text' => {:value => :text, :type => :unary},
-        'bb' => {:value => :bold, :type => :font},
-        'bbb' => {:value => :double_struck, :type => :font},
-        'ii' => {:value => :italic, :type => :font},
-        'bii' => {:value => :bold_italic, :type => :font},
-        'cc' => {:value => :script, :type => :font},
-        'bcc' => {:value => :bold_script, :type => :font},
-        'tt' => {:value => :monospace, :type => :font},
-        'fr' => {:value => :fraktur, :type => :font},
-        'bfr' => {:value => :bold_fraktur, :type => :font},
-        'sf' => {:value => :sans_serif, :type => :font},
-        'bsf' => {:value => :bold_sans_serif, :type => :font},
-        'sfi' => {:value => :sans_serif_italic, :type => :font},
-        'sfbi' => {:value => :sans_serif_bold_italic, :type => :font},
-        'frac' => {:value => :frac, :type => :binary},
-        'root' => {:value => :root, :type => :binary},
-        'stackrel' => {:value => :over, :type => :binary},
-        '/' => {:value => :frac, :type => :infix},
-        '_' => {:value => :sub, :type => :infix},
-        '^' => {:value => :sup, :type => :infix},
-
-        # Greek letters
-        'alpha' => {:value => '&#x03b1;', :type => :identifier},
-        'Alpha' => {:value => '&#x0391;', :type => :identifier},
-        'beta' => {:value => '&#x03b2;', :type => :identifier},
-        'Beta' => {:value => '&#x0392;', :type => :identifier},
-        'gamma' => {:value => '&#x03b3;', :type => :identifier},
-        'Gamma' => {:value => '&#x0393;', :type => :operator},
-        'delta' => {:value => '&#x03b4;', :type => :identifier},
-        'Delta' => {:value => '&#x0394;', :type => :operator},
-        'epsilon' => {:value => '&#x03b5;', :type => :identifier},
-        'Epsilon' => {:value => '&#x0395;', :type => :identifier},
-        'varepsilon' => {:value => '&#x025b;', :type => :identifier},
-        'zeta' => {:value => '&#x03b6;', :type => :identifier},
-        'Zeta' => {:value => '&#x0396;', :type => :identifier},
-        'eta' => {:value => '&#x03b7;', :type => :identifier},
-        'Eta' => {:value => '&#x0397;', :type => :identifier},
-        'theta' => {:value => '&#x03b8;', :type => :identifier},
-        'Theta' => {:value => '&#x0398;', :type => :operator},
-        'vartheta' => {:value => '&#x03d1;', :type => :identifier},
-        'iota' => {:value => '&#x03b9;', :type => :identifier},
-        'Iota' => {:value => '&#x0399;', :type => :identifier},
-        'kappa' => {:value => '&#x03ba;', :type => :identifier},
-        'Kappa' => {:value => '&#x039a;', :type => :identifier},
-        'lambda' => {:value => '&#x03bb;', :type => :identifier},
-        'Lambda' => {:value => '&#x039b;', :type => :operator},
-        'mu' => {:value => '&#x03bc;', :type => :identifier},
-        'Mu' => {:value => '&#x039c;', :type => :identifier},
-        'nu' => {:value => '&#x03bd;', :type => :identifier},
-        'Nu' => {:value => '&#x039d;', :type => :identifier},
-        'xi' => {:value => '&#x03be;', :type => :identifier},
-        'Xi' => {:value => '&#x039e;', :type => :operator},
-        'omicron' => {:value => '&#x03bf;', :type => :identifier},
-        'Omicron' => {:value => '&#x039f;', :type => :identifier},
-        'pi' => {:value => '&#x03c0;', :type => :identifier},
-        'Pi' => {:value => '&#x03a0;', :type => :operator},
-        'rho' => {:value => '&#x03c1;', :type => :identifier},
-        'Rho' => {:value => '&#x03a1;', :type => :identifier},
-        'sigma' => {:value => '&#x03c3;', :type => :identifier},
-        'Sigma' => {:value => '&#x03a3;', :type => :operator},
-        'tau' => {:value => '&#x03c4;', :type => :identifier},
-        'Tau' => {:value => '&#x03a4;', :type => :identifier},
-        'upsilon' => {:value => '&#x03c5;', :type => :identifier},
-        'Upsilon' => {:value => '&#x03a5;', :type => :identifier},
-        'phi' => {:value => '&#x03c6;', :type => :identifier},
-        'Phi' => {:value => '&#x03a6;', :type => :identifier},
-        'varphi' => {:value => '&#x03d5;', :type => :identifier},
-        'chi' => {:value => '\u03b3c7', :type => :identifier},
-        'Chi' => {:value => '\u0393a7', :type => :identifier},
-        'psi' => {:value => '&#x03c8;', :type => :identifier},
-        'Psi' => {:value => '&#x03a8;', :type => :identifier},
-        'omega' => {:value => '&#x03c9;', :type => :identifier},
-        'Omega' => {:value => '&#x03a9;', :type => :operator},
-    }
+    def self.add_default_colors(b)
+      b.add('aqua', 0, 255, 255)
+      b.add('black', 0, 0, 0)
+      b.add('blue', 0, 0, 255)
+      b.add('fuchsia', 255, 0, 255)
+      b.add('gray', 128, 128, 128)
+      b.add('green', 0, 128, 0)
+      b.add('lime', 0, 255, 0)
+      b.add('maroon', 128, 0, 0)
+      b.add('navy', 0, 0, 128)
+      b.add('olive', 128, 128, 0)
+      b.add('purple', 128, 0, 128)
+      b.add('red', 255, 0, 0)
+      b.add('silver', 192, 192, 192)
+      b.add('teal', 0, 128, 128)
+      b.add('white', 255, 255, 255)
+      b.add('yellow', 255, 255, 0)
+      b
+    end
+
+    def self.add_default_parser_symbols(b)
+      # Operation symbols
+      b.add('+', :plus, :symbol)
+      b.add('-', :minus, :symbol)
+      b.add('*', 'cdot', :cdot, :symbol)
+      b.add('**', 'ast', :ast, :symbol)
+      b.add('***', 'star', :star, :symbol)
+      b.add('//', :slash, :symbol)
+      b.add('\\\\', 'backslash', :backslash, :symbol)
+      b.add('setminus', :setminus, :symbol)
+      b.add('xx', 'times', :times, :symbol)
+      b.add('|><', 'ltimes', :ltimes, :symbol)
+      b.add('><|', 'rtimes', :rtimes, :symbol)
+      b.add('|><|', 'bowtie', :bowtie, :symbol)
+      b.add('-:', 'div', 'divide', :div, :symbol)
+      b.add('@', 'circ', :circ, :symbol)
+      b.add('o+', 'oplus', :oplus, :symbol)
+      b.add('ox', 'otimes', :otimes, :symbol)
+      b.add('o.', 'odot', :odot, :symbol)
+      b.add('sum', :sum, :symbol)
+      b.add('prod', :prod, :symbol)
+      b.add('^^', 'wedge', :wedge, :symbol)
+      b.add('^^^', 'bigwedge', :bigwedge, :symbol)
+      b.add('vv', 'vee', :vee, :symbol)
+      b.add('vvv', 'bigvee', :bigvee, :symbol)
+      b.add('nn', 'cap', :cap, :symbol)
+      b.add('nnn', 'bigcap', :bigcap, :symbol)
+      b.add('uu', 'cup', :cup, :symbol)
+      b.add('uuu', 'bigcup', :bigcup, :symbol)
+
+      # Relation symbols
+      b.add('=', :eq, :symbol)
+      b.add('!=', 'ne', :ne, :symbol)
+      b.add(':=', :assign, :symbol)
+      b.add('<', 'lt', :lt, :symbol)
+      b.add('>', 'gt', :gt, :symbol)
+      b.add('<=', 'le', :le, :symbol)
+      b.add('>=', 'ge', :ge, :symbol)
+      b.add('-<', '-lt', 'prec', :prec, :symbol)
+      b.add('>-', 'succ', :succ, :symbol)
+      b.add('-<=', 'preceq', :preceq, :symbol)
+      b.add('>-=', 'succeq', :succeq, :symbol)
+      b.add('in', :in, :symbol)
+      b.add('!in', 'notin', :notin, :symbol)
+      b.add('sub', 'subset', :subset, :symbol)
+      b.add('sup', 'supset', :supset, :symbol)
+      b.add('sube', 'subseteq', :subseteq, :symbol)
+      b.add('supe', 'supseteq', :supseteq, :symbol)
+      b.add('-=', 'equiv', :equiv, :symbol)
+      b.add('~=', 'cong', :cong, :symbol)
+      b.add('~~', 'approx', :approx, :symbol)
+      b.add('prop', 'propto', :propto, :symbol)
+
+      # Logical symbols
+      b.add('and', :and, :symbol)
+      b.add('or', :or, :symbol)
+      b.add('not', 'neg', :not, :symbol)
+      b.add('=>', 'implies', :implies, :symbol)
+      b.add('if', :if, :symbol)
+      b.add('<=>', 'iff', :iff, :symbol)
+      b.add('AA', 'forall', :forall, :symbol)
+      b.add('EE', 'exists', :exists, :symbol)
+      b.add('_|_', 'bot', :bot, :symbol)
+      b.add('TT', 'top', :top, :symbol)
+      b.add('|--', 'vdash', :vdash, :symbol)
+      b.add('|==', 'models', :models, :symbol)
+
+      # Grouping brackets
+      b.add('(', 'left(', :lparen, :lparen)
+      b.add(')', 'right)', :rparen, :rparen)
+      b.add('[', 'left[', :lbracket, :lparen)
+      b.add(']', 'right]', :rbracket, :rparen)
+      b.add('{', :lbrace, :lparen)
+      b.add('}', :rbrace, :rparen)
+      b.add('|', :vbar, :lrparen)
+      b.add(':|:', :vbar, :symbol)
+      b.add('|:', :vbar, :lparen)
+      b.add(':|', :vbar, :rparen)
+      # b.add('||', '||', :lrparen)
+      b.add('(:', '<<', 'langle', :langle, :lparen)
+      b.add(':)', '>>', 'rangle', :rangle, :rparen)
+      b.add('{:', nil, :lparen)
+      b.add(':}', nil, :rparen)
+
+      # Miscellaneous symbols
+      b.add('int', :integral, :symbol)
+      b.add('dx', :dx, :symbol)
+      b.add('dy', :dy, :symbol)
+      b.add('dz', :dz, :symbol)
+      b.add('dt', :dt, :symbol)
+      b.add('oint', :contourintegral, :symbol)
+      b.add('del', 'partial', :partial, :symbol)
+      b.add('grad', 'nabla', :nabla, :symbol)
+      b.add('+-', 'pm', :pm, :symbol)
+      b.add('O/', 'emptyset', :emptyset, :symbol)
+      b.add('oo', 'infty', :infty, :symbol)
+      b.add('aleph', :aleph, :symbol)
+      b.add('...', 'ldots', :ellipsis, :symbol)
+      b.add(':.', 'therefore', :therefore, :symbol)
+      b.add(':\'', 'because', :because, :symbol)
+      b.add('/_', 'angle', :angle, :symbol)
+      b.add('/_\\', 'triangle', :triangle, :symbol)
+      b.add('\'', 'prime', :prime, :symbol)
+      b.add('tilde', :tilde, :unary)
+      b.add('\\ ', :nbsp, :symbol)
+      b.add('frown', :frown, :symbol)
+      b.add('quad', :quad, :symbol)
+      b.add('qquad', :qquad, :symbol)
+      b.add('cdots', :cdots, :symbol)
+      b.add('vdots', :vdots, :symbol)
+      b.add('ddots', :ddots, :symbol)
+      b.add('diamond', :diamond, :symbol)
+      b.add('square', :square, :symbol)
+      b.add('|__', 'lfloor', :lfloor, :symbol)
+      b.add('__|', 'rfloor', :rfloor, :symbol)
+      b.add('|~', 'lceiling', :lceiling, :symbol)
+      b.add('~|', 'rceiling', :rceiling, :symbol)
+      b.add('CC', :dstruck_captial_c, :symbol)
+      b.add('NN', :dstruck_captial_n, :symbol)
+      b.add('QQ', :dstruck_captial_q, :symbol)
+      b.add('RR', :dstruck_captial_r, :symbol)
+      b.add('ZZ', :dstruck_captial_z, :symbol)
+      b.add('f', :f, :symbol)
+      b.add('g', :g, :symbol)
+
+
+      # Standard functions
+      b.add('lim', :lim, :symbol)
+      b.add('Lim', :Lim, :symbol)
+      b.add('min', :min, :symbol)
+      b.add('max', :max, :symbol)
+      b.add('sin', :sin, :symbol)
+      b.add('Sin', :Sin, :symbol)
+      b.add('cos', :cos, :symbol)
+      b.add('Cos', :Cos, :symbol)
+      b.add('tan', :tan, :symbol)
+      b.add('Tan', :Tan, :symbol)
+      b.add('sinh', :sinh, :symbol)
+      b.add('Sinh', :Sinh, :symbol)
+      b.add('cosh', :cosh, :symbol)
+      b.add('Cosh', :Cosh, :symbol)
+      b.add('tanh', :tanh, :symbol)
+      b.add('Tanh', :Tanh, :symbol)
+      b.add('cot', :cot, :symbol)
+      b.add('Cot', :Cot, :symbol)
+      b.add('sec', :sec, :symbol)
+      b.add('Sec', :Sec, :symbol)
+      b.add('csc', :csc, :symbol)
+      b.add('Csc', :Csc, :symbol)
+      b.add('arcsin', :arcsin, :symbol)
+      b.add('arccos', :arccos, :symbol)
+      b.add('arctan', :arctan, :symbol)
+      b.add('coth', :coth, :symbol)
+      b.add('sech', :sech, :symbol)
+      b.add('csch', :csch, :symbol)
+      b.add('exp', :exp, :symbol)
+      b.add('abs', :abs, :unary)
+      b.add('Abs', :abs, :unary)
+      b.add('norm', :norm, :unary)
+      b.add('floor', :floor, :unary)
+      b.add('ceil', :ceil, :unary)
+      b.add('log', :log, :symbol)
+      b.add('Log', :Log, :symbol)
+      b.add('ln', :ln, :symbol)
+      b.add('Ln', :Ln, :symbol)
+      b.add('det', :det, :symbol)
+      b.add('dim', :dim, :symbol)
+      b.add('ker', :ker, :symbol)
+      b.add('mod', :mod, :symbol)
+      b.add('gcd', :gcd, :symbol)
+      b.add('lcm', :lcm, :symbol)
+      b.add('lub', :lub, :symbol)
+      b.add('glb', :glb, :symbol)
+
+      # Arrows
+      b.add('uarr', 'uparrow', :uparrow, :symbol)
+      b.add('darr', 'downarrow', :downarrow, :symbol)
+      b.add('rarr', 'rightarrow', :rightarrow, :symbol)
+      b.add('->', 'to', :to, :symbol)
+      b.add('>->', 'rightarrowtail', :rightarrowtail, :symbol)
+      b.add('->>', 'twoheadrightarrow', :twoheadrightarrow, :symbol)
+      b.add('>->>', 'twoheadrightarrowtail', :twoheadrightarrowtail, :symbol)
+      b.add('|->', 'mapsto', :mapsto, :symbol)
+      b.add('larr', 'leftarrow', :leftarrow, :symbol)
+      b.add('harr', 'leftrightarrow', :leftrightarrow, :symbol)
+      b.add('rArr', 'Rightarrow', :Rightarrow, :symbol)
+      b.add('lArr', 'Leftarrow', :Leftarrow, :symbol)
+      b.add('hArr', 'Leftrightarrow', :Leftrightarrow, :symbol)
+
+      # Other
+      b.add('sqrt', :sqrt, :unary)
+      b.add('root', :root, :binary)
+      b.add('frac', :frac, :binary)
+      b.add('/', :frac, :infix)
+      b.add('stackrel', :stackrel, :binary)
+      b.add('overset', :overset, :binary)
+      b.add('underset', :underset, :binary)
+      b.add('color', :color, :binary, :convert_operand1 => ::AsciiMath::Parser.instance_method(:convert_to_color))
+      b.add('_', :sub, :infix)
+      b.add('^', :sup, :infix)
+      b.add('hat', :hat, :unary)
+      b.add('bar', :overline, :unary)
+      b.add('vec', :vec, :unary)
+      b.add('dot', :dot, :unary)
+      b.add('ddot', :ddot, :unary)
+      b.add('overarc', 'overparen', :overarc, :unary)
+      b.add('ul', 'underline', :underline, :unary)
+      b.add('ubrace', 'underbrace', :underbrace, :unary)
+      b.add('obrace', 'overbrace', :overbrace, :unary)
+      b.add('cancel', :cancel, :unary)
+      b.add('bb', :bold, :unary)
+      b.add('bbb', :double_struck, :unary)
+      b.add('ii', :italic, :unary)
+      b.add('bii', :bold_italic, :unary)
+      b.add('cc', :script, :unary)
+      b.add('bcc', :bold_script, :unary)
+      b.add('tt', :monospace, :unary)
+      b.add('fr', :fraktur, :unary)
+      b.add('bfr', :bold_fraktur, :unary)
+      b.add('sf', :sans_serif, :unary)
+      b.add('bsf', :bold_sans_serif, :unary)
+      b.add('sfi', :sans_serif_italic, :unary)
+      b.add('sfbi', :sans_serif_bold_italic, :unary)
+
+      # Greek letters
+      b.add('alpha', :alpha, :symbol)
+      b.add('Alpha', :Alpha, :symbol)
+      b.add('beta', :beta, :symbol)
+      b.add('Beta', :Beta, :symbol)
+      b.add('gamma', :gamma, :symbol)
+      b.add('Gamma', :Gamma, :symbol)
+      b.add('delta', :delta, :symbol)
+      b.add('Delta', :Delta, :symbol)
+      b.add('epsi', 'epsilon', :epsilon, :symbol)
+      b.add('Epsilon', :Epsilon, :symbol)
+      b.add('varepsilon', :varepsilon, :symbol)
+      b.add('zeta', :zeta, :symbol)
+      b.add('Zeta', :Zeta, :symbol)
+      b.add('eta', :eta, :symbol)
+      b.add('Eta', :Eta, :symbol)
+      b.add('theta', :theta, :symbol)
+      b.add('Theta', :Theta, :symbol)
+      b.add('vartheta', :vartheta, :symbol)
+      b.add('iota', :iota, :symbol)
+      b.add('Iota', :Iota, :symbol)
+      b.add('kappa', :kappa, :symbol)
+      b.add('Kappa', :Kappa, :symbol)
+      b.add('lambda', :lambda, :symbol)
+      b.add('Lambda', :Lambda, :symbol)
+      b.add('mu', :mu, :symbol)
+      b.add('Mu', :Mu, :symbol)
+      b.add('nu', :nu, :symbol)
+      b.add('Nu', :Nu, :symbol)
+      b.add('xi', :xi, :symbol)
+      b.add('Xi', :Xi, :symbol)
+      b.add('omicron', :omicron, :symbol)
+      b.add('Omicron', :Omicron, :symbol)
+      b.add('pi', :pi, :symbol)
+      b.add('Pi', :Pi, :symbol)
+      b.add('rho', :rho, :symbol)
+      b.add('Rho', :Rho, :symbol)
+      b.add('sigma', :sigma, :symbol)
+      b.add('Sigma', :Sigma, :symbol)
+      b.add('tau', :tau, :symbol)
+      b.add('Tau', :Tau, :symbol)
+      b.add('upsilon', :upsilon, :symbol)
+      b.add('Upsilon', :Upsilon, :symbol)
+      b.add('phi', :phi, :symbol)
+      b.add('Phi', :Phi, :symbol)
+      b.add('varphi', :varphi, :symbol)
+      b.add('chi', :chi, :symbol)
+      b.add('Chi', :Chi, :symbol)
+      b.add('psi', :psi, :symbol)
+      b.add('Psi', :Psi, :symbol)
+      b.add('omega', :omega, :symbol)
+      b.add('Omega', :Omega, :symbol)
+
+      b
+    end
+
+    def initialize(symbol_table, color_table)
+      @symbol_table = symbol_table
+      @color_table = color_table
+    end
 
     def parse(input)
       Expression.new(
           input,
-          parse_expression(Tokenizer.new(input, SYMBOLS), 0)
+          parse_expression(Tokenizer.new(input, @symbol_table), 0)
       )
     end
 
     private
+
+    include AsciiMath::AST
+
     def parse_expression(tok, depth)
       e = []
 
-      while (s1 = parse_simple_expression(tok, depth))
+      while (s1 = parse_intermediate_expression(tok, depth))
         t1 = tok.next_token
 
-        if t1[:type] == :infix
-          s2 = parse_simple_expression(tok, depth)
-          t2 = tok.next_token
-          if t1[:value] == :sub && t2[:value] == :sup
-            s3 = parse_simple_expression(tok, depth)
-            operator = s1[:underover] ? :underover : :subsup
-            e << {:type => :ternary, :operator => operator, :s1 => s1, :s2 => s2, :s3 => s3}
+        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))
           else
-            operator = s1[:underover] ? (t1[:value] == :sub ? :under : :over) : t1[:value]
-            e << {:type => :binary, :operator => operator, :s1 => s1, :s2 => s2}
-            tok.push_back(t2)
-            if (t2[:type] == :lrparen || t2[:type] == :rparen) && depth > 0
-              break
-            end
+            e << s1
           end
         elsif t1[:type] == :eof
           e << s1
@@ -466,7 +539,46 @@ module AsciiMath
         end
       end
 
-      e
+      expression(*e)
+    end
+
+    def parse_intermediate_expression(tok, depth)
+      s = parse_simple_expression(tok, depth)
+      sub = nil
+      sup = nil
+
+      t1 = tok.next_token
+      case t1[:type]
+        when :infix
+          case t1[:value]
+            when :sub
+              sub = parse_simple_expression(tok, depth)
+              if sub
+                t2 = tok.next_token
+                if t2[:type] == :infix && t2[:value] == :sup
+                  sup = parse_simple_expression(tok, depth)
+                else
+                  tok.push_back(t2)
+                end
+              end
+            when :sup
+              sup = parse_simple_expression(tok, depth)
+            else
+              tok.push_back(t1)
+          end
+        else
+          tok.push_back(t1)
+      end
+
+      if sub && sup
+        subsup(s, unwrap_paren(sub), unwrap_paren(sup))
+      elsif sub
+        sub(s, unwrap_paren(sub))
+      elsif sup
+        sup(s, unwrap_paren(sup))
+      else
+        s
+      end
     end
 
     def parse_simple_expression(tok, depth)
@@ -477,7 +589,7 @@ module AsciiMath
           t2 = tok.next_token
           case t2[:type]
             when :rparen, :lrparen
-              {:type => :paren, :e => nil, :lparen => t1[:value], :rparen => t2[:value]}
+              paren(token_to_symbol(t1), nil, token_to_symbol(t2))
             else
               tok.push_back(t2)
 
@@ -486,67 +598,168 @@ module AsciiMath
               t2 = tok.next_token
               case t2[:type]
                 when :rparen, :lrparen
-                  convert_to_matrix({:type => :paren, :e => e, :lparen => t1[:value], :rparen => t2[:value]})
+                  convert_to_matrix(paren(token_to_symbol(t1), e, token_to_symbol(t2)))
                 else
                   tok.push_back(t2)
-                  {:type => :paren, :e => e, :lparen => t1[:value]}
+                  paren(token_to_symbol(t1), e, nil)
               end
           end
-        when :accent
-          s = parse_simple_expression(tok, depth)
-          {:type => :binary, :s1 => s, :s2 => {:type => :operator, :c => t1[:value]}, :operator => t1[:position]}
-        when :unary, :font
-          s = parse_simple_expression(tok, depth)
-          {:type => t1[:type], :s => s, :operator => t1[:value]}
+        when :rparen
+          if depth > 0
+            tok.push_back(t1)
+            nil
+          else
+            token_to_symbol(t1)
+          end
+        when :unary
+          s = unwrap_paren(parse_simple_expression(tok, depth))
+          s = convert_node(s, t1[:convert_operand])
+          unary(token_to_symbol(t1), s)
         when :binary
-          s1 = parse_simple_expression(tok, depth)
-          s2 = parse_simple_expression(tok, depth)
-          {:type => :binary, :s1 => s1, :s2 => s2, :operator => t1[:value]}
+          s1 = unwrap_paren(parse_simple_expression(tok, depth))
+          s2 = unwrap_paren(parse_simple_expression(tok, depth))
+
+          s1 = convert_node(s1, t1[:convert_operand1])
+          s2 = convert_node(s2, t1[:convert_operand2])
+
+          binary(token_to_symbol(t1), s1, s2)
         when :eof
           nil
+        when :number
+          number(t1[:value])
+        when :text
+          text(t1[:value])
+        when :identifier
+          identifier(t1[:value])
         else
-          {:type => t1[:type], :c => t1[:value], :underover => t1[:underover]}
+          token_to_symbol(t1)
       end
     end
 
-    def convert_to_matrix(expression)
-      return expression unless matrix? expression
+    def token_to_symbol(t1)
+      symbol(t1[:value], t1[:text])
+    end
 
-      rows = expression[:e].select.with_index { |obj, i| i.even? }.map do |row|
-        row[:e].select.with_index { |obj, i| i.even? }
+    def unwrap_paren(node)
+      if node.is_a?(::AsciiMath::AST::Paren)
+        group(node.lparen, node.expression, node.rparen)
+      else
+        node
       end
-
-      {:type => :matrix, :rows => rows, :lparen => expression[:lparen], :rparen => expression[:rparen]}
     end
 
-    def matrix?(expression)
-      return false unless expression.is_a?(Hash) && expression[:type] == :paren
-
-      rows, separators = expression[:e].partition.with_index { |obj, i| i.even? }
+    def convert_to_matrix(node)
+      return node unless node.is_a?(::AsciiMath::AST::Paren) && node.expression.is_a?(::AsciiMath::AST::Sequence)
 
-      rows.length > 1 &&
+      rows, separators = node.expression.partition.with_index { |obj, i| i.even? }
+      return node unless rows.length > 1 &&
           rows.length > separators.length &&
-          separators.all? { |item| item[:type] == :identifier && item[:c] == ',' } &&
-          (rows.all? { |item| item[:type] == :paren && item[:lparen] == '(' && item[:rparen] == ')' } ||
-              rows.all? { |item| item[:type] == :paren && item[:lparen] == '[' && item[:rparen] == ']' }) &&
-          rows.all? { |item| item[:e].length == rows[0][:e].length } &&
-          rows.all? { |item| matrix_cols?(item[:e]) }
+          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 = rows.map do |row|
+        chunks = []
+        current_chunk = []
+
+        row_content = row.expression
+        unless row_content.is_a?(::AsciiMath::AST::Sequence)
+          [expression(row_content)]
+        else
+          row_content.each do |item|
+            if is_matrix_separator(item)
+              chunks << current_chunk
+              current_chunk = []
+            else
+              current_chunk << item
+            end
+          end
+
+          chunks << current_chunk
+
+          chunks.map { |c| c.length == 1 ? c[0] : expression(*c) }.to_a
+        end
+      end
+
+      return node unless rows.all? { |row| row.length == rows[0].length }
+
+      matrix(node.lparen, rows, node.rparen)
     end
 
-    def matrix_cols?(expression)
-      return false unless expression.is_a?(Array)
+    def is_matrix_separator(node)
+      node.is_a?(Identifier) && node.value == ','
+    end
+
+    def convert_node(node, converter)
+      case converter
+        when nil
+          node
+        when UnboundMethod
+          converter.bind(self).call(node)
+        when Method, Proc
+          converter.call(node)
+      end
+    end
 
-      cols, separators = expression.partition.with_index { |obj, i| i.even? }
+    def convert_to_color(color_expression)
+      s = ""
+      append_color_text(s, color_expression)
+      s
 
-      cols.all? { |item| item[:type] != :identifier || item[:c] != ',' } &&
-          separators.all? { |item| item[:type] == :identifier && item[:c] == ',' }
+      case s
+        when /#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})/i
+          color_value = {:r => $1.to_i(16), :g => $2.to_i(16), :b => $3.to_i(16), }
+        when /#([0-9a-f])([0-9a-f])([0-9a-f])/i
+          color_value = {:r => "#{$1}#{$1}".to_i(16), :g => "#{$2}#{$2}".to_i(16), :b => "#{$3}#{$3}".to_i(16), }
+        else
+          color_value = @color_table[s.downcase] || {:r => 0, :g => 0, :b => 0}
+      end
+
+      color(color_value[:r], color_value[:g], color_value[:b], s)
+    end
+
+    def append_color_text(s, node)
+      case node
+        when ::AsciiMath::AST::Sequence
+          node.each { |n| append_color_text(s, n) }
+        when ::AsciiMath::AST::Number, ::AsciiMath::AST::Identifier, ::AsciiMath::AST::Text
+          s << node.value
+        when ::AsciiMath::AST::Symbol
+          s << node.text
+        when ::AsciiMath::AST::Group
+          append_color_text(s, node.expression)
+        when ::AsciiMath::AST::Paren
+          append_color_text(s, node.lparen)
+          append_color_text(s, node.expression)
+          append_color_text(s, node.rparen)
+        when ::AsciiMath::AST::SubSup
+          append_color_text(s, node.base_expression)
+          append_color_text(s, node.operator)
+          append_color_text(s, node.operand2)
+        when ::AsciiMath::AST::UnaryOp
+          append_color_text(s, node.operator)
+          append_color_text(s, node.operand)
+        when ::AsciiMath::AST::BinaryOp
+          append_color_text(s, node.operator)
+          append_color_text(s, node.operand1)
+          append_color_text(s, node.operand2)
+        when ::AsciiMath::AST::InfixOp
+          append_color_text(s, node.operand1)
+          append_color_text(s, node.operator)
+          append_color_text(s, node.operand2)
+      end
     end
+
+    DEFAULT_COLOR_TABLE = ::AsciiMath::Parser.add_default_colors(AsciiMath::ColorTableBuilder.new).build
+    DEFAULT_PARSER_SYMBOL_TABLE = ::AsciiMath::Parser.add_default_parser_symbols(AsciiMath::SymbolTableBuilder.new).build
   end
 
   class Expression
-    def initialize(asciimath, parsed_expression)
+    attr_accessor :ast
+
+    def initialize(asciimath, ast)
       @asciimath = asciimath
-      @parsed_expression = parsed_expression
+      @ast = ast
     end
 
     def to_s
@@ -554,7 +767,7 @@ module AsciiMath
     end
   end
 
-  def self.parse(asciimath)
-    Parser.new.parse(asciimath)
+  def self.parse(asciimath, parser_symbol_table = ::AsciiMath::Parser::DEFAULT_PARSER_SYMBOL_TABLE, parser_color_table = ::AsciiMath::Parser::DEFAULT_COLOR_TABLE)
+    Parser.new(parser_symbol_table, parser_color_table).parse(asciimath)
   end
 end