grammar.hpp

#pragma once
 
// ------------------------------------------------------------------------------------------------
// 17. Grammar
//
// https://drafts.csswg.org/selectors-4/#grammar
// https://triple-underscore.github.io/selectors4-ja.html#grammar
// ------------------------------------------------------------------------------------------------
 
#include <wordring/wwwc/selectors/pseudo_class_defs.hpp>
#include <wordring/wwwc/css_defs.hpp>
#include <wordring/wwwc/selectors/tree_structural_pseudo_classes.hpp>
 
#include <wordring/wwwc/css_syntax/parsing.hpp>
 
#include <wordring/encoding/encoding.hpp>
#include <wordring/html/html_defs.hpp>
 
#include <wordring/whatwg/infra/infra.hpp>
 
#include <algorithm>
#include <iterator>
#include <optional>
#include <string>
#include <string_view>
#include <utility>
#include <variant>
#include <vector>
 
namespace wordring::wwwc::css
{
    // --------------------------------------------------------------------------------------------
    // 17. Grammar
    //
    // https://drafts.csswg.org/selectors-4/#grammar
    // https://triple-underscore.github.io/selectors4-ja.html#grammar
    // --------------------------------------------------------------------------------------------
 
    class selector_grammar
    {
    public:
        using const_iterator = syntax_primitive_stream::const_iterator;
 
        using document_type_name = wordring::html::document_type_name;
        using document_mode_name = wordring::html::document_mode_name;
 
    public:
        selector_grammar() = default;
        selector_grammar(selector_grammar const&) = default;
        selector_grammar(selector_grammar&&) = default;
 
        selector_grammar(const_iterator first, const_iterator last);
 
        selector_grammar& operator=(selector_grammar const&) = default;
        selector_grammar& operator=(selector_grammar&&) = default;
 
        operator bool() const;
 
        bool operator !() const;
 
        const_iterator begin() const;
 
        const_iterator end() const;
 
    protected:
        const_iterator m_first;
 
        const_iterator m_last;
 
    };
 
    class combinator: public selector_grammar
    {
    public:
        using const_iterator = syntax_primitive_stream::const_iterator;
 
    public:
        static combinator consume(syntax_primitive_stream in, parse_context& ctx);
 
    public:
        combinator() = default;
        combinator(combinator const&) = default;
        combinator(const_iterator first, const_iterator last, char32_t c);
 
        char32_t type() const;
 
    private:
        char32_t m_c;
    };
 
    class ns_prefix: public selector_grammar
    {
    public:
        using const_iterator = syntax_primitive_stream::const_iterator;
 
    public:
        static ns_prefix consume(syntax_primitive_stream in, parse_context& ctx);
 
    public:
        ns_prefix() = default;
        ns_prefix(ns_prefix const&) = default;
        ns_prefix(ns_prefix&&) = default;
        ns_prefix(const_iterator first, const_iterator last, std::u32string const& prefix);
 
        ns_prefix& operator =(ns_prefix const&) = default;
        ns_prefix& operator =(ns_prefix&&) = default;
 
        std::u32string const& string() const;
 
    private:
        std::u32string m_ns_prefix;
    };
 
    class wq_name: public selector_grammar
    {
    public:
        using const_iterator = syntax_primitive_stream::const_iterator;
 
    public:
        static wq_name consume(syntax_primitive_stream in, parse_context& ctx);
 
    public:
        wq_name() = default;
        wq_name(const_iterator first, const_iterator last, std::optional<ns_prefix> ns, std::u32string const& name);
 
        std::optional<ns_prefix> const& prefix() const;
 
        std::u32string const& name() const;
 
    private:
        std::optional<ns_prefix> m_ns_prefix;
        std::u32string m_name;
    };
    
    class id_selector: public selector_grammar
    {
    public:
        using const_iterator = syntax_primitive_stream::const_iterator;
 
        using document_type_name = wordring::html::document_type_name;
        using document_mode_name = wordring::html::document_mode_name;
 
    public:
        static id_selector consume(syntax_primitive_stream in, parse_context& ctx);
 
    public:
        id_selector() = default;
        
        id_selector(const_iterator first, const_iterator last, std::u32string const& value);
 
        std::u32string const& value() const;
 
        template <typename NodePointer>
        bool match(NodePointer const& np, match_context<NodePointer> const& ctx) const
        {
            using traits = wordring::html::node_traits<NodePointer>;
            
            assert(!(ctx.m_type_name == document_type_name::Xml
                && (ctx.m_mode_name == document_mode_name::LimitedQuirks || ctx.m_mode_name == document_mode_name::Quirks)));
 
            if (traits::is_element(np))
            {
                auto it1 = traits::abegin(np);
                auto it2 = traits::aend(np);
                while (it1 != it2)
                {
                    std::u32string name = wordring::encoding_cast<std::u32string>(traits::get_qualified_name(*it1));
                    if (ctx.m_type_name == document_type_name::Html)
                    {
                        std::u32string tmp;
                        wordring::whatwg::to_ascii_lowercase(name.begin(), name.end(), std::back_inserter(tmp));
                        name = std::move(tmp);
                    }
 
                    if (name == U"id")
                    {
                        std::u32string val = wordring::encoding_cast<std::u32string>(traits::value(*it1));
                        if (ctx.m_mode_name == document_mode_name::Quirks)
                        {
                            std::u32string tmp;
                            wordring::whatwg::to_ascii_lowercase(val.begin(), val.end(), std::back_inserter(tmp));
                            val = std::move(tmp);
                        }
                        if (val == m_value) return true;
                    }
                    ++it1;
                }
            }
            return false;
        }
 
    private:
        std::u32string m_value;
    };
 
    class class_selector: public selector_grammar
    {
    public:
        using const_iterator = syntax_primitive_stream::const_iterator;
 
        using document_type_name = wordring::html::document_type_name;
        using document_mode_name = wordring::html::document_mode_name;
 
    public:
        static class_selector consume(syntax_primitive_stream in, parse_context& ctx);
 
    public:
        class_selector() = default;
        class_selector(const_iterator first, const_iterator last, std::u32string const& name);
 
        std::u32string const& name() const;
 
        template <typename NodePointer>
        bool match(NodePointer const& np, match_context<NodePointer> const& ctx) const
        {
            using traits = wordring::html::node_traits<NodePointer>;
 
            assert(!(ctx.m_type_name == document_type_name::Xml
                && (ctx.m_mode_name == document_mode_name::LimitedQuirks || ctx.m_mode_name == document_mode_name::Quirks)));
 
            if (traits::is_element(np))
            {
                auto it1 = traits::abegin(np);
                auto it2 = traits::aend(np);
                while (it1 != it2)
                {
                    std::u32string name = wordring::encoding_cast<std::u32string>(traits::get_qualified_name(*it1));
                    if (ctx.m_type_name == document_type_name::Html)
                    {
                        std::u32string tmp;
                        wordring::whatwg::to_ascii_lowercase(name.begin(), name.end(), std::back_inserter(tmp));
                        name = std::move(tmp);
                    }
                    if (name != U"class")
                    {
                        ++it1;
                        continue;
                    }
 
                    std::u32string val = wordring::encoding_cast<std::u32string>(traits::value(*it1));
                    if (ctx.m_mode_name == document_mode_name::Quirks)
                    {
                        std::u32string tmp;
                        wordring::whatwg::to_ascii_lowercase(val.begin(), val.end(), std::back_inserter(tmp));
                        val = std::move(tmp);
                    }
 
                    std::vector<std::u32string> v;
                    wordring::whatwg::split_on_ascii_whitespace(val.begin(), val.end(), std::back_inserter(v));
                    for (std::u32string const& s : v)
                    {
                        bool matched = (ctx.m_mode_name == document_mode_name::Quirks)
                            ? wordring::whatwg::is_ascii_case_insensitive_match(s.begin(), s.end(), m_name.begin(), m_name.end())
                            : s == val;
 
                        if (matched) return true;
                    }
                    ++it1;
                }
            }
            return false;
        }
 
    private:
        std::u32string m_name;
    };
 
    class attr_matcher: public selector_grammar
    {
    public:
        using const_iterator = syntax_primitive_stream::const_iterator;
 
    public:
        static attr_matcher consume(syntax_primitive_stream in, parse_context& ctx);
 
    public:
        attr_matcher() = default;
        attr_matcher(const_iterator first, const_iterator last, char32_t c);
 
        char32_t prefix() const;
 
    private:
        char32_t m_prefix = U'\0';
    };
 
    class attr_modifier: public selector_grammar
    {
    public:
        using const_iterator = syntax_primitive_stream::const_iterator;
 
    public:
        static attr_modifier consume(syntax_primitive_stream in, parse_context& ctx);
 
    public:
        attr_modifier() = default;
        attr_modifier(const_iterator first, const_iterator last, char32_t c);
 
        char32_t value() const;
 
    private:
        char32_t m_c;
    };
 
    class pseudo_class_selector: public selector_grammar
    {
    public:
        using value_type = std::variant<std::monostate, ident_token, function>;
        using const_iterator = syntax_primitive_stream::const_iterator;
 
    public:
 
        static pseudo_class_selector consume(syntax_primitive_stream in, parse_context& ctx);
 
    public:
        pseudo_class_selector();
        pseudo_class_selector(const_iterator first, const_iterator last);
        pseudo_class_selector(const_iterator first, const_iterator last, ident_token const& id, pseudo_class_id_name name);
        pseudo_class_selector(const_iterator first, const_iterator last, function const& fn, pseudo_class_fn_name name);
 
        syntax_primitive_name type() const;
 
        template <typename T>
        T const& get() const { return std::get<T>(m_value); }
 
        template <typename NodePointer>
        bool match(NodePointer const& np, match_context<NodePointer> const& ctx) const
        {
            assert(!(ctx.m_type_name == document_type_name::Xml
                && (ctx.m_mode_name == document_mode_name::LimitedQuirks || ctx.m_mode_name == document_mode_name::Quirks)));
 
            // 識別子だけの疑似クラスはこちら
            switch (m_pseudo_class_id_name)
            {
            case pseudo_class_id_name::Root: // :root
                return root_pseudo_class::match(np, ctx);
            default:
                return false;
            }
 
            // 関数型の疑似クラスはこちら
            //switch (m_pseudo_class_fn_name)
            //{
            //default:
            //  break;
            //}
 
            return false;
        }
 
    protected:
        value_type m_value; 
        pseudo_class_id_name m_pseudo_class_id_name; 
        pseudo_class_fn_name m_pseudo_class_fn_name; 
    };
 
    class pseudo_element_selector : public pseudo_class_selector
    {
    public:
        using value_type = pseudo_class_selector::value_type;
        using const_iterator = syntax_primitive_stream::const_iterator;
 
    public:
        static pseudo_element_selector consume(syntax_primitive_stream in, parse_context& ctx);
 
    public:
        explicit pseudo_element_selector(pseudo_class_selector&& s);
        pseudo_element_selector(const_iterator first, const_iterator last);
        pseudo_element_selector(const_iterator first, const_iterator last, ident_token const& id, pseudo_element_id_name name);
 
        template <typename NodePointer>
        bool match(NodePointer const& np, match_context<NodePointer> const& ctx) const
        {
            assert(!(ctx.m_type_name == document_type_name::Xml
                && (ctx.m_mode_name == document_mode_name::LimitedQuirks || ctx.m_mode_name == document_mode_name::Quirks)));
 
            return false;
        }
 
    private:
        pseudo_element_id_name m_pseudo_element_id_name;
    };
 
    class attribute_selector: public selector_grammar
    {
    public:
        using const_iterator = syntax_primitive_stream::const_iterator;
 
    public:
        static attribute_selector consume(syntax_primitive_stream in, parse_context& ctx);
 
    public:
        attribute_selector() = default;
        attribute_selector(const_iterator first, const_iterator last, wq_name name, char32_t matcher, std::u32string const& value, char32_t modifier);
 
        std::optional<ns_prefix> const& prefix() const;
        std::u32string const& name() const;
        char32_t matcher() const;
        std::u32string const& value() const;
        char32_t modifier() const;
 
        template <typename NodePointer>
        bool match(NodePointer const& np, match_context<NodePointer> const& ctx) const
        {
            using traits = wordring::html::node_traits<NodePointer>;
            using wordring::whatwg::is_ascii_case_insensitive_match;
            using wordring::whatwg::split_on_ascii_whitespace;
            using wordring::encoding_cast;
            using wordring::whatwg::to_ascii_lowercase;
 
            assert(!(ctx.m_type_name == document_type_name::Xml
                && (ctx.m_mode_name == document_mode_name::LimitedQuirks || ctx.m_mode_name == document_mode_name::Quirks)));
 
            // 要素以外のノードに属性は無い
            if (!traits::is_element(np)) return false;
 
            // 属性名照合
            auto it1 = traits::abegin(np);
            auto it2 = traits::aend(np);
            while (it1 != it2)
            {
                // 名前空間接頭辞
                if (m_name.prefix()) // セレクタが名前空間接頭辞を含んでいる
                {
                    std::u32string const& prefix1 = m_name.prefix()->string();
                    std::u32string uri2 = encoding_cast<std::u32string>(traits::get_namespace(*it1));
 
                    if (prefix1 == U"*");    // 接頭辞を持たない属性を含めて全てにマッチ
                    else if (prefix1 == U"") // 接頭辞を持たない属性にマッチ
                    {
                        if (!uri2.empty())
                        {
                            ++it1;
                            continue;
                        }
                    }
                    else
                    {
                        auto it = ctx.m_namespace_uris.find(prefix1);
                        if (it == ctx.m_namespace_uris.end() || it->second != uri2)
                        {
                            ++it1;
                            continue;
                        }
                    }
                }
                else // セレクタが名前空間接頭辞を含まない（名前空間付きの属性にマッチしない）
                {
                    if (!traits::get_namespace(*it1).empty())
                    {
                        ++it1;
                        continue;
                    }
                }
 
                // 属性名
                std::u32string const& n1 = m_name.name();
                std::u32string n2 = encoding_cast<std::u32string>(traits::get_local_name(*it1));
                // XML はASCII大小区別、HTMLは大小無視
                if (ctx.m_type_name == document_type_name::Xml)
                {
                    if (n1 == n2) break;
                }
                else
                {
                    if (is_ascii_case_insensitive_match(n1.begin(), n1.end(), n2.begin(), n2.end())) break;
                }
                
                ++it1;
            }
            if (it1 == it2) return false;
        
            // 属性値照合
            switch (m_matcher)
            {
            case U'\0':// [attr]
                assert(m_value.empty());
                return true;
            case U'=': // [attr=val]
            {
                std::u32string s = encoding_cast<std::u32string>(traits::value(*it1));
                if (m_modifier == U'i') return is_ascii_case_insensitive_match(m_value.begin(), m_value.end(), s.begin(), s.end());
                else return m_value == s;
            }
            case U'~': // [attr~=val]
            {
                std::u32string tmp = encoding_cast<std::u32string>(traits::value(*it1));
                std::vector<std::u32string> v;
                split_on_ascii_whitespace(tmp.begin(), tmp.end(), std::back_inserter(v));
                for (std::u32string const& s : v)
                {
                    if (m_modifier == U'i' && is_ascii_case_insensitive_match(m_value.begin(), m_value.end(), s.begin(), s.end())) return true;
                    else if(m_value == s) return true;
                }
                break;
            }
            case U'|': // [attr|=val]
            {
                std::u32string s = encoding_cast<std::u32string>(traits::value(*it1));
                if (m_modifier == U'i')
                {
                    if (m_value.size() < s.size()
                        && is_ascii_case_insensitive_match(m_value.begin(), m_value.end(), s.begin(), s.begin() + m_value.size())
                        && s[m_value.size()] == U'-') return true;
                }
                else
                {
                    if (m_value.size() < s.size()
                        && std::equal(m_value.begin(), m_value.end(), s.begin(), s.begin() + m_value.size())
                        && s[m_value.size()] == U'-') return true;
                }
                break;
            }
            case U'^': // [attr^=val]
            {
                std::u32string s = encoding_cast<std::u32string>(traits::value(*it1));
                if (m_modifier == U'i')
                {
                    if (m_value.size() <= s.size()
                        && is_ascii_case_insensitive_match(m_value.begin(), m_value.end(), s.begin(), s.begin() + m_value.size())) return true;
                }
                else
                {
                    if (m_value.size() <= s.size()
                        && std::equal(m_value.begin(), m_value.end(), s.begin(), s.begin() + m_value.size())) return true;
                }
                break;
            }
            case U'$': // [attr$=val]
            {
                std::u32string s = encoding_cast<std::u32string>(traits::value(*it1));
                if (s.size() < m_value.size()) return false;
                if (m_modifier == U'i')
                {
                    if (is_ascii_case_insensitive_match(m_value.rbegin(), m_value.rend(), s.rbegin(), s.rbegin() + m_value.size())) return true;
                }
                else
                {
                    if (std::equal(m_value.rbegin(), m_value.rend(), s.rbegin(), s.rbegin() + m_value.size())) return true;
                }
                break;
            }
            case U'*': // [attr*=val]
            {
                std::u32string s1 = encoding_cast<std::u32string>(traits::value(*it1));
                std::u32string s2 = m_value;
                if (m_modifier == U'i')
                {
                    std::u32string tmp;
                    to_ascii_lowercase(s1.begin(), s1.end(), std::back_inserter(tmp));
                    std::swap(s1, tmp);
                    tmp.clear();
                    to_ascii_lowercase(s2.begin(), s2.end(), std::back_inserter(tmp));
                    s2 = std::move(tmp);
                }
                if (s1.find(s2) != std::u32string::npos) return true;
                break;
            }
            default:
                break;
            }
            return false;
        }
 
    private:
        wq_name        m_name;
        char32_t       m_matcher;
        std::u32string m_value;
 
        char32_t m_modifier;
    };
 
    class subclass_selector: public selector_grammar
    {
    public:
        using const_iterator = syntax_primitive_stream::const_iterator;
 
        using value_type = std::variant<id_selector, class_selector, attribute_selector, pseudo_class_selector>;
 
    public:
        static subclass_selector consume(syntax_primitive_stream in, parse_context& ctx);
    public:
        subclass_selector() = default;
        subclass_selector(const_iterator first, const_iterator last, value_type value);
 
        value_type const& value() const;
 
        template <typename NodePointer>
        bool match(NodePointer const& np, match_context<NodePointer> const& ctx) const
        {
            assert(!(ctx.m_type_name == document_type_name::Xml
                && (ctx.m_mode_name == document_mode_name::LimitedQuirks || ctx.m_mode_name == document_mode_name::Quirks)));
 
            return std::visit([&](auto const& x) { return x.match(np, ctx); }, m_value);
        }
 
    private:
        value_type m_value;
    };
 
    class type_selector: public selector_grammar
    {
    public:
        using const_iterator = syntax_primitive_stream::const_iterator;
 
        using value_type = std::variant<wq_name, std::optional<ns_prefix>>;
 
    public:
        static type_selector consume(syntax_primitive_stream in, parse_context& ctx);
 
    public:
        type_selector() = default;
        type_selector(const_iterator first, const_iterator last, value_type value);
 
        value_type const& value() const;
 
        template <typename NodePointer>
        bool match(NodePointer const& np, match_context<NodePointer> const& ctx) const
        {
            using traits = wordring::html::node_traits<NodePointer>;
            using wordring::whatwg::is_ascii_case_insensitive_match;
            using wordring::encoding_cast;
 
            assert(!(ctx.m_type_name == document_type_name::Xml
                && (ctx.m_mode_name == document_mode_name::LimitedQuirks || ctx.m_mode_name == document_mode_name::Quirks)));
 
            // 要素以外のノードにタグ名は無い
            if (!traits::is_element(np)) return false;
 
            // 名前空間接頭辞
            std::optional<ns_prefix> const& opt = (m_value.index() == 0)
                ? std::get_if<wq_name>(&m_value)->prefix()
                : **std::get_if<std::optional<ns_prefix>>(&m_value);
 
            std::u32string uri2 = encoding_cast<std::u32string>(traits::get_namespace(np));
 
            if (opt) // セレクタに名前空間接頭辞アリ
            {
                std::u32string const& prefix1 = opt->string();
                if (prefix1 == U"*");    // 接頭辞を持たない要素を含めて全てにマッチ
                else if (prefix1 == U"") // 接頭辞を持たない要素にマッチ
                {
                    if (!uri2.empty()) return false;
                }
                else
                {
                    auto it = ctx.m_namespace_uris.find(prefix1);
                    if (it == ctx.m_namespace_uris.end() || it->second != uri2) return false;
                }
            }
            else // セレクタに名前空間接頭辞ナシ
            {
                auto it = ctx.m_namespace_uris.find(U""); // 既定の名前空間を検索
                if (it == ctx.m_namespace_uris.end()); // 既定の名前空間が無い場合全てにマッチ
                else                                   // あれば既定の名前空間にマッチ
                {
                    if (it->second != uri2) return false;
                }
            }
 
            // タグ名
            if (m_value.index() == 1) return true;
 
            std::u32string const& name1 = std::get_if<wq_name>(&m_value)->name();
            std::u32string name2 = encoding_cast<std::u32string>(traits::get_local_name(np));
 
            if (ctx.m_type_name == document_type_name::Html)
            {
                if (is_ascii_case_insensitive_match(name1.begin(), name1.end(), name2.begin(), name2.end())) return true;
            }
            else
            {
                if (name1 == name2) return true;
            }
 
            return false;
        }
 
    private:
        value_type m_value;
    };
 
    class simple_selector: public selector_grammar
    {
    public:
        using const_iterator = syntax_primitive_stream::const_iterator;
 
        using value_type = std::variant<std::monostate, type_selector, subclass_selector>;
 
    public:
        static simple_selector consume(syntax_primitive_stream in, parse_context& ctx);
 
    public:
        simple_selector() = default;
        simple_selector(const_iterator first, const_iterator last, value_type value);
 
        value_type const& value() const;
 
        template <typename NodePointer>
        bool match(NodePointer const& np, match_context<NodePointer> const& ctx) const
        {
            assert(!(ctx.m_type_name == document_type_name::Xml
                && (ctx.m_mode_name == document_mode_name::LimitedQuirks || ctx.m_mode_name == document_mode_name::Quirks)));
 
            if (m_value.index() == 1) return std::get_if<type_selector>(&m_value)->match(np, ctx);
            else if (m_value.index() == 2) return std::get_if<subclass_selector>(&m_value)->match(np, ctx);
 
            return false;
        }
 
    private:
        value_type m_value;
    };
 
    class compound_selector: public selector_grammar
    {
    public:
        using const_iterator = syntax_primitive_stream::const_iterator;
 
        using value_type = std::variant<type_selector, subclass_selector, pseudo_element_selector, pseudo_class_selector>;
 
    public:
        static compound_selector consume(syntax_primitive_stream in, parse_context& ctx);
 
    public:
        compound_selector() = default;
        compound_selector(const_iterator first, const_iterator last, std::vector<value_type>&& value);
 
        std::vector<value_type> const& value() const;
 
        template <typename NodePointer>
        bool match(NodePointer const& np, match_context<NodePointer> const& ctx) const
        {
            assert(!(ctx.m_type_name == document_type_name::Xml
                && (ctx.m_mode_name == document_mode_name::LimitedQuirks || ctx.m_mode_name == document_mode_name::Quirks)));
 
            for (value_type const& val : m_value)
            {
                if (!std::visit([&](auto const& x) { return x.match(np, ctx); }, val)) return false;
            }
 
            return true;
        }
 
    private:
        std::vector<value_type> m_value;
    };
 
    class complex_selector: public selector_grammar
    {
    public:
        using const_iterator = syntax_primitive_stream::const_iterator;
 
        using value_type = std::variant<compound_selector, combinator>;
        using reverse_iterator = std::vector<value_type>::const_reverse_iterator;
    public:
        static complex_selector consume(syntax_primitive_stream in, parse_context& ctx);
 
    private:
        template <typename NodePointer>
        bool match(reverse_iterator it, NodePointer const& np, match_context<NodePointer> const& ctx) const
        {
            using traits = wordring::html::node_traits<NodePointer>;
 
            if (!std::get_if<compound_selector>(&*it)->match(np, ctx)) return false;
            ++it;
            if (it == m_value.rend()) return true;
 
            char32_t c = U' ';
            if (it->index() == 1)
            {
                c = std::get_if<combinator>(&*it)->type();
                ++it;
            }
 
            switch (c)
            {
            case U' ':
                for (auto p = traits::parent(np); p != traits::pointer(); p = traits::parent(p))
                {
                    if (match(it, p, ctx)) return true;
                }
                break;
            case U'>':
            {
                auto p = traits::parent(np);
                if (p != traits::pointer() && match(it, p, ctx)) return true;
                break;
            }
            case U'+':
            {
                auto parent = traits::parent(np);
                if (parent == traits::pointer()) return false; // 根に兄弟は無いはず。
                auto first = traits::begin(parent);
                for(auto p = np; p != first;)
                {
                    p = traits::prev(p);
                    if (traits::is_element(p)) return match(it, p, ctx);
                }
                break;
            }
            case U'~':
            {
                auto parent = traits::parent(np);
                if (parent == traits::pointer()) return false; // 根に兄弟は無いはず。
                auto first = traits::begin(parent);
                for (auto p = np; p != first;)
                {
                    p = traits::prev(p);
                    if (traits::is_element(p) && match(it, p, ctx)) return true;
                }
                break;
            }
            default:
                break;
            }
 
            return false;
        }
 
    public:
        complex_selector() = default;
        complex_selector(const_iterator first, const_iterator last, std::vector<value_type>&& value);
 
        std::vector<value_type> const& value() const;
 
        template <typename NodePointer>
        bool match(NodePointer const& np, match_context<NodePointer> const& ctx) const
        {
            assert(!(ctx.m_type_name == document_type_name::Xml
                && (ctx.m_mode_name == document_mode_name::LimitedQuirks || ctx.m_mode_name == document_mode_name::Quirks)));
 
            return match(m_value.rbegin(), np, ctx);
        }
 
    private:
        std::vector<value_type> m_value;
    };
 
    class relative_selector: public selector_grammar
    {
    public:
        using const_iterator = syntax_primitive_stream::const_iterator;
 
        using value_type = std::variant<compound_selector, combinator>;
 
    public:
        static relative_selector consume(syntax_primitive_stream in, parse_context& ctx);
 
    public:
        relative_selector() = default;
        relative_selector(const_iterator first, const_iterator last, std::vector<value_type>&& value);
 
        std::vector<value_type> const& value() const;
 
        template <typename NodePointer>
        bool match(NodePointer const& np, match_context<NodePointer> const& ctx) const
        {
            using traits = wordring::html::node_traits<NodePointer>;
            using ns_name = wordring::html::ns_name;
            using wordring::whatwg::is_ascii_case_insensitive_match;
            using wordring::encoding_cast;
 
            assert(!(ctx.m_type_name == document_type_name::Xml
                && (ctx.m_mode_name == document_mode_name::LimitedQuirks || ctx.m_mode_name == document_mode_name::Quirks)));
 
            return false;
        }
 
        template <typename NodePointer>
        void absolutize(match_context<NodePointer> const& ctx)
        {
            using traits = wordring::html::node_traits<NodePointer>;
 
            if (ctx.m_scope_elements.empty()
                && (ctx.m_scoping_root == traits::pointer() || !traits::is_element(ctx.m_scoping_root)));
            else
            {
            }
        }
 
    private:
        std::vector<value_type> m_value;
    };
 
    class relative_selector_list: public selector_grammar
    {
    public:
        using const_iterator = syntax_primitive_stream::const_iterator;
 
    public:
        static relative_selector_list consume(syntax_primitive_stream in, parse_context& ctx);
 
    public:
        relative_selector_list() = default;
        relative_selector_list(const_iterator first, const_iterator last, std::vector<relative_selector>&& value);
 
        std::vector<relative_selector> const& value() const;
 
        template <typename NodePointer>
        bool match(NodePointer const& np, match_context<NodePointer> const& ctx) const
        {
            assert(!(ctx.m_type_name == document_type_name::Xml
                && (ctx.m_mode_name == document_mode_name::LimitedQuirks || ctx.m_mode_name == document_mode_name::Quirks)));
 
            return false;
        }
 
 
        template <typename NodePointer>
        void absolutize(match_context<NodePointer> const& ctx)
        {
            for (relative_selector& rs : m_value) rs.absolutize(ctx);
        }
 
    private:
        std::vector<relative_selector> m_value;
    };
 
    class simple_selector_list: public selector_grammar
    {
    public:
        using const_iterator = syntax_primitive_stream::const_iterator;
 
    public:
        static simple_selector_list consume(syntax_primitive_stream in, parse_context& ctx);
 
    public:
        simple_selector_list() = default;
        simple_selector_list(const_iterator first, const_iterator last, std::vector<simple_selector>&& value);
 
        std::vector<simple_selector> const& value() const;
 
        template <typename NodePointer>
        bool match(NodePointer const& np, match_context<NodePointer> const& ctx) const
        {
            assert(!(ctx.m_type_name == document_type_name::Xml
                && (ctx.m_mode_name == document_mode_name::LimitedQuirks || ctx.m_mode_name == document_mode_name::Quirks)));
 
            for (simple_selector const& ss : m_value)
            {
                if (ss.match(np, ctx)) return true;
            }
 
            return false;
        }
 
    private:
        std::vector<simple_selector> m_value;
    };
 
    class compound_selector_list: public selector_grammar
    {
    public:
        using const_iterator = syntax_primitive_stream::const_iterator;
 
    public:
        static compound_selector_list consume(syntax_primitive_stream in, parse_context& ctx);
 
    public:
        compound_selector_list() = default;
        compound_selector_list(const_iterator first, const_iterator last, std::vector<compound_selector>&& value);
 
        std::vector<compound_selector> const& value() const;
 
        template <typename NodePointer>
        bool match(NodePointer const& np, match_context<NodePointer> const& ctx) const
        {
            assert(!(ctx.m_type_name == document_type_name::Xml
                && (ctx.m_mode_name == document_mode_name::LimitedQuirks || ctx.m_mode_name == document_mode_name::Quirks)));
 
            for (compound_selector const& cs : m_value)
            {
                if (cs.match(np, ctx)) return true;
            }
 
            return false;
        }
 
    private:
        std::vector<compound_selector> m_value;
    };
 
    class complex_selector_list: public selector_grammar
    {
    public:
        using const_iterator = syntax_primitive_stream::const_iterator;
 
    public:
        static complex_selector_list consume(syntax_primitive_stream in, parse_context& ctx);
 
    public:
        complex_selector_list() = default;
        complex_selector_list(const_iterator first, const_iterator last, std::vector<complex_selector>&& value);
 
        std::vector<complex_selector> const& value() const;
 
        template <typename NodePointer>
        bool match(NodePointer const& np, match_context<NodePointer> const& ctx) const
        {
            assert(!(ctx.m_type_name == document_type_name::Xml
                && (ctx.m_mode_name == document_mode_name::LimitedQuirks || ctx.m_mode_name == document_mode_name::Quirks)));
 
            for (complex_selector const& cs : m_value)
            {
                if (cs.match(np, ctx)) return true;
            }
 
            return false;
        }
 
    private:
        std::vector<complex_selector> m_value;
    };
 
 
    class selector_list: public selector_grammar
    {
    public:
        using const_iterator = syntax_primitive_stream::const_iterator;
 
    public:
        static selector_list consume(syntax_primitive_stream in, parse_context& ctx);
 
    public:
        selector_list() = default;
        selector_list(const_iterator first, const_iterator last, complex_selector_list&& value);
 
        complex_selector_list const& value() const;
 
        template <typename NodePointer>
        bool match(NodePointer const& np, match_context<NodePointer> const& ctx) const
        {
            assert(!(ctx.m_type_name == document_type_name::Xml
                && (ctx.m_mode_name == document_mode_name::LimitedQuirks || ctx.m_mode_name == document_mode_name::Quirks)));
 
            return m_value.match(np, ctx);
        }
 
    private:
        complex_selector_list m_value;
    };
 
 
}