oreorenasass 3.4.4 → 3.4.5

data/lib/sass/scss/rx.rb

@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 module Sass
   module SCSS
     # A module containing regular expressions used
@@ -23,7 +22,7 @@ module Sass
           out << escape_char(value.slice!(0...1))
         end
         out << value.gsub(/[^a-zA-Z0-9_-]/) {|c| escape_char c}
-        out
+        return out
       end
 
       # Escapes a single character for a CSS identifier.
@@ -33,7 +32,7 @@ module Sass
       # @private
       def self.escape_char(c)
         return "\\%06x" % Sass::Util.ord(c) unless c =~ /[ -\/:-~]/
-        "\\#{c}"
+        return "\\#{c}"
       end
 
       # Creates a Regexp from a plain text string,
@@ -64,9 +63,9 @@ module Sass
       STRING1  = /\"((?:[^\n\r\f\\"]|\\#{NL}|#{ESCAPE})*)\"/
       STRING2  = /\'((?:[^\n\r\f\\']|\\#{NL}|#{ESCAPE})*)\'/
 
-      IDENT    = /-*#{NMSTART}#{NMCHAR}*/
+      IDENT    = /-?#{NMSTART}#{NMCHAR}*/
       NAME     = /#{NMCHAR}+/
-      NUM      = //
+      NUM      = /[0-9]+|[0-9]*\.[0-9]+/
       STRING   = /#{STRING1}|#{STRING2}/
       URLCHAR  = /[#%&*-~]|#{NONASCII}|#{ESCAPE}/
       URL      = /(#{URLCHAR}*)/
@@ -81,8 +80,8 @@ module Sass
 
       S = /[ \t\r\n\f]+/
 
-      COMMENT = %r{/\*([^*]|\*+[^/*])*\**\*/}
-      SINGLE_LINE_COMMENT = %r{//.*(\n[ \t]*//.*)*}
+      COMMENT = /\/\*[^*]*\*+(?:[^\/][^*]*\*+)*\//
+      SINGLE_LINE_COMMENT = /\/\/.*(\n[ \t]*\/\/.*)*/
 
       CDO            = quote("<!--")
       CDC            = quote("-->")
@@ -95,10 +94,9 @@ module Sass
       HASH = /##{NAME}/
 
       IMPORTANT = /!#{W}important/i
+      DEFAULT = /!#{W}default/i
 
-      UNITLESS_NUMBER = /(?:[0-9]+|[0-9]*\.[0-9]+)(?:[eE][+-]?\d+)?/
-      NUMBER = /#{UNITLESS_NUMBER}(?:#{IDENT}|%)?/
-      PERCENTAGE = /#{UNITLESS_NUMBER}%/
+      NUMBER = /#{NUM}(?:#{IDENT}|%)?/
 
       URI = /url\(#{W}(?:#{STRING}|#{URL})#{W}\)/i
       FUNCTION = /#{IDENT}\(/
@@ -121,21 +119,15 @@ module Sass
       INTERP_START = /#\{/
       ANY = /:(-[-\w]+-)?any\(/i
       OPTIONAL = /!#{W}optional/i
-      IDENT_START = /-|#{NMSTART}/
-
-      # A unit is like an IDENT, but disallows a hyphen followed by a digit.
-      # This allows "1px-2px" to be interpreted as subtraction rather than "1"
-      # with the unit "px-2px". It also allows "%".
-      UNIT = /-?#{NMSTART}(?:[a-zA-Z0-9_]|#{NONASCII}|#{ESCAPE}|-(?!\d))*|%/
 
       IDENT_HYPHEN_INTERP = /-(#\{)/
-      STRING1_NOINTERP = /\"((?:[^\n\r\f\\"#]|#(?!\{)|#{ESCAPE})*)\"/
-      STRING2_NOINTERP = /\'((?:[^\n\r\f\\'#]|#(?!\{)|#{ESCAPE})*)\'/
+      STRING1_NOINTERP = /\"((?:[^\n\r\f\\"#]|#(?!\{)|\\#{NL}|#{ESCAPE})*)\"/
+      STRING2_NOINTERP = /\'((?:[^\n\r\f\\'#]|#(?!\{)|\\#{NL}|#{ESCAPE})*)\'/
       STRING_NOINTERP = /#{STRING1_NOINTERP}|#{STRING2_NOINTERP}/
 
       STATIC_COMPONENT = /#{IDENT}|#{STRING_NOINTERP}|#{HEXCOLOR}|[+-]?#{NUMBER}|\!important/i
       STATIC_VALUE = /#{STATIC_COMPONENT}(\s*[\s,\/]\s*#{STATIC_COMPONENT})*([;}])/i
-      STATIC_SELECTOR = /(#{NMCHAR}|[ \t]|[,>+*]|[:#.]#{NMSTART}){1,50}([{])/i
+      STATIC_SELECTOR = /(#{NMCHAR}|[ \t]|[,>+*]|[:#.]#{NMSTART}){0,50}([{])/i
     end
   end
 end

data/lib/sass/scss/static_parser.rb

@@ -24,343 +24,29 @@ module Sass
         seq
       end
 
-      # Parses a static at-root query.
-      #
-      # @return [(Symbol, Array<String>)] The type of the query
-      #   (`:with` or `:without`) and the values that are being filtered.
-      # @raise [Sass::SyntaxError] if there's a syntax error in the query,
-      #   or if it doesn't take up the entire input string.
-      def parse_static_at_root_query
-        init_scanner!
-        tok!(/\(/); ss
-        type = tok!(/\b(without|with)\b/).to_sym; ss
-        tok!(/:/); ss
-        directives = expr!(:at_root_directive_list); ss
-        tok!(/\)/)
-        expected("@at-root query list") unless @scanner.eos?
-        return type, directives
-      end
-
-      def parse_keyframes_selector
-        init_scanner!
-        sel = expr!(:keyframes_selector)
-        expected("keyframes selector") unless @scanner.eos?
-        sel
-      end
-
-      # @see Parser#initialize
-      # @param allow_parent_ref [Boolean] Whether to allow the
-      #   parent-reference selector, `&`, when parsing the document.
-      # @comment
-      #   rubocop:disable ParameterLists
-      def initialize(str, filename, importer, line = 1, offset = 1, allow_parent_ref = true)
-        # rubocop:enable ParameterLists
-        super(str, filename, importer, line, offset)
-        @allow_parent_ref = allow_parent_ref
-      end
-
       private
 
       def moz_document_function
-        val = tok(URI) || tok(URL_PREFIX) || tok(DOMAIN) || function(!:allow_var)
-        return unless val
+        return unless val = tok(URI) || tok(URL_PREFIX) || tok(DOMAIN) ||
+          function(!:allow_var)
         ss
         [val]
       end
 
       def variable; nil; end
       def script_value; nil; end
-      def interpolation(warn_for_color = false); nil; end
+      def interpolation; nil; end
       def var_expr; nil; end
-      def interp_string; (s = tok(STRING)) && [s]; end
-      def interp_uri; (s = tok(URI)) && [s]; end
-      def interp_ident(ident = IDENT); (s = tok(ident)) && [s]; end
+      def interp_string; s = tok(STRING) and [s]; end
+      def interp_uri; s = tok(URI) and [s]; end
+      def interp_ident(ident = IDENT); s = tok(ident) and [s]; end
       def use_css_import?; true; end
 
-      def special_directive(name, start_pos)
+      def special_directive(name)
         return unless %w[media import charset -moz-document].include?(name)
         super
       end
 
-      def selector_comma_sequence
-        sel = selector
-        return unless sel
-        selectors = [sel]
-        ws = ''
-        while tok(/,/)
-          ws << str {ss}
-          if (sel = selector)
-            selectors << sel
-            if ws.include?("\n")
-              selectors[-1] = Selector::Sequence.new(["\n"] + selectors.last.members)
-            end
-            ws = ''
-          end
-        end
-        Selector::CommaSequence.new(selectors)
-      end
-
-      def selector_string
-        sel = selector
-        return unless sel
-        sel.to_s
-      end
-
-      def selector
-        start_pos = source_position
-        # The combinator here allows the "> E" hack
-        val = combinator || simple_selector_sequence
-        return unless val
-        nl = str {ss}.include?("\n")
-        res = []
-        res << val
-        res << "\n" if nl
-
-        while (val = combinator || simple_selector_sequence)
-          res << val
-          res << "\n" if str {ss}.include?("\n")
-        end
-        seq = Selector::Sequence.new(res.compact)
-
-        if seq.members.any? {|sseq| sseq.is_a?(Selector::SimpleSequence) && sseq.subject?}
-          location = " of #{@filename}" if @filename
-          Sass::Util.sass_warn <<MESSAGE
-DEPRECATION WARNING on line #{start_pos.line}, column #{start_pos.offset}#{location}:
-The subject selector operator "!" is deprecated and will be removed in a future release.
-This operator has been replaced by ":has()" in the CSS spec.
-For example: #{seq.subjectless}
-MESSAGE
-        end
-
-        seq
-      end
-
-      def combinator
-        tok(PLUS) || tok(GREATER) || tok(TILDE) || reference_combinator
-      end
-
-      def reference_combinator
-        return unless tok(/\//)
-        res = '/'
-        ns, name = expr!(:qualified_name)
-        res << ns << '|' if ns
-        res << name << tok!(/\//)
-        res
-      end
-
-      def simple_selector_sequence
-        start_pos = source_position
-        e = element_name || id_selector || class_selector || placeholder_selector || attrib ||
-            pseudo || parent_selector
-        return unless e
-        res = [e]
-
-        # The tok(/\*/) allows the "E*" hack
-        while (v = id_selector || class_selector || placeholder_selector ||
-                   attrib || pseudo || (tok(/\*/) && Selector::Universal.new(nil)))
-          res << v
-        end
-
-        pos = @scanner.pos
-        line = @line
-        if (sel = str? {simple_selector_sequence})
-          @scanner.pos = pos
-          @line = line
-          begin
-            # If we see "*E", don't force a throw because this could be the
-            # "*prop: val" hack.
-            expected('"{"') if res.length == 1 && res[0].is_a?(Selector::Universal)
-            throw_error {expected('"{"')}
-          rescue Sass::SyntaxError => e
-            e.message << "\n\n\"#{sel}\" may only be used at the beginning of a compound selector."
-            raise e
-          end
-        end
-
-        Selector::SimpleSequence.new(res, tok(/!/), range(start_pos))
-      end
-
-      def parent_selector
-        return unless @allow_parent_ref && tok(/&/)
-        Selector::Parent.new(tok(NAME))
-      end
-
-      def class_selector
-        return unless tok(/\./)
-        @expected = "class name"
-        Selector::Class.new(tok!(IDENT))
-      end
-
-      def id_selector
-        return unless tok(/#(?!\{)/)
-        @expected = "id name"
-        Selector::Id.new(tok!(NAME))
-      end
-
-      def placeholder_selector
-        return unless tok(/%/)
-        @expected = "placeholder name"
-        Selector::Placeholder.new(tok!(IDENT))
-      end
-
-      def element_name
-        ns, name = Sass::Util.destructure(qualified_name(:allow_star_name))
-        return unless ns || name
-
-        if name == '*'
-          Selector::Universal.new(ns)
-        else
-          Selector::Element.new(name, ns)
-        end
-      end
-
-      def qualified_name(allow_star_name = false)
-        name = tok(IDENT) || tok(/\*/) || (tok?(/\|/) && "")
-        return unless name
-        return nil, name unless tok(/\|/)
-
-        return name, tok!(IDENT) unless allow_star_name
-        @expected = "identifier or *"
-        return name, tok(IDENT) || tok!(/\*/)
-      end
-
-      def attrib
-        return unless tok(/\[/)
-        ss
-        ns, name = attrib_name!
-        ss
-
-        op = tok(/=/) ||
-             tok(INCLUDES) ||
-             tok(DASHMATCH) ||
-             tok(PREFIXMATCH) ||
-             tok(SUFFIXMATCH) ||
-             tok(SUBSTRINGMATCH)
-        if op
-          @expected = "identifier or string"
-          ss
-          val = tok(IDENT) || tok!(STRING)
-          ss
-        end
-        flags = tok(IDENT) || tok(STRING)
-        tok!(/\]/)
-
-        Selector::Attribute.new(name, ns, op, val, flags)
-      end
-
-      def attrib_name!
-        if (name_or_ns = tok(IDENT))
-          # E, E|E
-          if tok(/\|(?!=)/)
-            ns = name_or_ns
-            name = tok(IDENT)
-          else
-            name = name_or_ns
-          end
-        else
-          # *|E or |E
-          ns = tok(/\*/) || ""
-          tok!(/\|/)
-          name = tok!(IDENT)
-        end
-        return ns, name
-      end
-
-      SELECTOR_PSEUDO_CLASSES = %w[not matches current any has host host-context].to_set
-
-      PREFIXED_SELECTOR_PSEUDO_CLASSES = %w[nth-child nth-last-child].to_set
-
-      def pseudo
-        s = tok(/::?/)
-        return unless s
-        @expected = "pseudoclass or pseudoelement"
-        name = tok!(IDENT)
-        if tok(/\(/)
-          ss
-          deprefixed = deprefix(name)
-          if s == ':' && SELECTOR_PSEUDO_CLASSES.include?(deprefixed)
-            sel = selector_comma_sequence
-          elsif s == ':' && PREFIXED_SELECTOR_PSEUDO_CLASSES.include?(deprefixed)
-            arg, sel = prefixed_selector_pseudo
-          else
-            arg = expr!(:pseudo_args)
-          end
-
-          tok!(/\)/)
-        end
-        Selector::Pseudo.new(s == ':' ? :class : :element, name, arg, sel)
-      end
-
-      def pseudo_args
-        arg = expr!(:pseudo_expr)
-        while tok(/,/)
-          arg << ',' << str {ss}
-          arg.concat expr!(:pseudo_expr)
-        end
-        arg
-      end
-
-      def pseudo_expr
-        res = pseudo_expr_token
-        return unless res
-        res << str {ss}
-        while (e = pseudo_expr_token)
-          res << e << str {ss}
-        end
-        res
-      end
-
-      def pseudo_expr_token
-        tok(PLUS) || tok(/[-*]/) || tok(NUMBER) || tok(STRING) || tok(IDENT)
-      end
-
-      def prefixed_selector_pseudo
-        prefix = str do
-          expr = str {expr!(:a_n_plus_b)}
-          ss
-          return expr, nil unless tok(/of/)
-          ss
-        end
-        return prefix, expr!(:selector_comma_sequence)
-      end
-
-      def a_n_plus_b
-        if (parity = tok(/even|odd/i))
-          return parity
-        end
-
-        if tok(/[+-]?[0-9]+/)
-          ss
-          return true unless tok(/n/)
-        else
-          return unless tok(/[+-]?n/i)
-        end
-        ss
-
-        return true unless tok(/[+-]/)
-        ss
-        @expected = "number"
-        tok!(/[0-9]+/)
-        true
-      end
-
-      def keyframes_selector
-        ss
-        str do
-          return unless keyframes_selector_component
-          ss
-          while tok(/,/)
-            ss
-            expr!(:keyframes_selector_component)
-            ss
-          end
-        end
-      end
-
-      def keyframes_selector_component
-        tok(/from|to/i) || tok(PERCENTAGE)
-      end
-
       @sass_script_parser = Class.new(Sass::Script::CssParser)
       @sass_script_parser.send(:include, ScriptParser)
     end

data/lib/sass/selector.rb

@@ -1,14 +1,13 @@
 require 'sass/selector/simple'
 require 'sass/selector/abstract_sequence'
 require 'sass/selector/comma_sequence'
-require 'sass/selector/pseudo'
 require 'sass/selector/sequence'
 require 'sass/selector/simple_sequence'
 
 module Sass
   # A namespace for nodes in the parse tree for selectors.
   #
-  # {CommaSequence} is the toplevel selector,
+  # {CommaSequence} is the toplevel seelctor,
   # representing a comma-separated sequence of {Sequence}s,
   # such as `foo bar, baz bang`.
   # {Sequence} is the next level,
@@ -22,25 +21,17 @@ module Sass
     # The base used for calculating selector specificity. The spec says this
     # should be "sufficiently high"; it's extremely unlikely that any single
     # selector sequence will contain 1,000 simple selectors.
+    #
+    # @type [Fixnum]
     SPECIFICITY_BASE = 1_000
 
     # A parent-referencing selector (`&` in Sass).
     # The function of this is to be replaced by the parent selector
     # in the nested hierarchy.
     class Parent < Simple
-      # The identifier following the `&`. `nil` indicates no suffix.
-      #
-      # @return [String, nil]
-      attr_reader :suffix
-
-      # @param name [String, nil] See \{#suffix}
-      def initialize(suffix = nil)
-        @suffix = suffix
-      end
-
-      # @see Selector#to_s
-      def to_s
-        "&" + (@suffix || '')
+      # @see Selector#to_a
+      def to_a
+        ["&"]
       end
 
       # Always raises an exception.
@@ -56,17 +47,17 @@ module Sass
     class Class < Simple
       # The class name.
       #
-      # @return [String]
+      # @return [Array<String, Sass::Script::Node>]
       attr_reader :name
 
-      # @param name [String] The class name
+      # @param name [Array<String, Sass::Script::Node>] The class name
       def initialize(name)
         @name = name
       end
 
-      # @see Selector#to_s
-      def to_s
-        "." + @name
+      # @see Selector#to_a
+      def to_a
+        [".", *@name]
       end
 
       # @see AbstractSequence#specificity
@@ -79,17 +70,17 @@ module Sass
     class Id < Simple
       # The id name.
       #
-      # @return [String]
+      # @return [Array<String, Sass::Script::Node>]
       attr_reader :name
 
-      # @param name [String] The id name
+      # @param name [Array<String, Sass::Script::Node>] The id name
       def initialize(name)
         @name = name
       end
 
-      # @see Selector#to_s
-      def to_s
-        "#" + @name
+      # @see Selector#to_a
+      def to_a
+        ["#", *@name]
       end
 
       # Returns `nil` if `sels` contains an {Id} selector
@@ -97,7 +88,7 @@ module Sass
       #
       # @see Selector#unify
       def unify(sels)
-        return if sels.any? {|sel2| sel2.is_a?(Id) && name != sel2.name}
+        return if sels.any? {|sel2| sel2.is_a?(Id) && self.name != sel2.name}
         super
       end
 
@@ -114,17 +105,17 @@ module Sass
     class Placeholder < Simple
       # The placeholder name.
       #
-      # @return [String]
+      # @return [Array<String, Sass::Script::Node>]
       attr_reader :name
 
-      # @param name [String] The placeholder name
+      # @param name [Array<String, Sass::Script::Node>] The placeholder name
       def initialize(name)
         @name = name
       end
 
-      # @see Selector#to_s
-      def to_s
-        "%" + @name
+      # @see Selector#to_a
+      def to_a
+        ["%", *@name]
       end
 
       # @see AbstractSequence#specificity
@@ -135,20 +126,22 @@ module Sass
 
     # A universal selector (`*` in CSS).
     class Universal < Simple
-      # The selector namespace. `nil` means the default namespace, `""` means no
-      # namespace, `"*"` means any namespace.
+      # The selector namespace.
+      # `nil` means the default namespace,
+      # `[""]` means no namespace,
+      # `["*"]` means any namespace.
       #
-      # @return [String, nil]
+      # @return [Array<String, Sass::Script::Node>, nil]
       attr_reader :namespace
 
-      # @param namespace [String, nil] See \{#namespace}
+      # @param namespace [Array<String, Sass::Script::Node>, nil] See \{#namespace}
       def initialize(namespace)
         @namespace = namespace
       end
 
-      # @see Selector#to_s
-      def to_s
-        @namespace ? "#{@namespace}|*" : "*"
+      # @see Selector#to_a
+      def to_a
+        @namespace ? @namespace + ["|*"] : ["*"]
       end
 
       # Unification of a universal selector is somewhat complicated,
@@ -182,7 +175,7 @@ module Sass
           when Universal; :universal
           when Element; sels.first.name
           else
-            return [self] + sels unless namespace.nil? || namespace == '*'
+            return [self] + sels unless namespace.nil? || namespace == ['*']
             return sels unless sels.empty?
             return [self]
           end
@@ -202,25 +195,27 @@ module Sass
     class Element < Simple
       # The element name.
       #
-      # @return [String]
+      # @return [Array<String, Sass::Script::Node>]
       attr_reader :name
 
-      # The selector namespace. `nil` means the default namespace, `""` means no
-      # namespace, `"*"` means any namespace.
+      # The selector namespace.
+      # `nil` means the default namespace,
+      # `[""]` means no namespace,
+      # `["*"]` means any namespace.
       #
-      # @return [String, nil]
+      # @return [Array<String, Sass::Script::Node>, nil]
       attr_reader :namespace
 
-      # @param name [String] The element name
-      # @param namespace [String, nil] See \{#namespace}
+      # @param name [Array<String, Sass::Script::Node>] The element name
+      # @param namespace [Array<String, Sass::Script::Node>, nil] See \{#namespace}
       def initialize(name, namespace)
         @name = name
         @namespace = namespace
       end
 
-      # @see Selector#to_s
-      def to_s
-        @namespace ? "#{@namespace}|#{@name}" : @name
+      # @see Selector#to_a
+      def to_a
+        @namespace ? @namespace + ["|"] + @name : @name
       end
 
       # Unification of an element selector is somewhat complicated,
@@ -263,17 +258,45 @@ module Sass
       end
     end
 
+    # Selector interpolation (`#{}` in Sass).
+    class Interpolation < Simple
+      # The script to run.
+      #
+      # @return [Sass::Script::Node]
+      attr_reader :script
+
+      # @param script [Sass::Script::Node] The script to run
+      def initialize(script)
+        @script = script
+      end
+
+      # @see Selector#to_a
+      def to_a
+        [@script]
+      end
+
+      # Always raises an exception.
+      #
+      # @raise [Sass::SyntaxError] Interpolation selectors should be resolved before unification
+      # @see Selector#unify
+      def unify(sels)
+        raise Sass::SyntaxError.new("[BUG] Cannot unify interpolation selectors.")
+      end
+    end
+
     # An attribute selector (e.g. `[href^="http://"]`).
     class Attribute < Simple
       # The attribute name.
       #
-      # @return [Array<String, Sass::Script::Tree::Node>]
+      # @return [Array<String, Sass::Script::Node>]
       attr_reader :name
 
-      # The attribute namespace. `nil` means the default namespace, `""` means
-      # no namespace, `"*"` means any namespace.
+      # The attribute namespace.
+      # `nil` means the default namespace,
+      # `[""]` means no namespace,
+      # `["*"]` means any namespace.
       #
-      # @return [String, nil]
+      # @return [Array<String, Sass::Script::Node>, nil]
       attr_reader :namespace
 
       # The matching operator, e.g. `"="` or `"^="`.
@@ -283,23 +306,20 @@ module Sass
 
       # The right-hand side of the operator.
       #
-      # @return [String]
+      # @return [Array<String, Sass::Script::Node>]
       attr_reader :value
 
       # Flags for the attribute selector (e.g. `i`).
       #
-      # @return [String]
+      # @return [Array<String, Sass::Script::Node>]
       attr_reader :flags
 
-      # @param name [String] The attribute name
-      # @param namespace [String, nil] See \{#namespace}
+      # @param name [Array<String, Sass::Script::Node>] The attribute name
+      # @param namespace [Array<String, Sass::Script::Node>, nil] See \{#namespace}
       # @param operator [String] The matching operator, e.g. `"="` or `"^="`
-      # @param value [String] See \{#value}
-      # @param flags [String] See \{#flags}
-      # @comment
-      #   rubocop:disable ParameterLists
+      # @param value [Array<String, Sass::Script::Node>] See \{#value}
+      # @param value [Array<String, Sass::Script::Node>] See \{#flags}
       def initialize(name, namespace, operator, value, flags)
-        # rubocop:enable ParameterLists
         @name = name
         @namespace = namespace
         @operator = operator
@@ -307,13 +327,13 @@ module Sass
         @flags = flags
       end
 
-      # @see Selector#to_s
-      def to_s
-        res = "["
-        res << @namespace << "|" if @namespace
-        res << @name
-        res << @operator << @value if @value
-        res << " " << @flags if @flags
+      # @see Selector#to_a
+      def to_a
+        res = ["["]
+        res.concat(@namespace) << "|" if @namespace
+        res.concat @name
+        (res << @operator).concat @value if @value
+        (res << " ").concat @flags if @flags
         res << "]"
       end
 
@@ -322,5 +342,111 @@ module Sass
         SPECIFICITY_BASE
       end
     end
+
+    # A pseudoclass (e.g. `:visited`) or pseudoelement (e.g. `::first-line`) selector.
+    # It can have arguments (e.g. `:nth-child(2n+1)`).
+    class Pseudo < Simple
+      # Some psuedo-class-syntax selectors are actually considered
+      # pseudo-elements and must be treated differently. This is a list of such
+      # selectors
+      #
+      # @return [Array<String>]
+      ACTUALLY_ELEMENTS = %w[after before first-line first-letter]
+
+      # Like \{#type}, but returns the type of selector this looks like, rather
+      # than the type it is semantically. This only differs from type for
+      # selectors in \{ACTUALLY\_ELEMENTS}.
+      #
+      # @return [Symbol]
+      attr_reader :syntactic_type
+
+      # The name of the selector.
+      #
+      # @return [Array<String, Sass::Script::Node>]
+      attr_reader :name
+
+      # The argument to the selector,
+      # or `nil` if no argument was given.
+      #
+      # This may include SassScript nodes that will be run during resolution.
+      # Note that this should not include SassScript nodes
+      # after resolution has taken place.
+      #
+      # @return [Array<String, Sass::Script::Node>, nil]
+      attr_reader :arg
+
+      # @param type [Symbol] See \{#type}
+      # @param name [Array<String, Sass::Script::Node>] The name of the selector
+      # @param arg [nil, Array<String, Sass::Script::Node>] The argument to the selector,
+      #   or nil if no argument was given
+      def initialize(type, name, arg)
+        @syntactic_type = type
+        @name = name
+        @arg = arg
+      end
+
+      # The type of the selector. `:class` if this is a pseudoclass selector,
+      # `:element` if it's a pseudoelement.
+      #
+      # @return [Symbol]
+      def type
+        ACTUALLY_ELEMENTS.include?(name.first) ? :element : syntactic_type
+      end
+
+      # @see Selector#to_a
+      def to_a
+        res = [syntactic_type == :class ? ":" : "::"] + @name
+        (res << "(").concat(Sass::Util.strip_string_array(@arg)) << ")" if @arg
+        res
+      end
+
+      # Returns `nil` if this is a pseudoelement selector
+      # and `sels` contains a pseudoelement selector different than this one.
+      #
+      # @see Selector#unify
+      def unify(sels)
+        return if type == :element && sels.any? do |sel|
+          sel.is_a?(Pseudo) && sel.type == :element &&
+            (sel.name != self.name || sel.arg != self.arg)
+        end
+        super
+      end
+
+      # @see AbstractSequence#specificity
+      def specificity
+        type == :class ? SPECIFICITY_BASE : 1
+      end
+    end
+
+    # A pseudoclass selector whose argument is itself a selector
+    # (e.g. `:not(.foo)` or `:-moz-all(.foo, .bar)`).
+    class SelectorPseudoClass < Simple
+      # The name of the pseudoclass.
+      #
+      # @return [String]
+      attr_reader :name
+
+      # The selector argument.
+      #
+      # @return [Selector::Sequence]
+      attr_reader :selector
+
+      # @param [String] The name of the pseudoclass
+      # @param [Selector::CommaSequence] The selector argument
+      def initialize(name, selector)
+        @name = name
+        @selector = selector
+      end
+
+      # @see Selector#to_a
+      def to_a
+        [":", @name, "("] + @selector.to_a + [")"]
+      end
+
+      # @see AbstractSequence#specificity
+      def specificity
+        SPECIFICITY_BASE
+      end
+    end
   end
 end