Module: Less

Includes:: Treetop::Runtime

Included in:: LessParser

Defined in:: lib/less.rb,
lib/less/command.rb,
lib/less/engine/parser.rb,
lib/less/engine/nodes/entity.rb,
lib/less/engine/nodes/element.rb,
lib/less/engine/nodes/literal.rb,
lib/less/engine/nodes/function.rb,
lib/less/engine/nodes/property.rb,
lib/less/engine/nodes/selector.rb

Defined Under Namespace

Modules: Accessor0, Accessor1, Argument0, Argument1, Argument2, Argument3, Argument4, Argument5, Arguments0, Arguments1, Attribute0, Attribute1, Class0, ClassId0, ClassId1, Color0, Color1, Color2, Color3, Color4, Comment0, Comment1, Comment2, Comment3, Declaration0, Declaration1, Declaration2, Declaration3, Dimension0, Element0, Element1, Expression0, Font0, Font1, Font2, Fonts0, Fonts1, Fonts2, Function0, Function1, Functions, Hex0, Id0, Ident0, Import0, Import1, Important0, Keyword0, Keyword1, Literal0, Literal1, Literal2, Literal3, Literal4, Medias0, Medias1, Node, Ns0, Number0, Number1, Operator0, Operator1, Operator2, Ruleset0, Ruleset1, Ruleset2, Ruleset3, Select0, Selector0, Selector1, Selectors0, Selectors1, Selectors2, String0, String1, String2, String3, String4, String5, Tag0, Url0, Url1, Variable0, Variable1 Classes: Command

Constant Summary collapse

PARSER =

'lib/less/engine/parser.rb'

GRAMMAR =

'lib/less/engine/less.tt'

MixedUnitsError =

Class.new(Exception)

PathError =

Class.new(Exception)

VariableNameError =

Class.new(NameError)

MixinNameError =

Class.new(NameError)

SyntaxError =

Class.new(RuntimeError)

ImportError =

Class.new(Exception)

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.parse(less) ⇒ `Object`



28
29
30

# File 'lib/less.rb', line 28

def self.parse less
  Engine.new(less).to_css
end

.version ⇒ `Object`



24
25
26

# File 'lib/less.rb', line 24

def self.version
  File.read( File.join( File.dirname(__FILE__), '..', 'VERSION') ).strip
end

Instance Method Details

#_nt_accessor ⇒ `Object`

# File 'lib/less/engine/parser.rb', line 2280

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

#_nt_argument ⇒ `Object`

# File 'lib/less/engine/parser.rb', line 3612

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?('[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
          @index = i0
          r0 = nil
        end
      end
    end
  end

  node_cache[:argument][start_index] = r0

  r0
end

#_nt_arguments ⇒ `Object`

# File 'lib/less/engine/parser.rb', line 3513

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 = index
  i1, s1 = index, []
  r2 = _nt_argument
  s1 << r2
  if r2
    r3 = _nt_s
    s1 << r3
    if r3
      if has_terminal?(',', false, index)
        r4 = instantiate_node(SyntaxNode,input, index...(index + 1))
        @index += 1
      else
        terminal_parse_failure(',')
        r4 = nil
      end
      s1 << r4
      if r4
        r5 = _nt_s
        s1 << r5
        if r5
          r6 = _nt_arguments
          s1 << r6
        end
      end
    end
  end
  if s1.last
    r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
    r1.extend(Arguments0)
    r1.extend(Arguments1)
  else
    @index = i1
    r1 = nil
  end
  if r1
    r0 = r1
  else
    r7 = _nt_argument
    if r7
      r0 = r7
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:arguments][start_index] = r0

  r0
end

#_nt_attribute ⇒ `Object`

# File 'lib/less/engine/parser.rb', line 1880

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, 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?('[a-z]', 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
    if r2
      i5, s5 = index, []
      if has_terminal?('[|~]', true, index)
        r7 = instantiate_node(SyntaxNode,input, index...(index + 1))
        @index += 1
      else
        r7 = nil
      end
      if r7
        r6 = r7
      else
        r6 = instantiate_node(SyntaxNode,input, index...index)
      end
      s5 << r6
      if r6
        if has_terminal?('=', false, index)
          r8 = instantiate_node(SyntaxNode,input, index...(index + 1))
          @index += 1
        else
          terminal_parse_failure('=')
          r8 = nil
        end
        s5 << r8
      end
      if s5.last
        r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
        r5.extend(Attribute0)
      else
        @index = i5
        r5 = nil
      end
      if r5
        r4 = r5
      else
        r4 = instantiate_node(SyntaxNode,input, index...index)
      end
      s0 << r4
      if r4
        i9 = index
        r10 = _nt_tag
        if r10
          r9 = r10
        else
          r11 = _nt_string
          if r11
            r9 = r11
          else
            @index = i9
            r9 = nil
          end
        end
        s0 << r9
        if r9
          if has_terminal?(']', false, index)
            r12 = instantiate_node(SyntaxNode,input, index...(index + 1))
            @index += 1
          else
            terminal_parse_failure(']')
            r12 = nil
          end
          s0 << r12
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(Attribute1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:attribute][start_index] = r0

  r0
end

#_nt_class ⇒ `Object`

# File 'lib/less/engine/parser.rb', line 2000

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?('[_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?('[-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

#_nt_class_id ⇒ `Object`

# File 'lib/less/engine/parser.rb', line 1797

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 = index
  i1, s1 = index, []
  r3 = _nt_tag
  if r3
    r2 = r3
  else
    r2 = instantiate_node(SyntaxNode,input, index...index)
  end
  s1 << r2
  if r2
    s4, i4 = [], index
    loop do
      r5 = _nt_class
      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
    s1 << r4
  end
  if s1.last
    r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
    r1.extend(ClassId0)
  else
    @index = i1
    r1 = nil
  end
  if r1
    r0 = r1
  else
    i6, s6 = index, []
    r8 = _nt_tag
    if r8
      r7 = r8
    else
      r7 = instantiate_node(SyntaxNode,input, index...index)
    end
    s6 << r7
    if r7
      r9 = _nt_id
      s6 << r9
    end
    if s6.last
      r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
      r6.extend(ClassId1)
    else
      @index = i6
      r6 = nil
    end
    if r6
      r0 = r6
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:class_id][start_index] = r0

  r0
end

#_nt_color ⇒ `Object`

# File 'lib/less/engine/parser.rb', line 3208

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_hex
    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
      if has_terminal?('(', false, index)
        r11 = instantiate_node(SyntaxNode,input, index...(index + 1))
        @index += 1
      else
        terminal_parse_failure('(')
        r11 = nil
      end
      s4 << r11
      if r11
        r12 = _nt_arguments
        s4 << r12
        if r12
          if has_terminal?(')', false, index)
            r13 = instantiate_node(SyntaxNode,input, index...(index + 1))
            @index += 1
          else
            terminal_parse_failure(')')
            r13 = nil
          end
          s4 << r13
        end
      end
    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

#_nt_comment ⇒ `Object`

# File 'lib/less/engine/parser.rb', line 134

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

#_nt_declaration ⇒ `Object`

# File 'lib/less/engine/parser.rb', line 1065

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_expression
            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

#_nt_dimension ⇒ `Object`

# File 'lib/less/engine/parser.rb', line 2901

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

#_nt_element ⇒ `Object`

# File 'lib/less/engine/parser.rb', line 1672

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
      @index = i2
      r2 = nil
    end
  end
  s1 << r2
  if r2
    s5, i5 = [], index
    loop do
      r6 = _nt_attribute
      if r6
        s5 << r6
      else
        break
      end
    end
    r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
    s1 << r5
    if r5
      i8, s8 = index, []
      if has_terminal?('(', false, index)
        r9 = instantiate_node(SyntaxNode,input, index...(index + 1))
        @index += 1
      else
        terminal_parse_failure('(')
        r9 = nil
      end
      s8 << r9
      if r9
        r10 = _nt_ident
        s8 << r10
        if r10
          if has_terminal?(')', false, index)
            r11 = instantiate_node(SyntaxNode,input, index...(index + 1))
            @index += 1
          else
            terminal_parse_failure(')')
            r11 = nil
          end
          s8 << r11
        end
      end
      if s8.last
        r8 = instantiate_node(SyntaxNode,input, i8...index, s8)
        r8.extend(Element0)
      else
        @index = i8
        r8 = nil
      end
      if r8
        r7 = r8
      else
        r7 = instantiate_node(SyntaxNode,input, index...index)
      end
      s1 << r7
    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
    if has_terminal?('@media', false, index)
      r12 = instantiate_node(SyntaxNode,input, index...(index + 6))
      @index += 6
    else
      terminal_parse_failure('@media')
      r12 = nil
    end
    if r12
      r0 = r12
    else
      if has_terminal?('@font-face', false, index)
        r13 = instantiate_node(SyntaxNode,input, index...(index + 10))
        @index += 10
      else
        terminal_parse_failure('@font-face')
        r13 = nil
      end
      if r13
        r0 = r13
      else
        @index = i0
        r0 = nil
      end
    end
  end

  node_cache[:element][start_index] = r0

  r0
end

#_nt_empty ⇒ `Object`

# File 'lib/less/engine/parser.rb', line 2604

def _nt_empty
  start_index = index
  if node_cache[:empty].has_key?(index)
    cached = node_cache[:empty][index]
    @index = cached.interval.end if cached
    return cached
  end

  if has_terminal?("", false, index)
    r0 = instantiate_node(Empty,input, index...(index + 0))
    @index += 0
  else
    terminal_parse_failure("")
    r0 = nil
  end

  node_cache[:empty][start_index] = r0

  r0
end

#_nt_entity ⇒ `Object`

# File 'lib/less/engine/parser.rb', line 1307

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

#_nt_expression ⇒ `Object`

# File 'lib/less/engine/parser.rb', line 1251

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_entity
  s1 << r2
  if r2
    i3 = index
    r4 = _nt_operator
    if r4
      r3 = r4
    else
      r5 = _nt_S
      if r5
        r3 = r5
      else
        @index = i3
        r3 = nil
      end
    end
    s1 << r3
    if r3
      r6 = _nt_expression
      s1 << r6
    end
  end
  if s1.last
    r1 = instantiate_node(Builder,input, i1...index, s1)
    r1.extend(Expression0)
  else
    @index = i1
    r1 = nil
  end
  if r1
    r0 = r1
  else
    r7 = _nt_entity
    if r7
      r0 = r7
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:expression][start_index] = r0

  r0
end

#_nt_font ⇒ `Object`

# File 'lib/less/engine/parser.rb', line 1477

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?('[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?('[-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

#_nt_fonts ⇒ `Object`

# File 'lib/less/engine/parser.rb', line 1392

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

#_nt_function ⇒ `Object`

# File 'lib/less/engine/parser.rb', line 3419

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?('[-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
    if has_terminal?('(', false, index)
      r3 = instantiate_node(SyntaxNode,input, index...(index + 1))
      @index += 1
    else
      terminal_parse_failure('(')
      r3 = nil
    end
    s0 << r3
    if r3
      r4 = _nt_arguments
      s0 << 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
        s0 << r5
      end
    end
  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

#_nt_hex ⇒ `Object`

# File 'lib/less/engine/parser.rb', line 3340

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

  i0, s0 = index, []
  if has_terminal?('[a-fA-F0-9]', true, index)
    r1 = instantiate_node(SyntaxNode,input, index...(index + 1))
    @index += 1
  else
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?('[a-fA-F0-9]', 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?('[a-fA-F0-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
      if s3.empty?
        @index = i3
        r3 = nil
      else
        r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
      end
      s0 << r3
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(Hex0)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:hex][start_index] = r0

  r0
end

#_nt_id ⇒ `Object`

# File 'lib/less/engine/parser.rb', line 2060

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?('[_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?('[-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

#_nt_ident ⇒ `Object`

# File 'lib/less/engine/parser.rb', line 1541

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
    s3, i3 = [], index
    loop do
      if has_terminal?('[-a-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
    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(Ident0)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:ident][start_index] = r0

  r0
end

#_nt_import ⇒ `Object`

# File 'lib/less/engine/parser.rb', line 509

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

#_nt_important ⇒ `Object`

# File 'lib/less/engine/parser.rb', line 2582

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

#_nt_keyword ⇒ `Object`

# File 'lib/less/engine/parser.rb', line 2634

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, []
  if has_terminal?('[a-zA-Z]', true, index)
    r1 = instantiate_node(SyntaxNode,input, index...(index + 1))
    @index += 1
  else
    r1 = nil
  end
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      if has_terminal?('[-a-zA-Z]', true, index)
        r3 = instantiate_node(SyntaxNode,input, index...(index + 1))
        @index += 1
      else
        r3 = nil
      end
      if r3
        s2 << r3
      else
        break
      end
    end
    r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    s0 << r2
    if r2
      i4 = index
      r5 = _nt_ns
      if r5
        r4 = nil
      else
        @index = i4
        r4 = instantiate_node(SyntaxNode,input, index...index)
      end
      s0 << r4
    end
  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

#_nt_literal ⇒ `Object`

# File 'lib/less/engine/parser.rb', line 2469

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?('[-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

#_nt_medias ⇒ `Object`

# File 'lib/less/engine/parser.rb', line 694

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?('[-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?('[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

#_nt_ns ⇒ `Object`

# File 'lib/less/engine/parser.rb', line 3803

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?('[ ;]', 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

#_nt_number ⇒ `Object`

# File 'lib/less/engine/parser.rb', line 2935

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?('[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?('[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?('[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

#_nt_operator ⇒ `Object`

# File 'lib/less/engine/parser.rb', line 2379

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?('[-+*/]', 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?('[-+*/]', 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

#_nt_primary ⇒ `Object`

# File 'lib/less/engine/parser.rb', line 8

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

#_nt_ruleset ⇒ `Object`

# File 'lib/less/engine/parser.rb', line 376

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

#_nt_s ⇒ `Object`

# File 'lib/less/engine/parser.rb', line 3708

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?('[ ]', 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

#_nt_S ⇒ `Object`

# File 'lib/less/engine/parser.rb', line 3737

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?('[ ]', 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

#_nt_select ⇒ `Object`

# File 'lib/less/engine/parser.rb', line 2209

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?('[:+>]', 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
    r6 = _nt_S
    if r6
      r1 = r6
    else
      @index = i1
      r1 = nil
    end
  end
  if r1
    r0 = r1
  else
    r0 = instantiate_node(SyntaxNode,input, index...index)
  end

  node_cache[:select][start_index] = r0

  r0
end

#_nt_selector ⇒ `Object`

# File 'lib/less/engine/parser.rb', line 947

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

  s0, i0 = [], index
  loop do
    i1, s1 = index, []
    r2 = _nt_s
    s1 << r2
    if r2
      r3 = _nt_select
      s1 << r3
      if r3
        r4 = _nt_element
        s1 << r4
        if r4
          r5 = _nt_s
          s1 << r5
        end
      end
    end
    if s1.last
      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
      r1.extend(Selector0)
    else
      @index = i1
      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)
    r0.extend(Selector1)
  end

  node_cache[:selector][start_index] = r0

  r0
end

#_nt_selectors ⇒ `Object`

# File 'lib/less/engine/parser.rb', line 840

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

#_nt_string ⇒ `Object`

# File 'lib/less/engine/parser.rb', line 2725

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?('["]', 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?('["]', 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?('["]', 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

#_nt_tag ⇒ `Object`

# File 'lib/less/engine/parser.rb', line 2120

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?('[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?('[-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?('[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

#_nt_unit ⇒ `Object`

# File 'lib/less/engine/parser.rb', line 3076

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

#_nt_url ⇒ `Object`

# File 'lib/less/engine/parser.rb', line 604

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?('[-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

#_nt_variable ⇒ `Object`

# File 'lib/less/engine/parser.rb', line 1608

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?('[-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

#_nt_ws ⇒ `Object`

# File 'lib/less/engine/parser.rb', line 3771

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?('[\\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

#root ⇒ `Object`



4
5
6

# File 'lib/less/engine/parser.rb', line 4

def root
  @root || :primary
end

Module: Less

Defined Under Namespace

Constant Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.parse(less) ⇒ Object

.version ⇒ Object

Instance Method Details

#_nt_accessor ⇒ Object

#_nt_argument ⇒ Object

#_nt_arguments ⇒ Object

#_nt_attribute ⇒ Object

#_nt_class ⇒ Object

#_nt_class_id ⇒ Object

#_nt_color ⇒ Object

#_nt_comment ⇒ Object

#_nt_declaration ⇒ Object

#_nt_dimension ⇒ Object

#_nt_element ⇒ Object

#_nt_empty ⇒ Object

#_nt_entity ⇒ Object

#_nt_expression ⇒ Object

#_nt_font ⇒ Object

#_nt_fonts ⇒ Object

#_nt_function ⇒ Object

#_nt_hex ⇒ Object

#_nt_id ⇒ Object

#_nt_ident ⇒ Object

#_nt_import ⇒ Object

#_nt_important ⇒ Object

#_nt_keyword ⇒ Object

#_nt_literal ⇒ Object

#_nt_medias ⇒ Object

#_nt_ns ⇒ Object

#_nt_number ⇒ Object

#_nt_operator ⇒ Object

#_nt_primary ⇒ Object

#_nt_ruleset ⇒ Object

#_nt_s ⇒ Object

#_nt_S ⇒ Object

#_nt_select ⇒ Object

#_nt_selector ⇒ Object

#_nt_selectors ⇒ Object

#_nt_string ⇒ Object

#_nt_tag ⇒ Object

#_nt_unit ⇒ Object

#_nt_url ⇒ Object

#_nt_variable ⇒ Object

#_nt_ws ⇒ Object

#root ⇒ Object

.parse(less) ⇒ `Object`

.version ⇒ `Object`

#_nt_accessor ⇒ `Object`

#_nt_argument ⇒ `Object`

#_nt_arguments ⇒ `Object`

#_nt_attribute ⇒ `Object`

#_nt_class ⇒ `Object`

#_nt_class_id ⇒ `Object`

#_nt_color ⇒ `Object`

#_nt_comment ⇒ `Object`

#_nt_declaration ⇒ `Object`

#_nt_dimension ⇒ `Object`

#_nt_element ⇒ `Object`

#_nt_empty ⇒ `Object`

#_nt_entity ⇒ `Object`

#_nt_expression ⇒ `Object`

#_nt_font ⇒ `Object`

#_nt_fonts ⇒ `Object`

#_nt_function ⇒ `Object`

#_nt_hex ⇒ `Object`

#_nt_id ⇒ `Object`

#_nt_ident ⇒ `Object`

#_nt_import ⇒ `Object`

#_nt_important ⇒ `Object`

#_nt_keyword ⇒ `Object`

#_nt_literal ⇒ `Object`

#_nt_medias ⇒ `Object`

#_nt_ns ⇒ `Object`

#_nt_number ⇒ `Object`

#_nt_operator ⇒ `Object`

#_nt_primary ⇒ `Object`

#_nt_ruleset ⇒ `Object`

#_nt_s ⇒ `Object`

#_nt_S ⇒ `Object`

#_nt_select ⇒ `Object`

#_nt_selector ⇒ `Object`

#_nt_selectors ⇒ `Object`

#_nt_string ⇒ `Object`

#_nt_tag ⇒ `Object`

#_nt_unit ⇒ `Object`

#_nt_url ⇒ `Object`

#_nt_variable ⇒ `Object`

#_nt_ws ⇒ `Object`

#root ⇒ `Object`