less 1.0.16 → 1.1.3

data/lib/less/engine/parser.rb

@@ -1,4296 +0,0 @@
-module Less
-  include Treetop::Runtime
-
-  def root
-    @root || :primary
-  end
-
-  def _nt_primary
-    start_index = index
-    if node_cache[:primary].has_key?(index)
-      cached = node_cache[:primary][index]
-      @index = cached.interval.end if cached
-      return cached
-    end
-
-    i0 = index
-    s1, i1 = [], index
-    loop do
-      i2 = index
-      r3 = _nt_declaration
-      if r3
-        r2 = r3
-      else
-        r4 = _nt_ruleset
-        if r4
-          r2 = r4
-        else
-          r5 = _nt_import
-          if r5
-            r2 = r5
-          else
-            r6 = _nt_comment
-            if r6
-              r2 = r6
-            else
-              @index = i2
-              r2 = nil
-            end
-          end
-        end
-      end
-      if r2
-        s1 << r2
-      else
-        break
-      end
-    end
-    if s1.empty?
-      @index = i1
-      r1 = nil
-    else
-      r1 = instantiate_node(Builder,input, i1...index, s1)
-    end
-    if r1
-      r0 = r1
-    else
-      s7, i7 = [], index
-      loop do
-        r8 = _nt_declaration
-        if r8
-          s7 << r8
-        else
-          break
-        end
-      end
-      r7 = instantiate_node(Builder,input, i7...index, s7)
-      if r7
-        r0 = r7
-      else
-        s9, i9 = [], index
-        loop do
-          r10 = _nt_import
-          if r10
-            s9 << r10
-          else
-            break
-          end
-        end
-        r9 = instantiate_node(Builder,input, i9...index, s9)
-        if r9
-          r0 = r9
-        else
-          s11, i11 = [], index
-          loop do
-            r12 = _nt_comment
-            if r12
-              s11 << r12
-            else
-              break
-            end
-          end
-          r11 = instantiate_node(SyntaxNode,input, i11...index, s11)
-          if r11
-            r0 = r11
-          else
-            @index = i0
-            r0 = nil
-          end
-        end
-      end
-    end
-
-    node_cache[:primary][start_index] = r0
-
-    r0
-  end
-
-  module Comment0
-  end
-
-  module Comment1
-    def ws
-      elements[0]
-    end
-
-    def ws
-      elements[4]
-    end
-  end
-
-  module Comment2
-  end
-
-  module Comment3
-    def ws
-      elements[0]
-    end
-
-    def ws
-      elements[4]
-    end
-  end
-
-  def _nt_comment
-    start_index = index
-    if node_cache[:comment].has_key?(index)
-      cached = node_cache[:comment][index]
-      @index = cached.interval.end if cached
-      return cached
-    end
-
-    i0 = index
-    i1, s1 = index, []
-    r2 = _nt_ws
-    s1 << r2
-    if r2
-      if has_terminal?('/*', false, index)
-        r3 = instantiate_node(SyntaxNode,input, index...(index + 2))
-        @index += 2
-      else
-        terminal_parse_failure('/*')
-        r3 = nil
-      end
-      s1 << r3
-      if r3
-        s4, i4 = [], index
-        loop do
-          i5, s5 = index, []
-          i6 = index
-          if has_terminal?('*/', false, index)
-            r7 = instantiate_node(SyntaxNode,input, index...(index + 2))
-            @index += 2
-          else
-            terminal_parse_failure('*/')
-            r7 = nil
-          end
-          if r7
-            r6 = nil
-          else
-            @index = i6
-            r6 = instantiate_node(SyntaxNode,input, index...index)
-          end
-          s5 << r6
-          if r6
-            if index < input_length
-              r8 = instantiate_node(SyntaxNode,input, index...(index + 1))
-              @index += 1
-            else
-              terminal_parse_failure("any character")
-              r8 = nil
-            end
-            s5 << r8
-          end
-          if s5.last
-            r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
-            r5.extend(Comment0)
-          else
-            @index = i5
-            r5 = nil
-          end
-          if r5
-            s4 << r5
-          else
-            break
-          end
-        end
-        r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
-        s1 << r4
-        if r4
-          if has_terminal?('*/', false, index)
-            r9 = instantiate_node(SyntaxNode,input, index...(index + 2))
-            @index += 2
-          else
-            terminal_parse_failure('*/')
-            r9 = nil
-          end
-          s1 << r9
-          if r9
-            r10 = _nt_ws
-            s1 << r10
-          end
-        end
-      end
-    end
-    if s1.last
-      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
-      r1.extend(Comment1)
-    else
-      @index = i1
-      r1 = nil
-    end
-    if r1
-      r0 = r1
-    else
-      i11, s11 = index, []
-      r12 = _nt_ws
-      s11 << r12
-      if r12
-        if has_terminal?('//', false, index)
-          r13 = instantiate_node(SyntaxNode,input, index...(index + 2))
-          @index += 2
-        else
-          terminal_parse_failure('//')
-          r13 = nil
-        end
-        s11 << r13
-        if r13
-          s14, i14 = [], index
-          loop do
-            i15, s15 = index, []
-            i16 = index
-            if has_terminal?("\n", false, index)
-              r17 = instantiate_node(SyntaxNode,input, index...(index + 1))
-              @index += 1
-            else
-              terminal_parse_failure("\n")
-              r17 = nil
-            end
-            if r17
-              r16 = nil
-            else
-              @index = i16
-              r16 = instantiate_node(SyntaxNode,input, index...index)
-            end
-            s15 << r16
-            if r16
-              if index < input_length
-                r18 = instantiate_node(SyntaxNode,input, index...(index + 1))
-                @index += 1
-              else
-                terminal_parse_failure("any character")
-                r18 = nil
-              end
-              s15 << r18
-            end
-            if s15.last
-              r15 = instantiate_node(SyntaxNode,input, i15...index, s15)
-              r15.extend(Comment2)
-            else
-              @index = i15
-              r15 = nil
-            end
-            if r15
-              s14 << r15
-            else
-              break
-            end
-          end
-          r14 = instantiate_node(SyntaxNode,input, i14...index, s14)
-          s11 << r14
-          if r14
-            if has_terminal?("\n", false, index)
-              r19 = instantiate_node(SyntaxNode,input, index...(index + 1))
-              @index += 1
-            else
-              terminal_parse_failure("\n")
-              r19 = nil
-            end
-            s11 << r19
-            if r19
-              r20 = _nt_ws
-              s11 << r20
-            end
-          end
-        end
-      end
-      if s11.last
-        r11 = instantiate_node(SyntaxNode,input, i11...index, s11)
-        r11.extend(Comment3)
-      else
-        @index = i11
-        r11 = nil
-      end
-      if r11
-        r0 = r11
-      else
-        @index = i0
-        r0 = nil
-      end
-    end
-
-    node_cache[:comment][start_index] = r0
-
-    r0
-  end
-
-  module Ruleset0
-    def selectors
-      elements[0]
-    end
-
-    def ws
-      elements[2]
-    end
-
-    def primary
-      elements[3]
-    end
-
-    def ws
-      elements[4]
-    end
-
-    def ws
-      elements[6]
-    end
-  end
-
-  module Ruleset1
-    def build env
-      # Build the ruleset for each selector
-      selectors.build(env, :ruleset).each do |sel|
-        primary.build sel
-      end
-    end
-  end
-
-  module Ruleset2
-    def ws
-      elements[0]
-    end
-
-    def selectors
-      elements[1]
-    end
-
-    def ws
-      elements[3]
-    end
-  end
-
-  module Ruleset3
-    def build env        
-      selectors.build(env, :mixin).each do |path|
-        rules = path.inject(env.root) do |current, node|
-          current.descend(node.selector, node) or raise MixinNameError, path.join
-        end.rules
-        env.rules += rules
-      end
-    end
-  end
-
-  def _nt_ruleset
-    start_index = index
-    if node_cache[:ruleset].has_key?(index)
-      cached = node_cache[:ruleset][index]
-      @index = cached.interval.end if cached
-      return cached
-    end
-
-    i0 = index
-    i1, s1 = index, []
-    r2 = _nt_selectors
-    s1 << r2
-    if r2
-      if has_terminal?("{", false, index)
-        r3 = instantiate_node(SyntaxNode,input, index...(index + 1))
-        @index += 1
-      else
-        terminal_parse_failure("{")
-        r3 = nil
-      end
-      s1 << r3
-      if r3
-        r4 = _nt_ws
-        s1 << r4
-        if r4
-          r5 = _nt_primary
-          s1 << r5
-          if r5
-            r6 = _nt_ws
-            s1 << r6
-            if r6
-              if has_terminal?("}", false, index)
-                r7 = instantiate_node(SyntaxNode,input, index...(index + 1))
-                @index += 1
-              else
-                terminal_parse_failure("}")
-                r7 = nil
-              end
-              s1 << r7
-              if r7
-                r8 = _nt_ws
-                s1 << r8
-              end
-            end
-          end
-        end
-      end
-    end
-    if s1.last
-      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
-      r1.extend(Ruleset0)
-      r1.extend(Ruleset1)
-    else
-      @index = i1
-      r1 = nil
-    end
-    if r1
-      r0 = r1
-    else
-      i9, s9 = index, []
-      r10 = _nt_ws
-      s9 << r10
-      if r10
-        r11 = _nt_selectors
-        s9 << r11
-        if r11
-          if has_terminal?(';', false, index)
-            r12 = instantiate_node(SyntaxNode,input, index...(index + 1))
-            @index += 1
-          else
-            terminal_parse_failure(';')
-            r12 = nil
-          end
-          s9 << r12
-          if r12
-            r13 = _nt_ws
-            s9 << r13
-          end
-        end
-      end
-      if s9.last
-        r9 = instantiate_node(SyntaxNode,input, i9...index, s9)
-        r9.extend(Ruleset2)
-        r9.extend(Ruleset3)
-      else
-        @index = i9
-        r9 = nil
-      end
-      if r9
-        r0 = r9
-      else
-        @index = i0
-        r0 = nil
-      end
-    end
-
-    node_cache[:ruleset][start_index] = r0
-
-    r0
-  end
-
-  module Import0
-    def S
-      elements[1]
-    end
-
-    def url
-      elements[2]
-    end
-
-    def s
-      elements[4]
-    end
-
-    def ws
-      elements[6]
-    end
-  end
-
-  module Import1
-    def build env
-      path = File.join(env.root.file, url.value)
-      path += '.less' unless path =~ /\.(le|c)ss$/
-      if File.exist? path
-        imported = Less::Engine.new(File.new(path)).to_tree
-        env.rules += imported.rules
-      else
-        raise ImportError, path
-      end
-    end
-  end
-
-  def _nt_import
-    start_index = index
-    if node_cache[:import].has_key?(index)
-      cached = node_cache[:import][index]
-      @index = cached.interval.end if cached
-      return cached
-    end
-
-    i0, s0 = index, []
-    if has_terminal?("@import", false, index)
-      r1 = instantiate_node(SyntaxNode,input, index...(index + 7))
-      @index += 7
-    else
-      terminal_parse_failure("@import")
-      r1 = nil
-    end
-    s0 << r1
-    if r1
-      r2 = _nt_S
-      s0 << r2
-      if r2
-        i3 = index
-        r4 = _nt_string
-        if r4
-          r3 = r4
-        else
-          r5 = _nt_url
-          if r5
-            r3 = r5
-          else
-            @index = i3
-            r3 = nil
-          end
-        end
-        s0 << r3
-        if r3
-          r7 = _nt_medias
-          if r7
-            r6 = r7
-          else
-            r6 = instantiate_node(SyntaxNode,input, index...index)
-          end
-          s0 << r6
-          if r6
-            r8 = _nt_s
-            s0 << r8
-            if r8
-              if has_terminal?(';', false, index)
-                r9 = instantiate_node(SyntaxNode,input, index...(index + 1))
-                @index += 1
-              else
-                terminal_parse_failure(';')
-                r9 = nil
-              end
-              s0 << r9
-              if r9
-                r10 = _nt_ws
-                s0 << r10
-              end
-            end
-          end
-        end
-      end
-    end
-    if s0.last
-      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-      r0.extend(Import0)
-      r0.extend(Import1)
-    else
-      @index = i0
-      r0 = nil
-    end
-
-    node_cache[:import][start_index] = r0
-
-    r0
-  end
-
-  module Url0
-    def path
-      elements[1]
-    end
-
-  end
-
-  module Url1
-    def build env = nil
-      Node::String.new CGI.unescape(path.text_value)
-    end
-    
-    def value
-      build
-    end
-  end
-
-  def _nt_url
-    start_index = index
-    if node_cache[:url].has_key?(index)
-      cached = node_cache[:url][index]
-      @index = cached.interval.end if cached
-      return cached
-    end
-
-    i0, s0 = index, []
-    if has_terminal?('url(', false, index)
-      r1 = instantiate_node(SyntaxNode,input, index...(index + 4))
-      @index += 4
-    else
-      terminal_parse_failure('url(')
-      r1 = nil
-    end
-    s0 << r1
-    if r1
-      i2 = index
-      r3 = _nt_string
-      if r3
-        r2 = r3
-      else
-        s4, i4 = [], index
-        loop do
-          if has_terminal?('\G[-a-zA-Z0-9_%$/.&=:;#+?]', true, index)
-            r5 = instantiate_node(SyntaxNode,input, index...(index + 1))
-            @index += 1
-          else
-            r5 = nil
-          end
-          if r5
-            s4 << r5
-          else
-            break
-          end
-        end
-        if s4.empty?
-          @index = i4
-          r4 = nil
-        else
-          r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
-        end
-        if r4
-          r2 = r4
-        else
-          @index = i2
-          r2 = nil
-        end
-      end
-      s0 << r2
-      if r2
-        if has_terminal?(')', false, index)
-          r6 = instantiate_node(SyntaxNode,input, index...(index + 1))
-          @index += 1
-        else
-          terminal_parse_failure(')')
-          r6 = nil
-        end
-        s0 << r6
-      end
-    end
-    if s0.last
-      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-      r0.extend(Url0)
-      r0.extend(Url1)
-    else
-      @index = i0
-      r0 = nil
-    end
-
-    node_cache[:url][start_index] = r0
-
-    r0
-  end
-
-  module Medias0
-    def s
-      elements[0]
-    end
-
-    def s
-      elements[2]
-    end
-
-  end
-
-  module Medias1
-  end
-
-  def _nt_medias
-    start_index = index
-    if node_cache[:medias].has_key?(index)
-      cached = node_cache[:medias][index]
-      @index = cached.interval.end if cached
-      return cached
-    end
-
-    i0, s0 = index, []
-    s1, i1 = [], index
-    loop do
-      if has_terminal?('\G[-a-z]', true, index)
-        r2 = instantiate_node(SyntaxNode,input, index...(index + 1))
-        @index += 1
-      else
-        r2 = nil
-      end
-      if r2
-        s1 << r2
-      else
-        break
-      end
-    end
-    if s1.empty?
-      @index = i1
-      r1 = nil
-    else
-      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
-    end
-    s0 << r1
-    if r1
-      s3, i3 = [], index
-      loop do
-        i4, s4 = index, []
-        r5 = _nt_s
-        s4 << r5
-        if r5
-          if has_terminal?(',', false, index)
-            r6 = instantiate_node(SyntaxNode,input, index...(index + 1))
-            @index += 1
-          else
-            terminal_parse_failure(',')
-            r6 = nil
-          end
-          s4 << r6
-          if r6
-            r7 = _nt_s
-            s4 << r7
-            if r7
-              s8, i8 = [], index
-              loop do
-                if has_terminal?('\G[a-z]', true, index)
-                  r9 = instantiate_node(SyntaxNode,input, index...(index + 1))
-                  @index += 1
-                else
-                  r9 = nil
-                end
-                if r9
-                  s8 << r9
-                else
-                  break
-                end
-              end
-              if s8.empty?
-                @index = i8
-                r8 = nil
-              else
-                r8 = instantiate_node(SyntaxNode,input, i8...index, s8)
-              end
-              s4 << r8
-            end
-          end
-        end
-        if s4.last
-          r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
-          r4.extend(Medias0)
-        else
-          @index = i4
-          r4 = nil
-        end
-        if r4
-          s3 << r4
-        else
-          break
-        end
-      end
-      r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
-      s0 << r3
-    end
-    if s0.last
-      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-      r0.extend(Medias1)
-    else
-      @index = i0
-      r0 = nil
-    end
-
-    node_cache[:medias][start_index] = r0
-
-    r0
-  end
-
-  module Selectors0
-    def s
-      elements[0]
-    end
-
-    def ws
-      elements[2]
-    end
-
-    def selector
-      elements[3]
-    end
-  end
-
-  module Selectors1
-    def ws
-      elements[0]
-    end
-
-    def selector
-      elements[1]
-    end
-
-    def tail
-      elements[2]
-    end
-
-    def ws
-      elements[3]
-    end
-  end
-
-  module Selectors2
-    def build env, method 
-      all.map do |e|
-        e.send(method, env) if e.respond_to? method
-      end.compact
-    end
-    
-    def all
-      [selector] + tail.elements.map {|e| e.selector }
-    end
-  end
-
-  def _nt_selectors
-    start_index = index
-    if node_cache[:selectors].has_key?(index)
-      cached = node_cache[:selectors][index]
-      @index = cached.interval.end if cached
-      return cached
-    end
-
-    i0, s0 = index, []
-    r1 = _nt_ws
-    s0 << r1
-    if r1
-      r2 = _nt_selector
-      s0 << r2
-      if r2
-        s3, i3 = [], index
-        loop do
-          i4, s4 = index, []
-          r5 = _nt_s
-          s4 << r5
-          if r5
-            if has_terminal?(',', false, index)
-              r6 = instantiate_node(SyntaxNode,input, index...(index + 1))
-              @index += 1
-            else
-              terminal_parse_failure(',')
-              r6 = nil
-            end
-            s4 << r6
-            if r6
-              r7 = _nt_ws
-              s4 << r7
-              if r7
-                r8 = _nt_selector
-                s4 << r8
-              end
-            end
-          end
-          if s4.last
-            r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
-            r4.extend(Selectors0)
-          else
-            @index = i4
-            r4 = nil
-          end
-          if r4
-            s3 << r4
-          else
-            break
-          end
-        end
-        r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
-        s0 << r3
-        if r3
-          r9 = _nt_ws
-          s0 << r9
-        end
-      end
-    end
-    if s0.last
-      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-      r0.extend(Selectors1)
-      r0.extend(Selectors2)
-    else
-      @index = i0
-      r0 = nil
-    end
-
-    node_cache[:selectors][start_index] = r0
-
-    r0
-  end
-
-  module Selector0
-    def s
-      elements[0]
-    end
-
-    def select
-      elements[1]
-    end
-
-    def element
-      elements[2]
-    end
-
-    def s
-      elements[3]
-    end
-  end
-
-  module Selector1
-    def sel
-      elements[0]
-    end
-
-  end
-
-  module Selector2
-    def ruleset env
-      sel.elements.inject(env) do |node, e|
-        node << Node::Element.new(e.element.text_value, e.select.text_value)
-        node.last
-      end
-    end
-    
-    def mixin env
-      sel.elements.map do |e|
-        Node::Element.new(e.element.text_value, e.select.text_value)
-      end
-    end
-  end
-
-  def _nt_selector
-    start_index = index
-    if node_cache[:selector].has_key?(index)
-      cached = node_cache[:selector][index]
-      @index = cached.interval.end if cached
-      return cached
-    end
-
-    i0, s0 = index, []
-    s1, i1 = [], index
-    loop do
-      i2, s2 = index, []
-      r3 = _nt_s
-      s2 << r3
-      if r3
-        r4 = _nt_select
-        s2 << r4
-        if r4
-          r5 = _nt_element
-          s2 << r5
-          if r5
-            r6 = _nt_s
-            s2 << r6
-          end
-        end
-      end
-      if s2.last
-        r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
-        r2.extend(Selector0)
-      else
-        @index = i2
-        r2 = nil
-      end
-      if r2
-        s1 << r2
-      else
-        break
-      end
-    end
-    if s1.empty?
-      @index = i1
-      r1 = nil
-    else
-      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
-    end
-    s0 << r1
-    if r1
-      r8 = _nt_arguments
-      if r8
-        r7 = r8
-      else
-        r7 = instantiate_node(SyntaxNode,input, index...index)
-      end
-      s0 << r7
-    end
-    if s0.last
-      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-      r0.extend(Selector1)
-      r0.extend(Selector2)
-    else
-      @index = i0
-      r0 = nil
-    end
-
-    node_cache[:selector][start_index] = r0
-
-    r0
-  end
-
-  module Declaration0
-    def ws
-      elements[0]
-    end
-
-  end
-
-  module Declaration1
-    def ws
-      elements[0]
-    end
-
-    def name
-      elements[1]
-    end
-
-    def s
-      elements[2]
-    end
-
-    def s
-      elements[4]
-    end
-
-    def expressions
-      elements[5]
-    end
-
-    def s
-      elements[6]
-    end
-
-    def ws
-      elements[8]
-    end
-  end
-
-  module Declaration2
-    def build env
-      env << (name.text_value =~ /^@/ ? 
-        Node::Variable : Node::Property).new(name.text_value, expressions.build(env), env)
-
-    end
-  # Empty rule
-  end
-
-  module Declaration3
-    def ws
-      elements[0]
-    end
-
-    def ident
-      elements[1]
-    end
-
-    def s
-      elements[2]
-    end
-
-    def s
-      elements[4]
-    end
-
-    def ws
-      elements[6]
-    end
-  end
-
-  def _nt_declaration
-    start_index = index
-    if node_cache[:declaration].has_key?(index)
-      cached = node_cache[:declaration][index]
-      @index = cached.interval.end if cached
-      return cached
-    end
-
-    i0 = index
-    i1, s1 = index, []
-    r2 = _nt_ws
-    s1 << r2
-    if r2
-      i3 = index
-      r4 = _nt_ident
-      if r4
-        r3 = r4
-      else
-        r5 = _nt_variable
-        if r5
-          r3 = r5
-        else
-          @index = i3
-          r3 = nil
-        end
-      end
-      s1 << r3
-      if r3
-        r6 = _nt_s
-        s1 << r6
-        if r6
-          if has_terminal?(':', false, index)
-            r7 = instantiate_node(SyntaxNode,input, index...(index + 1))
-            @index += 1
-          else
-            terminal_parse_failure(':')
-            r7 = nil
-          end
-          s1 << r7
-          if r7
-            r8 = _nt_s
-            s1 << r8
-            if r8
-              r9 = _nt_expressions
-              s1 << r9
-              if r9
-                r10 = _nt_s
-                s1 << r10
-                if r10
-                  i11 = index
-                  if has_terminal?(';', false, index)
-                    r12 = instantiate_node(SyntaxNode,input, index...(index + 1))
-                    @index += 1
-                  else
-                    terminal_parse_failure(';')
-                    r12 = nil
-                  end
-                  if r12
-                    r11 = r12
-                  else
-                    i13, s13 = index, []
-                    r14 = _nt_ws
-                    s13 << r14
-                    if r14
-                      i15 = index
-                      if has_terminal?('}', false, index)
-                        r16 = instantiate_node(SyntaxNode,input, index...(index + 1))
-                        @index += 1
-                      else
-                        terminal_parse_failure('}')
-                        r16 = nil
-                      end
-                      if r16
-                        @index = i15
-                        r15 = instantiate_node(SyntaxNode,input, index...index)
-                      else
-                        r15 = nil
-                      end
-                      s13 << r15
-                    end
-                    if s13.last
-                      r13 = instantiate_node(SyntaxNode,input, i13...index, s13)
-                      r13.extend(Declaration0)
-                    else
-                      @index = i13
-                      r13 = nil
-                    end
-                    if r13
-                      r11 = r13
-                    else
-                      @index = i11
-                      r11 = nil
-                    end
-                  end
-                  s1 << r11
-                  if r11
-                    r17 = _nt_ws
-                    s1 << r17
-                  end
-                end
-              end
-            end
-          end
-        end
-      end
-    end
-    if s1.last
-      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
-      r1.extend(Declaration1)
-      r1.extend(Declaration2)
-    else
-      @index = i1
-      r1 = nil
-    end
-    if r1
-      r0 = r1
-    else
-      i18, s18 = index, []
-      r19 = _nt_ws
-      s18 << r19
-      if r19
-        r20 = _nt_ident
-        s18 << r20
-        if r20
-          r21 = _nt_s
-          s18 << r21
-          if r21
-            if has_terminal?(':', false, index)
-              r22 = instantiate_node(SyntaxNode,input, index...(index + 1))
-              @index += 1
-            else
-              terminal_parse_failure(':')
-              r22 = nil
-            end
-            s18 << r22
-            if r22
-              r23 = _nt_s
-              s18 << r23
-              if r23
-                if has_terminal?(';', false, index)
-                  r24 = instantiate_node(SyntaxNode,input, index...(index + 1))
-                  @index += 1
-                else
-                  terminal_parse_failure(';')
-                  r24 = nil
-                end
-                s18 << r24
-                if r24
-                  r25 = _nt_ws
-                  s18 << r25
-                end
-              end
-            end
-          end
-        end
-      end
-      if s18.last
-        r18 = instantiate_node(SyntaxNode,input, i18...index, s18)
-        r18.extend(Declaration3)
-      else
-        @index = i18
-        r18 = nil
-      end
-      if r18
-        r0 = r18
-      else
-        @index = i0
-        r0 = nil
-      end
-    end
-
-    node_cache[:declaration][start_index] = r0
-
-    r0
-  end
-
-  module Expressions0
-    def build env
-      elements.map do |e|
-        e.build(env) if e.respond_to? :build
-      end.compact
-    end
-  end
-
-  def _nt_expressions
-    start_index = index
-    if node_cache[:expressions].has_key?(index)
-      cached = node_cache[:expressions][index]
-      @index = cached.interval.end if cached
-      return cached
-    end
-
-    s0, i0 = [], index
-    loop do
-      r1 = _nt_expression
-      if r1
-        s0 << r1
-      else
-        break
-      end
-    end
-    if s0.empty?
-      @index = i0
-      r0 = nil
-    else
-      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-      r0.extend(Expressions0)
-    end
-
-    node_cache[:expressions][start_index] = r0
-
-    r0
-  end
-
-  module Expression0
-    def s
-      elements[0]
-    end
-
-    def s
-      elements[2]
-    end
-
-    def expressions
-      elements[3]
-    end
-
-    def s
-      elements[4]
-    end
-
-    def s
-      elements[6]
-    end
-  end
-
-  module Expression1
-    def build env
-      Node::Expression.new(['('] + expressions.build(env).flatten + [')'])
-    end
-  end
-
-  module Expression2
-    def operator
-      elements[0]
-    end
-
-    def entity
-      elements[1]
-    end
-  end
-
-  module Expression3
-    def entity
-      elements[0]
-    end
-
-    def tail
-      elements[1]
-    end
-
-    def ws
-      elements[2]
-    end
-  end
-
-  module Expression4
-    def build env 
-      exp = all.map do |e|
-        e.method(:build).arity.zero?? 
-          e.build : e.build(env) if e.respond_to? :build
-      end.dissolve
-      exp.is_a?(Array) ? Node::Expression.new(exp) : exp
-    end
-    
-    def all
-      [entity] + tail.elements.map {|i| [i.operator, i.entity] }.flatten.compact
-    end
-  end
-
-  def _nt_expression
-    start_index = index
-    if node_cache[:expression].has_key?(index)
-      cached = node_cache[:expression][index]
-      @index = cached.interval.end if cached
-      return cached
-    end
-
-    i0 = index
-    i1, s1 = index, []
-    r2 = _nt_s
-    s1 << r2
-    if r2
-      if has_terminal?('(', false, index)
-        r3 = instantiate_node(SyntaxNode,input, index...(index + 1))
-        @index += 1
-      else
-        terminal_parse_failure('(')
-        r3 = nil
-      end
-      s1 << r3
-      if r3
-        r4 = _nt_s
-        s1 << r4
-        if r4
-          r5 = _nt_expressions
-          s1 << r5
-          if r5
-            r6 = _nt_s
-            s1 << r6
-            if r6
-              if has_terminal?(')', false, index)
-                r7 = instantiate_node(SyntaxNode,input, index...(index + 1))
-                @index += 1
-              else
-                terminal_parse_failure(')')
-                r7 = nil
-              end
-              s1 << r7
-              if r7
-                r8 = _nt_s
-                s1 << r8
-              end
-            end
-          end
-        end
-      end
-    end
-    if s1.last
-      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
-      r1.extend(Expression0)
-      r1.extend(Expression1)
-    else
-      @index = i1
-      r1 = nil
-    end
-    if r1
-      r0 = r1
-    else
-      i9, s9 = index, []
-      r10 = _nt_entity
-      s9 << r10
-      if r10
-        s11, i11 = [], index
-        loop do
-          i12, s12 = index, []
-          r13 = _nt_operator
-          s12 << r13
-          if r13
-            r14 = _nt_entity
-            s12 << r14
-          end
-          if s12.last
-            r12 = instantiate_node(SyntaxNode,input, i12...index, s12)
-            r12.extend(Expression2)
-          else
-            @index = i12
-            r12 = nil
-          end
-          if r12
-            s11 << r12
-          else
-            break
-          end
-        end
-        r11 = instantiate_node(SyntaxNode,input, i11...index, s11)
-        s9 << r11
-        if r11
-          r15 = _nt_ws
-          s9 << r15
-        end
-      end
-      if s9.last
-        r9 = instantiate_node(SyntaxNode,input, i9...index, s9)
-        r9.extend(Expression3)
-        r9.extend(Expression4)
-      else
-        @index = i9
-        r9 = nil
-      end
-      if r9
-        r0 = r9
-      else
-        @index = i0
-        r0 = nil
-      end
-    end
-
-    node_cache[:expression][start_index] = r0
-
-    r0
-  end
-
-  def _nt_entity
-    start_index = index
-    if node_cache[:entity].has_key?(index)
-      cached = node_cache[:entity][index]
-      @index = cached.interval.end if cached
-      return cached
-    end
-
-    i0 = index
-    r1 = _nt_function
-    if r1
-      r0 = r1
-    else
-      r2 = _nt_fonts
-      if r2
-        r0 = r2
-      else
-        r3 = _nt_keyword
-        if r3
-          r0 = r3
-        else
-          r4 = _nt_accessor
-          if r4
-            r0 = r4
-          else
-            r5 = _nt_variable
-            if r5
-              r0 = r5
-            else
-              r6 = _nt_literal
-              if r6
-                r0 = r6
-              else
-                r7 = _nt_important
-                if r7
-                  r0 = r7
-                else
-                  @index = i0
-                  r0 = nil
-                end
-              end
-            end
-          end
-        end
-      end
-    end
-
-    node_cache[:entity][start_index] = r0
-
-    r0
-  end
-
-  module Fonts0
-    def s
-      elements[0]
-    end
-
-    def s
-      elements[2]
-    end
-
-    def font
-      elements[3]
-    end
-  end
-
-  module Fonts1
-    def font
-      elements[0]
-    end
-
-    def family
-      elements[1]
-    end
-  end
-
-  module Fonts2
-    def build
-      Node::FontFamily.new(all.map(&:build))
-    end
-    
-    def all
-      [font] + family.elements.map {|f| f.font }
-    end
-  end
-
-  def _nt_fonts
-    start_index = index
-    if node_cache[:fonts].has_key?(index)
-      cached = node_cache[:fonts][index]
-      @index = cached.interval.end if cached
-      return cached
-    end
-
-    i0, s0 = index, []
-    r1 = _nt_font
-    s0 << r1
-    if r1
-      s2, i2 = [], index
-      loop do
-        i3, s3 = index, []
-        r4 = _nt_s
-        s3 << r4
-        if r4
-          if has_terminal?(',', false, index)
-            r5 = instantiate_node(SyntaxNode,input, index...(index + 1))
-            @index += 1
-          else
-            terminal_parse_failure(',')
-            r5 = nil
-          end
-          s3 << r5
-          if r5
-            r6 = _nt_s
-            s3 << r6
-            if r6
-              r7 = _nt_font
-              s3 << r7
-            end
-          end
-        end
-        if s3.last
-          r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
-          r3.extend(Fonts0)
-        else
-          @index = i3
-          r3 = nil
-        end
-        if r3
-          s2 << r3
-        else
-          break
-        end
-      end
-      if s2.empty?
-        @index = i2
-        r2 = nil
-      else
-        r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
-      end
-      s0 << r2
-    end
-    if s0.last
-      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-      r0.extend(Fonts1)
-      r0.extend(Fonts2)
-    else
-      @index = i0
-      r0 = nil
-    end
-
-    node_cache[:fonts][start_index] = r0
-
-    r0
-  end
-
-  module Font0
-  end
-
-  module Font1
-    def build
-      Node::Keyword.new(text_value)
-    end
-  end
-
-  module Font2
-    def build
-      Node::String.new(text_value)
-    end
-  end
-
-  def _nt_font
-    start_index = index
-    if node_cache[:font].has_key?(index)
-      cached = node_cache[:font][index]
-      @index = cached.interval.end if cached
-      return cached
-    end
-
-    i0 = index
-    i1, s1 = index, []
-    if has_terminal?('\G[a-zA-Z]', true, index)
-      r2 = instantiate_node(SyntaxNode,input, index...(index + 1))
-      @index += 1
-    else
-      r2 = nil
-    end
-    s1 << r2
-    if r2
-      s3, i3 = [], index
-      loop do
-        if has_terminal?('\G[-a-zA-Z0-9]', true, index)
-          r4 = instantiate_node(SyntaxNode,input, index...(index + 1))
-          @index += 1
-        else
-          r4 = nil
-        end
-        if r4
-          s3 << r4
-        else
-          break
-        end
-      end
-      r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
-      s1 << r3
-    end
-    if s1.last
-      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
-      r1.extend(Font0)
-      r1.extend(Font1)
-    else
-      @index = i1
-      r1 = nil
-    end
-    if r1
-      r0 = r1
-    else
-      r5 = _nt_string
-      r5.extend(Font2)
-      if r5
-        r0 = r5
-      else
-        @index = i0
-        r0 = nil
-      end
-    end
-
-    node_cache[:font][start_index] = r0
-
-    r0
-  end
-
-  module Ident0
-  end
-
-  def _nt_ident
-    start_index = index
-    if node_cache[:ident].has_key?(index)
-      cached = node_cache[:ident][index]
-      @index = cached.interval.end if cached
-      return cached
-    end
-
-    i0, s0 = index, []
-    if has_terminal?('*', false, index)
-      r2 = instantiate_node(SyntaxNode,input, index...(index + 1))
-      @index += 1
-    else
-      terminal_parse_failure('*')
-      r2 = nil
-    end
-    if r2
-      r1 = r2
-    else
-      r1 = instantiate_node(SyntaxNode,input, index...index)
-    end
-    s0 << r1
-    if r1
-      if has_terminal?('-', false, index)
-        r4 = instantiate_node(SyntaxNode,input, index...(index + 1))
-        @index += 1
-      else
-        terminal_parse_failure('-')
-        r4 = nil
-      end
-      if r4
-        r3 = r4
-      else
-        r3 = instantiate_node(SyntaxNode,input, index...index)
-      end
-      s0 << r3
-      if r3
-        s5, i5 = [], index
-        loop do
-          if has_terminal?('\G[-a-z0-9_]', true, index)
-            r6 = instantiate_node(SyntaxNode,input, index...(index + 1))
-            @index += 1
-          else
-            r6 = nil
-          end
-          if r6
-            s5 << r6
-          else
-            break
-          end
-        end
-        if s5.empty?
-          @index = i5
-          r5 = nil
-        else
-          r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
-        end
-        s0 << r5
-      end
-    end
-    if s0.last
-      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-      r0.extend(Ident0)
-    else
-      @index = i0
-      r0 = nil
-    end
-
-    node_cache[:ident][start_index] = r0
-
-    r0
-  end
-
-  module Variable0
-  end
-
-  module Variable1
-    def build
-      Node::Variable.new(text_value)
-    end
-  end
-
-  def _nt_variable
-    start_index = index
-    if node_cache[:variable].has_key?(index)
-      cached = node_cache[:variable][index]
-      @index = cached.interval.end if cached
-      return cached
-    end
-
-    i0, s0 = index, []
-    if has_terminal?('@', false, index)
-      r1 = instantiate_node(SyntaxNode,input, index...(index + 1))
-      @index += 1
-    else
-      terminal_parse_failure('@')
-      r1 = nil
-    end
-    s0 << r1
-    if r1
-      s2, i2 = [], index
-      loop do
-        if has_terminal?('\G[-a-zA-Z0-9_]', true, index)
-          r3 = instantiate_node(SyntaxNode,input, index...(index + 1))
-          @index += 1
-        else
-          r3 = nil
-        end
-        if r3
-          s2 << r3
-        else
-          break
-        end
-      end
-      if s2.empty?
-        @index = i2
-        r2 = nil
-      else
-        r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
-      end
-      s0 << r2
-    end
-    if s0.last
-      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-      r0.extend(Variable0)
-      r0.extend(Variable1)
-    else
-      @index = i0
-      r0 = nil
-    end
-
-    node_cache[:variable][start_index] = r0
-
-    r0
-  end
-
-  module Element0
-  end
-
-  module Element1
-  end
-
-  def _nt_element
-    start_index = index
-    if node_cache[:element].has_key?(index)
-      cached = node_cache[:element][index]
-      @index = cached.interval.end if cached
-      return cached
-    end
-
-    i0 = index
-    i1, s1 = index, []
-    i2 = index
-    r3 = _nt_class_id
-    if r3
-      r2 = r3
-    else
-      r4 = _nt_tag
-      if r4
-        r2 = r4
-      else
-        r5 = _nt_ident
-        if r5
-          r2 = r5
-        else
-          @index = i2
-          r2 = nil
-        end
-      end
-    end
-    s1 << r2
-    if r2
-      s6, i6 = [], index
-      loop do
-        r7 = _nt_attribute
-        if r7
-          s6 << r7
-        else
-          break
-        end
-      end
-      r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
-      s1 << r6
-      if r6
-        i9, s9 = index, []
-        if has_terminal?('(', false, index)
-          r10 = instantiate_node(SyntaxNode,input, index...(index + 1))
-          @index += 1
-        else
-          terminal_parse_failure('(')
-          r10 = nil
-        end
-        s9 << r10
-        if r10
-          r12 = _nt_ident
-          if r12
-            r11 = r12
-          else
-            r11 = instantiate_node(SyntaxNode,input, index...index)
-          end
-          s9 << r11
-          if r11
-            s13, i13 = [], index
-            loop do
-              r14 = _nt_attribute
-              if r14
-                s13 << r14
-              else
-                break
-              end
-            end
-            r13 = instantiate_node(SyntaxNode,input, i13...index, s13)
-            s9 << r13
-            if r13
-              if has_terminal?(')', false, index)
-                r15 = instantiate_node(SyntaxNode,input, index...(index + 1))
-                @index += 1
-              else
-                terminal_parse_failure(')')
-                r15 = nil
-              end
-              s9 << r15
-            end
-          end
-        end
-        if s9.last
-          r9 = instantiate_node(SyntaxNode,input, i9...index, s9)
-          r9.extend(Element0)
-        else
-          @index = i9
-          r9 = nil
-        end
-        if r9
-          r8 = r9
-        else
-          r8 = instantiate_node(SyntaxNode,input, index...index)
-        end
-        s1 << r8
-      end
-    end
-    if s1.last
-      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
-      r1.extend(Element1)
-    else
-      @index = i1
-      r1 = nil
-    end
-    if r1
-      r0 = r1
-    else
-      s16, i16 = [], index
-      loop do
-        r17 = _nt_attribute
-        if r17
-          s16 << r17
-        else
-          break
-        end
-      end
-      if s16.empty?
-        @index = i16
-        r16 = nil
-      else
-        r16 = instantiate_node(SyntaxNode,input, i16...index, s16)
-      end
-      if r16
-        r0 = r16
-      else
-        if has_terminal?('@media', false, index)
-          r18 = instantiate_node(SyntaxNode,input, index...(index + 6))
-          @index += 6
-        else
-          terminal_parse_failure('@media')
-          r18 = nil
-        end
-        if r18
-          r0 = r18
-        else
-          if has_terminal?('@font-face', false, index)
-            r19 = instantiate_node(SyntaxNode,input, index...(index + 10))
-            @index += 10
-          else
-            terminal_parse_failure('@font-face')
-            r19 = nil
-          end
-          if r19
-            r0 = r19
-          else
-            @index = i0
-            r0 = nil
-          end
-        end
-      end
-    end
-
-    node_cache[:element][start_index] = r0
-
-    r0
-  end
-
-  module ClassId0
-  end
-
-  def _nt_class_id
-    start_index = index
-    if node_cache[:class_id].has_key?(index)
-      cached = node_cache[:class_id][index]
-      @index = cached.interval.end if cached
-      return cached
-    end
-
-    i0, s0 = index, []
-    r2 = _nt_tag
-    if r2
-      r1 = r2
-    else
-      r1 = instantiate_node(SyntaxNode,input, index...index)
-    end
-    s0 << r1
-    if r1
-      s3, i3 = [], index
-      loop do
-        i4 = index
-        r5 = _nt_class
-        if r5
-          r4 = r5
-        else
-          r6 = _nt_id
-          if r6
-            r4 = r6
-          else
-            @index = i4
-            r4 = nil
-          end
-        end
-        if r4
-          s3 << r4
-        else
-          break
-        end
-      end
-      if s3.empty?
-        @index = i3
-        r3 = nil
-      else
-        r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
-      end
-      s0 << r3
-    end
-    if s0.last
-      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-      r0.extend(ClassId0)
-    else
-      @index = i0
-      r0 = nil
-    end
-
-    node_cache[:class_id][start_index] = r0
-
-    r0
-  end
-
-  module Attribute0
-  end
-
-  module Attribute1
-    def tag
-      elements[1]
-    end
-
-  end
-
-  module Attribute2
-  end
-
-  def _nt_attribute
-    start_index = index
-    if node_cache[:attribute].has_key?(index)
-      cached = node_cache[:attribute][index]
-      @index = cached.interval.end if cached
-      return cached
-    end
-
-    i0 = index
-    i1, s1 = index, []
-    if has_terminal?('[', false, index)
-      r2 = instantiate_node(SyntaxNode,input, index...(index + 1))
-      @index += 1
-    else
-      terminal_parse_failure('[')
-      r2 = nil
-    end
-    s1 << r2
-    if r2
-      r3 = _nt_tag
-      s1 << r3
-      if r3
-        i4, s4 = index, []
-        if has_terminal?('\G[|~*$^]', true, index)
-          r6 = instantiate_node(SyntaxNode,input, index...(index + 1))
-          @index += 1
-        else
-          r6 = nil
-        end
-        if r6
-          r5 = r6
-        else
-          r5 = instantiate_node(SyntaxNode,input, index...index)
-        end
-        s4 << r5
-        if r5
-          if has_terminal?('=', false, index)
-            r7 = instantiate_node(SyntaxNode,input, index...(index + 1))
-            @index += 1
-          else
-            terminal_parse_failure('=')
-            r7 = nil
-          end
-          s4 << r7
-        end
-        if s4.last
-          r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
-          r4.extend(Attribute0)
-        else
-          @index = i4
-          r4 = nil
-        end
-        s1 << r4
-        if r4
-          i8 = index
-          r9 = _nt_tag
-          if r9
-            r8 = r9
-          else
-            r10 = _nt_string
-            if r10
-              r8 = r10
-            else
-              @index = i8
-              r8 = nil
-            end
-          end
-          s1 << r8
-          if r8
-            if has_terminal?(']', false, index)
-              r11 = instantiate_node(SyntaxNode,input, index...(index + 1))
-              @index += 1
-            else
-              terminal_parse_failure(']')
-              r11 = nil
-            end
-            s1 << r11
-          end
-        end
-      end
-    end
-    if s1.last
-      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
-      r1.extend(Attribute1)
-    else
-      @index = i1
-      r1 = nil
-    end
-    if r1
-      r0 = r1
-    else
-      i12, s12 = index, []
-      if has_terminal?('[', false, index)
-        r13 = instantiate_node(SyntaxNode,input, index...(index + 1))
-        @index += 1
-      else
-        terminal_parse_failure('[')
-        r13 = nil
-      end
-      s12 << r13
-      if r13
-        i14 = index
-        r15 = _nt_tag
-        if r15
-          r14 = r15
-        else
-          r16 = _nt_string
-          if r16
-            r14 = r16
-          else
-            @index = i14
-            r14 = nil
-          end
-        end
-        s12 << r14
-        if r14
-          if has_terminal?(']', false, index)
-            r17 = instantiate_node(SyntaxNode,input, index...(index + 1))
-            @index += 1
-          else
-            terminal_parse_failure(']')
-            r17 = nil
-          end
-          s12 << r17
-        end
-      end
-      if s12.last
-        r12 = instantiate_node(SyntaxNode,input, i12...index, s12)
-        r12.extend(Attribute2)
-      else
-        @index = i12
-        r12 = nil
-      end
-      if r12
-        r0 = r12
-      else
-        @index = i0
-        r0 = nil
-      end
-    end
-
-    node_cache[:attribute][start_index] = r0
-
-    r0
-  end
-
-  module Class0
-  end
-
-  def _nt_class
-    start_index = index
-    if node_cache[:class].has_key?(index)
-      cached = node_cache[:class][index]
-      @index = cached.interval.end if cached
-      return cached
-    end
-
-    i0, s0 = index, []
-    if has_terminal?('.', false, index)
-      r1 = instantiate_node(SyntaxNode,input, index...(index + 1))
-      @index += 1
-    else
-      terminal_parse_failure('.')
-      r1 = nil
-    end
-    s0 << r1
-    if r1
-      if has_terminal?('\G[_a-z]', true, index)
-        r2 = instantiate_node(SyntaxNode,input, index...(index + 1))
-        @index += 1
-      else
-        r2 = nil
-      end
-      s0 << r2
-      if r2
-        s3, i3 = [], index
-        loop do
-          if has_terminal?('\G[-a-zA-Z0-9_]', true, index)
-            r4 = instantiate_node(SyntaxNode,input, index...(index + 1))
-            @index += 1
-          else
-            r4 = nil
-          end
-          if r4
-            s3 << r4
-          else
-            break
-          end
-        end
-        r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
-        s0 << r3
-      end
-    end
-    if s0.last
-      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-      r0.extend(Class0)
-    else
-      @index = i0
-      r0 = nil
-    end
-
-    node_cache[:class][start_index] = r0
-
-    r0
-  end
-
-  module Id0
-  end
-
-  def _nt_id
-    start_index = index
-    if node_cache[:id].has_key?(index)
-      cached = node_cache[:id][index]
-      @index = cached.interval.end if cached
-      return cached
-    end
-
-    i0, s0 = index, []
-    if has_terminal?('#', false, index)
-      r1 = instantiate_node(SyntaxNode,input, index...(index + 1))
-      @index += 1
-    else
-      terminal_parse_failure('#')
-      r1 = nil
-    end
-    s0 << r1
-    if r1
-      if has_terminal?('\G[_a-z]', true, index)
-        r2 = instantiate_node(SyntaxNode,input, index...(index + 1))
-        @index += 1
-      else
-        r2 = nil
-      end
-      s0 << r2
-      if r2
-        s3, i3 = [], index
-        loop do
-          if has_terminal?('\G[-a-zA-Z0-9_]', true, index)
-            r4 = instantiate_node(SyntaxNode,input, index...(index + 1))
-            @index += 1
-          else
-            r4 = nil
-          end
-          if r4
-            s3 << r4
-          else
-            break
-          end
-        end
-        r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
-        s0 << r3
-      end
-    end
-    if s0.last
-      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-      r0.extend(Id0)
-    else
-      @index = i0
-      r0 = nil
-    end
-
-    node_cache[:id][start_index] = r0
-
-    r0
-  end
-
-  module Tag0
-  end
-
-  def _nt_tag
-    start_index = index
-    if node_cache[:tag].has_key?(index)
-      cached = node_cache[:tag][index]
-      @index = cached.interval.end if cached
-      return cached
-    end
-
-    i0 = index
-    i1, s1 = index, []
-    if has_terminal?('\G[a-zA-Z]', true, index)
-      r2 = instantiate_node(SyntaxNode,input, index...(index + 1))
-      @index += 1
-    else
-      r2 = nil
-    end
-    s1 << r2
-    if r2
-      s3, i3 = [], index
-      loop do
-        if has_terminal?('\G[-a-zA-Z]', true, index)
-          r4 = instantiate_node(SyntaxNode,input, index...(index + 1))
-          @index += 1
-        else
-          r4 = nil
-        end
-        if r4
-          s3 << r4
-        else
-          break
-        end
-      end
-      r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
-      s1 << r3
-      if r3
-        if has_terminal?('\G[0-9]', true, index)
-          r6 = instantiate_node(SyntaxNode,input, index...(index + 1))
-          @index += 1
-        else
-          r6 = nil
-        end
-        if r6
-          r5 = r6
-        else
-          r5 = instantiate_node(SyntaxNode,input, index...index)
-        end
-        s1 << r5
-      end
-    end
-    if s1.last
-      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
-      r1.extend(Tag0)
-    else
-      @index = i1
-      r1 = nil
-    end
-    if r1
-      r0 = r1
-    else
-      if has_terminal?('*', false, index)
-        r7 = instantiate_node(SyntaxNode,input, index...(index + 1))
-        @index += 1
-      else
-        terminal_parse_failure('*')
-        r7 = nil
-      end
-      if r7
-        r0 = r7
-      else
-        @index = i0
-        r0 = nil
-      end
-    end
-
-    node_cache[:tag][start_index] = r0
-
-    r0
-  end
-
-  module Select0
-    def s
-      elements[0]
-    end
-
-    def s
-      elements[2]
-    end
-  end
-
-  module Select1
-    def s
-      elements[0]
-    end
-
-  end
-
-  def _nt_select
-    start_index = index
-    if node_cache[:select].has_key?(index)
-      cached = node_cache[:select][index]
-      @index = cached.interval.end if cached
-      return cached
-    end
-
-    i1 = index
-    i2, s2 = index, []
-    r3 = _nt_s
-    s2 << r3
-    if r3
-      if has_terminal?('\G[+>~]', true, index)
-        r4 = instantiate_node(SyntaxNode,input, index...(index + 1))
-        @index += 1
-      else
-        r4 = nil
-      end
-      s2 << r4
-      if r4
-        r5 = _nt_s
-        s2 << r5
-      end
-    end
-    if s2.last
-      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
-      r2.extend(Select0)
-    else
-      @index = i2
-      r2 = nil
-    end
-    if r2
-      r1 = r2
-    else
-      i6, s6 = index, []
-      r7 = _nt_s
-      s6 << r7
-      if r7
-        if has_terminal?(':', false, index)
-          r8 = instantiate_node(SyntaxNode,input, index...(index + 1))
-          @index += 1
-        else
-          terminal_parse_failure(':')
-          r8 = nil
-        end
-        s6 << r8
-      end
-      if s6.last
-        r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
-        r6.extend(Select1)
-      else
-        @index = i6
-        r6 = nil
-      end
-      if r6
-        r1 = r6
-      else
-        r9 = _nt_S
-        if r9
-          r1 = r9
-        else
-          @index = i1
-          r1 = nil
-        end
-      end
-    end
-    if r1
-      r0 = r1
-    else
-      r0 = instantiate_node(SyntaxNode,input, index...index)
-    end
-
-    node_cache[:select][start_index] = r0
-
-    r0
-  end
-
-  module Accessor0
-    def ident
-      elements[0]
-    end
-
-    def attr
-      elements[2]
-    end
-
-  end
-
-  module Accessor1
-    def build env
-      env.nearest(ident.text_value)[attr.text_value.delete(%q["'])].evaluate
-    end
-  end
-
-  def _nt_accessor
-    start_index = index
-    if node_cache[:accessor].has_key?(index)
-      cached = node_cache[:accessor][index]
-      @index = cached.interval.end if cached
-      return cached
-    end
-
-    i0, s0 = index, []
-    i1 = index
-    r2 = _nt_class_id
-    if r2
-      r1 = r2
-    else
-      r3 = _nt_tag
-      if r3
-        r1 = r3
-      else
-        @index = i1
-        r1 = nil
-      end
-    end
-    s0 << r1
-    if r1
-      if has_terminal?('[', false, index)
-        r4 = instantiate_node(SyntaxNode,input, index...(index + 1))
-        @index += 1
-      else
-        terminal_parse_failure('[')
-        r4 = nil
-      end
-      s0 << r4
-      if r4
-        i5 = index
-        r6 = _nt_string
-        if r6
-          r5 = r6
-        else
-          r7 = _nt_variable
-          if r7
-            r5 = r7
-          else
-            @index = i5
-            r5 = nil
-          end
-        end
-        s0 << r5
-        if r5
-          if has_terminal?(']', false, index)
-            r8 = instantiate_node(SyntaxNode,input, index...(index + 1))
-            @index += 1
-          else
-            terminal_parse_failure(']')
-            r8 = nil
-          end
-          s0 << r8
-        end
-      end
-    end
-    if s0.last
-      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-      r0.extend(Accessor0)
-      r0.extend(Accessor1)
-    else
-      @index = i0
-      r0 = nil
-    end
-
-    node_cache[:accessor][start_index] = r0
-
-    r0
-  end
-
-  module Operator0
-    def S
-      elements[0]
-    end
-
-    def S
-      elements[2]
-    end
-  end
-
-  module Operator1
-    def build
-      Node::Operator.new(text_value.strip)
-    end
-  end
-
-  module Operator2
-    def build
-      Node::Operator.new(text_value)
-    end
-  end
-
-  def _nt_operator
-    start_index = index
-    if node_cache[:operator].has_key?(index)
-      cached = node_cache[:operator][index]
-      @index = cached.interval.end if cached
-      return cached
-    end
-
-    i0 = index
-    i1, s1 = index, []
-    r2 = _nt_S
-    s1 << r2
-    if r2
-      if has_terminal?('\G[-+*/]', true, index)
-        r3 = instantiate_node(SyntaxNode,input, index...(index + 1))
-        @index += 1
-      else
-        r3 = nil
-      end
-      s1 << r3
-      if r3
-        r4 = _nt_S
-        s1 << r4
-      end
-    end
-    if s1.last
-      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
-      r1.extend(Operator0)
-      r1.extend(Operator1)
-    else
-      @index = i1
-      r1 = nil
-    end
-    if r1
-      r0 = r1
-    else
-      if has_terminal?('\G[-+*/]', true, index)
-        r5 = instantiate_node(SyntaxNode,input, index...(index + 1))
-        r5.extend(Operator2)
-        @index += 1
-      else
-        r5 = nil
-      end
-      if r5
-        r0 = r5
-      else
-        @index = i0
-        r0 = nil
-      end
-    end
-
-    node_cache[:operator][start_index] = r0
-
-    r0
-  end
-
-  module Literal0
-    def dimension
-      elements[2]
-    end
-  end
-
-  module Literal1
-    def build
-      Node::Anonymous.new(text_value)
-    end
-  end
-
-  module Literal2
-    def number
-      elements[0]
-    end
-
-    def unit
-      elements[1]
-    end
-  end
-
-  module Literal3
-    def build
-      Node::Number.new(number.text_value, unit.text_value)
-    end
-  end
-
-  module Literal4
-    def build
-      Node::String.new(text_value)
-    end
-  end
-
-  def _nt_literal
-    start_index = index
-    if node_cache[:literal].has_key?(index)
-      cached = node_cache[:literal][index]
-      @index = cached.interval.end if cached
-      return cached
-    end
-
-    i0 = index
-    r1 = _nt_color
-    if r1
-      r0 = r1
-    else
-      i2, s2 = index, []
-      i3 = index
-      r4 = _nt_dimension
-      if r4
-        r3 = r4
-      else
-        s5, i5 = [], index
-        loop do
-          if has_terminal?('\G[-a-z]', true, index)
-            r6 = instantiate_node(SyntaxNode,input, index...(index + 1))
-            @index += 1
-          else
-            r6 = nil
-          end
-          if r6
-            s5 << r6
-          else
-            break
-          end
-        end
-        if s5.empty?
-          @index = i5
-          r5 = nil
-        else
-          r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
-        end
-        if r5
-          r3 = r5
-        else
-          @index = i3
-          r3 = nil
-        end
-      end
-      s2 << r3
-      if r3
-        if has_terminal?('/', false, index)
-          r7 = instantiate_node(SyntaxNode,input, index...(index + 1))
-          @index += 1
-        else
-          terminal_parse_failure('/')
-          r7 = nil
-        end
-        s2 << r7
-        if r7
-          r8 = _nt_dimension
-          s2 << r8
-        end
-      end
-      if s2.last
-        r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
-        r2.extend(Literal0)
-        r2.extend(Literal1)
-      else
-        @index = i2
-        r2 = nil
-      end
-      if r2
-        r0 = r2
-      else
-        i9, s9 = index, []
-        r10 = _nt_number
-        s9 << r10
-        if r10
-          r11 = _nt_unit
-          s9 << r11
-        end
-        if s9.last
-          r9 = instantiate_node(SyntaxNode,input, i9...index, s9)
-          r9.extend(Literal2)
-          r9.extend(Literal3)
-        else
-          @index = i9
-          r9 = nil
-        end
-        if r9
-          r0 = r9
-        else
-          r12 = _nt_string
-          r12.extend(Literal4)
-          if r12
-            r0 = r12
-          else
-            @index = i0
-            r0 = nil
-          end
-        end
-      end
-    end
-
-    node_cache[:literal][start_index] = r0
-
-    r0
-  end
-
-  module Important0
-    def build
-      Node::Keyword.new(text_value)
-    end
-  end
-
-  def _nt_important
-    start_index = index
-    if node_cache[:important].has_key?(index)
-      cached = node_cache[:important][index]
-      @index = cached.interval.end if cached
-      return cached
-    end
-
-    if has_terminal?('!important', false, index)
-      r0 = instantiate_node(SyntaxNode,input, index...(index + 10))
-      r0.extend(Important0)
-      @index += 10
-    else
-      terminal_parse_failure('!important')
-      r0 = nil
-    end
-
-    node_cache[:important][start_index] = r0
-
-    r0
-  end
-
-  module Keyword0
-  end
-
-  module Keyword1
-    def build
-      Node::Keyword.new(text_value)
-    end
-  end
-
-  def _nt_keyword
-    start_index = index
-    if node_cache[:keyword].has_key?(index)
-      cached = node_cache[:keyword][index]
-      @index = cached.interval.end if cached
-      return cached
-    end
-
-    i0, s0 = index, []
-    s1, i1 = [], index
-    loop do
-      if has_terminal?('\G[-a-zA-Z]', true, index)
-        r2 = instantiate_node(SyntaxNode,input, index...(index + 1))
-        @index += 1
-      else
-        r2 = nil
-      end
-      if r2
-        s1 << r2
-      else
-        break
-      end
-    end
-    if s1.empty?
-      @index = i1
-      r1 = nil
-    else
-      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
-    end
-    s0 << r1
-    if r1
-      i3 = index
-      r4 = _nt_ns
-      if r4
-        r3 = nil
-      else
-        @index = i3
-        r3 = instantiate_node(SyntaxNode,input, index...index)
-      end
-      s0 << r3
-    end
-    if s0.last
-      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-      r0.extend(Keyword0)
-      r0.extend(Keyword1)
-    else
-      @index = i0
-      r0 = nil
-    end
-
-    node_cache[:keyword][start_index] = r0
-
-    r0
-  end
-
-  module String0
-  end
-
-  module String1
-    def content
-      elements[1]
-    end
-
-  end
-
-  module String2
-    def value
-      content.text_value
-    end
-  end
-
-  module String3
-  end
-
-  module String4
-    def content
-      elements[1]
-    end
-
-  end
-
-  module String5
-    def value
-      content.text_value
-    end
-  end
-
-  def _nt_string
-    start_index = index
-    if node_cache[:string].has_key?(index)
-      cached = node_cache[:string][index]
-      @index = cached.interval.end if cached
-      return cached
-    end
-
-    i0 = index
-    i1, s1 = index, []
-    if has_terminal?("'", false, index)
-      r2 = instantiate_node(SyntaxNode,input, index...(index + 1))
-      @index += 1
-    else
-      terminal_parse_failure("'")
-      r2 = nil
-    end
-    s1 << r2
-    if r2
-      s3, i3 = [], index
-      loop do
-        i4, s4 = index, []
-        i5 = index
-        if has_terminal?("'", false, index)
-          r6 = instantiate_node(SyntaxNode,input, index...(index + 1))
-          @index += 1
-        else
-          terminal_parse_failure("'")
-          r6 = nil
-        end
-        if r6
-          r5 = nil
-        else
-          @index = i5
-          r5 = instantiate_node(SyntaxNode,input, index...index)
-        end
-        s4 << r5
-        if r5
-          if index < input_length
-            r7 = instantiate_node(SyntaxNode,input, index...(index + 1))
-            @index += 1
-          else
-            terminal_parse_failure("any character")
-            r7 = nil
-          end
-          s4 << r7
-        end
-        if s4.last
-          r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
-          r4.extend(String0)
-        else
-          @index = i4
-          r4 = nil
-        end
-        if r4
-          s3 << r4
-        else
-          break
-        end
-      end
-      r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
-      s1 << r3
-      if r3
-        if has_terminal?("'", false, index)
-          r8 = instantiate_node(SyntaxNode,input, index...(index + 1))
-          @index += 1
-        else
-          terminal_parse_failure("'")
-          r8 = nil
-        end
-        s1 << r8
-      end
-    end
-    if s1.last
-      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
-      r1.extend(String1)
-      r1.extend(String2)
-    else
-      @index = i1
-      r1 = nil
-    end
-    if r1
-      r0 = r1
-    else
-      i9, s9 = index, []
-      if has_terminal?('\G["]', true, index)
-        r10 = instantiate_node(SyntaxNode,input, index...(index + 1))
-        @index += 1
-      else
-        r10 = nil
-      end
-      s9 << r10
-      if r10
-        s11, i11 = [], index
-        loop do
-          i12, s12 = index, []
-          i13 = index
-          if has_terminal?('\G["]', true, index)
-            r14 = instantiate_node(SyntaxNode,input, index...(index + 1))
-            @index += 1
-          else
-            r14 = nil
-          end
-          if r14
-            r13 = nil
-          else
-            @index = i13
-            r13 = instantiate_node(SyntaxNode,input, index...index)
-          end
-          s12 << r13
-          if r13
-            if index < input_length
-              r15 = instantiate_node(SyntaxNode,input, index...(index + 1))
-              @index += 1
-            else
-              terminal_parse_failure("any character")
-              r15 = nil
-            end
-            s12 << r15
-          end
-          if s12.last
-            r12 = instantiate_node(SyntaxNode,input, i12...index, s12)
-            r12.extend(String3)
-          else
-            @index = i12
-            r12 = nil
-          end
-          if r12
-            s11 << r12
-          else
-            break
-          end
-        end
-        r11 = instantiate_node(SyntaxNode,input, i11...index, s11)
-        s9 << r11
-        if r11
-          if has_terminal?('\G["]', true, index)
-            r16 = instantiate_node(SyntaxNode,input, index...(index + 1))
-            @index += 1
-          else
-            r16 = nil
-          end
-          s9 << r16
-        end
-      end
-      if s9.last
-        r9 = instantiate_node(SyntaxNode,input, i9...index, s9)
-        r9.extend(String4)
-        r9.extend(String5)
-      else
-        @index = i9
-        r9 = nil
-      end
-      if r9
-        r0 = r9
-      else
-        @index = i0
-        r0 = nil
-      end
-    end
-
-    node_cache[:string][start_index] = r0
-
-    r0
-  end
-
-  module Dimension0
-    def number
-      elements[0]
-    end
-
-    def unit
-      elements[1]
-    end
-  end
-
-  def _nt_dimension
-    start_index = index
-    if node_cache[:dimension].has_key?(index)
-      cached = node_cache[:dimension][index]
-      @index = cached.interval.end if cached
-      return cached
-    end
-
-    i0, s0 = index, []
-    r1 = _nt_number
-    s0 << r1
-    if r1
-      r2 = _nt_unit
-      s0 << r2
-    end
-    if s0.last
-      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-      r0.extend(Dimension0)
-    else
-      @index = i0
-      r0 = nil
-    end
-
-    node_cache[:dimension][start_index] = r0
-
-    r0
-  end
-
-  module Number0
-  end
-
-  module Number1
-  end
-
-  def _nt_number
-    start_index = index
-    if node_cache[:number].has_key?(index)
-      cached = node_cache[:number][index]
-      @index = cached.interval.end if cached
-      return cached
-    end
-
-    i0 = index
-    i1, s1 = index, []
-    if has_terminal?('-', false, index)
-      r3 = instantiate_node(SyntaxNode,input, index...(index + 1))
-      @index += 1
-    else
-      terminal_parse_failure('-')
-      r3 = nil
-    end
-    if r3
-      r2 = r3
-    else
-      r2 = instantiate_node(SyntaxNode,input, index...index)
-    end
-    s1 << r2
-    if r2
-      s4, i4 = [], index
-      loop do
-        if has_terminal?('\G[0-9]', true, index)
-          r5 = instantiate_node(SyntaxNode,input, index...(index + 1))
-          @index += 1
-        else
-          r5 = nil
-        end
-        if r5
-          s4 << r5
-        else
-          break
-        end
-      end
-      r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
-      s1 << r4
-      if r4
-        if has_terminal?('.', false, index)
-          r6 = instantiate_node(SyntaxNode,input, index...(index + 1))
-          @index += 1
-        else
-          terminal_parse_failure('.')
-          r6 = nil
-        end
-        s1 << r6
-        if r6
-          s7, i7 = [], index
-          loop do
-            if has_terminal?('\G[0-9]', true, index)
-              r8 = instantiate_node(SyntaxNode,input, index...(index + 1))
-              @index += 1
-            else
-              r8 = nil
-            end
-            if r8
-              s7 << r8
-            else
-              break
-            end
-          end
-          if s7.empty?
-            @index = i7
-            r7 = nil
-          else
-            r7 = instantiate_node(SyntaxNode,input, i7...index, s7)
-          end
-          s1 << r7
-        end
-      end
-    end
-    if s1.last
-      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
-      r1.extend(Number0)
-    else
-      @index = i1
-      r1 = nil
-    end
-    if r1
-      r0 = r1
-    else
-      i9, s9 = index, []
-      if has_terminal?('-', false, index)
-        r11 = instantiate_node(SyntaxNode,input, index...(index + 1))
-        @index += 1
-      else
-        terminal_parse_failure('-')
-        r11 = nil
-      end
-      if r11
-        r10 = r11
-      else
-        r10 = instantiate_node(SyntaxNode,input, index...index)
-      end
-      s9 << r10
-      if r10
-        s12, i12 = [], index
-        loop do
-          if has_terminal?('\G[0-9]', true, index)
-            r13 = instantiate_node(SyntaxNode,input, index...(index + 1))
-            @index += 1
-          else
-            r13 = nil
-          end
-          if r13
-            s12 << r13
-          else
-            break
-          end
-        end
-        if s12.empty?
-          @index = i12
-          r12 = nil
-        else
-          r12 = instantiate_node(SyntaxNode,input, i12...index, s12)
-        end
-        s9 << r12
-      end
-      if s9.last
-        r9 = instantiate_node(SyntaxNode,input, i9...index, s9)
-        r9.extend(Number1)
-      else
-        @index = i9
-        r9 = nil
-      end
-      if r9
-        r0 = r9
-      else
-        @index = i0
-        r0 = nil
-      end
-    end
-
-    node_cache[:number][start_index] = r0
-
-    r0
-  end
-
-  def _nt_unit
-    start_index = index
-    if node_cache[:unit].has_key?(index)
-      cached = node_cache[:unit][index]
-      @index = cached.interval.end if cached
-      return cached
-    end
-
-    i1 = index
-    if has_terminal?('px', false, index)
-      r2 = instantiate_node(SyntaxNode,input, index...(index + 2))
-      @index += 2
-    else
-      terminal_parse_failure('px')
-      r2 = nil
-    end
-    if r2
-      r1 = r2
-    else
-      if has_terminal?('em', false, index)
-        r3 = instantiate_node(SyntaxNode,input, index...(index + 2))
-        @index += 2
-      else
-        terminal_parse_failure('em')
-        r3 = nil
-      end
-      if r3
-        r1 = r3
-      else
-        if has_terminal?('pc', false, index)
-          r4 = instantiate_node(SyntaxNode,input, index...(index + 2))
-          @index += 2
-        else
-          terminal_parse_failure('pc')
-          r4 = nil
-        end
-        if r4
-          r1 = r4
-        else
-          if has_terminal?('%', false, index)
-            r5 = instantiate_node(SyntaxNode,input, index...(index + 1))
-            @index += 1
-          else
-            terminal_parse_failure('%')
-            r5 = nil
-          end
-          if r5
-            r1 = r5
-          else
-            if has_terminal?('pt', false, index)
-              r6 = instantiate_node(SyntaxNode,input, index...(index + 2))
-              @index += 2
-            else
-              terminal_parse_failure('pt')
-              r6 = nil
-            end
-            if r6
-              r1 = r6
-            else
-              if has_terminal?('cm', false, index)
-                r7 = instantiate_node(SyntaxNode,input, index...(index + 2))
-                @index += 2
-              else
-                terminal_parse_failure('cm')
-                r7 = nil
-              end
-              if r7
-                r1 = r7
-              else
-                if has_terminal?('mm', false, index)
-                  r8 = instantiate_node(SyntaxNode,input, index...(index + 2))
-                  @index += 2
-                else
-                  terminal_parse_failure('mm')
-                  r8 = nil
-                end
-                if r8
-                  r1 = r8
-                else
-                  @index = i1
-                  r1 = nil
-                end
-              end
-            end
-          end
-        end
-      end
-    end
-    if r1
-      r0 = r1
-    else
-      r0 = instantiate_node(SyntaxNode,input, index...index)
-    end
-
-    node_cache[:unit][start_index] = r0
-
-    r0
-  end
-
-  module Color0
-    def rgb
-      elements[1]
-    end
-  end
-
-  module Color1
-    def build
-      Node::Color.new(*rgb.build)
-    end
-  end
-
-  module Color2
-  end
-
-  module Color3
-    def fn
-      elements[0]
-    end
-
-    def arguments
-      elements[1]
-    end
-  end
-
-  module Color4
-    def build
-      Node::Function.new(fn.text_value, arguments.build.flatten)
-    end
-  end
-
-  def _nt_color
-    start_index = index
-    if node_cache[:color].has_key?(index)
-      cached = node_cache[:color][index]
-      @index = cached.interval.end if cached
-      return cached
-    end
-
-    i0 = index
-    i1, s1 = index, []
-    if has_terminal?('#', false, index)
-      r2 = instantiate_node(SyntaxNode,input, index...(index + 1))
-      @index += 1
-    else
-      terminal_parse_failure('#')
-      r2 = nil
-    end
-    s1 << r2
-    if r2
-      r3 = _nt_rgb
-      s1 << r3
-    end
-    if s1.last
-      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
-      r1.extend(Color0)
-      r1.extend(Color1)
-    else
-      @index = i1
-      r1 = nil
-    end
-    if r1
-      r0 = r1
-    else
-      i4, s4 = index, []
-      i5, s5 = index, []
-      i6 = index
-      if has_terminal?('hsl', false, index)
-        r7 = instantiate_node(SyntaxNode,input, index...(index + 3))
-        @index += 3
-      else
-        terminal_parse_failure('hsl')
-        r7 = nil
-      end
-      if r7
-        r6 = r7
-      else
-        if has_terminal?('rgb', false, index)
-          r8 = instantiate_node(SyntaxNode,input, index...(index + 3))
-          @index += 3
-        else
-          terminal_parse_failure('rgb')
-          r8 = nil
-        end
-        if r8
-          r6 = r8
-        else
-          @index = i6
-          r6 = nil
-        end
-      end
-      s5 << r6
-      if r6
-        if has_terminal?('a', false, index)
-          r10 = instantiate_node(SyntaxNode,input, index...(index + 1))
-          @index += 1
-        else
-          terminal_parse_failure('a')
-          r10 = nil
-        end
-        if r10
-          r9 = r10
-        else
-          r9 = instantiate_node(SyntaxNode,input, index...index)
-        end
-        s5 << r9
-      end
-      if s5.last
-        r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
-        r5.extend(Color2)
-      else
-        @index = i5
-        r5 = nil
-      end
-      s4 << r5
-      if r5
-        r11 = _nt_arguments
-        s4 << r11
-      end
-      if s4.last
-        r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
-        r4.extend(Color3)
-        r4.extend(Color4)
-      else
-        @index = i4
-        r4 = nil
-      end
-      if r4
-        r0 = r4
-      else
-        @index = i0
-        r0 = nil
-      end
-    end
-
-    node_cache[:color][start_index] = r0
-
-    r0
-  end
-
-  module Rgb0
-    def hex
-      elements[0]
-    end
-
-    def hex
-      elements[1]
-    end
-  end
-
-  module Rgb1
-    def hex
-      elements[0]
-    end
-
-    def hex
-      elements[1]
-    end
-  end
-
-  module Rgb2
-    def hex
-      elements[0]
-    end
-
-    def hex
-      elements[1]
-    end
-  end
-
-  module Rgb3
-    def r
-      elements[0]
-    end
-
-    def g
-      elements[1]
-    end
-
-    def b
-      elements[2]
-    end
-  end
-
-  module Rgb4
-    def build
-      [r.text_value, g.text_value, b.text_value]
-    end
-  end
-
-  module Rgb5
-    def r
-      elements[0]
-    end
-
-    def g
-      elements[1]
-    end
-
-    def b
-      elements[2]
-    end
-  end
-
-  module Rgb6
-    def build
-      [r.text_value, g.text_value, b.text_value].map {|c| c * 2 }
-    end
-  end
-
-  def _nt_rgb
-    start_index = index
-    if node_cache[:rgb].has_key?(index)
-      cached = node_cache[:rgb][index]
-      @index = cached.interval.end if cached
-      return cached
-    end
-
-    i0 = index
-    i1, s1 = index, []
-    i2, s2 = index, []
-    r3 = _nt_hex
-    s2 << r3
-    if r3
-      r4 = _nt_hex
-      s2 << r4
-    end
-    if s2.last
-      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
-      r2.extend(Rgb0)
-    else
-      @index = i2
-      r2 = nil
-    end
-    s1 << r2
-    if r2
-      i5, s5 = index, []
-      r6 = _nt_hex
-      s5 << r6
-      if r6
-        r7 = _nt_hex
-        s5 << r7
-      end
-      if s5.last
-        r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
-        r5.extend(Rgb1)
-      else
-        @index = i5
-        r5 = nil
-      end
-      s1 << r5
-      if r5
-        i8, s8 = index, []
-        r9 = _nt_hex
-        s8 << r9
-        if r9
-          r10 = _nt_hex
-          s8 << r10
-        end
-        if s8.last
-          r8 = instantiate_node(SyntaxNode,input, i8...index, s8)
-          r8.extend(Rgb2)
-        else
-          @index = i8
-          r8 = nil
-        end
-        s1 << r8
-      end
-    end
-    if s1.last
-      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
-      r1.extend(Rgb3)
-      r1.extend(Rgb4)
-    else
-      @index = i1
-      r1 = nil
-    end
-    if r1
-      r0 = r1
-    else
-      i11, s11 = index, []
-      r12 = _nt_hex
-      s11 << r12
-      if r12
-        r13 = _nt_hex
-        s11 << r13
-        if r13
-          r14 = _nt_hex
-          s11 << r14
-        end
-      end
-      if s11.last
-        r11 = instantiate_node(SyntaxNode,input, i11...index, s11)
-        r11.extend(Rgb5)
-        r11.extend(Rgb6)
-      else
-        @index = i11
-        r11 = nil
-      end
-      if r11
-        r0 = r11
-      else
-        @index = i0
-        r0 = nil
-      end
-    end
-
-    node_cache[:rgb][start_index] = r0
-
-    r0
-  end
-
-  def _nt_hex
-    start_index = index
-    if node_cache[:hex].has_key?(index)
-      cached = node_cache[:hex][index]
-      @index = cached.interval.end if cached
-      return cached
-    end
-
-    if has_terminal?('\G[a-fA-F0-9]', true, index)
-      r0 = instantiate_node(SyntaxNode,input, index...(index + 1))
-      @index += 1
-    else
-      r0 = nil
-    end
-
-    node_cache[:hex][start_index] = r0
-
-    r0
-  end
-
-  module Function0
-    def name
-      elements[0]
-    end
-
-    def arguments
-      elements[1]
-    end
-  end
-
-  module Function1
-    def build
-      Node::Function.new(name.text_value, [arguments.build].flatten)
-    end
-  end
-
-  def _nt_function
-    start_index = index
-    if node_cache[:function].has_key?(index)
-      cached = node_cache[:function][index]
-      @index = cached.interval.end if cached
-      return cached
-    end
-
-    i0, s0 = index, []
-    s1, i1 = [], index
-    loop do
-      if has_terminal?('\G[-a-zA-Z_]', true, index)
-        r2 = instantiate_node(SyntaxNode,input, index...(index + 1))
-        @index += 1
-      else
-        r2 = nil
-      end
-      if r2
-        s1 << r2
-      else
-        break
-      end
-    end
-    if s1.empty?
-      @index = i1
-      r1 = nil
-    else
-      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
-    end
-    s0 << r1
-    if r1
-      r3 = _nt_arguments
-      s0 << r3
-    end
-    if s0.last
-      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-      r0.extend(Function0)
-      r0.extend(Function1)
-    else
-      @index = i0
-      r0 = nil
-    end
-
-    node_cache[:function][start_index] = r0
-
-    r0
-  end
-
-  module Arguments0
-    def s
-      elements[1]
-    end
-
-    def argument
-      elements[2]
-    end
-
-    def s
-      elements[3]
-    end
-  end
-
-  module Arguments1
-    def s
-      elements[1]
-    end
-
-    def argument
-      elements[2]
-    end
-
-    def s
-      elements[3]
-    end
-
-    def tail
-      elements[4]
-    end
-
-  end
-
-  module Arguments2
-    def build
-      all.map do |e|
-        e.build if e.respond_to? :build
-      end.compact
-    end
-  
-    def all
-      [argument] + tail.elements.map {|e| e.argument }
-    end
-  end
-
-  def _nt_arguments
-    start_index = index
-    if node_cache[:arguments].has_key?(index)
-      cached = node_cache[:arguments][index]
-      @index = cached.interval.end if cached
-      return cached
-    end
-
-    i0, s0 = index, []
-    if has_terminal?('(', false, index)
-      r1 = instantiate_node(SyntaxNode,input, index...(index + 1))
-      @index += 1
-    else
-      terminal_parse_failure('(')
-      r1 = nil
-    end
-    s0 << r1
-    if r1
-      r2 = _nt_s
-      s0 << r2
-      if r2
-        r3 = _nt_argument
-        s0 << r3
-        if r3
-          r4 = _nt_s
-          s0 << r4
-          if r4
-            s5, i5 = [], index
-            loop do
-              i6, s6 = index, []
-              if has_terminal?(',', false, index)
-                r7 = instantiate_node(SyntaxNode,input, index...(index + 1))
-                @index += 1
-              else
-                terminal_parse_failure(',')
-                r7 = nil
-              end
-              s6 << r7
-              if r7
-                r8 = _nt_s
-                s6 << r8
-                if r8
-                  r9 = _nt_argument
-                  s6 << r9
-                  if r9
-                    r10 = _nt_s
-                    s6 << r10
-                  end
-                end
-              end
-              if s6.last
-                r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
-                r6.extend(Arguments0)
-              else
-                @index = i6
-                r6 = nil
-              end
-              if r6
-                s5 << r6
-              else
-                break
-              end
-            end
-            r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
-            s0 << r5
-            if r5
-              if has_terminal?(')', false, index)
-                r11 = instantiate_node(SyntaxNode,input, index...(index + 1))
-                @index += 1
-              else
-                terminal_parse_failure(')')
-                r11 = nil
-              end
-              s0 << r11
-            end
-          end
-        end
-      end
-    end
-    if s0.last
-      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-      r0.extend(Arguments1)
-      r0.extend(Arguments2)
-    else
-      @index = i0
-      r0 = nil
-    end
-
-    node_cache[:arguments][start_index] = r0
-
-    r0
-  end
-
-  module Argument0
-    def build
-      Node::Color.new text_value
-    end
-  end
-
-  module Argument1
-    def number
-      elements[0]
-    end
-
-    def unit
-      elements[1]
-    end
-  end
-
-  module Argument2
-    def build
-      Node::Number.new number.text_value, unit.text_value
-    end
-  end
-
-  module Argument3
-    def build
-      Node::String.new text_value
-    end
-  end
-
-  module Argument4
-    def dimension
-      elements[2]
-    end
-  end
-
-  module Argument5
-    def build
-      Node::Anonymous.new text_value
-    end
-  end
-
-  module Argument6
-    def build
-      Node::String.new text_value
-    end
-  end
-
-  def _nt_argument
-    start_index = index
-    if node_cache[:argument].has_key?(index)
-      cached = node_cache[:argument][index]
-      @index = cached.interval.end if cached
-      return cached
-    end
-
-    i0 = index
-    r1 = _nt_color
-    r1.extend(Argument0)
-    if r1
-      r0 = r1
-    else
-      i2, s2 = index, []
-      r3 = _nt_number
-      s2 << r3
-      if r3
-        r4 = _nt_unit
-        s2 << r4
-      end
-      if s2.last
-        r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
-        r2.extend(Argument1)
-        r2.extend(Argument2)
-      else
-        @index = i2
-        r2 = nil
-      end
-      if r2
-        r0 = r2
-      else
-        r5 = _nt_string
-        r5.extend(Argument3)
-        if r5
-          r0 = r5
-        else
-          i6, s6 = index, []
-          s7, i7 = [], index
-          loop do
-            if has_terminal?('\G[a-zA-Z]', true, index)
-              r8 = instantiate_node(SyntaxNode,input, index...(index + 1))
-              @index += 1
-            else
-              r8 = nil
-            end
-            if r8
-              s7 << r8
-            else
-              break
-            end
-          end
-          if s7.empty?
-            @index = i7
-            r7 = nil
-          else
-            r7 = instantiate_node(SyntaxNode,input, i7...index, s7)
-          end
-          s6 << r7
-          if r7
-            if has_terminal?('=', false, index)
-              r9 = instantiate_node(SyntaxNode,input, index...(index + 1))
-              @index += 1
-            else
-              terminal_parse_failure('=')
-              r9 = nil
-            end
-            s6 << r9
-            if r9
-              r10 = _nt_dimension
-              s6 << r10
-            end
-          end
-          if s6.last
-            r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
-            r6.extend(Argument4)
-            r6.extend(Argument5)
-          else
-            @index = i6
-            r6 = nil
-          end
-          if r6
-            r0 = r6
-          else
-            s11, i11 = [], index
-            loop do
-              if has_terminal?('\G[-a-zA-Z0-9_%$/.&=:;#+?]', true, index)
-                r12 = instantiate_node(SyntaxNode,input, index...(index + 1))
-                @index += 1
-              else
-                r12 = nil
-              end
-              if r12
-                s11 << r12
-              else
-                break
-              end
-            end
-            if s11.empty?
-              @index = i11
-              r11 = nil
-            else
-              r11 = instantiate_node(SyntaxNode,input, i11...index, s11)
-              r11.extend(Argument6)
-            end
-            if r11
-              r0 = r11
-            else
-              @index = i0
-              r0 = nil
-            end
-          end
-        end
-      end
-    end
-
-    node_cache[:argument][start_index] = r0
-
-    r0
-  end
-
-  def _nt_s
-    start_index = index
-    if node_cache[:s].has_key?(index)
-      cached = node_cache[:s][index]
-      @index = cached.interval.end if cached
-      return cached
-    end
-
-    s0, i0 = [], index
-    loop do
-      if has_terminal?('\G[ ]', true, index)
-        r1 = instantiate_node(SyntaxNode,input, index...(index + 1))
-        @index += 1
-      else
-        r1 = nil
-      end
-      if r1
-        s0 << r1
-      else
-        break
-      end
-    end
-    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-
-    node_cache[:s][start_index] = r0
-
-    r0
-  end
-
-  def _nt_S
-    start_index = index
-    if node_cache[:S].has_key?(index)
-      cached = node_cache[:S][index]
-      @index = cached.interval.end if cached
-      return cached
-    end
-
-    s0, i0 = [], index
-    loop do
-      if has_terminal?('\G[ ]', true, index)
-        r1 = instantiate_node(SyntaxNode,input, index...(index + 1))
-        @index += 1
-      else
-        r1 = nil
-      end
-      if r1
-        s0 << r1
-      else
-        break
-      end
-    end
-    if s0.empty?
-      @index = i0
-      r0 = nil
-    else
-      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-    end
-
-    node_cache[:S][start_index] = r0
-
-    r0
-  end
-
-  def _nt_ws
-    start_index = index
-    if node_cache[:ws].has_key?(index)
-      cached = node_cache[:ws][index]
-      @index = cached.interval.end if cached
-      return cached
-    end
-
-    s0, i0 = [], index
-    loop do
-      if has_terminal?('\G[\\n ]', true, index)
-        r1 = instantiate_node(SyntaxNode,input, index...(index + 1))
-        @index += 1
-      else
-        r1 = nil
-      end
-      if r1
-        s0 << r1
-      else
-        break
-      end
-    end
-    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-
-    node_cache[:ws][start_index] = r0
-
-    r0
-  end
-
-  def _nt_WS
-    start_index = index
-    if node_cache[:WS].has_key?(index)
-      cached = node_cache[:WS][index]
-      @index = cached.interval.end if cached
-      return cached
-    end
-
-    s0, i0 = [], index
-    loop do
-      if has_terminal?('\G[\\n ]', true, index)
-        r1 = instantiate_node(SyntaxNode,input, index...(index + 1))
-        @index += 1
-      else
-        r1 = nil
-      end
-      if r1
-        s0 << r1
-      else
-        break
-      end
-    end
-    if s0.empty?
-      @index = i0
-      r0 = nil
-    else
-      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-    end
-
-    node_cache[:WS][start_index] = r0
-
-    r0
-  end
-
-  module Ns0
-  end
-
-  def _nt_ns
-    start_index = index
-    if node_cache[:ns].has_key?(index)
-      cached = node_cache[:ns][index]
-      @index = cached.interval.end if cached
-      return cached
-    end
-
-    i0, s0 = index, []
-    i1 = index
-    if has_terminal?('\G[ ;\\n]', true, index)
-      r2 = instantiate_node(SyntaxNode,input, index...(index + 1))
-      @index += 1
-    else
-      r2 = nil
-    end
-    if r2
-      r1 = nil
-    else
-      @index = i1
-      r1 = instantiate_node(SyntaxNode,input, index...index)
-    end
-    s0 << r1
-    if r1
-      if index < input_length
-        r3 = instantiate_node(SyntaxNode,input, index...(index + 1))
-        @index += 1
-      else
-        terminal_parse_failure("any character")
-        r3 = nil
-      end
-      s0 << r3
-    end
-    if s0.last
-      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-      r0.extend(Ns0)
-    else
-      @index = i0
-      r0 = nil
-    end
-
-    node_cache[:ns][start_index] = r0
-
-    r0
-  end
-
-end
-
-class LessParser < Treetop::Runtime::CompiledParser
-  include Less
-end
-