cfsolve 0.1.0-arm64-darwin

data/THIRD_PARTY_LICENSES/selectors-0.38.0/source/context.rs

@@ -0,0 +1,525 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+use crate::attr::CaseSensitivity;
+use crate::bloom::BloomFilter;
+use crate::nth_index_cache::{NthIndexCache, NthIndexCacheInner};
+use crate::parser::{Selector, SelectorImpl};
+use crate::relative_selector::cache::RelativeSelectorCache;
+use crate::relative_selector::filter::RelativeSelectorFilterMap;
+use crate::tree::{Element, OpaqueElement};
+
+/// What kind of selector matching mode we should use.
+///
+/// There are two modes of selector matching. The difference is only noticeable
+/// in presence of pseudo-elements.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum MatchingMode {
+    /// Don't ignore any pseudo-element selectors.
+    Normal,
+
+    /// Ignores any stateless pseudo-element selectors in the rightmost sequence
+    /// of simple selectors.
+    ///
+    /// This is useful, for example, to match against ::before when you aren't a
+    /// pseudo-element yourself.
+    ///
+    /// For example, in presence of `::before:hover`, it would never match, but
+    /// `::before` would be ignored as in "matching".
+    ///
+    /// It's required for all the selectors you match using this mode to have a
+    /// pseudo-element.
+    ForStatelessPseudoElement,
+}
+
+/// The mode to use when matching unvisited and visited links.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum VisitedHandlingMode {
+    /// All links are matched as if they are unvisted.
+    AllLinksUnvisited,
+    /// All links are matched as if they are visited and unvisited (both :link
+    /// and :visited match).
+    ///
+    /// This is intended to be used from invalidation code, to be conservative
+    /// about whether we need to restyle a link.
+    AllLinksVisitedAndUnvisited,
+    /// A element's "relevant link" is the element being matched if it is a link
+    /// or the nearest ancestor link. The relevant link is matched as though it
+    /// is visited, and all other links are matched as if they are unvisited.
+    RelevantLinkVisited,
+}
+
+impl VisitedHandlingMode {
+    #[inline]
+    pub fn matches_visited(&self) -> bool {
+        matches!(
+            *self,
+            VisitedHandlingMode::RelevantLinkVisited
+                | VisitedHandlingMode::AllLinksVisitedAndUnvisited
+        )
+    }
+
+    #[inline]
+    pub fn matches_unvisited(&self) -> bool {
+        matches!(
+            *self,
+            VisitedHandlingMode::AllLinksUnvisited
+                | VisitedHandlingMode::AllLinksVisitedAndUnvisited
+        )
+    }
+}
+
+/// Whether we need to set selector invalidation flags on elements for this
+/// match request.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum NeedsSelectorFlags {
+    No,
+    Yes,
+}
+
+/// Whether we're matching in the contect of invalidation.
+#[derive(Clone, Copy, PartialEq)]
+pub enum MatchingForInvalidation {
+    No,
+    Yes,
+    YesForComparison,
+}
+
+impl MatchingForInvalidation {
+    /// Are we matching for invalidation?
+    pub fn is_for_invalidation(&self) -> bool {
+        matches!(*self, Self::Yes | Self::YesForComparison)
+    }
+}
+
+/// Which quirks mode is this document in.
+///
+/// See: https://quirks.spec.whatwg.org/
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+pub enum QuirksMode {
+    /// Quirks mode.
+    Quirks,
+    /// Limited quirks mode.
+    LimitedQuirks,
+    /// No quirks mode.
+    NoQuirks,
+}
+
+impl QuirksMode {
+    #[inline]
+    pub fn classes_and_ids_case_sensitivity(self) -> CaseSensitivity {
+        match self {
+            QuirksMode::NoQuirks | QuirksMode::LimitedQuirks => CaseSensitivity::CaseSensitive,
+            QuirksMode::Quirks => CaseSensitivity::AsciiCaseInsensitive,
+        }
+    }
+}
+
+/// Set of caches (And cache-likes) that speed up expensive selector matches.
+#[derive(Default)]
+pub struct SelectorCaches {
+    /// A cache to speed up nth-index-like selectors.
+    pub nth_index: NthIndexCache,
+    /// A cache to speed up relative selector matches. See module documentation.
+    pub relative_selector: RelativeSelectorCache,
+    /// A map of bloom filters to fast-reject relative selector matches.
+    pub relative_selector_filter_map: RelativeSelectorFilterMap,
+}
+
+/// Data associated with the matching process for a element.  This context is
+/// used across many selectors for an element, so it's not appropriate for
+/// transient data that applies to only a single selector.
+pub struct MatchingContext<'a, Impl>
+where
+    Impl: SelectorImpl,
+{
+    /// Input with the matching mode we should use when matching selectors.
+    matching_mode: MatchingMode,
+    /// Input with the bloom filter used to fast-reject selectors.
+    pub bloom_filter: Option<&'a BloomFilter>,
+    /// The element which is going to match :scope pseudo-class. It can be
+    /// either one :scope element, or the scoping element.
+    ///
+    /// Note that, although in theory there can be multiple :scope elements,
+    /// in current specs, at most one is specified, and when there is one,
+    /// scoping element is not relevant anymore, so we use a single field for
+    /// them.
+    ///
+    /// When this is None, :scope will match the root element.
+    ///
+    /// See https://drafts.csswg.org/selectors-4/#scope-pseudo
+    pub scope_element: Option<OpaqueElement>,
+
+    /// The current shadow host we're collecting :host rules for.
+    pub current_host: Option<OpaqueElement>,
+
+    /// Controls how matching for links is handled.
+    visited_handling: VisitedHandlingMode,
+
+    /// Whether we're currently matching a featureless element.
+    pub featureless: bool,
+
+    /// The current nesting level of selectors that we're matching.
+    nesting_level: usize,
+
+    /// Whether we're inside a negation or not.
+    in_negation: bool,
+
+    /// An optional hook function for checking whether a pseudo-element
+    /// should match when matching_mode is ForStatelessPseudoElement.
+    pub pseudo_element_matching_fn: Option<&'a dyn Fn(&Impl::PseudoElement) -> bool>,
+
+    /// Extra implementation-dependent matching data.
+    pub extra_data: Impl::ExtraMatchingData<'a>,
+
+    /// The current element we're anchoring on for evaluating the relative selector.
+    current_relative_selector_anchor: Option<OpaqueElement>,
+
+    quirks_mode: QuirksMode,
+    needs_selector_flags: NeedsSelectorFlags,
+
+    /// Whether we're matching in the context of invalidation.
+    matching_for_invalidation: MatchingForInvalidation,
+
+    /// Whether we're matching in the context of revalidation.
+    matching_for_revalidation: bool,
+
+    /// Caches to speed up expensive selector matches.
+    pub selector_caches: &'a mut SelectorCaches,
+
+    classes_and_ids_case_sensitivity: CaseSensitivity,
+    _impl: ::std::marker::PhantomData<Impl>,
+}
+
+impl<'a, Impl> MatchingContext<'a, Impl>
+where
+    Impl: SelectorImpl,
+{
+    /// Constructs a new `MatchingContext`.
+    pub fn new(
+        matching_mode: MatchingMode,
+        bloom_filter: Option<&'a BloomFilter>,
+        selector_caches: &'a mut SelectorCaches,
+        quirks_mode: QuirksMode,
+        needs_selector_flags: NeedsSelectorFlags,
+        matching_for_invalidation: MatchingForInvalidation,
+    ) -> Self {
+        Self::new_internal(
+            matching_mode,
+            bloom_filter,
+            selector_caches,
+            VisitedHandlingMode::AllLinksUnvisited,
+            quirks_mode,
+            needs_selector_flags,
+            matching_for_invalidation,
+            false,
+        )
+    }
+
+    /// Constructs a new `MatchingContext` for revalidation.
+    pub fn new_for_revalidation(
+        bloom_filter: Option<&'a BloomFilter>,
+        selector_caches: &'a mut SelectorCaches,
+        quirks_mode: QuirksMode,
+        needs_selector_flags: NeedsSelectorFlags,
+    ) -> Self {
+        Self::new_internal(
+            // NB: `MatchingMode` doesn't really matter, given we don't share style
+            // between pseudos.
+            MatchingMode::Normal,
+            bloom_filter,
+            selector_caches,
+            VisitedHandlingMode::AllLinksUnvisited,
+            quirks_mode,
+            needs_selector_flags,
+            MatchingForInvalidation::No,
+            true,
+        )
+    }
+
+    /// Constructs a new `MatchingContext` for use in visited matching.
+    pub fn new_for_visited(
+        matching_mode: MatchingMode,
+        bloom_filter: Option<&'a BloomFilter>,
+        selector_caches: &'a mut SelectorCaches,
+        visited_handling: VisitedHandlingMode,
+        quirks_mode: QuirksMode,
+        needs_selector_flags: NeedsSelectorFlags,
+        matching_for_invalidation: MatchingForInvalidation,
+    ) -> Self {
+        Self::new_internal(
+            matching_mode,
+            bloom_filter,
+            selector_caches,
+            visited_handling,
+            quirks_mode,
+            needs_selector_flags,
+            matching_for_invalidation,
+            false,
+        )
+    }
+
+    fn new_internal(
+        matching_mode: MatchingMode,
+        bloom_filter: Option<&'a BloomFilter>,
+        selector_caches: &'a mut SelectorCaches,
+        visited_handling: VisitedHandlingMode,
+        quirks_mode: QuirksMode,
+        needs_selector_flags: NeedsSelectorFlags,
+        matching_for_invalidation: MatchingForInvalidation,
+        matching_for_revalidation: bool,
+    ) -> Self {
+        Self {
+            matching_mode,
+            bloom_filter,
+            visited_handling,
+            quirks_mode,
+            classes_and_ids_case_sensitivity: quirks_mode.classes_and_ids_case_sensitivity(),
+            needs_selector_flags,
+            matching_for_invalidation,
+            matching_for_revalidation,
+            scope_element: None,
+            current_host: None,
+            featureless: false,
+            nesting_level: 0,
+            in_negation: false,
+            pseudo_element_matching_fn: None,
+            extra_data: Default::default(),
+            current_relative_selector_anchor: None,
+            selector_caches,
+            _impl: ::std::marker::PhantomData,
+        }
+    }
+
+    // Grab a reference to the appropriate cache.
+    #[inline]
+    pub fn nth_index_cache(
+        &mut self,
+        is_of_type: bool,
+        is_from_end: bool,
+        selectors: &[Selector<Impl>],
+    ) -> &mut NthIndexCacheInner {
+        self.selector_caches
+            .nth_index
+            .get(is_of_type, is_from_end, selectors)
+    }
+
+    /// Whether we're matching a nested selector.
+    #[inline]
+    pub fn is_nested(&self) -> bool {
+        self.nesting_level != 0
+    }
+
+    /// Whether we're matching inside a :not(..) selector.
+    #[inline]
+    pub fn in_negation(&self) -> bool {
+        self.in_negation
+    }
+
+    /// The quirks mode of the document.
+    #[inline]
+    pub fn quirks_mode(&self) -> QuirksMode {
+        self.quirks_mode
+    }
+
+    /// The matching-mode for this selector-matching operation.
+    #[inline]
+    pub fn matching_mode(&self) -> MatchingMode {
+        self.matching_mode
+    }
+
+    /// Whether we need to set selector flags.
+    #[inline]
+    pub fn needs_selector_flags(&self) -> bool {
+        self.needs_selector_flags == NeedsSelectorFlags::Yes
+    }
+
+    /// Whether or not we're matching to invalidate.
+    #[inline]
+    pub fn matching_for_invalidation(&self) -> bool {
+        self.matching_for_invalidation.is_for_invalidation()
+    }
+
+    /// Whether or not we're matching to revalidate.
+    #[inline]
+    pub fn matching_for_revalidation(&self) -> bool {
+        self.matching_for_revalidation
+    }
+
+    /// Whether or not we're comparing for invalidation, if we are matching for invalidation.
+    #[inline]
+    pub fn matching_for_invalidation_comparison(&self) -> Option<bool> {
+        match self.matching_for_invalidation {
+            MatchingForInvalidation::No => None,
+            MatchingForInvalidation::Yes => Some(false),
+            MatchingForInvalidation::YesForComparison => Some(true),
+        }
+    }
+
+    /// Run the given matching function for before/after invalidation comparison.
+    #[inline]
+    pub fn for_invalidation_comparison<F, R>(&mut self, f: F) -> R
+    where
+        F: FnOnce(&mut Self) -> R,
+    {
+        debug_assert!(
+            self.matching_for_invalidation(),
+            "Not matching for invalidation?"
+        );
+        let prev = self.matching_for_invalidation;
+        self.matching_for_invalidation = MatchingForInvalidation::YesForComparison;
+        let result = f(self);
+        self.matching_for_invalidation = prev;
+        result
+    }
+
+    /// The case-sensitivity for class and ID selectors
+    #[inline]
+    pub fn classes_and_ids_case_sensitivity(&self) -> CaseSensitivity {
+        self.classes_and_ids_case_sensitivity
+    }
+
+    /// Runs F with a deeper nesting level.
+    #[inline]
+    pub fn nest<F, R>(&mut self, f: F) -> R
+    where
+        F: FnOnce(&mut Self) -> R,
+    {
+        self.nesting_level += 1;
+        let result = f(self);
+        self.nesting_level -= 1;
+        result
+    }
+
+    /// Runs F with a deeper nesting level, and marking ourselves in a negation,
+    /// for a :not(..) selector, for example.
+    #[inline]
+    pub fn nest_for_negation<F, R>(&mut self, f: F) -> R
+    where
+        F: FnOnce(&mut Self) -> R,
+    {
+        let old_in_negation = self.in_negation;
+        self.in_negation = !self.in_negation;
+        let result = self.nest(f);
+        self.in_negation = old_in_negation;
+        result
+    }
+
+    #[inline]
+    pub fn visited_handling(&self) -> VisitedHandlingMode {
+        self.visited_handling
+    }
+
+    /// Runs F with a different featureless element flag.
+    #[inline]
+    pub fn with_featureless<F, R>(&mut self, featureless: bool, f: F) -> R
+    where
+        F: FnOnce(&mut Self) -> R,
+    {
+        let orig = self.featureless;
+        self.featureless = featureless;
+        let result = f(self);
+        self.featureless = orig;
+        result
+    }
+
+    /// Returns whether the currently matching element is acting as a featureless element (e.g.,
+    /// because we've crossed a shadow boundary). This is used to implement the :host selector
+    /// rules properly.
+    #[inline]
+    pub fn featureless(&self) -> bool {
+        self.featureless
+    }
+
+    /// Runs F with a different VisitedHandlingMode.
+    #[inline]
+    pub fn with_visited_handling_mode<F, R>(
+        &mut self,
+        handling_mode: VisitedHandlingMode,
+        f: F,
+    ) -> R
+    where
+        F: FnOnce(&mut Self) -> R,
+    {
+        let original_handling_mode = self.visited_handling;
+        self.visited_handling = handling_mode;
+        let result = f(self);
+        self.visited_handling = original_handling_mode;
+        result
+    }
+
+    /// Runs F with a given shadow host which is the root of the tree whose
+    /// rules we're matching.
+    #[inline]
+    pub fn with_shadow_host<F, E, R>(&mut self, host: Option<E>, f: F) -> R
+    where
+        E: Element,
+        F: FnOnce(&mut Self) -> R,
+    {
+        let original_host = self.current_host.take();
+        self.current_host = host.map(|h| h.opaque());
+        let result = f(self);
+        self.current_host = original_host;
+        result
+    }
+
+    /// Returns the current shadow host whose shadow root we're matching rules
+    /// against.
+    #[inline]
+    pub fn shadow_host(&self) -> Option<OpaqueElement> {
+        self.current_host
+    }
+
+    /// Runs F with a deeper nesting level, with the given element as the anchor,
+    /// for a :has(...) selector, for example.
+    #[inline]
+    pub fn nest_for_relative_selector<F, R>(&mut self, anchor: OpaqueElement, f: F) -> R
+    where
+        F: FnOnce(&mut Self) -> R,
+    {
+        debug_assert!(
+            self.current_relative_selector_anchor.is_none(),
+            "Nesting should've been rejected at parse time"
+        );
+        self.current_relative_selector_anchor = Some(anchor);
+        let result = self.nest(f);
+        self.current_relative_selector_anchor = None;
+        result
+    }
+
+    /// Runs F with a deeper nesting level, with the given element as the scope.
+    #[inline]
+    pub fn nest_for_scope<F, R>(&mut self, scope: Option<OpaqueElement>, f: F) -> R
+    where
+        F: FnOnce(&mut Self) -> R,
+    {
+        let original_scope_element = self.scope_element;
+        self.scope_element = scope;
+        let result = f(self);
+        self.scope_element = original_scope_element;
+        result
+    }
+
+    /// Runs F with a deeper nesting level, with the given element as the scope, for
+    /// matching `scope-start` and/or `scope-end` conditions.
+    #[inline]
+    pub fn nest_for_scope_condition<F, R>(&mut self, scope: Option<OpaqueElement>, f: F) -> R
+    where
+        F: FnOnce(&mut Self) -> R,
+    {
+        let original_matching_mode = self.matching_mode;
+        // We may as well be matching for a pseudo-element inside `@scope`, but
+        // the scope-defining selectors wouldn't be matching them.
+        self.matching_mode = MatchingMode::Normal;
+        let result = self.nest_for_scope(scope, f);
+        self.matching_mode = original_matching_mode;
+        result
+    }
+
+    /// Returns the current anchor element to evaluate the relative selector against.
+    #[inline]
+    pub fn relative_selector_anchor(&self) -> Option<OpaqueElement> {
+        self.current_relative_selector_anchor
+    }
+}

data/THIRD_PARTY_LICENSES/selectors-0.38.0/source/kleene_value.rs

@@ -0,0 +1,131 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+//! Kleen logic: https://en.wikipedia.org/wiki/Three-valued_logic#Kleene_and_Priest_logics
+
+/// A "trilean" value based on Kleen logic.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum KleeneValue {
+    /// False
+    False = 0,
+    /// True
+    True = 1,
+    /// Either true or false, but we’re not sure which yet.
+    Unknown,
+}
+
+impl From<bool> for KleeneValue {
+    fn from(b: bool) -> Self {
+        if b {
+            Self::True
+        } else {
+            Self::False
+        }
+    }
+}
+
+impl KleeneValue {
+    /// Turns this Kleene value to a bool, taking the unknown value as an
+    /// argument.
+    pub fn to_bool(self, unknown: bool) -> bool {
+        match self {
+            Self::True => true,
+            Self::False => false,
+            Self::Unknown => unknown,
+        }
+    }
+
+    /// Return true if any result of f() is definitely true.
+    /// Otherwise, return the `or` of all values.
+    /// Returns false if empty, like that of `Iterator`.
+    #[inline(always)]
+    pub fn any<T>(iter: impl Iterator<Item = T>, f: impl FnMut(T) -> Self) -> Self {
+        Self::any_value(iter, Self::True, Self::False, |a, b| a | b, f)
+    }
+
+    /// Return false if any results of f() is definitely false.
+    /// Otherwise, return the `and` of all values.
+    /// Returns true if empty, opposite of `Iterator`.
+    #[inline(always)]
+    pub fn any_false<T>(iter: impl Iterator<Item = T>, f: impl FnMut(T) -> Self) -> Self {
+        Self::any_value(iter, Self::False, Self::True, |a, b| a & b, f)
+    }
+
+    #[inline(always)]
+    fn any_value<T>(
+        iter: impl Iterator<Item = T>,
+        value: Self,
+        on_empty: Self,
+        op: impl Fn(Self, Self) -> Self,
+        mut f: impl FnMut(T) -> Self,
+    ) -> Self {
+        let mut result = None;
+        for item in iter {
+            let r = f(item);
+            if r == value {
+                return r;
+            }
+            if let Some(v) = result.as_mut() {
+                *v = op(*v, r);
+            } else {
+                result = Some(r);
+            }
+        }
+        result.unwrap_or(on_empty)
+    }
+}
+
+impl std::ops::Not for KleeneValue {
+    type Output = Self;
+
+    fn not(self) -> Self {
+        match self {
+            Self::True => Self::False,
+            Self::False => Self::True,
+            Self::Unknown => Self::Unknown,
+        }
+    }
+}
+
+// Implements the logical and operation.
+impl std::ops::BitAnd for KleeneValue {
+    type Output = Self;
+
+    fn bitand(self, other: Self) -> Self {
+        if self == Self::False || other == Self::False {
+            return Self::False;
+        }
+        if self == Self::Unknown || other == Self::Unknown {
+            return Self::Unknown;
+        }
+        Self::True
+    }
+}
+
+// Implements the logical or operation.
+impl std::ops::BitOr for KleeneValue {
+    type Output = Self;
+
+    fn bitor(self, other: Self) -> Self {
+        if self == Self::True || other == Self::True {
+            return Self::True;
+        }
+        if self == Self::Unknown || other == Self::Unknown {
+            return Self::Unknown;
+        }
+        Self::False
+    }
+}
+
+impl std::ops::BitOrAssign for KleeneValue {
+    fn bitor_assign(&mut self, other: Self) {
+        *self = *self | other;
+    }
+}
+
+impl std::ops::BitAndAssign for KleeneValue {
+    fn bitand_assign(&mut self, other: Self) {
+        *self = *self & other;
+    }
+}

data/THIRD_PARTY_LICENSES/selectors-0.38.0/source/lib.rs

@@ -0,0 +1,23 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+// Make |cargo bench| work.
+#![cfg_attr(feature = "bench", feature(test))]
+
+pub mod attr;
+pub mod bloom;
+mod builder;
+pub mod context;
+pub mod kleene_value;
+pub mod matching;
+mod nth_index_cache;
+pub mod parser;
+pub mod relative_selector;
+pub mod sink;
+mod tree;
+pub mod visitor;
+
+pub use crate::nth_index_cache::NthIndexCache;
+pub use crate::parser::{Parser, SelectorImpl, SelectorList};
+pub use crate::tree::{Element, OpaqueElement};