class Sass::Selector::SimpleSequence

def _eql?(other)
  other.base.eql?(self.base) && Haml::Util.set_eql?(other.rest, self.rest)
end

def _hash
  [base, Haml::Util.set_hash(rest)].hash
end

def base
  @base ||= (members.first if members.first.is_a?(Element) || members.first.is_a?(Universal))
end

def do_extend(extends, seen = Set.new)
  extends.get(members.to_set).map do |seq, sels|
    # If A {@extend B} and C {...},
    # seq is A, sels is B, and self is C
    self_without_sel = self.members - sels
    next unless unified = seq.members.last.unify(self_without_sel)
    [sels, seq.members[0...-1] + [unified]]
  end.compact.map do |sels, seq|
    seq = Sequence.new(seq)
    seen.include?(sels) ? [] : seq.do_extend(extends, seen + [sels])
  end.flatten.uniq
end

def initialize(selectors)
  @members = selectors
end

def inspect
  members.map {|m| m.inspect}.join
end

def resolve_parent_refs(super_seq)
  # Parent selector only appears as the first selector in the sequence
  return [self] unless @members.first.is_a?(Parent)
  return super_seq.members if @members.size == 1
  unless super_seq.members.last.is_a?(SimpleSequence)
    raise Sass::SyntaxError.new("Invalid parent selector: " + super_seq.to_a.join)
  end
  super_seq.members[0...-1] +
    [SimpleSequence.new(super_seq.members.last.members + @members[1..-1])]
end

def rest
  @rest ||= Set.new(base ? members[1..-1] : members)
end

def superselector?(sseq)
  (base.nil? || base.eql?(sseq.base)) && rest.subset?(sseq.rest)
end

def to_a
  @members.map {|sel| sel.to_a}.flatten
end

def unify(sels)
  return unless sseq = members.inject(sels) do |sseq, sel|
    return unless sseq
    sel.unify(sseq)
  end
  SimpleSequence.new(sseq)
end