csspool 4.0.0.pre → 4.0.0

data/lib/csspool/css/parser.y

@@ -1,17 +1,24 @@
 class CSSPool::CSS::Parser
 
 token CHARSET_SYM IMPORT_SYM STRING SEMI IDENT S COMMA LBRACE RBRACE STAR HASH
-token LSQUARE RSQUARE EQUAL INCLUDES DASHMATCH RPAREN FUNCTION GREATER PLUS
-token SLASH NUMBER MINUS LENGTH PERCENTAGE EMS EXS ANGLE TIME FREQ URI
-token IMPORTANT_SYM MEDIA_SYM NTH_PSEUDO_CLASS
-token IMPORTANT_SYM MEDIA_SYM DOCUMENT_QUERY_SYM FUNCTION_NO_QUOTE
-token IMPORTANT_SYM MEDIA_SYM
-token NAMESPACE_SYM TILDE
-token NAMESPACE_SYM PREFIXMATCH SUFFIXMATCH SUBSTRINGMATCH
-token NAMESPACE_SYM NOT_PSEUDO_CLASS
-token NAMESPACE_SYM KEYFRAMES_SYM
-token NAMESPACE_SYM MATCHES_PSEUDO_CLASS
-token NAMESPACE_SYM MATH
+token LSQUARE RSQUARE EQUAL INCLUDES DASHMATCH LPAREN RPAREN FUNCTION GREATER PLUS
+token SLASH NUMBER MINUS LENGTH PERCENTAGE ANGLE TIME FREQ URI
+token IMPORTANT_SYM MEDIA_SYM NOT ONLY AND NTH_PSEUDO_CLASS
+token DOCUMENT_QUERY_SYM FUNCTION_NO_QUOTE
+token TILDE
+token PREFIXMATCH SUFFIXMATCH SUBSTRINGMATCH
+token NOT_PSEUDO_CLASS
+token KEYFRAMES_SYM
+token MATCHES_PSEUDO_CLASS
+token NAMESPACE_SYM
+token MOZ_PSEUDO_ELEMENT
+token RESOLUTION
+token COLON
+token SUPPORTS_SYM
+token OR
+token VARIABLE_NAME
+token CALC_SYM
+token FONTFACE_SYM
 
 rule
   document
@@ -33,7 +40,7 @@ rule
     ;
   import
     : IMPORT_SYM import_location medium SEMI {
-        @handler.import_style [val[2]].flatten, val[1]
+        @handler.import_style val[2], val[1]
       }
     | IMPORT_SYM import_location SEMI {
         @handler.import_style [], val[1]
@@ -54,10 +61,46 @@ rule
     ;
   medium
     : medium COMMA IDENT {
-        result = [val.first, Terms::Ident.new(interpret_identifier val.last)]
+        result = val[0] << MediaType.new(val[2])
       }
     | IDENT {
-        result = Terms::Ident.new interpret_identifier val.first
+        result = [MediaType.new(val[0])]
+      }
+    ;
+  media_query_list
+    : media_query                           { result = MediaQueryList.new([ val[0] ]) }
+    | media_query_list COMMA media_query    { result = val[0] << val[2] }
+    |                                       { result = MediaQueryList.new }
+    ;
+  media_query
+    : optional_only_or_not media_type optional_and_exprs   { result = MediaQuery.new(val[0], val[1], val[2]) }
+    | media_expr optional_and_exprs                        { result = MediaQuery.new(nil, val[0], val[1]) }
+    ;
+  optional_only_or_not
+    : ONLY                { result = :only }
+    | NOT                 { result = :not }
+    |                     { result = nil }
+    ;
+  media_type
+    : IDENT               { result = MediaType.new(val[0]) }
+    ;
+  media_expr
+    : LPAREN optional_space IDENT optional_space RPAREN                            { result = MediaType.new(val[2]) }
+    | LPAREN optional_space IDENT optional_space COLON optional_space expr RPAREN  { result = MediaFeature.new(val[2], val[6][0]) }
+    ;
+  optional_space
+    : S                 { result = val[0] }
+    |                   { result = nil }
+    ;
+  optional_and_exprs
+    : optional_and_exprs AND media_expr  { result = val[0] << val[2] }
+    |                                    { result = [] }
+    ;
+  resolution
+    : RESOLUTION {
+        unit = val.first.gsub(/[\s\d.]/, '')
+        number = numeric(val.first)
+        result = Terms::Resolution.new(number, unit)
       }
     ;
   body
@@ -67,28 +110,38 @@ rule
     | ruleset
     | conditional_rule
     | keyframes_rule
+    | fontface_rule
     ;
   conditional_rule
     : media
     | document_query
+    | supports
+    ;
+  body_in_media
+    : body
+    | empty_ruleset
     ;
   media
-    : start_media body RBRACE { @handler.end_media val.first }
+    : start_media body_in_media RBRACE { @handler.end_media val.first }
     ;
   start_media
-    : MEDIA_SYM medium LBRACE {
-        result = [val[1]].flatten
+    : MEDIA_SYM media_query_list LBRACE {
+        result = val[1]
         @handler.start_media result
       }
-    | MEDIA_SYM LBRACE { result = [] }
     ;
   document_query
-    : start_document_query body RBRACE { @handler.end_document_query }
-    | start_document_query RBRACE { @handler.end_document_query }
+    : start_document_query body RBRACE { @handler.end_document_query(before_pos(val), after_pos(val)) }
+    | start_document_query RBRACE { @handler.end_document_query(before_pos(val), after_pos(val)) }
     ;
   start_document_query
-    : DOCUMENT_QUERY_SYM url_match_fns LBRACE {
-        @handler.start_document_query val[1]
+    : start_document_query_pos url_match_fns LBRACE {
+        @handler.start_document_query(val[1], after_pos(val))
+      }
+    ;
+  start_document_query_pos
+    : DOCUMENT_QUERY_SYM {
+        @handler.node_start_pos = before_pos(val)
       }
     ;
   url_match_fns
@@ -104,6 +157,48 @@ rule
     | function
     | uri
     ;
+  supports
+    : start_supports body RBRACE { @handler.end_supports }
+    | start_supports RBRACE { @handler.end_supports }
+    ;
+  start_supports
+    : SUPPORTS_SYM supports_condition_root LBRACE {
+        @handler.start_supports val[1]
+      }
+    ;
+  supports_condition_root
+    : supports_negation { result = val.join('') }
+    | supports_conjunction_or_disjunction { result = val.join('') }
+    | supports_condition_in_parens { result = val.join('') }
+    ;
+  supports_condition
+    : supports_negation { result = val.join('') }
+    | supports_conjunction_or_disjunction { result = val.join('') }
+    | supports_condition_in_parens { result = val.join('') }
+    ;
+  supports_condition_in_parens
+    : LPAREN supports_condition RPAREN { result = val.join('') }
+    | supports_declaration_condition { result = val.join('') }
+    ;
+  supports_negation
+    : NOT supports_condition_in_parens { result = val.join('') }
+    ;
+  supports_conjunction_or_disjunction
+    : supports_conjunction
+    | supports_disjunction
+    ;
+  supports_conjunction
+    : supports_condition_in_parens AND supports_condition_in_parens { result = val.join('') }
+    | supports_conjunction_or_disjunction AND supports_condition_in_parens { result = val.join('') }
+    ;
+  supports_disjunction
+    : supports_condition_in_parens OR supports_condition_in_parens { result = val.join('') }
+    | supports_conjunction_or_disjunction OR supports_condition_in_parens { result = val.join('') }
+    ;
+  supports_declaration_condition
+    : LPAREN declaration_internal RPAREN { result = val.join('') }
+    | LPAREN S declaration_internal RPAREN { result = val.join('') }
+  ;
   keyframes_rule
     : start_keyframes_rule keyframes_blocks RBRACE
     | start_keyframes_rule RBRACE
@@ -136,6 +231,15 @@ rule
     : IDENT
     | PERCENTAGE { result = val[0].strip }
     ;
+  fontface_rule
+    : start_fontface_rule declarations RBRACE { @handler.end_fontface_rule }
+    | start_fontface_rule RBRACE { @handler.end_fontface_rule }
+    ;
+  start_fontface_rule
+    : FONTFACE_SYM LBRACE {
+        @handler.start_fontface_rule
+      }
+    ;
   ruleset
     : start_selector declarations RBRACE {
         @handler.end_selector val.first
@@ -144,6 +248,12 @@ rule
         @handler.end_selector val.first
       }
     ;
+  empty_ruleset
+    : optional_space {
+        start = @handler.start_selector([])
+        @handler.end_selector(start)
+      }
+    ;
   start_selector
     : S start_selector { result = val.last }
     | selectors LBRACE {
@@ -153,9 +263,8 @@ rule
   selectors
     : selector COMMA selectors
       {
-        # FIXME: should always garantee array
         sel = Selector.new(val.first, {})
-        result = [sel, val[2]].flatten
+        result = [sel].concat(val[2])
       }
     | selector
       {
@@ -165,7 +274,7 @@ rule
   selector
     : simple_selector combinator selector
       {
-        val = val.flatten
+        val.flatten!
         val[2].combinator = val.delete_at 1
         result = val
       }
@@ -334,44 +443,62 @@ rule
       }
     ;
   pseudo
-    : ':' IDENT {
+    : COLON IDENT {
         result = Selectors::pseudo interpret_identifier(val[1])
       }
-    | ':' ':' IDENT {
+    | COLON COLON IDENT {
         result = Selectors::PseudoElement.new(
           interpret_identifier(val[2])
         )
       }
-    | ':' FUNCTION RPAREN {
+    | COLON FUNCTION RPAREN {
         result = Selectors::PseudoClass.new(
           interpret_identifier(val[1].sub(/\($/, '')),
           ''
         )
       }
-    | ':' FUNCTION IDENT RPAREN {
+    | COLON FUNCTION IDENT RPAREN {
         result = Selectors::PseudoClass.new(
           interpret_identifier(val[1].sub(/\($/, '')),
           interpret_identifier(val[2])
         )
       }
-    | ':' NOT_PSEUDO_CLASS simple_selector RPAREN {
+    | COLON NOT_PSEUDO_CLASS simple_selector RPAREN {
         result = Selectors::PseudoClass.new(
           'not',
           val[2].first.to_s
         )
       }
-    | ':' NTH_PSEUDO_CLASS {
+    | COLON NTH_PSEUDO_CLASS {
         result = Selectors::PseudoClass.new(
           interpret_identifier(val[1].sub(/\(.*/, '')),
           interpret_identifier(val[1].sub(/.*\(/, '').sub(/\).*/, ''))
         )
       }
-    | ':' MATCHES_PSEUDO_CLASS simple_selectors RPAREN {
+    | COLON MATCHES_PSEUDO_CLASS simple_selectors RPAREN {
         result = Selectors::PseudoClass.new(
           val[1].split('(').first.strip,
           val[2].join(', ')
         )
       }
+    | COLON MOZ_PSEUDO_ELEMENT any_number_of_idents RPAREN {
+        result = Selectors::PseudoElement.new(
+          interpret_identifier(val[1].sub(/\($/, ''))
+        )
+      }
+    | COLON COLON MOZ_PSEUDO_ELEMENT any_number_of_idents RPAREN {
+        result = Selectors::PseudoElement.new(
+          interpret_identifier(val[2].sub(/\($/, ''))
+        )
+      }
+    ;
+  any_number_of_idents
+    :
+    | multiple_idents
+    ;
+  multiple_idents
+    : IDENT
+    | IDENT COMMA multiple_idents
     ;
   # declarations can be separated by one *or more* semicolons. semi-colons at the start or end of a ruleset are also allowed
   one_or_more_semis
@@ -386,14 +513,17 @@ rule
     | one_or_more_semis
     ;
   declaration
-    : property ':' expr prio
-      { @handler.property val.first, val[2], val[3] }
-    | property ':' S expr prio
-      { @handler.property val.first, val[3], val[4] }
-    | property S ':' expr prio
-      { @handler.property val.first, val[3], val[4] }
-    | property S ':' S expr prio
-      { @handler.property val.first, val[4], val[5] }
+    : declaration_internal { @handler.property val.first }
+    ;
+  declaration_internal
+    : property COLON expr prio
+      { result = Declaration.new(val.first, val[2], val[3]) }
+    | property COLON S expr prio
+      { result = Declaration.new(val.first, val[3], val[4]) }
+    | property S COLON expr prio
+      { result = Declaration.new(val.first, val[3], val[4]) }
+    | property S COLON S expr prio
+      { result = Declaration.new(val.first, val[4], val[5]) }
     ;
   prio
     : IMPORTANT_SYM { result = true }
@@ -402,6 +532,7 @@ rule
   property
     : IDENT { result = interpret_identifier val[0] }
     | STAR IDENT { result = interpret_identifier val.join }
+    | VARIABLE_NAME { result = interpret_identifier val[0] }
     ;
   operator
     : COMMA
@@ -422,8 +553,10 @@ rule
     | string
     | uri
     | hexcolor
-    | math
+    | calc
     | function
+    | resolution
+    | VARIABLE_NAME
     ;
   function
     : function S { result = val.first }
@@ -435,6 +568,10 @@ rule
           result = Terms::Function.new name, val[1]
         end
       }
+    | FUNCTION RPAREN {
+        name = interpret_identifier val.first.sub(/\($/, '')
+        result = Terms::Function.new name
+      }
     ;
   function_no_quote
     : function_no_quote S { result = val.first }
@@ -444,14 +581,27 @@ rule
         result = Terms::Function.new(name, [Terms::String.new(interpret_string_no_quote(parts.last))])
       }
     ;
-  math
-    : MATH {
-        parts = val.first.split('(', 2)
-        name = parts[0].strip
-        expression = parts[1][0..parts[1].rindex(')')-1].strip
-        result = Terms::Math.new(name, expression)
+  calc
+    : CALC_SYM calc_sum RPAREN optional_space {
+       result = Terms::Math.new(val.first.split('(').first, val[1])
       }
     ;
+  # plus and minus are supposed to have whitespace around them, per http://dev.w3.org/csswg/css-values/#calc-syntax, but the numbers are eating trailing whitespace, so we inject it back in
+  calc_sum
+    : calc_product
+    | calc_product PLUS calc_sum { val.insert(1, ' '); result = val.join('') }
+    | calc_product MINUS calc_sum { val.insert(1, ' '); result = val.join('') }
+    ;
+  calc_product
+    : calc_value
+    | calc_value STAR calc_value { result = val.join('') }
+    | calc_value SLASH calc_value { result = val.join('') }
+    ;
+  calc_value
+    : numeric { result = val.join('') }
+    | function { result = val.join('') } # for var() variable references
+    | LPAREN calc_sum RPAREN { result = val.join('') }
+    ;
   hexcolor
     : hexcolor S { result = val.first }
     | HASH { result = Terms::Hash.new val.first.sub(/^#/, '') }
@@ -479,12 +629,6 @@ rule
         unit    = val.first.gsub(/[\s\d.]/, '')
         result = Terms::Number.new numeric(val.first), nil, unit
       }
-    | EMS {
-        result = Terms::Number.new numeric(val.first), nil, 'em'
-      }
-    | EXS {
-        result = Terms::Number.new numeric(val.first), nil, 'ex'
-      }
     | ANGLE {
         unit    = val.first.gsub(/[\s\d.]/, '')
         result = Terms::Number.new numeric(val.first), nil, unit
@@ -548,3 +692,29 @@ def interpret_escapes s
     end
   end.join ''
 end
+
+# override racc's on_error so we can have context in our error messages
+def on_error(t, val, vstack)
+  errcontext = (@ss.pre_match[-10..-1] || @ss.pre_match) +
+                @ss.matched + @ss.post_match[0..9]
+  line_number = @ss.pre_match.lines.count
+  raise ParseError, sprintf("parse error on value %s (%s) " +
+                            "on line %s around \"%s\"",
+                            val.inspect, token_to_str(t) || '?',
+                            line_number, errcontext)
+end
+
+def before_pos(val)
+  # don't include leading whitespace
+  return current_pos - val.last.length + val.last[/\A\s*/].size
+end
+
+def after_pos(val)
+  # don't include trailing whitespace
+  return current_pos - val.last[/\s*\z/].size
+end
+
+# charpos will work with multibyte strings but is not available until ruby 2
+def current_pos
+  @ss.respond_to?('charpos') ? @ss.charpos : @ss.pos
+end

data/lib/csspool/css/rule_set.rb

@@ -3,15 +3,16 @@ module CSSPool
     class RuleSet < CSSPool::Node
       attr_accessor :selectors
       attr_accessor :declarations
-      attr_accessor :media
+      attr_accessor :parent_rule
 
-      def initialize selectors, declarations = [], media = []
+      def initialize selectors, declarations = [], parent_rule = nil
         @selectors    = selectors
         @declarations = declarations
-        @media        = media
+        @parent_rule  = parent_rule
 
         selectors.each { |sel| sel.rule_set = self }
       end
+
     end
   end
 end

data/lib/csspool/css/supports_rule.rb

@@ -0,0 +1,14 @@
+# Represents an @supports conditional rule
+module CSSPool
+  module CSS
+    class SupportsRule < CSSPool::Node
+      attr_accessor :conditions
+      attr_accessor :rule_sets
+
+      def initialize conditions
+        @conditions = conditions
+        @rule_sets = []
+      end
+    end
+  end
+end

data/lib/csspool/css/tokenizer.rb

@@ -70,7 +70,7 @@ class Tokenizer < Parser
       when (text = @ss.scan(/[\s]*\/\*(.|[\s]*)*?\*\/[\s]*/i))
          action { next_token }
 
-      when (text = @ss.scan(/not\(\s*/i))
+      when (text = @ss.scan(/not\([\s]*/i))
          action { [:NOT_PSEUDO_CLASS, st(text)] }
 
       when (text = @ss.scan(/(nth\-child|nth\-last\-child|nth\-of\-type|nth\-last\-of\-type)\([\s]*([\+\-]?[0-9]*n([\s]*[\+\-][\s]*[0-9]+)?|[\+\-]?[0-9]+|odd|even)[\s]*\)/i))
@@ -85,10 +85,19 @@ class Tokenizer < Parser
       when (text = @ss.scan(/(domain|url\-prefix)\([\s]*([!#\$%&*-~]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f])*[\s]*\)/i))
          action { [:FUNCTION_NO_QUOTE, st(text)] }
 
-      when (text = @ss.scan(/[\s]*(\-[A-Za-z]+\-)?calc\([\s]*(([0-9]*\.[0-9]+|[0-9]+)|([0-9]*\.[0-9]+|[0-9]+)(px|cm|mm|in|pt|pc)|([0-9]*\.[0-9]+|[0-9]+)%|([0-9]*\.[0-9]+|[0-9]+)em|([0-9]*\.[0-9]+|[0-9]+)ex)([\s]*(\*[\s]*(([0-9]*\.[0-9]+|[0-9]+)|([0-9]*\.[0-9]+|[0-9]+)(px|cm|mm|in|pt|pc)|([0-9]*\.[0-9]+|[0-9]+)%|([0-9]*\.[0-9]+|[0-9]+)em|([0-9]*\.[0-9]+|[0-9]+)ex)|\/[\s]*([0-9]*\.[0-9]+|[0-9]+)))*([\s]+[\+\-][\s]+(([0-9]*\.[0-9]+|[0-9]+)|([0-9]*\.[0-9]+|[0-9]+)(px|cm|mm|in|pt|pc)|([0-9]*\.[0-9]+|[0-9]+)%|([0-9]*\.[0-9]+|[0-9]+)em|([0-9]*\.[0-9]+|[0-9]+)ex)([\s]*(\*[\s]*(([0-9]*\.[0-9]+|[0-9]+)|([0-9]*\.[0-9]+|[0-9]+)(px|cm|mm|in|pt|pc)|([0-9]*\.[0-9]+|[0-9]+)%|([0-9]*\.[0-9]+|[0-9]+)em|([0-9]*\.[0-9]+|[0-9]+)ex)|\/[\s]*([0-9]*\.[0-9]+|[0-9]+)))*)*[\s]*\)[\s]*[\s]*/i))
-         action { [:MATH, st(text)] }
+      when (text = @ss.scan(/(\-moz\-non\-element|\-moz\-anonymous\-block|\-moz\-anonymous\-positioned\-block|\-moz\-mathml\-anonymous\-block|\-moz\-xul\-anonymous\-block|\-moz\-hframeset\-border|\-moz\-vframeset\-border|\-moz\-line\-frame|\-moz\-button\-content|\-moz\-buttonlabel|\-moz\-cell\-content|\-moz\-dropdown\-list|\-moz\-fieldset\-content|\-moz\-frameset\-blank|\-moz\-display\-comboboxcontrol\-frame|\-moz\-html\-canvas\-content|\-moz\-inline\-table|\-moz\-table|\-moz\-table\-cell|\-moz\-table\-column\-group|\-moz\-table\-column|\-moz\-table\-outer|\-moz\-table\-row\-group|\-moz\-table\-row|\-moz\-canvas|\-moz\-pagebreak|\-moz\-page|\-moz\-pagecontent|\-moz\-page\-sequence|\-moz\-scrolled\-content|\-moz\-scrolled\-canvas|\-moz\-scrolled\-page\-sequence|\-moz\-column\-content|\-moz\-viewport|\-moz\-viewport\-scroll|\-moz\-anonymous\-flex\-item|\-moz\-tree\-column|\-moz\-tree\-row|\-moz\-tree\-separator|\-moz\-tree\-cell|\-moz\-tree\-indentation|\-moz\-tree\-line|\-moz\-tree\-twisty|\-moz\-tree\-image|\-moz\-tree\-cell\-text|\-moz\-tree\-checkbox|\-moz\-tree\-progressmeter|\-moz\-tree\-drop\-feedback|\-moz\-svg\-outer\-svg\-anon\-child|\-moz\-svg\-foreign\-content|\-moz\-svg\-text)\(/i))
+         action { [:MOZ_PSEUDO_ELEMENT, st(text)] }
 
-      when (text = @ss.scan(/[-@]?([_A-Za-z]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f])([_A-Za-z0-9-]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f]|[.])*\(\s*/i))
+      when (text = @ss.scan(/[\s]*@media[\s]*/i))
+         action { @state = :LOGICQUERY; [:MEDIA_SYM, st(text)] }
+
+      when (text = @ss.scan(/[\s]*@supports[\s]*/i))
+         action { @state = :LOGICQUERY; [:SUPPORTS_SYM, st(text)] }
+
+      when (text = @ss.scan(/calc\(\s*/i))
+         action { [:CALC_SYM, st(text)] }
+
+      when (text = @ss.scan(/\-?([_A-Za-z]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f])([_A-Za-z0-9-]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f])*\(\s*/i))
          action { [:FUNCTION, st(text)] }
 
       when (text = @ss.scan(/[\s]*@import[\s]*/i))
@@ -100,22 +109,25 @@ class Tokenizer < Parser
       when (text = @ss.scan(/[\s]*@charset[\s]*/i))
          action { [:CHARSET_SYM, st(text)] }
 
-      when (text = @ss.scan(/[\s]*@media[\s]*/i))
-         action { [:MEDIA_SYM, st(text)] }
-
       when (text = @ss.scan(/[\s]*@(\-[A-Za-z]+\-)?document[\s]*/i))
          action { [:DOCUMENT_QUERY_SYM, st(text)] }
 
       when (text = @ss.scan(/[\s]*@namespace[\s]*/i))
          action { [:NAMESPACE_SYM, st(text)] }
 
+      when (text = @ss.scan(/[\s]*@font\-face[\s]*/i))
+         action { [:FONTFACE_SYM, st(text)] }
+
       when (text = @ss.scan(/[\s]*@(\-[A-Za-z]+\-)?keyframes[\s]*/i))
          action { [:KEYFRAMES_SYM, st(text)] }
 
       when (text = @ss.scan(/[\s]*!([\s]*|[\s]*\/\*(.|[\s]*)*?\*\/[\s]*)important[\s]*/i))
          action { [:IMPORTANT_SYM, st(text)] }
 
-      when (text = @ss.scan(/[-@]?([_A-Za-z]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f])([_A-Za-z0-9-]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f])*/i))
+      when (text = @ss.scan(/\-\-([_A-Za-z0-9-]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f])+/i))
+         action { [:VARIABLE_NAME, st(text)] }
+
+      when (text = @ss.scan(/\-?([_A-Za-z]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f])([_A-Za-z0-9-]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f])*/i))
          action { [:IDENT, st(text)] }
 
       when (text = @ss.scan(/\#([_A-Za-z0-9-]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f])+/i))
@@ -145,6 +157,9 @@ class Tokenizer < Parser
       when (text = @ss.scan(/[\s]*\)/i))
          action { [:RPAREN, st(text)] }
 
+      when (text = @ss.scan(/[\s]*\(/i))
+         action { [:LPAREN, st(text)] }
+
       when (text = @ss.scan(/\[[\s]*/i))
          action { [:LSQUARE, st(text)] }
 
@@ -169,19 +184,16 @@ class Tokenizer < Parser
       when (text = @ss.scan(/[\s]*;[\s]*/i))
          action { [:SEMI, st(';')] }
 
+      when (text = @ss.scan(/\:/i))
+         action { [:COLON, st(text)] }
+
       when (text = @ss.scan(/\*/i))
          action { [:STAR, st(text)] }
 
       when (text = @ss.scan(/[\s]*~[\s]*/i))
          action { [:TILDE, st(text)] }
 
-      when (text = @ss.scan(/[\s]*([0-9]*\.[0-9]+|[0-9]+)em[\s]*/i))
-         action { [:EMS, st(text)] }
-
-      when (text = @ss.scan(/[\s]*([0-9]*\.[0-9]+|[0-9]+)ex[\s]*/i))
-         action { [:EXS, st(text)] }
-
-      when (text = @ss.scan(/[\s]*([0-9]*\.[0-9]+|[0-9]+)(px|cm|mm|in|pt|pc)[\s]*/i))
+      when (text = @ss.scan(/[\s]*([0-9]*\.[0-9]+|[0-9]+)(px|cm|mm|in|pt|pc|mozmm|em|ex|ch|rem|vh|vw|vmin|vmax)[\s]*/i))
          action { [:LENGTH, st(text)] }
 
       when (text = @ss.scan(/[\s]*([0-9]*\.[0-9]+|[0-9]+)(deg|rad|grad)[\s]*/i))
@@ -211,7 +223,7 @@ class Tokenizer < Parser
       when (text = @ss.scan(/-->/i))
          action { [:CDC, st(text)] }
 
-      when (text = @ss.scan(/[\s]*\-(?![-@]?([_A-Za-z]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f])([_A-Za-z0-9-]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f])*)[\s]*/i))
+      when (text = @ss.scan(/[\s]*\-(?!\-?([_A-Za-z]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f])([_A-Za-z0-9-]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f])*)[\s]*/i))
          action { [:MINUS, st(text)] }
 
       when (text = @ss.scan(/[\s]*\+[\s]*/i))
@@ -234,6 +246,70 @@ class Tokenizer < Parser
         raise  ScanError, "can not match: '" + text + "'"
       end  # if
 
+    when :LOGICQUERY
+      case
+      when (text = @ss.scan(/url\([\s]*("([^\n\r\f\\"]|\\(\n|\r\n|\r|\f)|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f])*"|'([^\n\r\f\\']|\\(\n|\r\n|\r|\f)|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f])*')[\s]*\)/i))
+         action { [:URI, st(text)] }
+
+      when (text = @ss.scan(/url\([\s]*([!#\$%&*-~]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f])*[\s]*\)/i))
+         action { [:URI, st(text)] }
+
+      when (text = @ss.scan(/\-?([_A-Za-z]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f])([_A-Za-z0-9-]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f])*\(\s*/i))
+         action { [:FUNCTION, st(text)] }
+
+      when (text = @ss.scan(/[\s]*(and|only|not|or)[\s]+/i))
+         action { [text.upcase.strip.intern, st(text)] }
+
+      when (text = @ss.scan(/[\s]*([0-9]*\.[0-9]+|[0-9]+)(dpi|dpcm)/i))
+         action { [:RESOLUTION, st(text)]}
+
+      when (text = @ss.scan(/[\s]*([0-9]*\.[0-9]+|[0-9]+)(px|cm|mm|in|pt|pc|mozmm|em|ex|ch|rem|vh|vw|vmin|vmax)[\s]*/i))
+         action { [:LENGTH, st(text)] }
+
+      when (text = @ss.scan(/[\s]*([0-9]*\.[0-9]+|[0-9]+)(deg|rad|grad)[\s]*/i))
+         action { [:ANGLE, st(text)] }
+
+      when (text = @ss.scan(/[\s]*([0-9]*\.[0-9]+|[0-9]+)(ms|s)[\s]*/i))
+         action { [:TIME, st(text)] }
+
+      when (text = @ss.scan(/[\s]*([0-9]*\.[0-9]+|[0-9]+)[k]?hz[\s]*/i))
+         action { [:FREQ, st(text)] }
+
+      when (text = @ss.scan(/[\s]*([0-9]*\.[0-9]+|[0-9]+)%[\s]*/i))
+         action { [:PERCENTAGE, st(text)] }
+
+      when (text = @ss.scan(/[\s]*([0-9]*\.[0-9]+|[0-9]+)[\s]*/i))
+         action { [:NUMBER, st(text)] }
+
+      when (text = @ss.scan(/\-?([_A-Za-z]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f])([_A-Za-z0-9-]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f])*/i))
+         action { [:IDENT, st(text)] }
+
+      when (text = @ss.scan(/[\s]*,[\s]*/i))
+         action { [:COMMA, st(',')] }
+
+      when (text = @ss.scan(/[\s]*\)/i))
+         action { [:RPAREN, st(text)] }
+
+      when (text = @ss.scan(/[\s]*\(/i))
+         action { [:LPAREN, st(text)] }
+
+      when (text = @ss.scan(/\:/i))
+         action { [:COLON, st(text)] }
+
+      when (text = @ss.scan(/[\s]*!([\s]*|[\s]*\/\*(.|[\s]*)*?\*\/[\s]*)important[\s]*/i))
+         action { [:IMPORTANT_SYM, st(text)] }
+
+      when (text = @ss.scan(/[\s]*\{[\s]*/i))
+         action { @state = nil; [:LBRACE, st(text)] }
+
+      when (text = @ss.scan(/[\s]+/i))
+         action { [:S, st(text)] }
+
+      else
+        text = @ss.string[@ss.pos .. -1]
+        raise  ScanError, "can not match: '" + text + "'"
+      end  # if
+
     else
       raise  ScanError, "undefined state: '" + state.to_s + "'"
     end  # case state