Full Code of servo/stylo for AI

gitextract_8xmmvn70/

├── .github/
│   └── workflows/
│       ├── main.yml
│       ├── mirror-to-release-branch.yml
│       └── sync-upstream.yml
├── .gitignore
├── Cargo.toml
├── README.md
├── SYNCING.md
├── commit-from-merge.sh
├── commit-from-squashed.sh
├── malloc_size_of/
│   ├── Cargo.toml
│   ├── LICENSE-APACHE
│   ├── LICENSE-MIT
│   └── lib.rs
├── rustfmt.toml
├── selectors/
│   ├── CHANGES.md
│   ├── Cargo.toml
│   ├── README.md
│   ├── attr.rs
│   ├── bloom.rs
│   ├── build.rs
│   ├── builder.rs
│   ├── context.rs
│   ├── kleene_value.rs
│   ├── lib.rs
│   ├── matching.rs
│   ├── nth_index_cache.rs
│   ├── parser.rs
│   ├── relative_selector/
│   │   ├── cache.rs
│   │   ├── filter.rs
│   │   └── mod.rs
│   ├── sink.rs
│   ├── tree.rs
│   └── visitor.rs
├── servo_arc/
│   ├── Cargo.toml
│   ├── LICENSE-APACHE
│   ├── LICENSE-MIT
│   └── lib.rs
├── shell.nix
├── start-rebase.sh
├── style/
│   ├── Cargo.toml
│   ├── README.md
│   ├── applicable_declarations.rs
│   ├── author_styles.rs
│   ├── bezier.rs
│   ├── bloom.rs
│   ├── build.rs
│   ├── build_gecko.rs
│   ├── color/
│   │   ├── color_function.rs
│   │   ├── component.rs
│   │   ├── convert.rs
│   │   ├── mix.rs
│   │   ├── mod.rs
│   │   ├── parsing.rs
│   │   └── to_css.rs
│   ├── context.rs
│   ├── counter_style/
│   │   ├── mod.rs
│   │   ├── predefined.rs
│   │   └── update_predefined.py
│   ├── custom_properties.rs
│   ├── custom_properties_map.rs
│   ├── data.rs
│   ├── device/
│   │   ├── gecko.rs
│   │   ├── mod.rs
│   │   └── servo.rs
│   ├── dom.rs
│   ├── dom_apis.rs
│   ├── driver.rs
│   ├── error_reporting.rs
│   ├── font_face.rs
│   ├── font_metrics.rs
│   ├── gecko/
│   │   ├── anon_boxes.toml
│   │   ├── arc_types.rs
│   │   ├── conversions.rs
│   │   ├── data.rs
│   │   ├── media_features.rs
│   │   ├── mod.rs
│   │   ├── non_ts_pseudo_class_list.rs
│   │   ├── pseudo_element.rs
│   │   ├── pseudo_element_definition.mako.rs
│   │   ├── pseudo_elements.py
│   │   ├── pseudo_elements.toml
│   │   ├── regen_atoms.py
│   │   ├── restyle_damage.rs
│   │   ├── selector_parser.rs
│   │   ├── snapshot.rs
│   │   ├── snapshot_helpers.rs
│   │   ├── traversal.rs
│   │   ├── url.rs
│   │   └── wrapper.rs
│   ├── gecko_bindings/
│   │   ├── mod.rs
│   │   └── sugar/
│   │       ├── mod.rs
│   │       ├── ns_com_ptr.rs
│   │       ├── ns_compatibility.rs
│   │       ├── ns_style_auto_array.rs
│   │       ├── origin_flags.rs
│   │       ├── ownership.rs
│   │       └── refptr.rs
│   ├── gecko_string_cache/
│   │   ├── mod.rs
│   │   └── namespace.rs
│   ├── global_style_data.rs
│   ├── invalidation/
│   │   ├── element/
│   │   │   ├── document_state.rs
│   │   │   ├── element_wrapper.rs
│   │   │   ├── invalidation_map.rs
│   │   │   ├── invalidator.rs
│   │   │   ├── mod.rs
│   │   │   ├── relative_selector.rs
│   │   │   ├── restyle_hints.rs
│   │   │   └── state_and_attributes.rs
│   │   ├── media_queries.rs
│   │   ├── mod.rs
│   │   ├── stylesheets.rs
│   │   └── viewport_units.rs
│   ├── lib.rs
│   ├── logical_geometry.rs
│   ├── macros.rs
│   ├── matching.rs
│   ├── media_queries/
│   │   ├── media_list.rs
│   │   ├── media_query.rs
│   │   └── mod.rs
│   ├── parallel.rs
│   ├── parser.rs
│   ├── piecewise_linear.rs
│   ├── properties/
│   │   ├── build.py
│   │   ├── cascade.rs
│   │   ├── computed_value_flags.rs
│   │   ├── counted_unknown_properties.py
│   │   ├── counter_style_descriptors.toml
│   │   ├── data.py
│   │   ├── declaration_block.rs
│   │   ├── font_face_descriptors.toml
│   │   ├── gecko.mako.rs
│   │   ├── helpers/
│   │   │   └── animated_properties.mako.rs
│   │   ├── helpers.mako.rs
│   │   ├── longhands.toml
│   │   ├── mod.rs
│   │   ├── properties.html.mako
│   │   ├── properties.mako.rs
│   │   ├── property_descriptors.toml
│   │   ├── shorthands.rs
│   │   ├── shorthands.toml
│   │   ├── vendored_python/
│   │   │   ├── mako-1.3.10-py3-none-any.whl
│   │   │   ├── markupsafe/
│   │   │   │   ├── LICENSE.txt
│   │   │   │   └── __init__.py
│   │   │   └── toml-0.10.2-py2.py3-none-any.whl
│   │   └── view_transition_descriptors.toml
│   ├── properties_and_values/
│   │   ├── mod.rs
│   │   ├── registry.rs
│   │   ├── rule.rs
│   │   ├── syntax/
│   │   │   ├── ascii.rs
│   │   │   ├── data_type.rs
│   │   │   └── mod.rs
│   │   └── value.rs
│   ├── queries/
│   │   ├── condition.rs
│   │   ├── feature.rs
│   │   ├── feature_expression.rs
│   │   ├── mod.rs
│   │   └── values.rs
│   ├── rule_cache.rs
│   ├── rule_collector.rs
│   ├── rule_tree/
│   │   ├── core.rs
│   │   ├── level.rs
│   │   ├── map.rs
│   │   ├── mod.rs
│   │   ├── source.rs
│   │   └── unsafe_box.rs
│   ├── scoped_tls.rs
│   ├── selector_map.rs
│   ├── selector_parser.rs
│   ├── servo/
│   │   ├── animation.rs
│   │   ├── attr.rs
│   │   ├── encoding_support.rs
│   │   ├── media_features.rs
│   │   ├── mod.rs
│   │   ├── restyle_damage.rs
│   │   ├── selector_parser.rs
│   │   ├── shadow_parts.rs
│   │   └── url.rs
│   ├── shared_lock.rs
│   ├── sharing/
│   │   ├── checks.rs
│   │   └── mod.rs
│   ├── simple_buckets_map.rs
│   ├── str.rs
│   ├── style_adjuster.rs
│   ├── style_resolver.rs
│   ├── stylesheet_set.rs
│   ├── stylesheets/
│   │   ├── appearance_base_rule.rs
│   │   ├── container_rule.rs
│   │   ├── counter_style_rule.rs
│   │   ├── document_rule.rs
│   │   ├── font_face_rule.rs
│   │   ├── font_feature_values_rule.rs
│   │   ├── font_palette_values_rule.rs
│   │   ├── import_rule.rs
│   │   ├── keyframes_rule.rs
│   │   ├── layer_rule.rs
│   │   ├── loader.rs
│   │   ├── margin_rule.rs
│   │   ├── media_rule.rs
│   │   ├── mod.rs
│   │   ├── namespace_rule.rs
│   │   ├── nested_declarations_rule.rs
│   │   ├── origin.rs
│   │   ├── page_rule.rs
│   │   ├── position_try_rule.rs
│   │   ├── property_rule.rs
│   │   ├── rule_list.rs
│   │   ├── rule_parser.rs
│   │   ├── rules_iterator.rs
│   │   ├── scope_rule.rs
│   │   ├── starting_style_rule.rs
│   │   ├── style_rule.rs
│   │   ├── stylesheet.rs
│   │   ├── supports_rule.rs
│   │   └── view_transition_rule.rs
│   ├── stylist.rs
│   ├── thread_state.rs
│   ├── traversal.rs
│   ├── traversal_flags.rs
│   ├── typed_om/
│   │   ├── mod.rs
│   │   ├── numeric_declaration.rs
│   │   ├── numeric_values.rs
│   │   └── sum_value.rs
│   ├── use_counters/
│   │   └── mod.rs
│   └── values/
│       ├── animated/
│       │   ├── color.rs
│       │   ├── effects.rs
│       │   ├── font.rs
│       │   ├── grid.rs
│       │   ├── lists.rs
│       │   ├── mod.rs
│       │   ├── svg.rs
│       │   └── transform.rs
│       ├── computed/
│       │   ├── align.rs
│       │   ├── angle.rs
│       │   ├── animation.rs
│       │   ├── background.rs
│       │   ├── basic_shape.rs
│       │   ├── border.rs
│       │   ├── box.rs
│       │   ├── color.rs
│       │   ├── column.rs
│       │   ├── counters.rs
│       │   ├── easing.rs
│       │   ├── effects.rs
│       │   ├── flex.rs
│       │   ├── font.rs
│       │   ├── image.rs
│       │   ├── length.rs
│       │   ├── length_percentage.rs
│       │   ├── list.rs
│       │   ├── mod.rs
│       │   ├── motion.rs
│       │   ├── outline.rs
│       │   ├── page.rs
│       │   ├── percentage.rs
│       │   ├── position.rs
│       │   ├── ratio.rs
│       │   ├── rect.rs
│       │   ├── resolution.rs
│       │   ├── svg.rs
│       │   ├── table.rs
│       │   ├── text.rs
│       │   ├── time.rs
│       │   ├── transform.rs
│       │   ├── ui.rs
│       │   └── url.rs
│       ├── distance.rs
│       ├── generics/
│       │   ├── animation.rs
│       │   ├── background.rs
│       │   ├── basic_shape.rs
│       │   ├── border.rs
│       │   ├── box.rs
│       │   ├── calc.rs
│       │   ├── color.rs
│       │   ├── column.rs
│       │   ├── counters.rs
│       │   ├── easing.rs
│       │   ├── effects.rs
│       │   ├── flex.rs
│       │   ├── font.rs
│       │   ├── grid.rs
│       │   ├── image.rs
│       │   ├── length.rs
│       │   ├── mod.rs
│       │   ├── motion.rs
│       │   ├── page.rs
│       │   ├── position.rs
│       │   ├── ratio.rs
│       │   ├── rect.rs
│       │   ├── size.rs
│       │   ├── svg.rs
│       │   ├── text.rs
│       │   ├── transform.rs
│       │   ├── ui.rs
│       │   └── url.rs
│       ├── mod.rs
│       ├── resolved/
│       │   ├── animation.rs
│       │   ├── color.rs
│       │   ├── counters.rs
│       │   └── mod.rs
│       └── specified/
│           ├── align.rs
│           ├── angle.rs
│           ├── animation.rs
│           ├── background.rs
│           ├── basic_shape.rs
│           ├── border.rs
│           ├── box.rs
│           ├── calc.rs
│           ├── color.rs
│           ├── column.rs
│           ├── counters.rs
│           ├── easing.rs
│           ├── effects.rs
│           ├── flex.rs
│           ├── font.rs
│           ├── grid.rs
│           ├── image.rs
│           ├── intersection_observer.rs
│           ├── length.rs
│           ├── list.rs
│           ├── mod.rs
│           ├── motion.rs
│           ├── outline.rs
│           ├── page.rs
│           ├── percentage.rs
│           ├── position.rs
│           ├── ratio.rs
│           ├── rect.rs
│           ├── resolution.rs
│           ├── source_size_list.rs
│           ├── svg.rs
│           ├── svg_path.rs
│           ├── table.rs
│           ├── text.rs
│           ├── time.rs
│           ├── transform.rs
│           ├── ui.rs
│           └── url.rs
├── style.paths
├── style_derive/
│   ├── Cargo.toml
│   ├── animate.rs
│   ├── cg.rs
│   ├── compute_squared_distance.rs
│   ├── lib.rs
│   ├── parse.rs
│   ├── specified_value_info.rs
│   ├── to_animated_value.rs
│   ├── to_animated_zero.rs
│   ├── to_computed_value.rs
│   ├── to_css.rs
│   ├── to_resolved_value.rs
│   └── to_typed.rs
├── style_traits/
│   ├── Cargo.toml
│   ├── arc_slice.rs
│   ├── dom.rs
│   ├── lib.rs
│   ├── owned_slice.rs
│   ├── owned_str.rs
│   ├── specified_value_info.rs
│   └── values.rs
├── stylo_atoms/
│   ├── Cargo.toml
│   ├── build.rs
│   ├── lib.rs
│   ├── predefined_counter_styles.rs
│   └── static_atoms.txt
├── stylo_dom/
│   ├── Cargo.toml
│   └── lib.rs
├── stylo_static_prefs/
│   ├── Cargo.toml
│   └── src/
│       └── lib.rs
├── sync.sh
├── to_shmem/
│   ├── Cargo.toml
│   └── lib.rs
└── to_shmem_derive/
    ├── Cargo.toml
    ├── lib.rs
    ├── to_shmem.rs
    └── util.rs

SYMBOL INDEX (8600 symbols across 306 files)

FILE: malloc_size_of/lib.rs
  type VoidPtrToSizeFn (line 57) | type VoidPtrToSizeFn = unsafe extern "C" fn(ptr: *const c_void) -> usize;
  type VoidPtrToBoolFnMut (line 60) | type VoidPtrToBoolFnMut = dyn FnMut(*const c_void) -> bool;
  type MallocSizeOfOps (line 63) | pub struct MallocSizeOfOps {
    method new (line 80) | pub fn new(
    method is_empty (line 94) | fn is_empty<T: ?Sized>(ptr: *const T) -> bool {
    method malloc_size_of (line 107) | pub unsafe fn malloc_size_of<T: ?Sized>(&self, ptr: *const T) -> usize {
    method has_malloc_enclosing_size_of (line 116) | pub fn has_malloc_enclosing_size_of(&self) -> bool {
    method malloc_enclosing_size_of (line 122) | pub unsafe fn malloc_enclosing_size_of<T>(&self, ptr: *const T) -> usi...
    method have_seen_ptr (line 128) | pub fn have_seen_ptr<T>(&mut self, ptr: *const T) -> bool {
  type MallocSizeOf (line 139) | pub trait MallocSizeOf {
    method size_of (line 142) | fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize;
    method size_of (line 186) | fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
    method size_of (line 192) | fn size_of(&self, _ops: &mut MallocSizeOfOps) -> usize {
    method size_of (line 205) | fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
    method size_of (line 211) | fn size_of(&self, _ops: &mut MallocSizeOfOps) -> usize {
    method size_of (line 221) | fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
    method size_of (line 232) | fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
    method size_of (line 244) | fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
    method size_of (line 250) | fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
    method size_of (line 260) | fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
    method size_of (line 269) | fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
    method size_of (line 275) | fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
    method size_of (line 284) | fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
    method size_of (line 293) | fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
    method size_of (line 309) | fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
    method size_of (line 336) | fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
    method size_of (line 360) | fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
    method size_of (line 385) | fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
    method size_of (line 494) | fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
    method size_of (line 506) | fn size_of(&self, _ops: &mut MallocSizeOfOps) -> usize {
    method size_of (line 557) | fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
    method size_of (line 563) | fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
    method size_of (line 573) | fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
    method size_of (line 579) | fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
    method size_of (line 585) | fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
    method size_of (line 591) | fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
    method size_of (line 597) | fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
    method size_of (line 606) | fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
    method size_of (line 612) | fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
    method size_of (line 623) | fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
    method size_of (line 644) | fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
    method size_of (line 650) | fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
    method size_of (line 746) | fn size_of(&self, _ops: &mut MallocSizeOfOps) -> usize {
    method size_of (line 752) | fn size_of(&self, _ops: &mut MallocSizeOfOps) -> usize {
    method size_of (line 759) | fn size_of(&self, _ops: &mut MallocSizeOfOps) -> usize {
    method size_of (line 766) | fn size_of(&self, _ops: &mut MallocSizeOfOps) -> usize {
  type MallocShallowSizeOf (line 146) | pub trait MallocShallowSizeOf {
    method shallow_size_of (line 151) | fn shallow_size_of(&self, ops: &mut MallocSizeOfOps) -> usize;
    method shallow_size_of (line 199) | fn shallow_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
    method shallow_size_of (line 303) | fn shallow_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
    method shallow_size_of (line 319) | fn shallow_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
    method shallow_size_of (line 346) | fn shallow_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
    method shallow_size_of (line 370) | fn shallow_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
    method shallow_size_of (line 478) | fn shallow_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
  type MallocUnconditionalSizeOf (line 157) | pub trait MallocUnconditionalSizeOf {
    method unconditional_size_of (line 160) | fn unconditional_size_of(&self, ops: &mut MallocSizeOfOps) -> usize;
    method unconditional_size_of (line 525) | fn unconditional_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
    method unconditional_size_of (line 662) | fn unconditional_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
    method unconditional_size_of (line 683) | fn unconditional_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
    method unconditional_size_of (line 704) | fn unconditional_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
  type MallocUnconditionalShallowSizeOf (line 164) | pub trait MallocUnconditionalShallowSizeOf {
    method unconditional_shallow_size_of (line 166) | fn unconditional_shallow_size_of(&self, ops: &mut MallocSizeOfOps) -> ...
    method unconditional_shallow_size_of (line 519) | fn unconditional_shallow_size_of(&self, ops: &mut MallocSizeOfOps) -> ...
  type MallocConditionalSizeOf (line 172) | pub trait MallocConditionalSizeOf {
    method conditional_size_of (line 176) | fn conditional_size_of(&self, ops: &mut MallocSizeOfOps) -> usize;
    method conditional_size_of (line 541) | fn conditional_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
  type MallocConditionalShallowSizeOf (line 180) | pub trait MallocConditionalShallowSizeOf {
    method conditional_shallow_size_of (line 182) | fn conditional_shallow_size_of(&self, ops: &mut MallocSizeOfOps) -> us...
    method conditional_shallow_size_of (line 531) | fn conditional_shallow_size_of(&self, ops: &mut MallocSizeOfOps) -> us...
  type Measurable (line 826) | pub struct Measurable<T: MallocSizeOf>(pub T);
  type Target (line 829) | type Target = T;
  method deref (line 831) | fn deref(&self) -> &T {
  method deref_mut (line 837) | fn deref_mut(&mut self) -> &mut T {

FILE: selectors/attr.rs
  type AttrSelectorWithOptionalNamespace (line 15) | pub struct AttrSelectorWithOptionalNamespace<Impl: SelectorImpl> {
  function namespace (line 26) | pub fn namespace(&self) -> Option<NamespaceConstraint<&Impl::NamespaceUr...
  type NamespaceConstraint (line 36) | pub enum NamespaceConstraint<NamespaceUrl> {
  type ParsedAttrSelectorOperation (line 45) | pub enum ParsedAttrSelectorOperation<AttrValue> {
  type AttrSelectorOperation (line 55) | pub enum AttrSelectorOperation<AttrValue> {
  function eval_str (line 65) | pub fn eval_str(&self, element_attr_value: &str) -> bool
  type AttrSelectorOperator (line 82) | pub enum AttrSelectorOperator {
    method eval_str (line 110) | pub fn eval_str(
  method to_css (line 92) | fn to_css<W>(&self, dest: &mut W) -> fmt::Result
  type ParsedCaseSensitivity (line 148) | pub enum ParsedCaseSensitivity {
  type CaseSensitivity (line 160) | pub enum CaseSensitivity {
    method eq (line 166) | pub fn eq(self, a: &[u8], b: &[u8]) -> bool {
    method contains (line 173) | pub fn contains(self, haystack: &str, needle: &str) -> bool {

FILE: selectors/bloom.rs
  constant BLOOM_HASH_MASK (line 12) | pub const BLOOM_HASH_MASK: u32 = 0x00ffffff;
  constant KEY_SIZE (line 13) | const KEY_SIZE: usize = 12;
  constant ARRAY_SIZE (line 15) | const ARRAY_SIZE: usize = 1 << KEY_SIZE;
  constant KEY_MASK (line 16) | const KEY_MASK: u32 = (1 << KEY_SIZE) - 1;
  type BloomFilter (line 19) | pub type BloomFilter = CountingBloomFilter<BloomStorageU8>;
  type CountingBloomFilter (line 68) | pub struct CountingBloomFilter<S>
  function new (line 81) | pub fn new() -> Self {
  function clear (line 86) | pub fn clear(&mut self) {
  function is_zeroed (line 93) | pub fn is_zeroed(&self) -> bool {
  function is_zeroed (line 98) | pub fn is_zeroed(&self) -> bool {
  function insert_hash (line 104) | pub fn insert_hash(&mut self, hash: u32) {
  function remove_hash (line 111) | pub fn remove_hash(&mut self, hash: u32) {
  function might_contain_hash (line 120) | pub fn might_contain_hash(&self, hash: u32) -> bool {
  method fmt (line 129) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  type BloomStorage (line 140) | pub trait BloomStorage: Clone + Default {
    method slot_is_empty (line 141) | fn slot_is_empty(&self, index: usize) -> bool;
    method adjust_slot (line 142) | fn adjust_slot(&mut self, index: usize, increment: bool);
    method is_zeroed (line 143) | fn is_zeroed(&self) -> bool;
    method first_slot_is_empty (line 146) | fn first_slot_is_empty(&self, hash: u32) -> bool {
    method second_slot_is_empty (line 151) | fn second_slot_is_empty(&self, hash: u32) -> bool {
    method adjust_first_slot (line 156) | fn adjust_first_slot(&mut self, hash: u32, increment: bool) {
    method adjust_second_slot (line 161) | fn adjust_second_slot(&mut self, hash: u32, increment: bool) {
    method first_slot_index (line 166) | fn first_slot_index(hash: u32) -> usize {
    method second_slot_index (line 171) | fn second_slot_index(hash: u32) -> usize {
    method adjust_slot (line 183) | fn adjust_slot(&mut self, index: usize, increment: bool) {
    method slot_is_empty (line 196) | fn slot_is_empty(&self, index: usize) -> bool {
    method is_zeroed (line 201) | fn is_zeroed(&self) -> bool {
    method adjust_slot (line 229) | fn adjust_slot(&mut self, index: usize, increment: bool) {
    method slot_is_empty (line 247) | fn slot_is_empty(&self, index: usize) -> bool {
    method is_zeroed (line 253) | fn is_zeroed(&self) -> bool {
  type BloomStorageU8 (line 177) | pub struct BloomStorageU8 {
  method default (line 207) | fn default() -> Self {
  method clone (line 215) | fn clone(&self) -> Self {
  type BloomStorageBool (line 223) | pub struct BloomStorageBool {
  method default (line 259) | fn default() -> Self {
  method clone (line 267) | fn clone(&self) -> Self {
  function hash1 (line 275) | fn hash1(hash: u32) -> u32 {
  function hash2 (line 280) | fn hash2(hash: u32) -> u32 {
  function create_and_insert_some_stuff (line 285) | fn create_and_insert_some_stuff() {
  type HashGenerator (line 348) | struct HashGenerator(u32);
    method next (line 351) | fn next(&mut self) -> u32 {
  function create_insert_1000_remove_100_lookup_100 (line 366) | fn create_insert_1000_remove_100_lookup_100(b: &mut test::Bencher) {
  function might_contain_10 (line 384) | fn might_contain_10(b: &mut test::Bencher) {
  function clear (line 395) | fn clear(b: &mut test::Bencher) {
  function insert_10 (line 401) | fn insert_10(b: &mut test::Bencher) {
  function remove_10 (line 412) | fn remove_10(b: &mut test::Bencher) {

FILE: selectors/build.rs
  function main (line 12) | fn main() {

FILE: selectors/builder.rs
  type SelectorBuilder (line 48) | pub struct SelectorBuilder<Impl: SelectorImpl> {
  function push (line 58) | fn push(&mut self, value: Component<Impl>) {
  function push_simple_selector (line 66) | pub fn push_simple_selector(&mut self, ss: Component<Impl>) {
  function push_combinator (line 74) | pub fn push_combinator(&mut self, c: Combinator) {
  function reverse_last_compound (line 80) | fn reverse_last_compound(&mut self) {
  function has_combinators (line 87) | pub fn has_combinators(&self) -> bool {
  function build (line 93) | pub fn build(&mut self, parse_relative: ParseRelative) -> SelectorData<I...
  function build_with_specificity_and_flags (line 105) | pub(crate) fn build_with_specificity_and_flags(
  method default (line 155) | fn default() -> Self {
  type ExactChain (line 165) | struct ExactChain<A, B>(A, B);
  method len (line 172) | fn len(&self) -> usize {
  type Item (line 182) | type Item = Item;
  method next (line 185) | fn next(&mut self) -> Option<Self::Item> {
  method size_hint (line 189) | fn size_hint(&self) -> (usize, Option<usize>) {
  type SelectorFlags (line 198) | pub(crate) struct SelectorFlags(u8);
    method fmt (line 212) | fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
    method forbidden_for_nesting (line 228) | pub(crate) fn forbidden_for_nesting() -> Self {
  type SpecificityAndFlags (line 235) | pub struct SpecificityAndFlags {
  constant MAX_10BIT (line 243) | const MAX_10BIT: u32 = (1u32 << 10) - 1;
  type Specificity (line 246) | pub(crate) struct Specificity {
    method single_class_like (line 255) | pub fn single_class_like() -> Self {
    method from (line 266) | fn from(value: u32) -> Specificity {
  function from (line 278) | fn from(specificity: Specificity) -> u32 {
  function specificity_and_flags (line 285) | fn specificity_and_flags<Impl>(
  function selector_list_specificity_and_flags (line 428) | pub(crate) fn selector_list_specificity_and_flags<'a, Impl: SelectorImpl>(
  function relative_selector_list_specificity_and_flags (line 450) | pub(crate) fn relative_selector_list_specificity_and_flags<Impl: Selecto...

FILE: selectors/context.rs
  type MatchingMode (line 18) | pub enum MatchingMode {
  type VisitedHandlingMode (line 38) | pub enum VisitedHandlingMode {
    method matches_visited (line 55) | pub fn matches_visited(&self) -> bool {
    method matches_unvisited (line 64) | pub fn matches_unvisited(&self) -> bool {
  type NeedsSelectorFlags (line 76) | pub enum NeedsSelectorFlags {
  type MatchingForInvalidation (line 83) | pub enum MatchingForInvalidation {
    method is_for_invalidation (line 91) | pub fn is_for_invalidation(&self) -> bool {
  type QuirksMode (line 100) | pub enum QuirksMode {
    method classes_and_ids_case_sensitivity (line 111) | pub fn classes_and_ids_case_sensitivity(self) -> CaseSensitivity {
  type SelectorCaches (line 121) | pub struct SelectorCaches {
  type MatchingContext (line 133) | pub struct MatchingContext<'a, Impl>
  function new (line 200) | pub fn new(
  function new_for_revalidation (line 221) | pub fn new_for_revalidation(
  function new_for_visited (line 242) | pub fn new_for_visited(
  function new_internal (line 263) | fn new_internal(
  function nth_index_cache (line 297) | pub fn nth_index_cache(
  function is_nested (line 310) | pub fn is_nested(&self) -> bool {
  function in_negation (line 316) | pub fn in_negation(&self) -> bool {
  function quirks_mode (line 322) | pub fn quirks_mode(&self) -> QuirksMode {
  function matching_mode (line 328) | pub fn matching_mode(&self) -> MatchingMode {
  function needs_selector_flags (line 334) | pub fn needs_selector_flags(&self) -> bool {
  function matching_for_invalidation (line 340) | pub fn matching_for_invalidation(&self) -> bool {
  function matching_for_revalidation (line 346) | pub fn matching_for_revalidation(&self) -> bool {
  function matching_for_invalidation_comparison (line 352) | pub fn matching_for_invalidation_comparison(&self) -> Option<bool> {
  function for_invalidation_comparison (line 362) | pub fn for_invalidation_comparison<F, R>(&mut self, f: F) -> R
  function classes_and_ids_case_sensitivity (line 379) | pub fn classes_and_ids_case_sensitivity(&self) -> CaseSensitivity {
  function nest (line 385) | pub fn nest<F, R>(&mut self, f: F) -> R
  function nest_for_negation (line 398) | pub fn nest_for_negation<F, R>(&mut self, f: F) -> R
  function visited_handling (line 410) | pub fn visited_handling(&self) -> VisitedHandlingMode {
  function with_featureless (line 416) | pub fn with_featureless<F, R>(&mut self, featureless: bool, f: F) -> R
  function featureless (line 431) | pub fn featureless(&self) -> bool {
  function with_visited_handling_mode (line 437) | pub fn with_visited_handling_mode<F, R>(
  function with_shadow_host (line 455) | pub fn with_shadow_host<F, E, R>(&mut self, host: Option<E>, f: F) -> R
  function shadow_host (line 470) | pub fn shadow_host(&self) -> Option<OpaqueElement> {
  function nest_for_relative_selector (line 477) | pub fn nest_for_relative_selector<F, R>(&mut self, anchor: OpaqueElement...
  function nest_for_scope (line 493) | pub fn nest_for_scope<F, R>(&mut self, scope: Option<OpaqueElement>, f: ...
  function nest_for_scope_condition (line 507) | pub fn nest_for_scope_condition<F, R>(&mut self, scope: Option<OpaqueEle...
  function relative_selector_anchor (line 522) | pub fn relative_selector_anchor(&self) -> Option<OpaqueElement> {

FILE: selectors/kleene_value.rs
  type KleeneValue (line 9) | pub enum KleeneValue {
    method from (line 19) | fn from(b: bool) -> Self {
    method to_bool (line 31) | pub fn to_bool(self, unknown: bool) -> bool {
    method any (line 43) | pub fn any<T>(iter: impl Iterator<Item = T>, f: impl FnMut(T) -> Self)...
    method any_false (line 51) | pub fn any_false<T>(iter: impl Iterator<Item = T>, f: impl FnMut(T) ->...
    method any_value (line 56) | fn any_value<T>(
    type Output (line 80) | type Output = Self;
    method not (line 82) | fn not(self) -> Self {
    type Output (line 93) | type Output = Self;
    method bitand (line 95) | fn bitand(self, other: Self) -> Self {
    type Output (line 108) | type Output = Self;
    method bitor (line 110) | fn bitor(self, other: Self) -> Self {
    method bitor_assign (line 122) | fn bitor_assign(&mut self, other: Self) {
    method bitand_assign (line 128) | fn bitand_assign(&mut self, other: Self) {

FILE: selectors/matching.rs
  method for_self (line 92) | pub fn for_self(self) -> ElementSelectorFlags {
  method for_parent (line 101) | pub fn for_parent(self) -> ElementSelectorFlags {
  type LocalMatchingContext (line 111) | struct LocalMatchingContext<'a, 'b: 'a, Impl: SelectorImpl> {
  function matches_selector_list (line 118) | pub fn matches_selector_list<E>(
  function selector_may_match (line 141) | pub fn selector_may_match(hashes: &AncestorHashes, bf: &BloomFilter) -> ...
  type SelectorMatchingResult (line 225) | enum SelectorMatchingResult {
  method from (line 235) | fn from(value: SelectorMatchingResult) -> Self {
  function matches_selector (line 255) | pub fn matches_selector<E>(
  function matches_selector_kleene (line 279) | pub fn matches_selector_kleene<E>(
  type CompoundSelectorMatchingResult (line 311) | pub enum CompoundSelectorMatchingResult {
  function complex_selector_early_reject_by_local_name (line 321) | fn complex_selector_early_reject_by_local_name<E: Element>(
  function early_reject_by_local_name (line 332) | pub fn early_reject_by_local_name<E: Element>(
  function matches_compound_selector_from (line 359) | pub fn matches_compound_selector_from<E>(
  function matches_complex_selector (line 440) | fn matches_complex_selector<E>(
  function matches_complex_selector_list (line 492) | fn matches_complex_selector_list<E: Element>(
  function matches_relative_selector (line 503) | fn matches_relative_selector<E: Element>(
  function relative_selector_match_early (line 593) | fn relative_selector_match_early<E: Element>(
  function match_relative_selectors (line 623) | fn match_relative_selectors<E: Element>(
  function do_match_relative_selectors (line 655) | fn do_match_relative_selectors<E: Element>(
  function matches_relative_selector_subtree (line 702) | fn matches_relative_selector_subtree<E: Element>(
  function hover_and_active_quirk_applies (line 733) | fn hover_and_active_quirk_applies<Impl: SelectorImpl>(
  type SubjectOrPseudoElement (line 759) | enum SubjectOrPseudoElement {
  function host_for_part (line 764) | fn host_for_part<E>(element: &E, context: &MatchingContext<E::Impl>) -> ...
  function assigned_slot (line 782) | fn assigned_slot<E>(element: &E, context: &MatchingContext<E::Impl>) -> ...
  type NextElement (line 797) | struct NextElement<E> {
  function new (line 804) | fn new(next_element: Option<E>, featureless: bool) -> Self {
  function next_element_for_combinator (line 813) | fn next_element_for_combinator<E>(
  function matches_complex_selector_internal (line 845) | fn matches_complex_selector_internal<E>(
  function matches_local_name (line 1000) | fn matches_local_name<E>(element: &E, local_name: &LocalName<E::Impl>) -...
  function matches_part (line 1008) | fn matches_part<E>(
  function matches_host (line 1054) | fn matches_host<E>(
  function matches_slotted (line 1080) | fn matches_slotted<E>(
  function matches_rare_attribute_selector (line 1096) | fn matches_rare_attribute_selector<E>(
  function compound_matches_featureless_host (line 1132) | pub(crate) fn compound_matches_featureless_host<Impl: SelectorImpl>(
  function matches_compound_selector (line 1192) | fn matches_compound_selector<E>(
  function matches_simple_selector (line 1225) | fn matches_simple_selector<E>(
  function select_name (line 1364) | pub fn select_name<'a, E: Element, T: PartialEq>(
  function to_unconditional_case_sensitivity (line 1377) | pub fn to_unconditional_case_sensitivity<'a, E: Element>(
  function matches_generic_nth_child (line 1396) | fn matches_generic_nth_child<E>(
  function nth_child_index (line 1525) | fn nth_child_index<E>(

FILE: selectors/nth_index_cache.rs
  type NthIndexCache (line 16) | pub struct NthIndexCache {
    method get (line 27) | pub fn get<Impl: SelectorImpl>(
  type SelectorListCacheKey (line 56) | struct SelectorListCacheKey(usize);
    method new (line 61) | fn new<Impl: SelectorImpl>(selectors: &[Selector<Impl>]) -> Self {
  type NthIndexOfSelectorsCaches (line 68) | pub struct NthIndexOfSelectorsCaches(FxHashMap<SelectorListCacheKey, Nth...
    method lookup (line 73) | pub fn lookup<Impl: SelectorImpl>(
  type NthIndexCacheInner (line 85) | pub struct NthIndexCacheInner(FxHashMap<OpaqueElement, i32>);
    method lookup (line 89) | pub fn lookup(&mut self, el: OpaqueElement) -> Option<i32> {
    method insert (line 94) | pub fn insert(&mut self, element: OpaqueElement, index: i32) {
    method is_empty (line 99) | pub fn is_empty(&self) -> bool {

FILE: selectors/parser.rs
  type PseudoElement (line 35) | pub trait PseudoElement: Sized + ToCss {
    method accepts_state_pseudo_classes (line 41) | fn accepts_state_pseudo_classes(&self) -> bool {
    method valid_after_slotted (line 46) | fn valid_after_slotted(&self) -> bool {
    method valid_after_before_or_after (line 51) | fn valid_after_before_or_after(&self) -> bool {
    method parses_as_element_backed (line 57) | fn parses_as_element_backed(&self) -> bool {
    method is_before_or_after (line 64) | fn is_before_or_after(&self) -> bool {
    method specificity_count (line 69) | fn specificity_count(&self) -> u32 {
    method is_in_pseudo_element_tree (line 76) | fn is_in_pseudo_element_tree(&self) -> bool {
    type Impl (line 3789) | type Impl = DummySelectorImpl;
    method accepts_state_pseudo_classes (line 3791) | fn accepts_state_pseudo_classes(&self) -> bool {
    method valid_after_slotted (line 3795) | fn valid_after_slotted(&self) -> bool {
    method valid_after_before_or_after (line 3799) | fn valid_after_before_or_after(&self) -> bool {
    method is_before_or_after (line 3803) | fn is_before_or_after(&self) -> bool {
    method parses_as_element_backed (line 3807) | fn parses_as_element_backed(&self) -> bool {
  type NonTSPseudoClass (line 82) | pub trait NonTSPseudoClass: Sized + ToCss {
    method is_active_or_hover (line 87) | fn is_active_or_hover(&self) -> bool;
    method is_user_action_state (line 92) | fn is_user_action_state(&self) -> bool;
    method visit (line 94) | fn visit<V>(&self, _visitor: &mut V) -> bool
  function to_ascii_lowercase (line 104) | fn to_ascii_lowercase(s: &str) -> Cow<'_, str> {
  method allows_slotted (line 169) | fn allows_slotted(self) -> bool {
  method allows_part (line 174) | fn allows_part(self) -> bool {
  method allows_non_functional_pseudo_classes (line 179) | fn allows_non_functional_pseudo_classes(self) -> bool {
  method allows_tree_structural_pseudo_classes (line 184) | fn allows_tree_structural_pseudo_classes(self) -> bool {
  method allows_combinators (line 189) | fn allows_combinators(self) -> bool {
  method allows_only_child_pseudo_class_only (line 194) | fn allows_only_child_pseudo_class_only(self) -> bool {
  type SelectorParseError (line 199) | pub type SelectorParseError<'i> = ParseError<'i, SelectorParseErrorKind<...
  type SelectorParseErrorKind (line 202) | pub enum SelectorParseErrorKind<'i> {
  type Parser (line 278) | pub trait Parser<'i> {
    method parse_slotted (line 283) | fn parse_slotted(&self) -> bool {
    method parse_part (line 288) | fn parse_part(&self) -> bool {
    method parse_nth_child_of (line 293) | fn parse_nth_child_of(&self) -> bool {
    method parse_is_and_where (line 298) | fn parse_is_and_where(&self) -> bool {
    method parse_has (line 303) | fn parse_has(&self) -> bool {
    method parse_parent_selector (line 308) | fn parse_parent_selector(&self) -> bool {
    method is_is_alias (line 313) | fn is_is_alias(&self, _name: &str) -> bool {
    method parse_host (line 318) | fn parse_host(&self) -> bool {
    method allow_forgiving_selectors (line 323) | fn allow_forgiving_selectors(&self) -> bool {
    method parse_non_ts_pseudo_class (line 329) | fn parse_non_ts_pseudo_class(
    method parse_non_ts_functional_pseudo_class (line 341) | fn parse_non_ts_functional_pseudo_class<'t>(
    method parse_pseudo_element (line 354) | fn parse_pseudo_element(
    method parse_functional_pseudo_element (line 366) | fn parse_functional_pseudo_element<'t>(
    method default_namespace (line 378) | fn default_namespace(&self) -> Option<<Self::Impl as SelectorImpl>::Na...
    method namespace_for_prefix (line 382) | fn namespace_for_prefix(
  type SelectorList (line 395) | pub struct SelectorList<Impl: SelectorImpl>(
  function mark_as_intentionally_leaked (line 402) | pub fn mark_as_intentionally_leaked(&self) {
  function from_one (line 411) | pub fn from_one(selector: Selector<Impl>) -> Self {
  function from_iter (line 424) | pub fn from_iter(mut iter: impl ExactSizeIterator<Item = Selector<Impl>>...
  function slice (line 436) | pub fn slice(&self) -> &[Selector<Impl>] {
  function len (line 448) | pub fn len(&self) -> usize {
  function thin_arc_heap_ptr (line 456) | pub fn thin_arc_heap_ptr(&self) -> *const ::std::os::raw::c_void {
  type SelectorKey (line 467) | pub struct SelectorKey(usize);
    method new (line 471) | pub fn new<Impl: SelectorImpl>(selector: &Selector<Impl>) -> Self {
  type ForgivingParsing (line 478) | enum ForgivingParsing {
  type ParseRelative (line 490) | pub enum ParseRelative {
  function scope (line 505) | pub fn scope() -> Self {
  function implicit_scope (line 509) | pub fn implicit_scope() -> Self {
  function parse (line 517) | pub fn parse<'i, 't, P>(
  function parse_disallow_pseudo (line 535) | pub fn parse_disallow_pseudo<'i, 't, P>(
  function parse_forgiving (line 552) | pub fn parse_forgiving<'i, 't, P>(
  function parse_with_state (line 570) | fn parse_with_state<'i, 't, P>(
  function replace_parent_selector (line 605) | pub fn replace_parent_selector(&self, parent: &SelectorList<Impl>) -> Se...
  function from_vec (line 615) | pub(crate) fn from_vec(v: Vec<Selector<Impl>>) -> Self {
  function parse_inner_compound_selector (line 621) | fn parse_inner_compound_selector<'i, 't, P, Impl>(
  type AncestorHashes (line 654) | pub struct AncestorHashes {
    method new (line 761) | pub fn new<Impl: SelectorImpl>(selector: &Selector<Impl>, quirks_mode:...
    method fourth_hash (line 783) | pub fn fourth_hash(&self) -> u32 {
  function collect_selector_hashes (line 658) | pub(crate) fn collect_selector_hashes<'a, Impl: SelectorImpl, Iter>(
  function collect_ancestor_hashes (line 749) | fn collect_ancestor_hashes<Impl: SelectorImpl>(
  function namespace_empty_string (line 791) | pub fn namespace_empty_string<Impl: SelectorImpl>() -> Impl::NamespaceUrl {
  type SelectorData (line 796) | pub(super) type SelectorData<Impl> = ThinArc<SpecificityAndFlags, Compon...
  type MatchesFeaturelessHost (line 801) | pub enum MatchesFeaturelessHost {
    method may_match (line 813) | pub fn may_match(self) -> bool {
  type Selector (line 836) | pub struct Selector<Impl: SelectorImpl>(
  function mark_as_intentionally_leaked (line 842) | pub fn mark_as_intentionally_leaked(&self) {
  function scope (line 846) | fn scope() -> Self {
  function implicit_scope (line 857) | fn implicit_scope() -> Self {
  function specificity (line 868) | pub fn specificity(&self) -> u32 {
  function flags (line 873) | pub(crate) fn flags(&self) -> SelectorFlags {
  function has_pseudo_element (line 878) | pub fn has_pseudo_element(&self) -> bool {
  function has_parent_selector (line 883) | pub fn has_parent_selector(&self) -> bool {
  function has_scope_selector (line 888) | pub fn has_scope_selector(&self) -> bool {
  function is_slotted (line 893) | pub fn is_slotted(&self) -> bool {
  function is_part (line 898) | pub fn is_part(&self) -> bool {
  function parts (line 903) | pub fn parts(&self) -> Option<&[Impl::Identifier]> {
  function pseudo_element (line 928) | pub fn pseudo_element(&self) -> Option<&Impl::PseudoElement> {
  function pseudo_elements (line 944) | pub fn pseudo_elements(&self) -> SmallVec<[&Impl::PseudoElement; 3]> {
  function is_universal (line 973) | pub fn is_universal(&self) -> bool {
  function matches_featureless_host (line 988) | pub fn matches_featureless_host(
  function iter (line 1025) | pub fn iter(&self) -> SelectorIter<'_, Impl> {
  function iter_skip_relative_selector_anchor (line 1034) | pub fn iter_skip_relative_selector_anchor(&self) -> SelectorIter<'_, Imp...
  function iter_from (line 1059) | pub fn iter_from(&self, offset: usize) -> SelectorIter<'_, Impl> {
  function combinator_at_match_order (line 1070) | pub fn combinator_at_match_order(&self, index: usize) -> Combinator {
  function iter_raw_match_order (line 1083) | pub fn iter_raw_match_order(&self) -> slice::Iter<'_, Component<Impl>> {
  function combinator_at_parse_order (line 1090) | pub fn combinator_at_parse_order(&self, index: usize) -> Combinator {
  function iter_raw_parse_order_from (line 1104) | pub fn iter_raw_parse_order_from(
  function from_vec (line 1113) | pub(crate) fn from_vec(
  function into_data (line 1131) | fn into_data(self) -> SelectorData<Impl> {
  function replace_parent_selector (line 1135) | pub fn replace_parent_selector(&self, parent: &SelectorList<Impl>) -> Se...
  function len (line 1355) | pub fn len(&self) -> usize {
  function thin_arc_heap_ptr (line 1360) | pub fn thin_arc_heap_ptr(&self) -> *const ::std::os::raw::c_void {
  function visit (line 1382) | pub fn visit<V>(&self, visitor: &mut V) -> bool
  function parse (line 1410) | pub fn parse<'i, 't, P>(
  function new_invalid (line 1425) | pub fn new_invalid(s: &str) -> Self {
  function is_rightmost (line 1470) | pub fn is_rightmost(&self, offset: usize) -> bool {
  type SelectorIter (line 1482) | pub struct SelectorIter<'a, Impl: 'a + SelectorImpl> {
  function next_sequence (line 1491) | pub fn next_sequence(&mut self) -> Option<Combinator> {
  function matches_for_stateless_pseudo_element (line 1496) | pub(crate) fn matches_for_stateless_pseudo_element(&mut self) -> bool {
  function matches_for_stateless_pseudo_element_internal (line 1507) | fn matches_for_stateless_pseudo_element_internal(&mut self, first: &Comp...
  function selector_length (line 1524) | pub fn selector_length(&self) -> usize {
  type Item (line 1530) | type Item = &'a Component<Impl>;
  method next (line 1533) | fn next(&mut self) -> Option<Self::Item> {
  function fmt (line 1549) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  type CombinatorIter (line 1559) | struct CombinatorIter<'a, Impl: 'a + SelectorImpl>(SelectorIter<'a, Impl>);
  function new (line 1561) | fn new(inner: SelectorIter<'a, Impl>) -> Self {
  function consume_non_combinators (line 1567) | fn consume_non_combinators(&mut self) {
  type Item (line 1573) | type Item = Combinator;
  method next (line 1574) | fn next(&mut self) -> Option<Self::Item> {
  type AncestorIter (line 1582) | struct AncestorIter<'a, Impl: 'a + SelectorImpl>(SelectorIter<'a, Impl>);
  function new (line 1586) | fn new(inner: SelectorIter<'a, Impl>) -> Self {
  function skip_until_ancestor (line 1594) | fn skip_until_ancestor(&mut self) {
  type Item (line 1610) | type Item = &'a Component<Impl>;
  method next (line 1611) | fn next(&mut self) -> Option<Self::Item> {
  type Combinator (line 1631) | pub enum Combinator {
    method is_ancestor (line 1654) | pub fn is_ancestor(&self) -> bool {
    method is_pseudo_element (line 1666) | pub fn is_pseudo_element(&self) -> bool {
    method is_sibling (line 1672) | pub fn is_sibling(&self) -> bool {
    method to_css_internal (line 2557) | fn to_css_internal<W>(&self, dest: &mut W, prefix_space: bool) -> fmt:...
    method to_css_relative (line 2581) | fn to_css_relative<W>(&self, dest: &mut W) -> fmt::Result
  type NthType (line 1681) | pub enum NthType {
    method is_only (line 1691) | pub fn is_only(self) -> bool {
    method is_of_type (line 1695) | pub fn is_of_type(self) -> bool {
    method is_from_end (line 1699) | pub fn is_from_end(self) -> bool {
  type AnPlusB (line 1708) | pub struct AnPlusB(pub i32, pub i32);
    method matches_index (line 1712) | pub fn matches_index(&self, i: i32) -> bool {
  method to_css (line 1728) | fn to_css<W>(&self, dest: &mut W) -> fmt::Result
  type NthSelectorData (line 1753) | pub struct NthSelectorData {
    method only (line 1762) | pub const fn only(of_type: bool) -> Self {
    method first (line 1776) | pub const fn first(of_type: bool) -> Self {
    method last (line 1790) | pub const fn last(of_type: bool) -> Self {
    method is_simple_edge (line 1804) | pub fn is_simple_edge(&self) -> bool {
    method write_start (line 1813) | fn write_start<W: fmt::Write>(&self, dest: &mut W) -> fmt::Result {
    method write_affine (line 1829) | fn write_affine<W: fmt::Write>(&self, dest: &mut W) -> fmt::Result {
  type NthOfSelectorData (line 1840) | pub struct NthOfSelectorData<Impl: SelectorImpl>(
  function new (line 1847) | pub fn new<I>(nth_data: &NthSelectorData, selectors: I) -> Self
  function nth_data (line 1856) | pub fn nth_data(&self) -> &NthSelectorData {
  function selectors (line 1862) | pub fn selectors(&self) -> &[Selector<Impl>] {
  type RelativeSelectorMatchHint (line 1870) | pub enum RelativeSelectorMatchHint {
    method new (line 1887) | pub fn new(
    method is_descendant_direction (line 1932) | pub fn is_descendant_direction(&self) -> bool {
    method is_next_sibling (line 1937) | pub fn is_next_sibling(&self) -> bool {
    method is_subtree (line 1942) | pub fn is_subtree(&self) -> bool {
  type RelativeSelectorCombinatorCount (line 1952) | pub struct RelativeSelectorCombinatorCount {
    method new (line 1960) | pub fn new<Impl: SelectorImpl>(relative_selector: &RelativeSelector<Im...
    method get_match_hint (line 1988) | pub fn get_match_hint(&self) -> RelativeSelectorMatchHint {
  type RelativeSelector (line 2001) | pub struct RelativeSelector<Impl: SelectorImpl> {
  method for_relative_selector (line 2019) | fn for_relative_selector<Impl: SelectorImpl>(inner_selector: &Selector<I...
  function from_selector_list (line 2042) | fn from_selector_list(selector_list: SelectorList<Impl>) -> Box<[Self]> {
  type Component (line 2086) | pub enum Component<Impl: SelectorImpl> {
  function is_combinator (line 2196) | pub fn is_combinator(&self) -> bool {
  function is_host (line 2202) | pub fn is_host(&self) -> bool {
  function as_combinator (line 2207) | pub fn as_combinator(&self) -> Option<Combinator> {
  function matches_for_stateless_pseudo_element (line 2217) | fn matches_for_stateless_pseudo_element(&self) -> bool {
  function visit (line 2235) | pub fn visit<V>(&self, visitor: &mut V) -> bool
  function has_indexed_selector_in_subject (line 2325) | pub fn has_indexed_selector_in_subject(&self) -> bool {
  type LocalName (line 2350) | pub struct LocalName<Impl: SelectorImpl> {
  method fmt (line 2357) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  method fmt (line 2370) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  method fmt (line 2375) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  method fmt (line 2380) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  function serialize_selector_list (line 2385) | fn serialize_selector_list<'a, Impl, I, W>(iter: I, dest: &mut W) -> fmt...
  method to_css (line 2403) | fn to_css<W>(&self, dest: &mut W) -> fmt::Result
  method to_css (line 2412) | fn to_css<W>(&self, dest: &mut W) -> fmt::Result
  method to_css (line 2590) | fn to_css<W>(&self, dest: &mut W) -> fmt::Result
  method to_css (line 2599) | fn to_css<W>(&self, dest: &mut W) -> fmt::Result
  method to_css (line 2734) | fn to_css<W>(&self, dest: &mut W) -> fmt::Result
  method to_css (line 2771) | fn to_css<W>(&self, dest: &mut W) -> fmt::Result
  function parse_selector (line 2783) | fn parse_selector<'i, 't, P, Impl>(
  function try_parse_combinator (line 2860) | fn try_parse_combinator<'i, 't>(input: &mut CssParser<'i, 't>) -> Result...
  function parse_type_selector (line 2891) | fn parse_type_selector<'i, 't, P, Impl, S>(
  type SimpleSelectorParseResult (line 2961) | enum SimpleSelectorParseResult<Impl: SelectorImpl> {
  type QNamePrefix (line 2969) | enum QNamePrefix<Impl: SelectorImpl> {
  type OptionalQName (line 2978) | enum OptionalQName<'i, Impl: SelectorImpl> {
  function parse_qualified_name (line 2987) | fn parse_qualified_name<'i, 't, P, Impl>(
  function parse_attribute_selector (line 3082) | fn parse_attribute_selector<'i, 't, P, Impl>(
  type AttributeFlags (line 3205) | enum AttributeFlags {
    method to_case_sensitivity (line 3215) | fn to_case_sensitivity(
  function parse_attribute_flags (line 3240) | fn parse_attribute_flags<'i, 't>(
  function parse_negation (line 3268) | fn parse_negation<'i, 't, P, Impl>(
  function parse_compound_selector (line 3296) | fn parse_compound_selector<'i, 't, P, Impl>(
  function parse_is_where (line 3399) | fn parse_is_where<'i, 't, P, Impl>(
  function parse_has (line 3427) | fn parse_has<'i, 't, P, Impl>(
  function parse_functional_pseudo_class (line 3459) | fn parse_functional_pseudo_class<'i, 't, P, Impl>(
  function parse_nth_pseudo_class (line 3504) | fn parse_nth_pseudo_class<'i, 't, P, Impl>(
  function is_css2_pseudo_element (line 3551) | pub fn is_css2_pseudo_element(name: &str) -> bool {
  function parse_one_simple_selector (line 3564) | fn parse_one_simple_selector<'i, 't, P, Impl>(
  function parse_simple_pseudo_class (line 3707) | fn parse_simple_pseudo_class<'i, P, Impl>(
  type PseudoClass (line 3773) | pub enum PseudoClass {
    type Impl (line 3813) | type Impl = DummySelectorImpl;
    method is_active_or_hover (line 3816) | fn is_active_or_hover(&self) -> bool {
    method is_user_action_state (line 3821) | fn is_user_action_state(&self) -> bool {
  type PseudoElement (line 3780) | pub enum PseudoElement {
    method accepts_state_pseudo_classes (line 41) | fn accepts_state_pseudo_classes(&self) -> bool {
    method valid_after_slotted (line 46) | fn valid_after_slotted(&self) -> bool {
    method valid_after_before_or_after (line 51) | fn valid_after_before_or_after(&self) -> bool {
    method parses_as_element_backed (line 57) | fn parses_as_element_backed(&self) -> bool {
    method is_before_or_after (line 64) | fn is_before_or_after(&self) -> bool {
    method specificity_count (line 69) | fn specificity_count(&self) -> u32 {
    method is_in_pseudo_element_tree (line 76) | fn is_in_pseudo_element_tree(&self) -> bool {
    type Impl (line 3789) | type Impl = DummySelectorImpl;
    method accepts_state_pseudo_classes (line 3791) | fn accepts_state_pseudo_classes(&self) -> bool {
    method valid_after_slotted (line 3795) | fn valid_after_slotted(&self) -> bool {
    method valid_after_before_or_after (line 3799) | fn valid_after_before_or_after(&self) -> bool {
    method is_before_or_after (line 3803) | fn is_before_or_after(&self) -> bool {
    method parses_as_element_backed (line 3807) | fn parses_as_element_backed(&self) -> bool {
  method to_css (line 3827) | fn to_css<W>(&self, dest: &mut W) -> fmt::Result
  method to_css (line 3844) | fn to_css<W>(&self, dest: &mut W) -> fmt::Result
  type DummySelectorImpl (line 3863) | pub struct DummySelectorImpl;
  type DummyParser (line 3866) | pub struct DummyParser {
    method default_with_namespace (line 3872) | fn default_with_namespace(default_ns: DummyAtom) -> DummyParser {
    type Impl (line 3946) | type Impl = DummySelectorImpl;
    type Error (line 3947) | type Error = SelectorParseErrorKind<'i>;
    method parse_slotted (line 3949) | fn parse_slotted(&self) -> bool {
    method parse_nth_child_of (line 3953) | fn parse_nth_child_of(&self) -> bool {
    method parse_is_and_where (line 3957) | fn parse_is_and_where(&self) -> bool {
    method parse_has (line 3961) | fn parse_has(&self) -> bool {
    method parse_parent_selector (line 3965) | fn parse_parent_selector(&self) -> bool {
    method parse_part (line 3969) | fn parse_part(&self) -> bool {
    method parse_host (line 3973) | fn parse_host(&self) -> bool {
    method parse_non_ts_pseudo_class (line 3977) | fn parse_non_ts_pseudo_class(
    method parse_non_ts_functional_pseudo_class (line 3994) | fn parse_non_ts_functional_pseudo_class<'t>(
    method parse_pseudo_element (line 4014) | fn parse_pseudo_element(
    method parse_functional_pseudo_element (line 4033) | fn parse_functional_pseudo_element<'t>(
    method default_namespace (line 4049) | fn default_namespace(&self) -> Option<DummyAtom> {
    method namespace_for_prefix (line 4053) | fn namespace_for_prefix(&self, prefix: &DummyAtom) -> Option<DummyAtom> {
  type ExtraMatchingData (line 3881) | type ExtraMatchingData<'a> = std::marker::PhantomData<&'a ()>;
  type AttrValue (line 3882) | type AttrValue = DummyAttrValue;
  type Identifier (line 3883) | type Identifier = DummyAtom;
  type LocalName (line 3884) | type LocalName = DummyAtom;
  type NamespaceUrl (line 3885) | type NamespaceUrl = DummyAtom;
  type NamespacePrefix (line 3886) | type NamespacePrefix = DummyAtom;
  type BorrowedLocalName (line 3887) | type BorrowedLocalName = DummyAtom;
  type BorrowedNamespaceUrl (line 3888) | type BorrowedNamespaceUrl = DummyAtom;
  type NonTSPseudoClass (line 3889) | type NonTSPseudoClass = PseudoClass;
  type PseudoElement (line 3890) | type PseudoElement = PseudoElement;
  type DummyAttrValue (line 3894) | pub struct DummyAttrValue(String);
    method from (line 3910) | fn from(string: &'a str) -> Self {
  method to_css (line 3897) | fn to_css<W>(&self, dest: &mut W) -> fmt::Result
  type DummyAtom (line 3916) | pub struct DummyAtom(String);
    method from (line 3928) | fn from(string: String) -> Self {
    method from (line 3934) | fn from(string: &'a str) -> Self {
  method to_css (line 3919) | fn to_css<W>(&self, dest: &mut W) -> fmt::Result
  method precomputed_hash (line 3940) | fn precomputed_hash(&self) -> u32 {
  function parse (line 4058) | fn parse<'i>(
  function parse_relative (line 4064) | fn parse_relative<'i>(
  function parse_expected (line 4071) | fn parse_expected<'i, 'a>(
  function parse_relative_expected (line 4078) | fn parse_relative_expected<'i, 'a>(
  function parse_ns (line 4086) | fn parse_ns<'i>(
  function parse_ns_relative (line 4093) | fn parse_ns_relative<'i>(
  function parse_ns_expected (line 4101) | fn parse_ns_expected<'i, 'a>(
  function parse_ns_relative_expected (line 4109) | fn parse_ns_relative_expected<'i, 'a>(
  function specificity (line 4136) | fn specificity(a: u32, b: u32, c: u32) -> u32 {
  function test_empty (line 4141) | fn test_empty() {
  constant MATHML (line 4151) | const MATHML: &str = "http://www.w3.org/1998/Math/MathML";
  constant SVG (line 4152) | const SVG: &str = "http://www.w3.org/2000/svg";
  function test_parsing (line 4155) | fn test_parsing() {
  function parent_selector (line 4630) | fn parent_selector() {
  function test_pseudo_iter (line 4672) | fn test_pseudo_iter() {
  function test_pseudo_before_marker (line 4696) | fn test_pseudo_before_marker() {
  function test_pseudo_duplicate_before_after_or_marker (line 4719) | fn test_pseudo_duplicate_before_after_or_marker() {
  function test_pseudo_on_element_backed_pseudo (line 4726) | fn test_pseudo_on_element_backed_pseudo() {
  function test_universal (line 4749) | fn test_universal() {
  function test_empty_pseudo_iter (line 4760) | fn test_empty_pseudo_iter() {
  function test_parse_implicit_scope (line 4776) | fn test_parse_implicit_scope() {
  type TestVisitor (line 4832) | struct TestVisitor {
  type Impl (line 4837) | type Impl = DummySelectorImpl;
  method visit_simple_selector (line 4839) | fn visit_simple_selector(&mut self, s: &Component<DummySelectorImpl>) ->...
  function visitor (line 4848) | fn visitor() {

FILE: selectors/relative_selector/cache.rs
  type RelativeSelectorCachedMatch (line 24) | pub enum RelativeSelectorCachedMatch {
    method matched (line 33) | pub fn matched(&self) -> bool {
  type Key (line 39) | struct Key {
    method new (line 45) | pub fn new<Impl: SelectorImpl>(
  type RelativeSelectorCache (line 58) | pub struct RelativeSelectorCache {
    method add (line 64) | pub fn add<Impl: SelectorImpl>(
    method lookup (line 74) | pub fn lookup<Impl: SelectorImpl>(

FILE: selectors/relative_selector/filter.rs
  type Entry (line 14) | enum Entry {
  type TraversalKind (line 25) | enum TraversalKind {
  function add_to_filter (line 30) | fn add_to_filter<E: Element>(element: &E, filter: &mut BloomFilter, kind...
  type Key (line 47) | struct Key(OpaqueElement, TraversalKind);
  type RelativeSelectorFilterMap (line 51) | pub struct RelativeSelectorFilterMap {
    method get_filter (line 87) | fn get_filter<E: Element>(&mut self, element: &E, kind: TraversalKind)...
    method fast_reject (line 116) | pub fn fast_reject<Impl: SelectorImpl, E: Element>(
  function fast_reject (line 55) | fn fast_reject<Impl: SelectorImpl>(

FILE: selectors/sink.rs
  type Push (line 16) | pub trait Push<T> {
    method push (line 18) | fn push(&mut self, value: T);
  function push (line 22) | fn push(&mut self, value: T) {
  function push (line 28) | fn push(&mut self, value: A::Item) {

FILE: selectors/tree.rs
  type OpaqueElement (line 17) | pub struct OpaqueElement(NonNull<()>);
    method new (line 26) | pub fn new<T>(ptr: &T) -> Self {
    method from_non_null_ptr (line 35) | pub fn from_non_null_ptr(ptr: NonNull<()>) -> Self {
    method as_const_ptr (line 41) | pub unsafe fn as_const_ptr<T>(&self) -> *const T {
  type Element (line 46) | pub trait Element: Sized + Clone + Debug {
    method opaque (line 50) | fn opaque(&self) -> OpaqueElement;
    method parent_element (line 52) | fn parent_element(&self) -> Option<Self>;
    method parent_node_is_shadow_root (line 55) | fn parent_node_is_shadow_root(&self) -> bool;
    method containing_shadow_host (line 58) | fn containing_shadow_host(&self) -> Option<Self>;
    method pseudo_element_originating_element (line 64) | fn pseudo_element_originating_element(&self) -> Option<Self> {
    method is_pseudo_element (line 70) | fn is_pseudo_element(&self) -> bool;
    method prev_sibling_element (line 73) | fn prev_sibling_element(&self) -> Option<Self>;
    method next_sibling_element (line 76) | fn next_sibling_element(&self) -> Option<Self>;
    method first_element_child (line 79) | fn first_element_child(&self) -> Option<Self>;
    method is_html_element_in_html_document (line 81) | fn is_html_element_in_html_document(&self) -> bool;
    method has_local_name (line 83) | fn has_local_name(&self, local_name: &<Self::Impl as SelectorImpl>::Bo...
    method has_namespace (line 86) | fn has_namespace(&self, ns: &<Self::Impl as SelectorImpl>::BorrowedNam...
    method is_same_type (line 89) | fn is_same_type(&self, other: &Self) -> bool;
    method attr_matches (line 91) | fn attr_matches(
    method has_attr_in_no_namespace (line 98) | fn has_attr_in_no_namespace(
    method match_non_ts_pseudo_class (line 109) | fn match_non_ts_pseudo_class(
    method match_pseudo_element (line 115) | fn match_pseudo_element(
    method apply_selector_flags (line 124) | fn apply_selector_flags(&self, flags: ElementSelectorFlags);
    method is_link (line 127) | fn is_link(&self) -> bool;
    method is_html_slot_element (line 130) | fn is_html_slot_element(&self) -> bool;
    method assigned_slot (line 135) | fn assigned_slot(&self) -> Option<Self> {
    method has_id (line 139) | fn has_id(
    method has_class (line 145) | fn has_class(
    method has_custom_state (line 151) | fn has_custom_state(&self, name: &<Self::Impl as SelectorImpl>::Identi...
    method imported_part (line 155) | fn imported_part(
    method is_part (line 160) | fn is_part(&self, name: &<Self::Impl as SelectorImpl>::Identifier) -> ...
    method is_empty (line 166) | fn is_empty(&self) -> bool;
    method is_root (line 173) | fn is_root(&self) -> bool;
    method ignores_nth_child_selectors (line 177) | fn ignores_nth_child_selectors(&self) -> bool {
    method add_element_unique_hashes (line 183) | fn add_element_unique_hashes(&self, filter: &mut BloomFilter) -> bool;

FILE: selectors/visitor.rs
  type SelectorVisitor (line 17) | pub trait SelectorVisitor: Sized {
    method visit_attribute_selector (line 24) | fn visit_attribute_selector(
    method visit_simple_selector (line 34) | fn visit_simple_selector(&mut self, _: &Component<Self::Impl>) -> bool {
    method visit_relative_selector_list (line 42) | fn visit_relative_selector_list(&mut self, _list: &[RelativeSelector<S...
    method visit_selector_list (line 50) | fn visit_selector_list(
    method visit_complex_selector (line 67) | fn visit_complex_selector(&mut self, _combinator_to_right: Option<Comb...
  method from_component (line 92) | pub fn from_component<Impl: SelectorImpl>(component: &Component<Impl>) -...
  method in_negation (line 103) | pub fn in_negation(&self) -> bool {
  method in_is (line 108) | pub fn in_is(&self) -> bool {
  method in_where (line 113) | pub fn in_where(&self) -> bool {
  method in_nth_of (line 119) | pub fn in_nth_of(&self) -> bool {
  method in_has (line 124) | pub fn in_has(&self) -> bool {
  method relevant_to_nth_of_dependencies (line 129) | pub fn relevant_to_nth_of_dependencies(&self) -> bool {

FILE: servo_arc/lib.rs
  constant MAX_REFCOUNT (line 50) | const MAX_REFCOUNT: usize = (isize::MAX) as usize;
  constant STATIC_REFCOUNT (line 54) | const STATIC_REFCOUNT: usize = usize::MAX;
  type Arc (line 69) | pub struct Arc<T: ?Sized> {
  type UniqueArc (line 100) | pub struct UniqueArc<T: ?Sized>(Arc<T>);
  function new (line 105) | pub fn new(data: T) -> Self {
  function new_uninit (line 111) | pub fn new_uninit() -> UniqueArc<mem::MaybeUninit<T>> {
  function shareable (line 136) | pub fn shareable(self) -> Arc<T> {
  function assume_init (line 144) | pub unsafe fn assume_init(this: Self) -> UniqueArc<T> {
  type Target (line 153) | type Target = T;
  method deref (line 154) | fn deref(&self) -> &T {
  method deref_mut (line 160) | fn deref_mut(&mut self) -> &mut T {
  type ArcInner (line 176) | struct ArcInner<T: ?Sized> {
  function data_offset (line 195) | fn data_offset<T>() -> usize {
  function new (line 205) | pub fn new(data: T) -> Self {
  function new_leaked (line 239) | pub fn new_leaked(data: T) -> Self {
  function into_raw (line 249) | pub fn into_raw(this: Self) -> *const T {
  function from_raw (line 260) | pub unsafe fn from_raw(ptr: *const T) -> Self {
  function from_raw_addrefed (line 272) | pub unsafe fn from_raw_addrefed(ptr: *const T) -> Self {
  function new_static (line 286) | pub unsafe fn new_static<F>(alloc: F, data: T) -> Arc<T>
  function borrow_arc (line 313) | pub fn borrow_arc<'a>(&'a self) -> ArcBorrow<'a, T> {
  function heap_ptr (line 321) | pub fn heap_ptr(&self) -> *const c_void {
  function inner (line 332) | fn inner(&self) -> &ArcInner<T> {
  function record_drop (line 342) | fn record_drop(&self) {
  function mark_as_intentionally_leaked (line 355) | pub fn mark_as_intentionally_leaked(&self) {
  function drop_slow (line 362) | unsafe fn drop_slow(&mut self) {
  function ptr_eq (line 377) | pub fn ptr_eq(this: &Self, other: &Self) -> bool {
  function ptr (line 381) | fn ptr(&self) -> *mut ArcInner<T> {
  function raw_ptr (line 386) | pub fn raw_ptr(&self) -> ptr::NonNull<()> {
  function NS_LogCtor (line 393) | fn NS_LogCtor(
  function NS_LogDtor (line 398) | fn NS_LogDtor(
  method clone (line 407) | fn clone(&self) -> Self {
  type Target (line 451) | type Target = T;
  method deref (line 454) | fn deref(&self) -> &T {
  function make_mut (line 474) | pub fn make_mut(this: &mut Self) -> &mut T {
  function get_mut (line 494) | pub fn get_mut(this: &mut Self) -> Option<&mut T> {
  function is_static (line 507) | pub fn is_static(&self) -> bool {
  function is_unique (line 516) | pub fn is_unique(&self) -> bool {
  method drop (line 526) | fn drop(&mut self) {
  method eq (line 568) | fn eq(&self, other: &Arc<T>) -> bool {
  method ne (line 572) | fn ne(&self, other: &Arc<T>) -> bool {
  method partial_cmp (line 578) | fn partial_cmp(&self, other: &Arc<T>) -> Option<Ordering> {
  method lt (line 582) | fn lt(&self, other: &Arc<T>) -> bool {
  method le (line 586) | fn le(&self, other: &Arc<T>) -> bool {
  method gt (line 590) | fn gt(&self, other: &Arc<T>) -> bool {
  method ge (line 594) | fn ge(&self, other: &Arc<T>) -> bool {
  method cmp (line 599) | fn cmp(&self, other: &Arc<T>) -> Ordering {
  function fmt (line 606) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  function fmt (line 612) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  function fmt (line 618) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  method default (line 624) | fn default() -> Arc<T> {
  method hash (line 630) | fn hash<H: Hasher>(&self, state: &mut H) {
  function from (line 637) | fn from(t: T) -> Self {
  function borrow (line 644) | fn borrow(&self) -> &T {
  function as_ref (line 651) | fn as_ref(&self) -> &T {
  function deserialize (line 661) | fn deserialize<D>(deserializer: D) -> Result<Arc<T>, D::Error>
  method serialize (line 671) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  type HeaderSlice (line 686) | pub struct HeaderSlice<H, T> {
  method eq (line 698) | fn eq(&self, other: &Self) -> bool {
  method drop (line 704) | fn drop(&mut self) {
  function fmt (line 716) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  function slice (line 727) | pub fn slice(&self) -> &[T] {
  function data (line 732) | fn data(&self) -> *const T {
  function data_mut (line 737) | fn data_mut(&mut self) -> *mut T {
  function slice_mut (line 743) | pub fn slice_mut(&mut self) -> &mut [T] {
  function len (line 749) | pub fn len(&self) -> usize {
  function from_header_and_iter_alloc (line 767) | pub fn from_header_and_iter_alloc<F, I>(
  function from_header_and_iter_with_size (line 855) | pub fn from_header_and_iter_with_size<I>(header: H, items: I, num_items:...
  function from_header_and_iter (line 871) | pub fn from_header_and_iter<I>(header: H, items: I) -> Self
  type ThinArc (line 887) | pub type ThinArc<H, T> = Arc<HeaderSlice<H, T>>;
  type ThinArcUnion (line 890) | pub type ThinArcUnion<H1, T1, H2, T2> = ArcUnion<HeaderSlice<H1, T1>, He...
  function from_header_and_iter (line 894) | pub fn from_header_and_iter<I>(header: H, items: I) -> Self
  function from_header_and_iter_with_size (line 902) | pub fn from_header_and_iter_with_size<I>(header: H, items: I, num_items:...
  function header_mut (line 912) | pub fn header_mut(&mut self) -> &mut H {
  function data_mut (line 918) | pub fn data_mut(&mut self) -> &mut [T] {
  type ArcBorrow (line 939) | pub struct ArcBorrow<'a, T: 'a>(&'a T);
  method clone (line 944) | fn clone(&self) -> Self {
  function clone_arc (line 952) | pub fn clone_arc(&self) -> Arc<T> {
  function from_ref (line 962) | pub unsafe fn from_ref(r: &'a T) -> Self {
  function ptr_eq (line 968) | pub fn ptr_eq(this: &Self, other: &Self) -> bool {
  function with_arc (line 975) | pub fn with_arc<F, U>(&self, f: F) -> U
  function get (line 993) | pub fn get(&self) -> &'a T {
  type Target (line 999) | type Target = T;
  method deref (line 1002) | fn deref(&self) -> &T {
  type ArcUnion (line 1016) | pub struct ArcUnion<A, B> {
  method eq (line 1026) | fn eq(&self, other: &Self) -> bool {
  type ArcUnionBorrow (line 1040) | pub enum ArcUnionBorrow<'a, A: 'a, B: 'a> {
  function new (line 1046) | unsafe fn new(ptr: *mut ()) -> Self {
  function ptr_eq (line 1056) | pub fn ptr_eq(this: &Self, other: &Self) -> bool {
  function ptr (line 1061) | pub fn ptr(&self) -> ptr::NonNull<()> {
  function borrow (line 1067) | pub fn borrow(&self) -> ArcUnionBorrow<'_, A, B> {
  function from_first (line 1080) | pub fn from_first(other: Arc<A>) -> Self {
  function from_second (line 1087) | pub fn from_second(other: Arc<B>) -> Self {
  function is_first (line 1094) | pub fn is_first(&self) -> bool {
  function is_second (line 1099) | pub fn is_second(&self) -> bool {
  function as_first (line 1104) | pub fn as_first(&self) -> Option<ArcBorrow<'_, A>> {
  function as_second (line 1112) | pub fn as_second(&self) -> Option<ArcBorrow<'_, B>> {
  method clone (line 1121) | fn clone(&self) -> Self {
  method drop (line 1130) | fn drop(&mut self) {
  function fmt (line 1143) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  type Canary (line 1157) | struct Canary(*mut atomic::AtomicUsize);
  method drop (line 1160) | fn drop(&mut self) {
  function empty_thin (line 1168) | fn empty_thin() {
  function thin_assert_padding (line 1175) | fn thin_assert_padding() {
  function slices_and_thin (line 1191) | fn slices_and_thin() {

FILE: style/applicable_declarations.rs
  type ApplicableDeclarationList (line 22) | pub type ApplicableDeclarationList = SmallVec<[ApplicableDeclarationBloc...
  constant SOURCE_ORDER_BITS (line 35) | const SOURCE_ORDER_BITS: usize = 24;
  constant SOURCE_ORDER_MAX (line 36) | const SOURCE_ORDER_MAX: u32 = (1 << SOURCE_ORDER_BITS) - 1;
  constant SOURCE_ORDER_MASK (line 37) | const SOURCE_ORDER_MASK: u32 = SOURCE_ORDER_MAX;
  type CascadePriority (line 41) | pub struct CascadePriority {
    method new (line 100) | pub fn new(
    method flags (line 114) | pub fn flags(&self) -> RuleCascadeFlags {
    method set_flags (line 120) | pub fn set_flags(&mut self, flags: RuleCascadeFlags) {
    method layer_order (line 126) | pub fn layer_order(&self) -> LayerOrder {
    method cascade_level (line 132) | pub fn cascade_level(&self) -> CascadeLevel {
    method allows_when_reverted (line 140) | pub fn allows_when_reverted(&self, other: &Self, kind: RevertKind) -> ...
    method unimportant (line 153) | pub fn unimportant(&self) -> Self {
    method important (line 162) | pub fn important(&self) -> Self {
    method same_tree_author_normal_at_root_layer (line 171) | pub fn same_tree_author_normal_at_root_layer() -> Self {
  method partial_cmp (line 54) | fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
  method cmp (line 60) | fn cmp(&self, other: &Self) -> std::cmp::Ordering {
  type RevertKind (line 89) | pub enum RevertKind {
  type ScopeProximity (line 184) | pub struct ScopeProximity(u16);
    method new (line 206) | pub fn new(proximity: usize) -> Self {
    method infinity (line 214) | pub fn infinity() -> Self {
    method get (line 219) | pub fn get(&self) -> Option<u16> {
  method partial_cmp (line 188) | fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
  method cmp (line 194) | fn cmp(&self, other: &Self) -> std::cmp::Ordering {
  constant PROXIMITY_INFINITY (line 202) | const PROXIMITY_INFINITY: u16 = u16::MAX;
  type ApplicableDeclarationBlock (line 230) | pub struct ApplicableDeclarationBlock {
    method from_declarations (line 250) | pub fn from_declarations(
    method new (line 266) | pub fn new(
    method source_order (line 286) | pub fn source_order(&self) -> u32 {
    method level (line 292) | pub fn level(&self) -> CascadeLevel {
    method layer_order (line 298) | pub fn layer_order(&self) -> LayerOrder {
    method scope_proximity (line 304) | pub fn scope_proximity(&self) -> ScopeProximity {
    method for_rule_tree (line 311) | pub fn for_rule_tree(self) -> (StyleSource, CascadePriority) {
    method sort_key (line 317) | pub fn sort_key(&self) -> (LayerOrder, u32, ScopeProximity, u32) {

FILE: style/author_styles.rs
  type GenericAuthorStyles (line 21) | pub struct GenericAuthorStyles<S>
  function new (line 44) | pub fn new() -> Self {
  function flush (line 53) | pub fn flush(

FILE: style/bezier.rs
  constant NEWTON_METHOD_ITERATIONS (line 13) | const NEWTON_METHOD_ITERATIONS: u8 = 8;
  type Bezier (line 16) | pub struct Bezier {
    method calculate_bezier_output (line 33) | pub fn calculate_bezier_output(
    method new (line 84) | fn new(x1: CSSFloat, y1: CSSFloat, x2: CSSFloat, y2: CSSFloat) -> Bezi...
    method sample_curve_x (line 102) | fn sample_curve_x(&self, t: f64) -> f64 {
    method sample_curve_y (line 108) | fn sample_curve_y(&self, t: f64) -> f64 {
    method sample_curve_derivative_x (line 113) | fn sample_curve_derivative_x(&self, t: f64) -> f64 {
    method solve_curve_x (line 118) | fn solve_curve_x(&self, x: f64, epsilon: f64) -> f64 {
    method solve (line 162) | fn solve(&self, x: f64, epsilon: f64) -> f64 {
  type ApproxEq (line 167) | trait ApproxEq {
    method approx_eq (line 168) | fn approx_eq(self, value: Self, epsilon: Self) -> bool;
    method approx_eq (line 173) | fn approx_eq(self, value: f64, epsilon: f64) -> bool {

FILE: style/bloom.rs
  type StyleBloom (line 63) | pub struct StyleBloom<E: TElement> {
  constant MEMSET_CLEAR_THRESHOLD (line 86) | const MEMSET_CLEAR_THRESHOLD: usize = 25;
  type PushedElement (line 88) | struct PushedElement<E: TElement> {
  function new (line 97) | fn new(el: E, num_hashes: usize) -> Self {
  function is_attr_name_excluded_from_filter (line 110) | pub fn is_attr_name_excluded_from_filter(name: &LocalName) -> bool {
  function each_relevant_element_hash (line 115) | pub fn each_relevant_element_hash<E, F>(element: E, mut f: F)
  method drop (line 137) | fn drop(&mut self) {
  function new (line 153) | pub fn new() -> Self {
  function filter (line 167) | pub fn filter(&self) -> &BloomFilter {
  function push (line 173) | pub fn push(&mut self, element: E) {
  function push_internal (line 184) | fn push_internal(&mut self, element: E) {
  function pop (line 196) | fn pop(&mut self) -> Option<E> {
  function matching_depth (line 221) | pub fn matching_depth(&self) -> usize {
  function clear (line 226) | pub fn clear(&mut self) {
  function rebuild (line 241) | pub fn rebuild(&mut self, mut element: E) {
  function assert_complete (line 259) | pub fn assert_complete(&self, mut element: E) {
  function current_parent (line 278) | pub fn current_parent(&self) -> Option<E> {
  function insert_parents_recovering (line 290) | pub fn insert_parents_recovering(&mut self, element: E, element_depth: u...

FILE: style/build.rs
  function generate (line 16) | pub fn generate() {}
  function generate_properties (line 43) | fn generate_properties(engine: &str) {
  function main (line 75) | fn main() {

FILE: style/build_gecko.rs
  constant STRUCTS_FILE (line 25) | const STRUCTS_FILE: &'static str = "structs.rs";
  function read_config (line 27) | fn read_config(path: &PathBuf) -> Table {
  function get_modified_time (line 73) | fn get_modified_time(file: &Path) -> Option<SystemTime> {
  function update_last_modified (line 77) | fn update_last_modified(file: &Path) {
  function search_include (line 83) | fn search_include(name: &str) -> Option<PathBuf> {
  function add_headers_recursively (line 94) | fn add_headers_recursively(path: PathBuf, added_paths: &mut HashSet<Path...
  function add_include (line 110) | fn add_include(name: &str) -> String {
  type BuilderExt (line 121) | trait BuilderExt {
    method get_initial_builder (line 122) | fn get_initial_builder() -> Builder;
    method include (line 123) | fn include<T: Into<String>>(self, file: T) -> Builder;
    method get_initial_builder (line 127) | fn get_initial_builder() -> Builder {
    method include (line 157) | fn include<T: Into<String>>(self, file: T) -> Builder {
  type Fixup (line 162) | struct Fixup {
  function write_binding_file (line 167) | fn write_binding_file(builder: Builder, file: &str, fixups: &[Fixup]) {
  type BuilderWithConfig (line 202) | struct BuilderWithConfig<'a> {
  function new (line 208) | fn new(builder: Builder, config: &'a Table) -> Self {
  function handle_list (line 216) | fn handle_list<F>(self, key: &'static str, func: F) -> BuilderWithConfig...
  function handle_items (line 233) | fn handle_items<F>(self, key: &'static str, mut func: F) -> BuilderWithC...
  function handle_str_items (line 239) | fn handle_str_items<F>(self, key: &'static str, mut func: F) -> BuilderW...
  function handle_table_items (line 245) | fn handle_table_items<F>(self, key: &'static str, mut func: F) -> Builde...
  function handle_common (line 251) | fn handle_common(self, fixups: &mut Vec<Fixup>) -> BuilderWithConfig<'a> {
  function get_builder (line 264) | fn get_builder(self) -> Builder {
  function generate_structs (line 274) | fn generate_structs() {
  function setup_logging (line 319) | fn setup_logging() -> bool {
  function generate_atoms (line 370) | fn generate_atoms() {
  function generate (line 386) | pub fn generate() {

FILE: style/color/color_function.rs
  type ColorFunction (line 25) | pub enum ColorFunction<OriginColor> {
  function resolve_to_absolute (line 95) | pub fn resolve_to_absolute(&self) -> Result<AbsoluteColor, ()> {
  function has_origin_color (line 357) | pub fn has_origin_color(&self) -> bool {
  function resolve_to_absolute (line 372) | pub fn resolve_to_absolute(&self) -> Result<AbsoluteColor, ()> {
  function map_origin_color (line 381) | pub fn map_origin_color<U>(
  function resolve_to_absolute (line 426) | pub fn resolve_to_absolute(&self, current_color: &AbsoluteColor) -> Abso...
  function to_css (line 445) | fn to_css<W>(&self, dest: &mut style_traits::CssWriter<W>) -> std::fmt::...

FILE: style/color/component.rs
  type ColorComponent (line 28) | pub enum ColorComponent<ValueType> {
  function is_none (line 44) | pub fn is_none(&self) -> bool {
  type ColorComponentType (line 51) | pub trait ColorComponentType: Sized + Clone {
    method from_value (line 56) | fn from_value(value: f32) -> Self;
    method units (line 59) | fn units() -> CalcUnits;
    method try_from_token (line 62) | fn try_from_token(token: &Token) -> Result<Self, ()>;
    method try_from_leaf (line 66) | fn try_from_leaf(leaf: &Leaf) -> Result<Self, ()>;
  function parse (line 71) | pub fn parse<'i, 't>(
  function resolve (line 112) | pub fn resolve(&self, origin_color: Option<&AbsoluteColor>) -> Result<Op...
  method to_css (line 158) | fn to_css<W>(&self, dest: &mut style_traits::CssWriter<W>) -> std::fmt::...
  type AnimatedValue (line 183) | type AnimatedValue = Self;
  method to_animated_value (line 185) | fn to_animated_value(self, _context: &crate::values::animated::Context) ...
  method from_animated_value (line 189) | fn from_animated_value(animated: Self::AnimatedValue) -> Self {

FILE: style/color/convert.rs
  type Transform (line 18) | type Transform = euclid::default::Transform3D<f32>;
  type Vector (line 19) | type Vector = euclid::default::Vector3D<f32>;
  function normalize_hue (line 23) | pub fn normalize_hue(hue: f32) -> f32 {
  function rgb_to_hue_min_max (line 30) | fn rgb_to_hue_min_max(red: f32, green: f32, blue: f32) -> (f32, f32, f32) {
  function hsl_to_rgb (line 54) | pub fn hsl_to_rgb(from: &ColorComponents) -> ColorComponents {
  function rgb_to_hsl (line 90) | pub fn rgb_to_hsl(from: &ColorComponents) -> ColorComponents {
  function hwb_to_rgb (line 114) | pub fn hwb_to_rgb(from: &ColorComponents) -> ColorComponents {
  function rgb_to_hwb (line 133) | pub fn rgb_to_hwb(from: &ColorComponents) -> ColorComponents {
  function epsilon_for_range (line 146) | pub fn epsilon_for_range(min: f32, max: f32) -> f32 {
  function orthogonal_to_polar (line 154) | pub fn orthogonal_to_polar(from: &ColorComponents, e: f32) -> ColorCompo...
  function polar_to_orthogonal (line 179) | pub fn polar_to_orthogonal(from: &ColorComponents) -> ColorComponents {
  function transform (line 195) | fn transform(from: &ColorComponents, mat: &Transform) -> ColorComponents {
  function xyz_d65_to_xyz_d50 (line 200) | fn xyz_d65_to_xyz_d50(from: &ColorComponents) -> ColorComponents {
  function xyz_d50_to_xyz_d65 (line 212) | fn xyz_d50_to_xyz_d65(from: &ColorComponents) -> ColorComponents {
  type WhitePoint (line 225) | pub enum WhitePoint {
    method values (line 233) | const fn values(&self) -> ColorComponents {
  function convert_white_point (line 244) | fn convert_white_point(from: WhitePoint, to: WhitePoint, components: &mu...
  type ColorSpaceConversion (line 263) | pub trait ColorSpaceConversion {
    constant WHITE_POINT (line 265) | const WHITE_POINT: WhitePoint;
    method to_linear_light (line 269) | fn to_linear_light(from: &ColorComponents) -> ColorComponents;
    method to_xyz (line 273) | fn to_xyz(from: &ColorComponents) -> ColorComponents;
    method from_xyz (line 277) | fn from_xyz(from: &ColorComponents) -> ColorComponents;
    method to_gamma_encoded (line 281) | fn to_gamma_encoded(from: &ColorComponents) -> ColorComponents;
    constant WHITE_POINT (line 337) | const WHITE_POINT: WhitePoint = WhitePoint::D65;
    method to_linear_light (line 339) | fn to_linear_light(from: &ColorComponents) -> ColorComponents {
    method to_xyz (line 351) | fn to_xyz(from: &ColorComponents) -> ColorComponents {
    method from_xyz (line 355) | fn from_xyz(from: &ColorComponents) -> ColorComponents {
    method to_gamma_encoded (line 359) | fn to_gamma_encoded(from: &ColorComponents) -> ColorComponents {
    constant WHITE_POINT (line 376) | const WHITE_POINT: WhitePoint = Srgb::WHITE_POINT;
    method to_linear_light (line 378) | fn to_linear_light(from: &ColorComponents) -> ColorComponents {
    method to_xyz (line 383) | fn to_xyz(from: &ColorComponents) -> ColorComponents {
    method from_xyz (line 388) | fn from_xyz(from: &ColorComponents) -> ColorComponents {
    method to_gamma_encoded (line 392) | fn to_gamma_encoded(from: &ColorComponents) -> ColorComponents {
    constant WHITE_POINT (line 401) | const WHITE_POINT: WhitePoint = Srgb::WHITE_POINT;
    method to_linear_light (line 403) | fn to_linear_light(from: &ColorComponents) -> ColorComponents {
    method to_xyz (line 408) | fn to_xyz(from: &ColorComponents) -> ColorComponents {
    method from_xyz (line 413) | fn from_xyz(from: &ColorComponents) -> ColorComponents {
    method to_gamma_encoded (line 417) | fn to_gamma_encoded(from: &ColorComponents) -> ColorComponents {
    constant WHITE_POINT (line 427) | const WHITE_POINT: WhitePoint = Srgb::WHITE_POINT;
    method to_linear_light (line 429) | fn to_linear_light(from: &ColorComponents) -> ColorComponents {
    method to_xyz (line 434) | fn to_xyz(from: &ColorComponents) -> ColorComponents {
    method from_xyz (line 438) | fn from_xyz(from: &ColorComponents) -> ColorComponents {
    method to_gamma_encoded (line 442) | fn to_gamma_encoded(from: &ColorComponents) -> ColorComponents {
    constant WHITE_POINT (line 471) | const WHITE_POINT: WhitePoint = WhitePoint::D65;
    method to_linear_light (line 473) | fn to_linear_light(from: &ColorComponents) -> ColorComponents {
    method to_xyz (line 477) | fn to_xyz(from: &ColorComponents) -> ColorComponents {
    method from_xyz (line 481) | fn from_xyz(from: &ColorComponents) -> ColorComponents {
    method to_gamma_encoded (line 485) | fn to_gamma_encoded(from: &ColorComponents) -> ColorComponents {
    constant WHITE_POINT (line 493) | const WHITE_POINT: WhitePoint = DisplayP3::WHITE_POINT;
    method to_linear_light (line 495) | fn to_linear_light(from: &ColorComponents) -> ColorComponents {
    method to_xyz (line 499) | fn to_xyz(from: &ColorComponents) -> ColorComponents {
    method from_xyz (line 503) | fn from_xyz(from: &ColorComponents) -> ColorComponents {
    method to_gamma_encoded (line 507) | fn to_gamma_encoded(from: &ColorComponents) -> ColorComponents {
    constant WHITE_POINT (line 535) | const WHITE_POINT: WhitePoint = WhitePoint::D65;
    method to_linear_light (line 537) | fn to_linear_light(from: &ColorComponents) -> ColorComponents {
    method to_xyz (line 541) | fn to_xyz(from: &ColorComponents) -> ColorComponents {
    method from_xyz (line 545) | fn from_xyz(from: &ColorComponents) -> ColorComponents {
    method to_gamma_encoded (line 549) | fn to_gamma_encoded(from: &ColorComponents) -> ColorComponents {
    constant WHITE_POINT (line 578) | const WHITE_POINT: WhitePoint = WhitePoint::D50;
    method to_linear_light (line 580) | fn to_linear_light(from: &ColorComponents) -> ColorComponents {
    method to_xyz (line 594) | fn to_xyz(from: &ColorComponents) -> ColorComponents {
    method from_xyz (line 598) | fn from_xyz(from: &ColorComponents) -> ColorComponents {
    method to_gamma_encoded (line 602) | fn to_gamma_encoded(from: &ColorComponents) -> ColorComponents {
    constant WHITE_POINT (line 642) | const WHITE_POINT: WhitePoint = WhitePoint::D65;
    method to_linear_light (line 644) | fn to_linear_light(from: &ColorComponents) -> ColorComponents {
    method to_xyz (line 656) | fn to_xyz(from: &ColorComponents) -> ColorComponents {
    method from_xyz (line 660) | fn from_xyz(from: &ColorComponents) -> ColorComponents {
    method to_gamma_encoded (line 664) | fn to_gamma_encoded(from: &ColorComponents) -> ColorComponents {
    constant WHITE_POINT (line 682) | const WHITE_POINT: WhitePoint = WhitePoint::D50;
    method to_linear_light (line 684) | fn to_linear_light(from: &ColorComponents) -> ColorComponents {
    method to_xyz (line 688) | fn to_xyz(from: &ColorComponents) -> ColorComponents {
    method from_xyz (line 692) | fn from_xyz(from: &ColorComponents) -> ColorComponents {
    method to_gamma_encoded (line 696) | fn to_gamma_encoded(from: &ColorComponents) -> ColorComponents {
    constant WHITE_POINT (line 706) | const WHITE_POINT: WhitePoint = WhitePoint::D65;
    method to_linear_light (line 708) | fn to_linear_light(from: &ColorComponents) -> ColorComponents {
    method to_xyz (line 712) | fn to_xyz(from: &ColorComponents) -> ColorComponents {
    method from_xyz (line 716) | fn from_xyz(from: &ColorComponents) -> ColorComponents {
    method to_gamma_encoded (line 720) | fn to_gamma_encoded(from: &ColorComponents) -> ColorComponents {
    constant WHITE_POINT (line 735) | const WHITE_POINT: WhitePoint = WhitePoint::D50;
    method to_linear_light (line 737) | fn to_linear_light(from: &ColorComponents) -> ColorComponents {
    method to_xyz (line 746) | fn to_xyz(from: &ColorComponents) -> ColorComponents {
    method from_xyz (line 781) | fn from_xyz(from: &ColorComponents) -> ColorComponents {
    method to_gamma_encoded (line 800) | fn to_gamma_encoded(from: &ColorComponents) -> ColorComponents {
    constant WHITE_POINT (line 811) | const WHITE_POINT: WhitePoint = Lab::WHITE_POINT;
    method to_linear_light (line 813) | fn to_linear_light(from: &ColorComponents) -> ColorComponents {
    method to_xyz (line 818) | fn to_xyz(from: &ColorComponents) -> ColorComponents {
    method from_xyz (line 826) | fn from_xyz(from: &ColorComponents) -> ColorComponents {
    method to_gamma_encoded (line 834) | fn to_gamma_encoded(from: &ColorComponents) -> ColorComponents {
    constant WHITE_POINT (line 879) | const WHITE_POINT: WhitePoint = WhitePoint::D65;
    method to_linear_light (line 881) | fn to_linear_light(from: &ColorComponents) -> ColorComponents {
    method to_xyz (line 886) | fn to_xyz(from: &ColorComponents) -> ColorComponents {
    method from_xyz (line 892) | fn from_xyz(from: &ColorComponents) -> ColorComponents {
    method to_gamma_encoded (line 898) | fn to_gamma_encoded(from: &ColorComponents) -> ColorComponents {
    constant WHITE_POINT (line 909) | const WHITE_POINT: WhitePoint = Oklab::WHITE_POINT;
    method to_linear_light (line 911) | fn to_linear_light(from: &ColorComponents) -> ColorComponents {
    method to_xyz (line 916) | fn to_xyz(from: &ColorComponents) -> ColorComponents {
    method from_xyz (line 924) | fn from_xyz(from: &ColorComponents) -> ColorComponents {
    method to_gamma_encoded (line 932) | fn to_gamma_encoded(from: &ColorComponents) -> ColorComponents {
  function to_xyz (line 286) | pub fn to_xyz<From: ColorSpaceConversion>(from: &ColorComponents) -> (Co...
  function from_xyz (line 297) | pub fn from_xyz<To: ColorSpaceConversion>(
  type Srgb (line 316) | pub struct Srgb;
    constant TO_XYZ (line 320) | const TO_XYZ: Transform = Transform::new(
    constant FROM_XYZ (line 328) | const FROM_XYZ: Transform = Transform::new(
  type Hsl (line 373) | pub struct Hsl;
  type Hwb (line 398) | pub struct Hwb;
  type SrgbLinear (line 424) | pub struct SrgbLinear;
  type DisplayP3 (line 450) | pub struct DisplayP3;
    constant TO_XYZ (line 454) | const TO_XYZ: Transform = Transform::new(
    constant FROM_XYZ (line 462) | const FROM_XYZ: Transform = Transform::new(
  type DisplayP3Linear (line 491) | pub struct DisplayP3Linear;
  type A98Rgb (line 514) | pub struct A98Rgb;
    constant TO_XYZ (line 518) | const TO_XYZ: Transform = Transform::new(
    constant FROM_XYZ (line 526) | const FROM_XYZ: Transform = Transform::new(
  type ProphotoRgb (line 557) | pub struct ProphotoRgb;
    constant TO_XYZ (line 561) | const TO_XYZ: Transform = Transform::new(
    constant FROM_XYZ (line 569) | const FROM_XYZ: Transform = Transform::new(
  type Rec2020 (line 618) | pub struct Rec2020;
    constant ALPHA (line 621) | const ALPHA: f32 = 1.09929682680944;
    constant BETA (line 622) | const BETA: f32 = 0.018053968510807;
    constant TO_XYZ (line 625) | const TO_XYZ: Transform = Transform::new(
    constant FROM_XYZ (line 633) | const FROM_XYZ: Transform = Transform::new(
  type XyzD50 (line 679) | pub struct XyzD50;
  type XyzD65 (line 703) | pub struct XyzD65;
  type Lab (line 727) | pub struct Lab;
    constant KAPPA (line 730) | const KAPPA: f32 = 24389.0 / 27.0;
    constant EPSILON (line 731) | const EPSILON: f32 = 216.0 / 24389.0;
  type Lch (line 808) | pub struct Lch;
  type Oklab (line 842) | pub struct Oklab;
    constant XYZ_TO_LMS (line 846) | const XYZ_TO_LMS: Transform = Transform::new(
    constant LMS_TO_OKLAB (line 854) | const LMS_TO_OKLAB: Transform = Transform::new(
    constant LMS_TO_XYZ (line 862) | const LMS_TO_XYZ: Transform = Transform::new(
    constant OKLAB_TO_LMS (line 870) | const OKLAB_TO_LMS: Transform = Transform::new(
  type Oklch (line 906) | pub struct Oklch;

FILE: style/color/mix.rs
  type HueInterpolationMethod (line 34) | pub enum HueInterpolationMethod {
  type ColorInterpolationMethod (line 61) | pub struct ColorInterpolationMethod {
    method srgb (line 70) | pub const fn srgb() -> Self {
    method oklab (line 79) | pub const fn oklab() -> Self {
    method is_default (line 87) | pub fn is_default(&self) -> bool {
    method best_interpolation_between (line 93) | pub fn best_interpolation_between(left: &AbsoluteColor, right: &Absolu...
  method default (line 106) | fn default() -> Self {
  method parse (line 112) | fn parse<'i, 't>(
  method to_css (line 137) | fn to_css<W>(&self, dest: &mut CssWriter<W>) -> fmt::Result
  type ColorMixItem (line 153) | pub struct ColorMixItem {
    method new (line 163) | pub fn new(color: AbsoluteColor, weight: f32) -> Self {
  function mix_many (line 169) | pub fn mix_many(
  type ComponentMixOutcome (line 268) | enum ComponentMixOutcome {
    method from_colors (line 280) | fn from_colors(
  method carry_forward_analogous_missing_components (line 301) | fn carry_forward_analogous_missing_components(&mut self, source: &Absolu...
  function mix_with_weights (line 371) | fn mix_with_weights(
  function convert_for_mix (line 407) | fn convert_for_mix(color: &AbsoluteColor, color_space: ColorSpace) -> Ab...
  function interpolate_premultiplied_component (line 413) | fn interpolate_premultiplied_component(
  function normalize_hue (line 426) | fn normalize_hue(v: f32) -> f32 {
  function adjust_hue (line 430) | fn adjust_hue(left: &mut f32, right: &mut f32, hue_interpolation: HueInt...
  function interpolate_hue (line 492) | fn interpolate_hue(
  type InterpolatedAlpha (line 503) | struct InterpolatedAlpha {
  function interpolate_alpha (line 514) | fn interpolate_alpha(
  function interpolate_premultiplied (line 560) | fn interpolate_premultiplied(

FILE: style/color/mod.rs
  constant PRE_ALLOCATED_COLOR_MIX_ITEMS (line 23) | pub const PRE_ALLOCATED_COLOR_MIX_ITEMS: usize = 3;
  type ColorMixItemList (line 26) | pub type ColorMixItemList<T> = smallvec::SmallVec<[T; PRE_ALLOCATED_COLO...
  type ColorComponents (line 32) | pub struct ColorComponents(pub f32, pub f32, pub f32);
    method map (line 37) | pub fn map(self, f: impl Fn(f32) -> f32) -> Self {
    type Output (line 43) | type Output = Self;
    method mul (line 45) | fn mul(self, rhs: Self) -> Self::Output {
    type Output (line 51) | type Output = Self;
    method div (line 53) | fn div(self, rhs: Self) -> Self::Output {
  type ColorSpace (line 77) | pub enum ColorSpace {
    method is_rectangular (line 139) | pub fn is_rectangular(&self) -> bool {
    method is_polar (line 145) | pub fn is_polar(&self) -> bool {
    method is_rgb_or_xyz_like (line 151) | pub fn is_rgb_or_xyz_like(&self) -> bool {
    method hue_index (line 169) | pub fn hue_index(&self) -> Option<usize> {
    method from (line 700) | fn from(value: PredefinedColorSpace) -> Self {
  type ColorFlags (line 186) | pub struct ColorFlags(u8);
  type AbsoluteColor (line 209) | pub struct AbsoluteColor {
    constant TRANSPARENT_BLACK (line 333) | pub const TRANSPARENT_BLACK: Self = Self {
    constant BLACK (line 341) | pub const BLACK: Self = Self {
    constant WHITE (line 349) | pub const WHITE: Self = Self {
    method new (line 358) | pub fn new(
    method into_srgb_legacy (line 415) | pub fn into_srgb_legacy(self) -> Self {
    method srgb_legacy (line 430) | pub fn srgb_legacy(red: u8, green: u8, blue: u8, alpha: f32) -> Self {
    method raw_components (line 438) | pub fn raw_components(&self) -> &[f32; 4] {
    method is_legacy_syntax (line 444) | pub fn is_legacy_syntax(&self) -> bool {
    method is_transparent (line 455) | pub fn is_transparent(&self) -> bool {
    method c0 (line 461) | pub fn c0(&self) -> Option<f32> {
    method c1 (line 471) | pub fn c1(&self) -> Option<f32> {
    method c2 (line 481) | pub fn c2(&self) -> Option<f32> {
    method alpha (line 491) | pub fn alpha(&self) -> Option<f32> {
    method get_component_by_channel_keyword (line 500) | pub fn get_component_by_channel_keyword(
    method to_color_space (line 571) | pub fn to_color_space(&self, color_space: ColorSpace) -> Self {
    method to_nscolor (line 675) | pub fn to_nscolor(&self) -> u32 {
    method from_nscolor (line 686) | pub fn from_nscolor(color: u32) -> Self {
  method eq (line 222) | fn eq(&self, other: &Self) -> bool {
  type ComponentDetails (line 276) | pub struct ComponentDetails {
    method from (line 282) | fn from(value: f32) -> Self {
    method from (line 291) | fn from(value: u8) -> Self {
    method from (line 300) | fn from(value: Option<f32>) -> Self {
    method from (line 316) | fn from(value: ColorComponent<f32>) -> Self {
  function from_nscolor_should_be_in_legacy_syntax (line 693) | fn from_nscolor_should_be_in_legacy_syntax() {

FILE: style/color/parsing.rs
  function rcs_enabled (line 30) | pub fn rcs_enabled() -> bool {
  type ChannelKeyword (line 37) | pub enum ChannelKeyword {
  function parse_color_keyword (line 72) | pub fn parse_color_keyword(ident: &str) -> Result<SpecifiedColor, ()> {
  function parse_color_with (line 87) | pub fn parse_color_with<'i, 't>(
  function parse_color_function (line 125) | fn parse_color_function<'i, 't>(
  function parse_origin_color (line 163) | fn parse_origin_color<'i, 't>(
  function parse_rgb (line 184) | fn parse_rgb<'i, 't>(
  function parse_hsl (line 228) | fn parse_hsl<'i, 't>(
  function parse_hwb (line 267) | fn parse_hwb<'i, 't>(
  type IntoLabFn (line 287) | type IntoLabFn<Output> = fn(
  function parse_lab_like (line 296) | fn parse_lab_like<'i, 't>(
  type IntoLchFn (line 311) | type IntoLchFn<Output> = fn(
  function parse_lch_like (line 320) | fn parse_lch_like<'i, 't>(
  function parse_color_with_color_space (line 343) | fn parse_color_with_color_space<'i, 't>(
  type NumberOrPercentageComponent (line 369) | pub enum NumberOrPercentageComponent {
    method to_number (line 380) | pub fn to_number(&self, percentage_basis: f32) -> f32 {
  method from_value (line 389) | fn from_value(value: f32) -> Self {
  method units (line 393) | fn units() -> CalcUnits {
  method try_from_token (line 397) | fn try_from_token(token: &Token) -> Result<Self, ()> {
  method try_from_leaf (line 407) | fn try_from_leaf(leaf: &Leaf) -> Result<Self, ()> {
  type NumberOrAngleComponent (line 419) | pub enum NumberOrAngleComponent {
    method degrees (line 430) | pub fn degrees(&self) -> f32 {
  method from_value (line 439) | fn from_value(value: f32) -> Self {
  method units (line 443) | fn units() -> CalcUnits {
  method try_from_token (line 447) | fn try_from_token(token: &Token) -> Result<Self, ()> {
  method try_from_leaf (line 465) | fn try_from_leaf(leaf: &Leaf) -> Result<Self, ()> {
  method from_value (line 476) | fn from_value(value: f32) -> Self {
  method units (line 480) | fn units() -> CalcUnits {
  method try_from_token (line 484) | fn try_from_token(token: &Token) -> Result<Self, ()> {
  method try_from_leaf (line 492) | fn try_from_leaf(leaf: &Leaf) -> Result<Self, ()> {
  function parse_number_or_angle (line 502) | fn parse_number_or_angle<'i, 't>(
  function parse_percentage (line 511) | fn parse_percentage<'i, 't>(
  function parse_number (line 527) | fn parse_number<'i, 't>(
  function parse_number_or_percentage (line 544) | fn parse_number_or_percentage<'i, 't>(
  function parse_legacy_alpha (line 552) | fn parse_legacy_alpha<'i, 't>(
  function parse_modern_alpha (line 564) | fn parse_modern_alpha<'i, 't>(
  function could_be_number (line 579) | fn could_be_number(&self) -> bool {
  function could_be_percentage (line 599) | fn could_be_percentage(&self) -> bool {

FILE: style/color/to_css.rs
  type ModernComponent (line 18) | struct ModernComponent<'a>(&'a Option<f32>);
  method to_css (line 21) | fn to_css<W>(&self, dest: &mut CssWriter<W>) -> fmt::Result
  method to_css (line 45) | fn to_css<W>(&self, dest: &mut CssWriter<W>) -> fmt::Result
  method to_css (line 60) | fn to_css<W>(&self, dest: &mut CssWriter<W>) -> fmt::Result
  method to_css (line 75) | fn to_css<W>(&self, dest: &mut CssWriter<W>) -> fmt::Result
  method write_author_preferred_value (line 172) | pub fn write_author_preferred_value<W>(&self, dest: &mut CssWriter<W>) -...

FILE: style/context.rs
  type StyleSystemOptions (line 52) | pub struct StyleSystemOptions {
  function get_env_bool (line 63) | fn get_env_bool(name: &str) -> bool {
  constant DEFAULT_STATISTICS_THRESHOLD (line 71) | const DEFAULT_STATISTICS_THRESHOLD: usize = 50;
  function get_env_usize (line 74) | fn get_env_usize(name: &str) -> Option<usize> {
  method default (line 98) | fn default() -> Self {
  method default (line 110) | fn default() -> Self {
  type SharedStyleContext (line 124) | pub struct SharedStyleContext<'a> {
  function viewport_size (line 161) | pub fn viewport_size(&self) -> Size2D<Au> {
  function device_pixel_ratio (line 166) | pub fn device_pixel_ratio(&self) -> Scale<f32, CSSPixel, DevicePixel> {
  function quirks_mode (line 171) | pub fn quirks_mode(&self) -> QuirksMode {
  type CascadeInputs (line 184) | pub struct CascadeInputs {
    method new_from_style (line 204) | pub fn new_from_style(style: &ComputedValues) -> Self {
  type EagerPseudoCascadeInputs (line 217) | pub struct EagerPseudoCascadeInputs(Option<[Option<CascadeInputs>; EAGER...
    method new_from_style (line 237) | fn new_from_style(styles: &EagerPseudoStyles) -> Self {
    method into_array (line 248) | pub fn into_array(self) -> Option<[Option<CascadeInputs>; EAGER_PSEUDO...
  method clone (line 222) | fn clone(&self) -> Self {
  type ElementCascadeInputs (line 261) | pub struct ElementCascadeInputs {
    method new_from_element_data (line 271) | pub fn new_from_element_data(data: &ElementData) -> Self {
  type PerThreadTraversalStatistics (line 284) | pub struct PerThreadTraversalStatistics {
  type TraversalStatistics (line 301) | pub struct TraversalStatistics {
    method fmt (line 325) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    method new (line 379) | pub fn new<E, D>(
  type SequentialTask (line 439) | pub enum SequentialTask<E: TElement> {
  function execute (line 462) | pub fn execute(self) {
  function update_animations (line 481) | pub fn update_animations(
  type SequentialTaskList (line 496) | pub struct SequentialTaskList<E>(Vec<SequentialTask<E>>)
  type Target (line 504) | type Target = Vec<SequentialTask<E>>;
  function deref (line 506) | fn deref(&self) -> &Self::Target {
  function deref_mut (line 515) | fn deref_mut(&mut self) -> &mut Self::Target {
  method drop (line 524) | fn drop(&mut self) {
  type StackLimitChecker (line 534) | pub struct StackLimitChecker {
    method new (line 542) | pub fn new(stack_size_limit: usize) -> Self {
    method limit_exceeded (line 550) | pub fn limit_exceeded(&self) -> bool {
    method get_sp (line 590) | fn get_sp() -> usize {
  type ThreadLocalStyleContext (line 601) | pub struct ThreadLocalStyleContext<E: TElement> {
  function new (line 627) | pub fn new() -> Self {
  type StyleContext (line 644) | pub struct StyleContext<'a, E: TElement + 'a> {
  type RegisteredSpeculativePainter (line 653) | pub trait RegisteredSpeculativePainter: SpeculativePainter {
    method name (line 655) | fn name(&self) -> Atom;
    method properties (line 657) | fn properties(&self) -> &FxHashMap<Atom, PropertyId>;
  type RegisteredSpeculativePainters (line 662) | pub trait RegisteredSpeculativePainters: Sync {
    method get (line 664) | fn get(&self, name: &Atom) -> Option<&dyn RegisteredSpeculativePainter>;

FILE: style/counter_style/mod.rs
  type SymbolsType (line 47) | pub enum SymbolsType {
  type CounterStyle (line 63) | pub enum CounterStyle {
    method disc (line 88) | pub fn disc() -> Self {
    method decimal (line 93) | pub fn decimal() -> Self {
    method is_bullet (line 99) | pub fn is_bullet(&self) -> bool {
    method parse (line 126) | pub fn parse<'i, 't>(
  function is_symbolic (line 82) | fn is_symbolic(symbols_type: &SymbolsType) -> bool {
  method collect_completion_keywords (line 173) | fn collect_completion_keywords(f: KeywordsCollectFn) {
  function parse_counter_style_name (line 188) | fn parse_counter_style_name<'i>(input: &mut Parser<'i, '_>) -> Result<Cu...
  function counter_style_name_from_ident (line 195) | fn counter_style_name_from_ident<'i>(
  function is_valid_name_definition (line 221) | fn is_valid_name_definition(ident: &CustomIdent) -> bool {
  function parse_counter_style_name_definition (line 231) | pub fn parse_counter_style_name_definition<'i, 't>(
  type CounterStyleRule (line 245) | pub struct CounterStyleRule {
    method empty (line 331) | fn empty(name: CustomIdent, source_location: SourceLocation) -> Self {
    method descriptors (line 342) | pub fn descriptors(&self) -> &Descriptors {
    method set_descriptor (line 347) | pub fn set_descriptor<'i>(
    method check_system (line 396) | fn check_system(&self, value: &System) -> bool {
    method check_symbols (line 400) | fn check_symbols(&self, value: &Symbols) -> bool {
    method name (line 411) | pub fn name(&self) -> &CustomIdent {
    method set_name (line 417) | pub fn set_name(&mut self, name: CustomIdent) {
    method generation (line 423) | pub fn generation(&self) -> u32 {
    method resolved_system (line 429) | pub fn resolved_system(&self) -> &System {
  function parse_counter_style_body (line 254) | pub fn parse_counter_style_body<'i, 't>(
  method to_css (line 319) | fn to_css(&self, _guard: &SharedRwLockReadGuard, dest: &mut CssStringWri...
  type System (line 439) | pub enum System {
  method parse (line 460) | fn parse<'i, 't>(
  method to_css (line 483) | fn to_css<W>(&self, dest: &mut CssWriter<W>) -> fmt::Result
  type Symbol (line 514) | pub enum Symbol {
    method is_allowed_in_symbols (line 540) | pub fn is_allowed_in_symbols(&self) -> bool {
  method parse (line 525) | fn parse<'i, 't>(
  type Negative (line 551) | pub struct Negative(pub Symbol, pub Option<Symbol>);
  method parse (line 554) | fn parse<'i, 't>(
  type CounterRange (line 567) | pub struct CounterRange {
  type CounterRanges (line 579) | pub struct CounterRanges(#[css(iterable, if_empty = "auto")] pub crate::...
  type CounterBound (line 583) | pub enum CounterBound {
  method parse (line 591) | fn parse<'i, 't>(
  function parse_bound (line 617) | fn parse_bound<'i, 't>(
  type Pad (line 630) | pub struct Pad(pub Integer, pub Symbol);
  method parse (line 633) | fn parse<'i, 't>(
  type Fallback (line 646) | pub struct Fallback(pub CustomIdent);
  method parse (line 649) | fn parse<'i, 't>(
  type Symbols (line 662) | pub struct Symbols(
  method parse (line 669) | fn parse<'i, 't>(
  type AdditiveSymbols (line 687) | pub struct AdditiveSymbols(#[css(iterable)] pub crate::OwnedSlice<Additi...
  method parse (line 690) | fn parse<'i, 't>(
  type AdditiveTuple (line 708) | pub struct AdditiveTuple {
  type S (line 716) | type S = Comma;
  method parse (line 720) | fn parse<'i, 't>(
  type SpeakAs (line 733) | pub enum SpeakAs {
  method parse (line 749) | fn parse<'i, 't>(

FILE: style/counter_style/update_predefined.py
  function main (line 12) | def main(filename):

FILE: style/custom_properties.rs
  type CssEnvironment (line 58) | pub struct CssEnvironment;
    method get (line 209) | fn get(&self, name: &Atom, device: &Device, url_data: &UrlExtraData) -...
  type EnvironmentEvaluator (line 60) | type EnvironmentEvaluator = fn(device: &Device, url_data: &UrlExtraData)...
  type EnvironmentVariable (line 62) | struct EnvironmentVariable {
  function get_safearea_inset_top (line 76) | fn get_safearea_inset_top(device: &Device, url_data: &UrlExtraData) -> V...
  function get_safearea_inset_bottom (line 80) | fn get_safearea_inset_bottom(device: &Device, url_data: &UrlExtraData) -...
  function get_safearea_inset_left (line 84) | fn get_safearea_inset_left(device: &Device, url_data: &UrlExtraData) -> ...
  function get_safearea_inset_right (line 88) | fn get_safearea_inset_right(device: &Device, url_data: &UrlExtraData) ->...
  function get_content_preferred_color_scheme (line 93) | fn get_content_preferred_color_scheme(device: &Device, url_data: &UrlExt...
  function get_content_preferred_color_scheme (line 111) | fn get_content_preferred_color_scheme(_device: &Device, url_data: &UrlEx...
  function get_scrollbar_inline_size (line 116) | fn get_scrollbar_inline_size(device: &Device, url_data: &UrlExtraData) -...
  function get_hairline (line 120) | fn get_hairline(device: &Device, url_data: &UrlExtraData) -> VariableVal...
  function eval_gtk_csd_titlebar_radius (line 162) | fn eval_gtk_csd_titlebar_radius(device: &Device, url_data: &UrlExtraData...
  type Name (line 226) | pub type Name = Atom;
  function parse_name (line 231) | pub fn parse_name(s: &str) -> Result<&str, ()> {
  type VariableValue (line 244) | pub struct VariableValue {
    method empty (line 769) | fn empty(url_data: &UrlExtraData) -> Self {
    method new (line 781) | pub fn new(
    method push (line 796) | fn push<'i>(
    method parse (line 844) | pub fn parse<'i, 't>(
    method is_attr_tainted (line 887) | pub fn is_attr_tainted(&self) -> bool {
    method integer (line 892) | fn integer(number: i32, url_data: &UrlExtraData) -> Self {
    method ident (line 904) | fn ident(ident: &'static str, url_data: &UrlExtraData) -> Self {
    method pixels (line 909) | fn pixels(number: f32, url_data: &UrlExtraData) -> Self {
    method int_ms (line 925) | fn int_ms(number: i32, url_data: &UrlExtraData) -> Self {
    method int_pixels (line 938) | fn int_pixels(number: i32, url_data: &UrlExtraData) -> Self {
    method from_token (line 950) | fn from_token(token: Token, url_data: &UrlExtraData) -> Self {
    method css_text (line 965) | pub fn css_text(&self) -> &str {
    method has_references (line 971) | pub fn has_references(&self) -> bool {
  function compute_variable_value (line 261) | pub fn compute_variable_value(
  method eq (line 281) | fn eq(&self, other: &Self) -> bool {
  method to_css (line 289) | fn to_css<W>(&self, dest: &mut CssWriter<W>) -> fmt::Result
  method to_typed (line 298) | fn to_typed(&self, dest: &mut ThinVec<TypedValue>) -> Result<(), ()> {
  function reify_variable_value (line 305) | fn reify_variable_value(value: &VariableValue) -> Result<UnparsedValue, ...
  function reify_variable_value_range (line 322) | fn reify_variable_value_range(
  type ComputedCustomProperties (line 395) | pub struct ComputedCustomProperties {
    method is_empty (line 405) | pub fn is_empty(&self) -> bool {
    method property_at (line 410) | pub fn property_at(&self, index: usize) -> Option<(&Name, &Option<Comp...
    method insert (line 420) | pub(crate) fn insert(
    method remove (line 431) | pub(crate) fn remove(&mut self, registration: &PropertyDescriptors, na...
    method shrink_to_fit (line 436) | fn shrink_to_fit(&mut self) {
    method map_mut (line 441) | fn map_mut(&mut self, registration: &PropertyDescriptors) -> &mut Cust...
    method get (line 450) | pub fn get(
  type SpecifiedValue (line 465) | pub type SpecifiedValue = VariableValue;
  type ComputedValue (line 468) | pub type ComputedValue = VariableValue;
  type NonCustomReferences (line 472) | struct NonCustomReferences(u8);
    method for_each (line 492) | fn for_each<F>(&self, mut f: F)
    method from_unit (line 508) | fn from_unit(value: &CowRcStr) -> Self {
  type SingleNonCustomReference (line 540) | enum SingleNonCustomReference {
  type NonCustomReferenceMap (line 547) | struct NonCustomReferenceMap<T>([Option<T>; 4]);
  method default (line 550) | fn default() -> Self {
  type Output (line 556) | type Output = Option<T>;
  function index (line 558) | fn index(&self, reference: SingleNonCustomReference) -> &Self::Output {
  function index_mut (line 564) | fn index_mut(&mut self, reference: SingleNonCustomReference) -> &mut Sel...
  type DeferFontRelativeCustomPropertyResolution (line 572) | pub enum DeferFontRelativeCustomPropertyResolution {
  type SubstitutionFunctionKind (line 579) | pub enum SubstitutionFunctionKind {
  type ComputedSubstitutionFunctions (line 592) | pub struct ComputedSubstitutionFunctions {
    method new (line 603) | pub fn new(
    method insert_var (line 614) | fn insert_var(
    method insert_attr (line 624) | fn insert_attr(&mut self, name: &Name, value: ComputedRegisteredValue) {
    method remove_var (line 629) | fn remove_var(&mut self, registration: &PropertyDescriptors, name: &Na...
    method remove_attr (line 634) | fn remove_attr(&mut self, name: &Name) {
    method get_var (line 639) | fn get_var(
    method get_attr (line 648) | fn get_attr(&self, name: &Name) -> Option<&ComputedRegisteredValue> {
  type AttributeType (line 654) | enum AttributeType {
  type AttributeData (line 662) | struct AttributeData {
  type AttrTaintedRange (line 669) | pub struct AttrTaintedRange {
    method new (line 679) | pub fn new(start: usize, end: usize) -> Self {
  type AttrTaint (line 690) | pub struct AttrTaint(SmallVec<[AttrTaintedRange; 1]>);
    method should_disallow_urls_in_range (line 696) | pub fn should_disallow_urls_in_range(&self, range: &AttrTaintedRange) ...
    method is_empty (line 704) | pub fn is_empty(&self) -> bool {
    method new_fully_tainted (line 709) | fn new_fully_tainted(end: usize) -> Self {
    method push (line 716) | fn push(&mut self, start: usize, end: usize) {
  type VariableFallback (line 722) | struct VariableFallback {
  type SubstitutionFunctionReference (line 732) | struct SubstitutionFunctionReference {
  type References (line 746) | struct References {
    method has_references (line 755) | fn has_references(&self) -> bool {
    method non_custom_references (line 759) | fn non_custom_references(&self, is_root_element: bool) -> NonCustomRef...
  function parse_declaration_value (line 977) | fn parse_declaration_value<'i, 't>(
  function parse_declaration_value_block (line 996) | fn parse_declaration_value_block<'i, 't>(
  function parse_attr_type (line 1250) | fn parse_attr_type<'i, 't>(input: &mut Parser<'i, 't>) -> AttributeType {
  function parse_attribute_value (line 1278) | fn parse_attribute_value(
  type SeenSubstitutionFunctions (line 1301) | struct SeenSubstitutionFunctions<'a> {
  type CustomPropertiesBuilder (line 1307) | pub struct CustomPropertiesBuilder<'a, 'b: 'a> {
  function find_non_custom_references (line 1318) | fn find_non_custom_references(
  function new_with_properties (line 1348) | pub fn new_with_properties(
  function new (line 1369) | pub fn new(stylist: &'a Stylist, context: &'a mut computed::Context<'b>)...
  function cascade (line 1393) | pub fn cascade(
  function might_have_non_custom_or_attr_dependency (line 1505) | pub fn might_have_non_custom_or_attr_dependency(
  function maybe_note_non_custom_dependency (line 1521) | pub fn maybe_note_non_custom_dependency(
  function value_may_affect_style (line 1607) | fn value_may_affect_style(&self, name: &Name, value: &CustomDeclarationV...
  function update_attributes_map (line 1724) | pub fn update_attributes_map(
  function build (line 1768) | pub fn build(
  function build_deferred (line 1836) | pub fn build_deferred(
  function substitute_all (line 1870) | fn substitute_all(
  function handle_invalid_at_computed_value_time (line 2348) | fn handle_invalid_at_computed_value_time(
  function substitute_references_if_needed_and_apply (line 2388) | fn substitute_references_if_needed_and_apply(
  type Substitution (line 2510) | struct Substitution<'a> {
  function from_value (line 2518) | fn from_value(v: VariableValue, attr_tainted: bool) -> Self {
  function into_value (line 2527) | fn into_value(
  function new (line 2557) | fn new(
  type SubstitutionResult (line 2574) | pub struct SubstitutionResult<'a> {
  function compute_value (line 2581) | fn compute_value(
  function remove_and_insert_initial_value (line 2605) | fn remove_and_insert_initial_value(
  function do_substitute_chunk (line 2617) | fn do_substitute_chunk<'a>(
  function quoted_css_string (line 2706) | fn quoted_css_string(src: &str) -> String {
  function substitute_one_reference (line 2712) | fn substitute_one_reference<'a>(
  function substitute_internal (line 2863) | fn substitute_internal<'a>(
  function substitute (line 2889) | pub fn substitute<'a>(

FILE: style/custom_properties_map.rs
  type CustomPropertiesMap (line 19) | pub struct CustomPropertiesMap(Arc<Inner>);
    method is_empty (line 154) | pub fn is_empty(&self) -> bool {
    method len (line 159) | pub fn len(&self) -> usize {
    method get_index (line 164) | pub fn get_index(&self, index: usize) -> Option<(&Name, &Option<Comput...
    method get (line 173) | pub fn get(&self, name: &Name) -> Option<&ComputedRegisteredValue> {
    method do_insert (line 177) | fn do_insert(&mut self, name: &Name, value: Option<ComputedRegisteredV...
    method insert (line 201) | pub fn insert(&mut self, name: &Name, value: ComputedRegisteredValue) {
    method remove (line 206) | pub fn remove(&mut self, name: &Name) {
    method shrink_to_fit (line 211) | pub fn shrink_to_fit(&mut self) {
    method iter (line 218) | pub fn iter(&self) -> Iter<'_> {
  method default (line 22) | fn default() -> Self {
  type OwnMap (line 28) | pub type OwnMap =
  type Inner (line 41) | struct Inner {
    method iter (line 112) | fn iter(&self) -> Iter<'_> {
    method is_empty (line 120) | fn is_empty(&self) -> bool {
    method len (line 124) | fn len(&self) -> usize {
    method get (line 128) | fn get(&self, name: &Name) -> Option<&ComputedRegisteredValue> {
    method insert (line 135) | fn insert(&mut self, name: &Name, value: Option<ComputedRegisteredValu...
    method should_expand_chain (line 143) | fn should_expand_chain(&self) -> bool {
  constant ANCESTOR_COUNT_LIMIT (line 52) | const ANCESTOR_COUNT_LIMIT: usize = 4;
  type Iter (line 55) | pub struct Iter<'a> {
  type Item (line 62) | type Item = (&'a Name, &'a Option<ComputedRegisteredValue>);
  method next (line 64) | fn next(&mut self) -> Option<Self::Item> {
  method eq (line 88) | fn eq(&self, other: &Self) -> bool {
  type AllSubstitutionFunctions (line 225) | pub struct AllSubstitutionFunctions(IndexMap<Key, ComputedRegisteredValu...
    method is_empty (line 242) | pub fn is_empty(&self) -> bool {
    method get (line 248) | pub fn get(
    method insert (line 259) | pub fn insert(
    method iter (line 272) | pub fn iter(
  type Key (line 228) | struct Key(Name, SubstitutionFunctionKind);
  type KeyRef (line 231) | struct KeyRef<'a>(&'a Name, SubstitutionFunctionKind);
  function equivalent (line 234) | fn equivalent(&self, key: &Key) -> bool {

FILE: style/data.rs
  type EagerPseudoStyles (line 60) | pub struct EagerPseudoStyles(Option<Arc<EagerPseudoArray>>);
    method is_empty (line 116) | pub fn is_empty(&self) -> bool {
    method as_optional_array (line 121) | pub fn as_optional_array(&self) -> Option<&EagerPseudoArrayInner> {
    method as_array (line 130) | pub fn as_array(&self) -> &EagerPseudoArrayInner {
    method get (line 135) | pub fn get(&self, pseudo: &PseudoElement) -> Option<&Arc<ComputedValue...
    method set (line 143) | pub fn set(&mut self, pseudo: &PseudoElement, value: Arc<ComputedValue...
  type EagerPseudoArray (line 63) | struct EagerPseudoArray(EagerPseudoArrayInner);
    method fmt (line 94) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  type EagerPseudoArrayInner (line 64) | type EagerPseudoArrayInner = [Option<Arc<ComputedValues>>; EAGER_PSEUDO_...
  type Target (line 67) | type Target = EagerPseudoArrayInner;
  method deref (line 68) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 74) | fn deref_mut(&mut self) -> &mut Self::Target {
  method clone (line 82) | fn clone(&self) -> Self {
  constant EMPTY_PSEUDO_ARRAY (line 112) | const EMPTY_PSEUDO_ARRAY: &'static EagerPseudoArrayInner = &[None, None,...
  type ElementStyles (line 155) | pub struct ElementStyles {
    method get_primary (line 180) | pub fn get_primary(&self) -> Option<&Arc<ComputedValues>> {
    method primary (line 185) | pub fn primary(&self) -> &Arc<ComputedValues> {
    method is_display_none (line 190) | pub fn is_display_none(&self) -> bool {
    method viewport_unit_usage (line 195) | pub fn viewport_unit_usage(&self) -> ViewportUnitUsage {
    method size_of_excluding_cvs (line 228) | fn size_of_excluding_cvs(&self, _ops: &mut MallocSizeOfOps) -> usize {
    method fmt (line 243) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  type ViewportUnitUsage (line 167) | pub enum ViewportUnitUsage {
  type ElementData (line 259) | pub struct ElementData {
    method invalidate_style_if_needed (line 391) | pub fn invalidate_style_if_needed<'a, E: TElement>(
    method has_styles (line 435) | pub fn has_styles(&self) -> bool {
    method share_styles (line 440) | pub fn share_styles(&self) -> ResolvedElementStyles {
    method share_primary_style (line 448) | pub fn share_primary_style(&self) -> PrimaryStyle {
    method clone_style_with_flags (line 461) | pub fn clone_style_with_flags(&self, flags: ComputedValueFlags) -> Res...
    method set_styles (line 474) | pub fn set_styles(&mut self, new_styles: ResolvedElementStyles) -> Ele...
    method restyle_kind (line 484) | pub fn restyle_kind(&self, shared_context: &SharedStyleContext) -> Opt...
    method restyle_kind_for_animation (line 526) | fn restyle_kind_for_animation(
    method clear_restyle_state (line 571) | pub fn clear_restyle_state(&mut self) {
    method clear_restyle_flags_and_damage (line 578) | pub fn clear_restyle_flags_and_damage(&mut self) {
    method set_restyled (line 585) | pub fn set_restyled(&mut self) {
    method is_restyle (line 593) | pub fn is_restyle(&self) -> bool {
    method set_traversed_without_styling (line 598) | pub fn set_traversed_without_styling(&mut self) {
    method contains_restyle_data (line 605) | pub fn contains_restyle_data(&self) -> bool {
    method safe_for_cousin_sharing (line 627) | pub fn safe_for_cousin_sharing(&self) -> bool {
    method size_of_excluding_cvs (line 648) | pub fn size_of_excluding_cvs(&self, ops: &mut MallocSizeOfOps) -> usize {
  type ElementDataWrapper (line 277) | pub struct ElementDataWrapper {
    method borrow (line 303) | pub fn borrow(&self) -> ElementDataRef<'_> {
    method borrow_mut (line 315) | pub fn borrow_mut(&self) -> ElementDataMut<'_> {
  type ElementDataMut (line 286) | pub struct ElementDataMut<'a> {
  type ElementDataRef (line 294) | pub struct ElementDataRef<'a> {
  type Target (line 327) | type Target = ElementData;
  method deref (line 329) | fn deref(&self) -> &Self::Target {
  type Target (line 335) | type Target = ElementData;
  method deref (line 337) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 343) | fn deref_mut(&mut self) -> &mut Self::Target {
  type RestyleKind (line 353) | pub enum RestyleKind {
  function needs_to_match_self (line 365) | fn needs_to_match_self(hint: RestyleHint, style: &ComputedValues) -> bool {

FILE: style/device/gecko.rs
  type ExtraDeviceData (line 37) | pub(super) struct ExtraDeviceData {
  method new (line 48) | pub fn new(document: *const structs::Document) -> Self {
  method calc_line_height (line 80) | pub fn calc_line_height(
  method animation_name_may_be_referenced (line 102) | pub fn animation_name_may_be_referenced(&self, name: &KeyframesName) -> ...
  method quirks_mode (line 114) | pub fn quirks_mode(&self) -> QuirksMode {
  method base_size_for_generic (line 119) | pub fn base_size_for_generic(&self, language: &Atom, generic: GenericFon...
  method scrollbar_inline_size (line 124) | pub fn scrollbar_inline_size(&self) -> Length {
  method query_font_metrics (line 134) | pub fn query_font_metrics(
  method document (line 184) | pub fn document(&self) -> &structs::Document {
  method pres_context (line 190) | pub fn pres_context(&self) -> Option<&structs::nsPresContext> {
  method pref_sheet_prefs (line 203) | pub fn pref_sheet_prefs(&self) -> &structs::PreferenceSheet_Prefs {
  method reset_computed_values (line 208) | pub fn reset_computed_values(&mut self) {
  method rebuild_cached_data (line 213) | pub fn rebuild_cached_data(&mut self) {
  method reset (line 228) | pub fn reset(&mut self) {
  method is_print_preview (line 233) | pub fn is_print_preview(&self) -> bool {
  method media_type (line 242) | pub fn media_type(&self) -> MediaType {
  method page_size_minus_default_margin (line 261) | fn page_size_minus_default_margin(&self, pc: &structs::nsPresContext) ->...
  method au_viewport_size (line 271) | pub fn au_viewport_size(&self) -> Size2D<Au> {
  method au_viewport_size_for_viewport_unit_resolution (line 287) | pub fn au_viewport_size_for_viewport_unit_resolution(
  method visited_styles_enabled (line 343) | pub fn visited_styles_enabled(&self) -> bool {
  method app_units_per_device_pixel (line 348) | pub fn app_units_per_device_pixel(&self) -> i32 {
  method app_units_per_device_pixel_at_unit_full_zoom (line 356) | fn app_units_per_device_pixel_at_unit_full_zoom(&self) -> i32 {
  method device_pixel_ratio_ignoring_full_zoom (line 364) | pub fn device_pixel_ratio_ignoring_full_zoom(&self) -> Scale<f32, CSSPix...
  method device_pixel_ratio (line 370) | pub fn device_pixel_ratio(&self) -> Scale<f32, CSSPixel, DevicePixel> {
  method forced_colors (line 387) | pub fn forced_colors(&self) -> ForcedColors {
  method system_nscolor (line 393) | pub(crate) fn system_nscolor(
  method is_dark_color_scheme (line 402) | pub(crate) fn is_dark_color_scheme(&self, color_scheme: ColorSchemeFlags...
  method default_background_color (line 410) | pub fn default_background_color(&self) -> AbsoluteColor {
  method default_color (line 419) | pub fn default_color(&self) -> AbsoluteColor {
  method text_zoom (line 427) | fn text_zoom(&self) -> f32 {
  method zoom_text (line 437) | pub fn zoom_text(&self, size: Length) -> Length {
  method unzoom_text (line 443) | pub fn unzoom_text(&self, size: Length) -> Length {
  method safe_area_insets (line 448) | pub fn safe_area_insets(&self) -> SideOffsets2D<f32, CSSPixel> {
  method is_supported_mime_type (line 464) | pub fn is_supported_mime_type(&self, mime_type: &str) -> bool {
  method chrome_rules_enabled_for_document (line 475) | pub fn chrome_rules_enabled_for_document(&self) -> bool {
  method fmt (line 481) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

FILE: style/device/mod.rs
  type Device (line 42) | pub struct Device {
    method environment (line 97) | pub fn environment(&self) -> &CssEnvironment {
    method default_computed_values (line 103) | pub fn default_computed_values(&self) -> &ComputedValues {
    method default_computed_values_arc (line 108) | pub fn default_computed_values_arc(&self) -> &Arc<ComputedValues> {
    method set_root_style (line 114) | pub fn set_root_style(&self, style: &Arc<ComputedValues>) {
    method root_font_size (line 119) | pub fn root_font_size(&self) -> Length {
    method set_root_font_size (line 125) | pub fn set_root_font_size(&self, size: f32) {
    method root_line_height (line 130) | pub fn root_line_height(&self) -> Length {
    method set_root_line_height (line 138) | pub fn set_root_line_height(&self, size: f32) {
    method root_font_metrics_ex (line 144) | pub fn root_font_metrics_ex(&self) -> Length {
    method set_root_font_metrics_ex (line 152) | pub fn set_root_font_metrics_ex(&self, size: f32) -> bool {
    method root_font_metrics_cap (line 159) | pub fn root_font_metrics_cap(&self) -> Length {
    method set_root_font_metrics_cap (line 167) | pub fn set_root_font_metrics_cap(&self, size: f32) -> bool {
    method root_font_metrics_ch (line 174) | pub fn root_font_metrics_ch(&self) -> Length {
    method set_root_font_metrics_ch (line 182) | pub fn set_root_font_metrics_ch(&self, size: f32) -> bool {
    method root_font_metrics_ic (line 189) | pub fn root_font_metrics_ic(&self) -> Length {
    method set_root_font_metrics_ic (line 197) | pub fn set_root_font_metrics_ic(&self, size: f32) -> bool {
    method ensure_root_font_metrics_updated (line 203) | fn ensure_root_font_metrics_updated(&self) {
    method update_root_font_metrics (line 213) | pub fn update_root_font_metrics(&self) -> bool {
    method used_root_font_size (line 253) | pub fn used_root_font_size(&self) -> bool {
    method used_root_line_height (line 258) | pub fn used_root_line_height(&self) -> bool {
    method used_root_font_metrics (line 263) | pub fn used_root_font_metrics(&self) -> bool {
    method used_viewport_size (line 268) | pub fn used_viewport_size(&self) -> bool {
    method used_dynamic_viewport_size (line 273) | pub fn used_dynamic_viewport_size(&self) -> bool {
    method used_font_metrics (line 278) | pub fn used_font_metrics(&self) -> bool {
    method body_text_color (line 283) | pub fn body_text_color(&self) -> AbsoluteColor {
    method set_body_text_color (line 290) | pub fn set_body_text_color(&self, color: AbsoluteColor) {

FILE: style/device/servo.rs
  type FontMetricsProvider (line 40) | pub trait FontMetricsProvider: Debug + Sync {
    method query_font_metrics (line 42) | fn query_font_metrics(
    method base_size_for_generic (line 50) | fn base_size_for_generic(&self, generic: GenericFontFamily) -> Length;
  type ExtraDeviceData (line 54) | pub(super) struct ExtraDeviceData {
  method new (line 74) | pub fn new(
  method calc_line_height (line 115) | pub fn calc_line_height(
  method quirks_mode (line 131) | pub fn quirks_mode(&self) -> QuirksMode {
  method base_size_for_generic (line 136) | pub fn base_size_for_generic(&self, generic: GenericFontFamily) -> Length {
  method animation_name_may_be_referenced (line 143) | pub fn animation_name_may_be_referenced(&self, _: &KeyframesName) -> bool {
  method viewport_size (line 149) | pub fn viewport_size(&self) -> Size2D<f32, CSSPixel> {
  method set_viewport_size (line 158) | pub fn set_viewport_size(&mut self, viewport_size: Size2D<f32, CSSPixel>) {
  method au_viewport_size (line 165) | pub fn au_viewport_size(&self) -> UntypedSize2D<Au> {
  method au_viewport_size_for_viewport_unit_resolution (line 173) | pub fn au_viewport_size_for_viewport_unit_resolution(
  method app_units_per_device_pixel (line 184) | pub fn app_units_per_device_pixel(&self) -> i32 {
  method device_pixel_ratio_ignoring_full_zoom (line 189) | pub fn device_pixel_ratio_ignoring_full_zoom(&self) -> Scale<f32, CSSPix...
  method device_pixel_ratio (line 194) | pub fn device_pixel_ratio(&self) -> Scale<f32, CSSPixel, DevicePixel> {
  method set_device_pixel_ratio (line 203) | pub fn set_device_pixel_ratio(
  method scrollbar_inline_size (line 211) | pub fn scrollbar_inline_size(&self) -> CSSPixelLength {
  method query_font_metrics (line 217) | pub fn query_font_metrics(
  method media_type (line 234) | pub fn media_type(&self) -> MediaType {
  method forced_colors (line 239) | pub fn forced_colors(&self) -> ForcedColors {
  method default_background_color (line 244) | pub fn default_background_color(&self) -> AbsoluteColor {
  method default_color (line 249) | pub fn default_color(&self) -> AbsoluteColor {
  method set_color_scheme (line 258) | pub fn set_color_scheme(&mut self, new_color_scheme: PrefersColorScheme) {
  method color_scheme (line 263) | pub fn color_scheme(&self) -> PrefersColorScheme {
  method is_dark_color_scheme (line 267) | pub(crate) fn is_dark_color_scheme(&self, _: ColorSchemeFlags) -> bool {
  method system_color (line 271) | pub(crate) fn system_color(
  method safe_area_insets (line 387) | pub fn safe_area_insets(&self) -> SideOffsets2D<f32, CSSPixel> {
  method is_supported_mime_type (line 392) | pub fn is_supported_mime_type(&self, mime_type: &str) -> bool {
  method chrome_rules_enabled_for_document (line 410) | pub fn chrome_rules_enabled_for_document(&self) -> bool {

FILE: style/dom.rs
  type NodeInfo (line 42) | pub trait NodeInfo {
    method is_element (line 44) | fn is_element(&self) -> bool;
    method is_text_node (line 46) | fn is_text_node(&self) -> bool;
  type LayoutIterator (line 50) | pub struct LayoutIterator<T>(pub T);
  type Item (line 57) | type Item = N;
  method next (line 59) | fn next(&mut self) -> Option<N> {
  type DomChildren (line 71) | pub struct DomChildren<N>(Option<N>);
  type Item (line 76) | type Item = N;
  method next (line 78) | fn next(&mut self) -> Option<N> {
  type DomDescendants (line 86) | pub struct DomDescendants<N> {
  function next_skipping_children (line 97) | pub fn next_skipping_children(&mut self) -> Option<N> {
  type Item (line 108) | type Item = N;
  method next (line 111) | fn next(&mut self) -> Option<N> {
  type TDocument (line 119) | pub trait TDocument: Sized + Copy + Clone {
    method as_node (line 124) | fn as_node(&self) -> Self::ConcreteNode;
    method is_html_document (line 127) | fn is_html_document(&self) -> bool;
    method quirks_mode (line 130) | fn quirks_mode(&self) -> QuirksMode;
    method elements_with_id (line 137) | fn elements_with_id<'a>(
    method shared_lock (line 148) | fn shared_lock(&self) -> &SharedRwLock;
  type TNode (line 153) | pub trait TNode: Sized + Copy + Clone + Debug + NodeInfo + PartialEq {
    method parent_node (line 164) | fn parent_node(&self) -> Option<Self>;
    method first_child (line 167) | fn first_child(&self) -> Option<Self>;
    method last_child (line 170) | fn last_child(&self) -> Option<Self>;
    method prev_sibling (line 173) | fn prev_sibling(&self) -> Option<Self>;
    method next_sibling (line 176) | fn next_sibling(&self) -> Option<Self>;
    method owner_doc (line 179) | fn owner_doc(&self) -> Self::ConcreteDocument;
    method dom_children (line 183) | fn dom_children(&self) -> DomChildren<Self> {
    method is_in_document (line 188) | fn is_in_document(&self) -> bool;
    method dom_descendants (line 192) | fn dom_descendants(&self) -> DomDescendants<Self> {
    method next_in_preorder (line 202) | fn next_in_preorder(&self, scoped_to: Self) -> Option<Self> {
    method next_in_preorder_skipping_children (line 214) | fn next_in_preorder_skipping_children(&self, scoped_to: Self) -> Optio...
    method depth (line 234) | fn depth(&self) -> usize {
    method traversal_parent (line 246) | fn traversal_parent(&self) -> Option<Self::ConcreteElement>;
    method parent_element (line 249) | fn parent_element(&self) -> Option<Self::ConcreteElement> {
    method parent_element_or_host (line 254) | fn parent_element_or_host(&self) -> Option<Self::ConcreteElement> {
    method opaque (line 266) | fn opaque(&self) -> OpaqueNode;
    method debug_id (line 269) | fn debug_id(self) -> usize;
    method as_element (line 272) | fn as_element(&self) -> Option<Self::ConcreteElement>;
    method as_document (line 275) | fn as_document(&self) -> Option<Self::ConcreteDocument>;
    method as_shadow_root (line 278) | fn as_shadow_root(&self) -> Option<Self::ConcreteShadowRoot>;
  type ShowSubtree (line 283) | pub struct ShowSubtree<N: TNode>(pub N);
  method fmt (line 285) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  type ShowSubtreeData (line 293) | pub struct ShowSubtreeData<N: TNode>(pub N);
  method fmt (line 295) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  type ShowSubtreeDataAndPrimaryValues (line 304) | pub struct ShowSubtreeDataAndPrimaryValues<N: TNode>(pub N);
  method fmt (line 307) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  function fmt_with_data (line 313) | fn fmt_with_data<N: TNode>(f: &mut fmt::Formatter, n: N) -> fmt::Result {
  function fmt_with_data_and_primary_values (line 329) | fn fmt_with_data_and_primary_values<N: TNode>(f: &mut fmt::Formatter, n:...
  function fmt_subtree (line 345) | fn fmt_subtree<F, N: TNode>(f: &mut fmt::Formatter, stringify: &F, n: N,...
  type TShadowRoot (line 364) | pub trait TShadowRoot: Sized + Copy + Clone + Debug + PartialEq {
    method as_node (line 369) | fn as_node(&self) -> Self::ConcreteNode;
    method host (line 372) | fn host(&self) -> <Self::ConcreteNode as TNode>::ConcreteElement;
    method style_data (line 375) | fn style_data<'a>(&self) -> Option<&'a CascadeData>
    method parts (line 380) | fn parts<'a>(&self) -> &[<Self::ConcreteNode as TNode>::ConcreteElement]
    method elements_with_id (line 392) | fn elements_with_id<'a>(
    method implicit_scope_for_sheet (line 403) | fn implicit_scope_for_sheet(&self, _sheet_index: usize) -> Option<Impl...
  type TElement (line 409) | pub trait TElement:
    method as_node (line 430) | fn as_node(&self) -> Self::ConcreteNode;
    method owner_doc_matches_for_testing (line 437) | fn owner_doc_matches_for_testing(&self, _: &Device) -> bool {
    method matches_user_and_content_rules (line 444) | fn matches_user_and_content_rules(&self) -> bool {
    method traversal_parent (line 450) | fn traversal_parent(&self) -> Option<Self> {
    method traversal_children (line 455) | fn traversal_children(&self) -> LayoutIterator<Self::TraversalChildren...
    method inheritance_parent (line 463) | fn inheritance_parent(&self) -> Option<Self> {
    method each_anonymous_content_child (line 469) | fn each_anonymous_content_child<F>(&self, _f: F)
    method is_html_element (line 476) | fn is_html_element(&self) -> bool;
    method is_mathml_element (line 479) | fn is_mathml_element(&self) -> bool;
    method is_svg_element (line 482) | fn is_svg_element(&self) -> bool;
    method is_xul_element (line 485) | fn is_xul_element(&self) -> bool {
    method subtree_bloom_filter (line 497) | fn subtree_bloom_filter(&self) -> u64 {
    method bloom_may_have_hash (line 502) | fn bloom_may_have_hash(&self, bloom_hash: u64) -> bool {
    method hash_for_bloom_filter (line 509) | fn hash_for_bloom_filter(hash: u32) -> u64 {
    method slotted_nodes (line 525) | fn slotted_nodes(&self) -> &[Self::ConcreteNode] {
    method style_attribute (line 530) | fn style_attribute(&self) -> Option<ArcBorrow<'_, Locked<PropertyDecla...
    method unset_dirty_style_attribute (line 534) | fn unset_dirty_style_attribute(&self) {}
    method smil_override (line 537) | fn smil_override(&self) -> Option<ArcBorrow<'_, Locked<PropertyDeclara...
    method animation_declarations (line 544) | fn animation_declarations(&self, context: &SharedStyleContext) -> Anim...
    method animation_rule (line 556) | fn animation_rule(
    method transition_rule (line 562) | fn transition_rule(
    method state (line 568) | fn state(&self) -> ElementState;
    method has_part_attr (line 571) | fn has_part_attr(&self) -> bool;
    method exports_any_part (line 574) | fn exports_any_part(&self) -> bool;
    method id (line 577) | fn id(&self) -> Option<&WeakAtom>;
    method each_class (line 580) | fn each_class<F>(&self, callback: F)
    method each_custom_state (line 585) | fn each_custom_state<F>(&self, callback: F)
    method each_part (line 590) | fn each_part<F>(&self, _callback: F)
    method each_attr_name (line 597) | fn each_attr_name<F>(&self, callback: F)
    method each_exported_part (line 603) | fn each_exported_part<F>(&self, _name: &AtomIdent, _callback: F)
    method may_generate_pseudo (line 615) | fn may_generate_pseudo(&self, pseudo: &PseudoElement, _primary_style: ...
    method has_dirty_descendants (line 636) | fn has_dirty_descendants(&self) -> bool;
    method has_snapshot (line 641) | fn has_snapshot(&self) -> bool;
    method handled_snapshot (line 644) | fn handled_snapshot(&self) -> bool;
    method set_handled_snapshot (line 647) | unsafe fn set_handled_snapshot(&self);
    method has_current_styles (line 651) | fn has_current_styles(&self, data: &ElementData) -> bool {
    method set_dirty_descendants (line 674) | unsafe fn set_dirty_descendants(&self);
    method unset_dirty_descendants (line 679) | unsafe fn unset_dirty_descendants(&self);
    method has_animation_only_dirty_descendants (line 683) | fn has_animation_only_dirty_descendants(&self) -> bool {
    method set_animation_only_dirty_descendants (line 691) | unsafe fn set_animation_only_dirty_descendants(&self) {}
    method unset_animation_only_dirty_descendants (line 696) | unsafe fn unset_animation_only_dirty_descendants(&self) {}
    method clear_descendant_bits (line 703) | unsafe fn clear_descendant_bits(&self) {
    method is_visited_link (line 710) | fn is_visited_link(&self) -> bool {
    method implemented_pseudo_element (line 722) | fn implemented_pseudo_element(&self) -> Option<PseudoElement> {
    method store_children_to_process (line 728) | fn store_children_to_process(&self, n: isize);
    method did_process_child (line 732) | fn did_process_child(&self) -> isize;
    method ensure_data (line 738) | unsafe fn ensure_data(&self) -> ElementDataMut<'_>;
    method clear_data (line 743) | unsafe fn clear_data(&self);
    method has_data (line 746) | fn has_data(&self) -> bool;
    method borrow_data (line 749) | fn borrow_data(&self) -> Option<ElementDataRef<'_>>;
    method mutate_data (line 752) | fn mutate_data(&self) -> Option<ElementDataMut<'_>>;
    method skip_item_display_fixup (line 757) | fn skip_item_display_fixup(&self) -> bool;
    method may_have_animations (line 762) | fn may_have_animations(&self) -> bool;
    method update_animations (line 766) | fn update_animations(
    method has_animations (line 775) | fn has_animations(&self, context: &SharedStyleContext) -> bool;
    method has_css_animations (line 780) | fn has_css_animations(
    method has_css_transitions (line 789) | fn has_css_transitions(
    method has_animation_restyle_hints (line 796) | fn has_animation_restyle_hints(&self) -> bool {
    method note_highlight_pseudo_style_invalidated (line 807) | fn note_highlight_pseudo_style_invalidated(&self) {}
    method shadow_root (line 810) | fn shadow_root(&self) -> Option<<Self::ConcreteNode as TNode>::Concret...
    method containing_shadow (line 813) | fn containing_shadow(&self) -> Option<<Self::ConcreteNode as TNode>::C...
    method rule_hash_target (line 821) | fn rule_hash_target(&self) -> Self {
    method each_applicable_non_document_style_rule_data (line 841) | fn each_applicable_non_document_style_rule_data<'a, F>(&self, mut f: F...
    method needs_transitions_update (line 916) | fn needs_transitions_update(
    method lang_attr (line 924) | fn lang_attr(&self) -> Option<AttrValue>;
    method match_element_lang (line 931) | fn match_element_lang(&self, override_lang: Option<Option<AttrValue>>,...
    method is_html_document_body_element (line 935) | fn is_html_document_body_element(&self) -> bool;
    method synthesize_presentational_hints_for_legacy_attributes (line 939) | fn synthesize_presentational_hints_for_legacy_attributes<V>(
    method synthesize_view_transition_dynamic_rules (line 949) | fn synthesize_view_transition_dynamic_rules<V>(&self, _rules: &mut V)
    method local_name (line 956) | fn local_name(&self) -> &<SelectorImpl as selectors::parser::SelectorI...
    method namespace (line 959) | fn namespace(&self)
    method query_container_size (line 965) | fn query_container_size(
    method has_selector_flags (line 971) | fn has_selector_flags(&self, flags: ElementSelectorFlags) -> bool;
    method relative_selector_search_direction (line 974) | fn relative_selector_search_direction(&self) -> ElementSelectorFlags;
    method implicit_scope_for_sheet_in_shadow_root (line 977) | fn implicit_scope_for_sheet_in_shadow_root(
    method compute_layout_damage (line 985) | fn compute_layout_damage(_old: &ComputedValues, _new: &ComputedValues)...
  type AttributeProvider (line 991) | pub trait AttributeProvider {
    method get_attr (line 993) | fn get_attr(&self, attr: &LocalName, namespace: &Namespace) -> Option<...
    method get_attr (line 1050) | fn get_attr(&self, _attr: &LocalName, _namespace: &Namespace) -> Optio...
  type AttributeReferences (line 997) | pub type AttributeReferences = Option<Box<PrecomputedHashMap<LocalName, ...
  type AttributeTracker (line 1000) | pub struct AttributeTracker<'a> {
  function new (line 1009) | pub fn new(provider: &'a dyn AttributeProvider) -> Self {
  function new_dummy (line 1017) | pub fn new_dummy() -> Self {
  function finalize (line 1025) | pub fn finalize(self) -> AttributeReferences {
  function query (line 1030) | pub fn query(&mut self, name: &LocalName, namespace: &Namespace) -> Opti...
  type DummyAttributeProvider (line 1047) | struct DummyAttributeProvider;
  type SendNode (line 1062) | pub struct SendNode<N: TNode>(N);
  function new (line 1066) | pub unsafe fn new(node: N) -> Self {
  type Target (line 1071) | type Target = N;
  method deref (line 1072) | fn deref(&self) -> &N {
  type SendElement (line 1080) | pub struct SendElement<E: TElement>(E);
  function new (line 1084) | pub unsafe fn new(el: E) -> Self {
  type Target (line 1089) | type Target = E;
  method deref (line 1090) | fn deref(&self) -> &E {

FILE: style/dom_apis.rs
  function element_matches (line 28) | pub fn element_matches<E>(
  function element_closest (line 52) | pub fn element_closest<E>(
  type SelectorQuery (line 86) | pub trait SelectorQuery<E: TElement> {
    method should_stop_after_first_match (line 91) | fn should_stop_after_first_match() -> bool;
    method append_element (line 94) | fn append_element(output: &mut Self::Output, element: E);
    method is_empty (line 97) | fn is_empty(output: &Self::Output) -> bool;
  type QuerySelectorAllResult (line 101) | pub type QuerySelectorAllResult<E> = SmallVec<[E; 128]>;
  type QueryAll (line 104) | pub struct QueryAll;
    type Output (line 107) | type Output = QuerySelectorAllResult<E>;
    method should_stop_after_first_match (line 109) | fn should_stop_after_first_match() -> bool {
    method append_element (line 113) | fn append_element(output: &mut Self::Output, element: E) {
    method is_empty (line 117) | fn is_empty(output: &Self::Output) -> bool {
  type QueryFirst (line 123) | pub struct QueryFirst;
    type Output (line 126) | type Output = Option<E>;
    method should_stop_after_first_match (line 128) | fn should_stop_after_first_match() -> bool {
    method append_element (line 132) | fn append_element(output: &mut Self::Output, element: E) {
    method is_empty (line 138) | fn is_empty(output: &Self::Output) -> bool {
  type QuerySelectorProcessor (line 143) | struct QuerySelectorProcessor<'a, 'b, E, Q>
  function light_tree_only (line 161) | fn light_tree_only(&self) -> bool {
  function check_outer_dependency (line 165) | fn check_outer_dependency(&mut self, _: &Dependency, _: E, _: Option<Opa...
  function collect_invalidations (line 173) | fn collect_invalidations(
  function matching_context (line 212) | fn matching_context(&mut self) -> &mut MatchingContext<'b, E::Impl> {
  function sibling_traversal_map (line 216) | fn sibling_traversal_map(&self) -> &SiblingTraversalMap<E> {
  function should_process_descendants (line 220) | fn should_process_descendants(&mut self, _: E) -> bool {
  function invalidated_self (line 228) | fn invalidated_self(&mut self, e: E) {
  function invalidated_sibling (line 232) | fn invalidated_sibling(&mut self, e: E, _of: E) {
  function recursion_limit_exceeded (line 236) | fn recursion_limit_exceeded(&mut self, _e: E) {}
  function invalidated_descendants (line 237) | fn invalidated_descendants(&mut self, _e: E, _child: E) {}
  type Operation (line 240) | enum Operation {
    method from (line 248) | fn from(matches: bool) -> Self {
  function collect_all_elements (line 257) | fn collect_all_elements<E, Q, F>(root: E::ConcreteNode, results: &mut Q:...
  function connected_element_is_descendant_of (line 296) | fn connected_element_is_descendant_of<E>(element: E, root: E::ConcreteNo...
  function fast_connected_elements_with_id (line 334) | fn fast_connected_elements_with_id<'a, N>(
  function collect_elements_with_id (line 362) | fn collect_elements_with_id<E, Q, F>(
  function has_attr (line 402) | fn has_attr<E>(element: E, local_name: &crate::LocalName) -> bool
  function local_name_matches (line 412) | fn local_name_matches<E>(element: E, local_name: &LocalName<E::Impl>) ->...
  function get_attr_name (line 430) | fn get_attr_name(component: &Component<SelectorImpl>) -> Option<&crate::...
  function get_id (line 447) | fn get_id(component: &Component<SelectorImpl>) -> Option<&AtomIdent> {
  function query_selector_single_query (line 470) | fn query_selector_single_query<E, Q>(
  type SimpleFilter (line 593) | enum SimpleFilter<'a> {
  function query_selector_fast (line 608) | fn query_selector_fast<E, Q>(
  function query_selector_slow (line 815) | fn query_selector_slow<E, Q>(
  type MayUseInvalidation (line 835) | pub enum MayUseInvalidation {
  function query_selector (line 843) | pub fn query_selector<E, Q>(

FILE: style/driver.rs
  function should_report_statistics (line 20) | fn should_report_statistics() -> bool {
  function should_report_statistics (line 25) | fn should_report_statistics() -> bool {
  function report_statistics (line 30) | fn report_statistics(_stats: &PerThreadTraversalStatistics) {
  function report_statistics (line 35) | fn report_statistics(stats: &PerThreadTraversalStatistics) {
  function with_pool_in_place_scope (line 49) | fn with_pool_in_place_scope<'scope>(
  function work_unit_max (line 75) | fn work_unit_max() -> usize {
  function traverse_dom (line 88) | pub fn traverse_dom<E, D>(

FILE: style/error_reporting.rs
  type ContextualParseError (line 20) | pub enum ContextualParseError<'a> {
  function fmt (line 64) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  type ParseErrorReporter (line 245) | pub trait ParseErrorReporter {
    method report_error (line 250) | fn report_error(
    method report_error (line 269) | fn report_error(
  type RustLogReporter (line 265) | pub struct RustLogReporter;
  type SelectorWarningKind (line 291) | pub enum SelectorWarningKind {
    method from_selector (line 302) | pub fn from_selector(selector: &Selector<SelectorImpl>) -> Vec<Self> {
  type PerCompoundState (line 315) | struct PerCompoundState {
    method new (line 325) | fn new(in_relative_selector: bool) -> Self {
  type UnconstrainedRelativeSelectorVisitor (line 335) | struct UnconstrainedRelativeSelectorVisitor {
    method new (line 340) | fn new(in_relative_selector: bool) -> Self {
    method has_warning (line 346) | fn has_warning(
  type Impl (line 388) | type Impl = SelectorImpl;
  method visit_simple_selector (line 390) | fn visit_simple_selector(&mut self, c: &Component<Self::Impl>) -> bool {
  method visit_selector_list (line 403) | fn visit_selector_list(
  method visit_relative_selector_list (line 448) | fn visit_relative_selector_list(&mut self, list: &[RelativeSelector<Self...
  type SiblingCombinatorAfterScopeSelectorVisitor (line 466) | struct SiblingCombinatorAfterScopeSelectorVisitor {
    method new (line 472) | fn new(right_combinator_is_sibling: bool) -> Self {
    method has_warning (line 478) | fn has_warning(selector: &Selector<SelectorImpl>) -> bool {
    method find_never_matching_scope_selector (line 486) | fn find_never_matching_scope_selector(mut self, selector: &Selector<Se...
  type Impl (line 493) | type Impl = SelectorImpl;
  method visit_simple_selector (line 495) | fn visit_simple_selector(&mut self, c: &Component<Self::Impl>) -> bool {
  method visit_selector_list (line 506) | fn visit_selector_list(
  method visit_complex_selector (line 518) | fn visit_complex_selector(&mut self, combinator_to_right: Option<Combina...

FILE: style/font_face.rs
  type Source (line 30) | pub enum Source {
  type SourceList (line 41) | pub struct SourceList(#[css(iterable)] pub Vec<Source>);
  method parse (line 47) | fn parse<'i, 't>(
  type FontFaceSourceFormatKeyword (line 75) | pub enum FontFaceSourceFormatKeyword {
  type FontFaceSourceTechFlags (line 94) | pub struct FontFaceSourceTechFlags(u16);
    method parse_one (line 124) | pub fn parse_one<'i, 't>(input: &mut Parser<'i, 't>) -> Result<Self, P...
  method parse (line 142) | fn parse<'i, 't>(
  method to_css (line 165) | fn to_css<W>(&self, dest: &mut CssWriter<W>) -> fmt::Result
  type FontFaceRule (line 202) | pub struct FontFaceRule {
    method empty (line 211) | pub fn empty(source_location: SourceLocation) -> Self {
  type FontFaceSourceListComponent (line 227) | pub enum FontFaceSourceListComponent {
  type FontFaceSourceFormat (line 242) | pub enum FontFaceSourceFormat {
  type UrlSource (line 253) | pub struct UrlSource {
  method to_css (line 263) | fn to_css<W>(&self, dest: &mut CssWriter<W>) -> fmt::Result
  type FontDisplay (line 291) | pub enum FontDisplay {
  type FontWeightRange (line 333) | pub struct FontWeightRange(pub AbsoluteFontWeight, pub AbsoluteFontWeight);
    method compute (line 355) | pub fn compute(&self) -> ComputedFontWeightRange {
  type ComputedFontWeightRange (line 342) | pub struct ComputedFontWeightRange(f32, f32);
  function sort_range (line 345) | fn sort_range<T: PartialOrd>(a: T, b: T) -> (T, T) {
  type FontStretchRange (line 365) | pub struct FontStretchRange(pub SpecifiedFontStretch, pub SpecifiedFontS...
    method compute (line 376) | pub fn compute(&self) -> ComputedFontStretchRange {
  type ComputedFontStretchRange (line 372) | pub struct ComputedFontStretchRange(FontStretch, FontStretch);
  type FontStyle (line 395) | pub enum FontStyle {
    method compute (line 467) | pub fn compute(&self) -> ComputedFontStyleDescriptor {
  type ComputedFontStyleDescriptor (line 404) | pub enum ComputedFontStyleDescriptor {
  method parse (line 410) | fn parse<'i, 't>(
  method to_css (line 438) | fn to_css<W>(&self, dest: &mut CssWriter<W>) -> fmt::Result
  function parse_font_face_block (line 484) | pub fn parse_font_face_block(
  method parse (line 509) | fn parse<'i, 't>(
  method to_css (line 562) | fn to_css(&self, _guard: &SharedRwLockReadGuard, dest: &mut CssStringWri...

FILE: style/font_metrics.rs
  type FontMetrics (line 14) | pub struct FontMetrics {
    method x_height_or_default (line 49) | pub fn x_height_or_default(&self, reference_font_size: Length) -> Leng...
    method zero_advance_measure_or_default (line 62) | pub fn zero_advance_measure_or_default(
    method cap_height_or_default (line 89) | pub fn cap_height_or_default(&self) -> Length {
    method ic_width_or_default (line 100) | pub fn ic_width_or_default(&self, reference_font_size: Length) -> Leng...
  method default (line 34) | fn default() -> Self {
  type FontMetricsOrientation (line 115) | pub enum FontMetricsOrientation {

FILE: style/gecko/conversions.rs
  method from (line 18) | fn from(other: RulesMutateError) -> Self {
  method from (line 29) | fn from(m: &'a Matrix4x4Components) -> Matrix3D {
  method from (line 52) | fn from(matrix: Matrix3D) -> Self {

FILE: style/gecko/data.rs
  type GeckoStyleSheet (line 30) | pub struct GeckoStyleSheet(*const DomStyleSheet);
    method fmt (line 43) | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
    method new (line 56) | pub unsafe fn new(s: *const DomStyleSheet) -> Self {
    method from_addrefed (line 65) | pub unsafe fn from_addrefed(s: *const DomStyleSheet) -> Self {
    method hack_is_null (line 73) | pub fn hack_is_null(&self) -> bool {
    method raw (line 78) | pub fn raw(&self) -> &DomStyleSheet {
    method inner (line 82) | fn inner(&self) -> &StyleSheetInfo {
    method raw_contents (line 86) | fn raw_contents(&self) -> &StylesheetContents {
  method drop (line 93) | fn drop(&mut self) {
  method clone (line 99) | fn clone(&self) -> Self {
  method media (line 106) | fn media<'a>(&'a self, guard: &'a SharedRwLockReadGuard) -> Option<&'a M...
  method enabled (line 121) | fn enabled(&self) -> bool {
  method contents (line 126) | fn contents<'a>(&'a self, _: &'a SharedRwLockReadGuard) -> &'a Styleshee...
  method implicit_scope_root (line 130) | fn implicit_scope_root(&self) -> Option<ImplicitScopeRoot> {
  type PerDocumentStyleDataImpl (line 159) | pub struct PerDocumentStyleDataImpl {
    method flush_stylesheets (line 201) | pub fn flush_stylesheets(
    method default_computed_values (line 209) | pub fn default_computed_values(&self) -> &Arc<ComputedValues> {
    method add_size_of (line 214) | pub fn add_size_of(&self, ops: &mut MallocSizeOfOps, sizes: &mut Servo...
  type PerDocumentStyleData (line 173) | pub struct PerDocumentStyleData(AtomicRefCell<PerDocumentStyleDataImpl>);
    method new (line 177) | pub fn new(document: *const structs::Document) -> Self {
    method borrow (line 189) | pub fn borrow(&self) -> AtomicRef<'_, PerDocumentStyleDataImpl> {
    method borrow_mut (line 194) | pub fn borrow_mut(&self) -> AtomicRefMut<'_, PerDocumentStyleDataImpl> {
  type AuthorStyles (line 220) | pub type AuthorStyles = crate::author_styles::AuthorStyles<GeckoStyleShe...

FILE: style/gecko/media_features.rs
  function device_size (line 20) | fn device_size(device: &Device) -> Size2D<Au> {
  function eval_width (line 30) | fn eval_width(context: &Context) -> CSSPixelLength {
  function eval_device_width (line 35) | fn eval_device_width(context: &Context) -> CSSPixelLength {
  function eval_height (line 40) | fn eval_height(context: &Context) -> CSSPixelLength {
  function eval_device_height (line 45) | fn eval_device_height(context: &Context) -> CSSPixelLength {
  function eval_aspect_ratio_for (line 49) | fn eval_aspect_ratio_for<F>(context: &Context, get_size: F) -> Ratio
  function eval_aspect_ratio (line 58) | fn eval_aspect_ratio(context: &Context) -> Ratio {
  function eval_device_aspect_ratio (line 63) | fn eval_device_aspect_ratio(context: &Context) -> Ratio {
  function eval_device_pixel_ratio (line 68) | fn eval_device_pixel_ratio(context: &Context) -> f32 {
  function eval_orientation (line 73) | fn eval_orientation(context: &Context, value: Option<Orientation>) -> bo...
  function eval_device_orientation (line 78) | fn eval_device_orientation(context: &Context, value: Option<Orientation>...
  function document_picture_in_picture_enabled (line 82) | fn document_picture_in_picture_enabled(context: &ParserContext) -> bool {
  type DisplayMode (line 90) | pub enum DisplayMode {
  function eval_display_mode (line 100) | fn eval_display_mode(context: &Context, query_value: Option<DisplayMode>...
  function eval_grid (line 112) | fn eval_grid(_: &Context) -> bool {
  function eval_transform_3d (line 119) | fn eval_transform_3d(_: &Context) -> bool {
  type Scan (line 125) | enum Scan {
  function eval_scan (line 131) | fn eval_scan(_: &Context, _: Option<Scan>) -> bool {
  function eval_color (line 138) | fn eval_color(context: &Context) -> i32 {
  function eval_color_index (line 143) | fn eval_color_index(_: &Context) -> i32 {
  function eval_monochrome (line 149) | fn eval_monochrome(context: &Context) -> i32 {
  type ColorGamut (line 159) | pub enum ColorGamut {
  function eval_color_gamut (line 169) | fn eval_color_gamut(context: &Context, query_value: Option<ColorGamut>) ...
  function eval_resolution (line 181) | fn eval_resolution(context: &Context) -> Resolution {
  type PrefersReducedMotion (line 189) | enum PrefersReducedMotion {
  type PrefersReducedTransparency (line 196) | enum PrefersReducedTransparency {
  type DynamicRange (line 208) | pub enum DynamicRange {
  function eval_prefers_reduced_motion (line 214) | fn eval_prefers_reduced_motion(
  function eval_prefers_reduced_transparency (line 232) | fn eval_prefers_reduced_transparency(
  type PrefersContrast (line 254) | pub enum PrefersContrast {
  function eval_prefers_contrast (line 266) | fn eval_prefers_contrast(context: &Context, query_value: Option<PrefersC...
  function eval_forced_colors (line 276) | fn eval_forced_colors(context: &Context, query_value: Option<ForcedColor...
  type InvertedColors (line 288) | enum InvertedColors {
  function eval_inverted_colors (line 296) | fn eval_inverted_colors(context: &Context, query_value: Option<InvertedC...
  type OverflowBlock (line 312) | enum OverflowBlock {
  function eval_overflow_block (line 319) | fn eval_overflow_block(context: &Context, query_value: Option<OverflowBl...
  type OverflowInline (line 342) | enum OverflowInline {
  function eval_overflow_inline (line 348) | fn eval_overflow_inline(context: &Context, query_value: Option<OverflowI...
  type Update (line 364) | enum Update {
  function eval_update (line 371) | fn eval_update(context: &Context, query_value: Option<Update>) -> bool {
  function do_eval_prefers_color_scheme (line 390) | fn do_eval_prefers_color_scheme(
  function eval_prefers_color_scheme (line 405) | fn eval_prefers_color_scheme(context: &Context, query_value: Option<Pref...
  function eval_content_prefers_color_scheme (line 409) | fn eval_content_prefers_color_scheme(
  function eval_dynamic_range (line 417) | fn eval_dynamic_range(context: &Context, query_value: Option<DynamicRang...
  function eval_video_dynamic_range (line 426) | fn eval_video_dynamic_range(context: &Context, query_value: Option<Dynam...
  function primary_pointer_capabilities (line 444) | fn primary_pointer_capabilities(context: &Context) -> PointerCapabilities {
  function all_pointer_capabilities (line 450) | fn all_pointer_capabilities(context: &Context) -> PointerCapabilities {
  type Pointer (line 458) | enum Pointer {
  function eval_pointer_capabilities (line 464) | fn eval_pointer_capabilities(
  function eval_pointer (line 481) | fn eval_pointer(context: &Context, query_value: Option<Pointer>) -> bool {
  function eval_any_pointer (line 486) | fn eval_any_pointer(context: &Context, query_value: Option<Pointer>) -> ...
  type Hover (line 492) | enum Hover {
  function eval_hover_capabilities (line 497) | fn eval_hover_capabilities(
  function eval_hover (line 514) | fn eval_hover(context: &Context, query_value: Option<Hover>) -> bool {
  function eval_any_hover (line 519) | fn eval_any_hover(context: &Context, query_value: Option<Hover>) -> bool {
  function eval_moz_is_glyph (line 523) | fn eval_moz_is_glyph(context: &Context) -> bool {
  function eval_moz_in_android_pip_mode (line 527) | fn eval_moz_in_android_pip_mode(context: &Context) -> bool {
  function eval_moz_print_preview (line 531) | fn eval_moz_print_preview(context: &Context) -> bool {
  function eval_moz_is_resource_document (line 539) | fn eval_moz_is_resource_document(context: &Context) -> bool {
  type Platform (line 546) | pub enum Platform {
  function eval_moz_platform (line 562) | fn eval_moz_platform(_: &Context, query_value: Option<Platform>) -> bool {
  type GtkThemeFamily (line 574) | pub enum GtkThemeFamily {
  function eval_gtk_theme_family (line 585) | fn eval_gtk_theme_family(_: &Context, query_value: Option<GtkThemeFamily...
  type Scripting (line 597) | pub enum Scripting {
  function eval_scripting (line 610) | fn eval_scripting(context: &Context, query_value: Option<Scripting>) -> ...
  function eval_moz_overlay_scrollbars (line 618) | fn eval_moz_overlay_scrollbars(context: &Context) -> bool {
  function eval_moz_mac_rtl (line 622) | fn eval_moz_mac_rtl(context: &Context) -> bool {
  function eval_moz_native_theme (line 626) | fn eval_moz_native_theme(context: &Context) -> bool {
  function get_lnf_int (line 633) | fn get_lnf_int(int_id: i32) -> i32 {
  function get_lnf_int_as_bool (line 637) | fn get_lnf_int_as_bool(int_id: i32) -> bool {

FILE: style/gecko/pseudo_element.rs
  type Target (line 75) | pub enum Target {
  type PtNameAndClassSelector (line 99) | pub struct PtNameAndClassSelector(thin_vec::ThinVec<Atom>);
    method from_name (line 103) | pub fn from_name(name: Atom) -> Self {
    method name (line 108) | pub fn name(&self) -> &Atom {
    method classes (line 114) | pub fn classes(&self) -> &[Atom] {
    method name_and_classes (line 120) | pub fn name_and_classes(&self) -> &thin_vec::ThinVec<Atom> {
    method parse (line 130) | pub fn parse<'i, 't>(
  method to_css (line 197) | fn to_css<W>(&self, dest: &mut W) -> fmt::Result
  type Impl (line 219) | type Impl = SelectorImpl;
  method valid_after_slotted (line 225) | fn valid_after_slotted(&self) -> bool {
  method valid_after_before_or_after (line 233) | fn valid_after_before_or_after(&self) -> bool {
  method accepts_state_pseudo_classes (line 238) | fn accepts_state_pseudo_classes(&self) -> bool {
  method specificity_count (line 245) | fn specificity_count(&self) -> u32 {
  method is_in_pseudo_element_tree (line 250) | fn is_in_pseudo_element_tree(&self) -> bool {
  method parses_as_element_backed (line 256) | fn parses_as_element_backed(&self) -> bool {
  method is_before_or_after (line 263) | fn is_before_or_after(&self) -> bool {
  method is_element_backed (line 272) | pub fn is_element_backed(&self) -> bool {
  method cascade_type (line 284) | pub fn cascade_type(&self) -> PseudoElementCascadeType {
  method index (line 299) | pub fn index(&self) -> usize {
  method discriminant (line 304) | fn discriminant(&self) -> u8 {
  method is_unknown_webkit_pseudo_element (line 312) | pub fn is_unknown_webkit_pseudo_element(&self) -> bool {
  method is_anon_box (line 318) | pub fn is_anon_box(&self) -> bool {
  method is_eager (line 324) | pub fn is_eager(&self) -> bool {
  method eager_index (line 330) | pub fn eager_index(&self) -> usize {
  method from_eager_index (line 339) | pub fn from_eager_index(i: usize) -> Self {
  method animations_stored_in_parent (line 346) | pub fn animations_stored_in_parent(&self) -> bool {
  method is_before (line 355) | pub fn is_before(&self) -> bool {
  method is_after (line 361) | pub fn is_after(&self) -> bool {
  method is_marker (line 367) | pub fn is_marker(&self) -> bool {
  method is_selection (line 373) | pub fn is_selection(&self) -> bool {
  method is_first_letter (line 379) | pub fn is_first_letter(&self) -> bool {
  method is_first_line (line 385) | pub fn is_first_line(&self) -> bool {
  method is_lazy (line 391) | pub fn is_lazy(&self) -> bool {
  method highlight_name (line 396) | pub fn highlight_name(&self) -> Option<&AtomIdent> {
  method is_highlight (line 404) | pub fn is_highlight(&self) -> bool {
  method is_target_text (line 410) | pub fn is_target_text(&self) -> bool {
  method is_lazy_painted_highlight_pseudo (line 418) | pub fn is_lazy_painted_highlight_pseudo(&self) -> bool {
  method is_named_view_transition (line 423) | pub fn is_named_view_transition(&self) -> bool {
  method specificity_count (line 434) | pub fn specificity_count(&self) -> u32 {
  method supports_user_action_state (line 456) | pub fn supports_user_action_state(&self) -> bool {
  method enabled_in_content (line 462) | pub fn enabled_in_content(&self) -> bool {
  method enabled_in_ua_sheets (line 467) | pub fn enabled_in_ua_sheets(&self) -> bool {
  method enabled_in_chrome (line 472) | pub fn enabled_in_chrome(&self) -> bool {
  method skip_item_display_fixup (line 480) | pub fn skip_item_display_fixup(&self) -> bool {
  method is_precomputed (line 488) | pub fn is_precomputed(&self) -> bool {
  method property_restriction (line 494) | pub fn property_restriction(&self) -> Option<PropertyFlags> {
  method should_exist (line 507) | pub fn should_exist(&self, style: &ComputedValues) -> bool {
  method parse_ignore_enabled_state (line 524) | pub fn parse_ignore_enabled_state<'i, 't>(
  method matches_named_view_transition_pseudo_element (line 572) | pub fn matches_named_view_transition_pseudo_element(

FILE: style/gecko/pseudo_element_definition.mako.rs
  type AtomThinVec (line 7) | type AtomThinVec = thin_vec::ThinVec<Atom>;
  constant PSEUDO_COUNT (line 35) | pub const PSEUDO_COUNT: usize = ${len(PSEUDOS)};
  constant EAGER_PSEUDOS (line 38) | pub const EAGER_PSEUDOS: [PseudoElement; EAGER_PSEUDO_COUNT] = [
  function matches (line 224) | pub fn matches(
  method to_css (line 243) | fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {

FILE: style/gecko/pseudo_elements.py
  class Pseudo (line 18) | class Pseudo(object):
    method __init__ (line 19) | def __init__(self, name, argument, enabled_in, pref):
    method is_pseudo_element (line 27) | def is_pseudo_element(self):
    method is_anon_box (line 30) | def is_anon_box(self):
    method is_non_inheriting_anon_box (line 33) | def is_non_inheriting_anon_box(self):
    method is_inheriting_anon_box (line 36) | def is_inheriting_anon_box(self):
    method flags (line 39) | def flags(self):
  class AnonBox (line 76) | class AnonBox(Pseudo):
    method __init__ (line 77) | def __init__(self, name, wrapper=False, inherits=True):
  class PseudoElement (line 83) | class PseudoElement(Pseudo):
    method __init__ (line 84) | def __init__(
  class PseudoElementData (line 114) | class PseudoElementData:
    method __init__ (line 115) | def __init__(self):
    method all_pseudos (line 132) | def all_pseudos(self):

FILE: style/gecko/regen_atoms.py
  function map_atom (line 25) | def map_atom(ident):
  class Atom (line 42) | class Atom:
    method __init__ (line 43) | def __init__(self, ident, value, hash):
  function collect_atoms (line 50) | def collect_atoms(objdir):
  class FileAvoidWrite (line 67) | class FileAvoidWrite(BytesIO):
    method __init__ (line 70) | def __init__(self, filename):
    method write (line 74) | def write(self, buf):
    method close (line 79) | def close(self):
    method __enter__ (line 93) | def __enter__(self):
    method __exit__ (line 96) | def __exit__(self, type, value, traceback):
  function write_atom_macro (line 130) | def write_atom_macro(atoms, file_name):
  function generate_atoms (line 140) | def generate_atoms(dist, out):
  function generate_pseudo_elements (line 145) | def generate_pseudo_elements(dist, out):

FILE: style/gecko/restyle_damage.rs
  type GeckoRestyleDamage (line 17) | pub struct GeckoRestyleDamage(nsChangeHint);
    method new (line 22) | pub fn new(raw: nsChangeHint) -> Self {
    method as_change_hint (line 28) | pub fn as_change_hint(&self) -> nsChangeHint {
    method empty (line 34) | pub fn empty() -> Self {
    method is_empty (line 40) | pub fn is_empty(&self) -> bool {
    method compute_style_difference (line 46) | pub fn compute_style_difference(
    method contains (line 85) | pub fn contains(self, other: Self) -> bool {
    method reconstruct (line 91) | pub fn reconstruct() -> Self {
  method default (line 97) | fn default() -> Self {
  type Output (line 103) | type Output = Self;
  method bitor (line 104) | fn bitor(self, other: Self) -> Self {
  method bitor_assign (line 110) | fn bitor_assign(&mut self, other: Self) {
  type Output (line 116) | type Output = Self;
  method bitand (line 117) | fn bitand(self, other: Self) -> Self {
  type Output (line 123) | type Output = Self;
  method not (line 124) | fn not(self) -> Self {

FILE: style/gecko/selector_parser.rs
  type Lang (line 43) | pub struct Lang(#[css(iterable)] pub ThinVec<AtomIdent>);
  type CustomState (line 47) | pub struct CustomState(pub AtomIdent);
  type HeadingSelectorData (line 52) | pub struct HeadingSelectorData(pub ThinVec<CSSInteger>);
    method matches_state (line 58) | pub fn matches_state(&self, state: ElementState) -> bool {
  method to_css (line 104) | fn to_css<W>(&self, dest: &mut W) -> fmt::Result
  method parse_non_functional (line 172) | pub fn parse_non_functional(name: &str) -> Option<Self> {
  method has_any_flag (line 193) | fn has_any_flag(&self, flags: NonTSPseudoClassFlag) -> bool {
  method is_enabled_in_content (line 220) | fn is_enabled_in_content(&self) -> bool {
  method state_flag (line 246) | pub fn state_flag(&self) -> ElementState {
  method document_state_flag (line 272) | pub fn document_state_flag(&self) -> DocumentState {
  method needs_cache_revalidation (line 286) | pub fn needs_cache_revalidation(&self) -> bool {
  type Impl (line 308) | type Impl = SelectorImpl;
  method is_active_or_hover (line 311) | fn is_active_or_hover(&self) -> bool {
  method is_user_action_state (line 317) | fn is_user_action_state(&self) -> bool {
  type SelectorImpl (line 327) | pub struct SelectorImpl;
    type ExtraMatchingData (line 346) | type ExtraMatchingData<'a> = ExtraMatchingData<'a>;
    type AttrValue (line 347) | type AttrValue = AtomString;
    type Identifier (line 348) | type Identifier = AtomIdent;
    type LocalName (line 349) | type LocalName = AtomIdent;
    type NamespacePrefix (line 350) | type NamespacePrefix = AtomIdent;
    type NamespaceUrl (line 351) | type NamespaceUrl = Namespace;
    type BorrowedNamespaceUrl (line 352) | type BorrowedNamespaceUrl = WeakNamespace;
    type BorrowedLocalName (line 353) | type BorrowedLocalName = WeakAtom;
    type PseudoElement (line 355) | type PseudoElement = PseudoElement;
    type NonTSPseudoClass (line 356) | type NonTSPseudoClass = NonTSPseudoClass;
    method should_collect_attr_hash (line 358) | fn should_collect_attr_hash(name: &AtomIdent) -> bool {
    method each_eagerly_cascaded_pseudo_element (line 641) | pub fn each_eagerly_cascaded_pseudo_element<F>(mut fun: F)
  type ExtraMatchingData (line 332) | pub struct ExtraMatchingData<'a> {
  function is_pseudo_class_enabled (line 364) | fn is_pseudo_class_enabled(&self, pseudo_class: &NonTSPseudoClass) -> bo...
  function is_pseudo_element_enabled (line 388) | fn is_pseudo_element_enabled(&self, pseudo_element: &PseudoElement) -> b...
  function parse_functional_pseudo_element_with_name (line 406) | pub fn parse_functional_pseudo_element_with_name<'i, 't>(
  type Impl (line 472) | type Impl = SelectorImpl;
  type Error (line 473) | type Error = StyleParseErrorKind<'i>;
  function parse_parent_selector (line 476) | fn parse_parent_selector(&self) -> bool {
  function parse_slotted (line 481) | fn parse_slotted(&self) -> bool {
  function parse_host (line 486) | fn parse_host(&self) -> bool {
  function parse_nth_child_of (line 491) | fn parse_nth_child_of(&self) -> bool {
  function parse_is_and_where (line 496) | fn parse_is_and_where(&self) -> bool {
  function parse_has (line 501) | fn parse_has(&self) -> bool {
  function parse_part (line 506) | fn parse_part(&self) -> bool {
  function is_is_alias (line 511) | fn is_is_alias(&self, function: &str) -> bool {
  function allow_forgiving_selectors (line 516) | fn allow_forgiving_selectors(&self) -> bool {
  function parse_non_ts_pseudo_class (line 520) | fn parse_non_ts_pseudo_class(
  function parse_non_ts_functional_pseudo_class (line 537) | fn parse_non_ts_functional_pseudo_class<'t>(
  function parse_pseudo_element (line 592) | fn parse_pseudo_element(
  function parse_functional_pseudo_element (line 611) | fn parse_functional_pseudo_element<'t>(
  function default_namespace (line 628) | fn default_namespace(&self) -> Option<Namespace> {
  function namespace_for_prefix (line 632) | fn namespace_for_prefix(&self, prefix: &AtomIdent) -> Option<Namespace> {

FILE: style/gecko/snapshot.rs
  type GeckoElementSnapshot (line 25) | pub type GeckoElementSnapshot = ServoElementSnapshot;
    method has_any (line 52) | fn has_any(&self, flags: Flags) -> bool {
    method has_other_pseudo_class_state (line 59) | pub fn has_other_pseudo_class_state(&self) -> bool {
    method id_changed (line 65) | pub fn id_changed(&self) -> bool {
    method class_changed (line 71) | pub fn class_changed(&self) -> bool {
    method each_attr_changed (line 77) | pub fn each_attr_changed<F>(&self, mut callback: F)
    method attr_matches (line 87) | pub fn attr_matches(
  type SnapshotMap (line 28) | pub type SnapshotMap = ServoElementSnapshotTable;
    method get (line 40) | pub fn get<E: TElement>(&self, element: &E) -> Option<&GeckoElementSna...
  method debug_list_attributes (line 98) | fn debug_list_attributes(&self) -> String {
  method state (line 107) | fn state(&self) -> Option<ElementState> {
  method has_attrs (line 116) | fn has_attrs(&self) -> bool {
  method id_attr (line 121) | fn id_attr(&self) -> Option<&WeakAtom> {
  method is_part (line 130) | fn is_part(&self, name: &AtomIdent) -> bool {
  method imported_part (line 140) | fn imported_part(&self, name: &AtomIdent) -> Option<AtomIdent> {
  method has_class (line 145) | fn has_class(&self, name: &AtomIdent, case_sensitivity: CaseSensitivity)...
  method each_class (line 154) | fn each_class<F>(&self, callback: F)
  method lang_attr (line 166) | fn lang_attr(&self) -> Option<AtomString> {
  method has_custom_states (line 177) | fn has_custom_states(&self) -> bool {
  method has_custom_state (line 183) | fn has_custom_state(&self, state: &AtomIdent) -> bool {
  method each_custom_state (line 192) | fn each_custom_state<F>(&self, mut callback: F)

FILE: style/gecko/snapshot_helpers.rs
  type Class (line 23) | enum Class<'a> {
  function base_type (line 30) | fn base_type(attr: &structs::nsAttrValue) -> structs::nsAttrValue_ValueB...
  function ptr (line 35) | unsafe fn ptr<T>(attr: &structs::nsAttrValue) -> *const T {
  function get_class_or_part_from_attr (line 40) | unsafe fn get_class_or_part_from_attr(attr: &structs::nsAttrValue) -> Cl...
  function get_id_from_attr (line 69) | unsafe fn get_id_from_attr(attr: &structs::nsAttrValue) -> &WeakAtom {
  function is_nodeinfo (line 79) | fn is_nodeinfo(&self) -> bool {
  function as_nodeinfo (line 84) | unsafe fn as_nodeinfo(&self) -> &structs::NodeInfo {
  function namespace_id (line 90) | fn namespace_id(&self) -> i32 {
  function name (line 99) | pub fn name(&self) -> *const nsAtom {
  function find_attr (line 110) | pub fn find_attr<'a>(
  function get_id (line 122) | pub fn get_id(attrs: &[structs::AttrArray_InternalAttr]) -> Option<&Weak...
  function each_exported_part (line 127) | pub(super) fn each_exported_part(
  function imported_part (line 150) | pub(super) fn imported_part(
  function has_class_or_part (line 165) | pub fn has_class_or_part(
  function each_class_or_part (line 190) | pub fn each_class_or_part<F>(attr: &structs::nsAttrValue, mut callback: F)
  function classes_changed (line 209) | pub fn classes_changed<E: TElement>(element: &E, snapshots: &SnapshotMap...
  function attr_matches (line 233) | pub(crate) fn attr_matches(
  function attr_matches_checked_name (line 261) | fn attr_matches_checked_name(

FILE: style/gecko/traversal.rs
  type RecalcStyleOnly (line 14) | pub struct RecalcStyleOnly<'a> {
  function new (line 20) | pub fn new(shared: SharedStyleContext<'a>) -> Self {
  function process_preorder (line 26) | fn process_preorder<F>(
  function process_postorder (line 41) | fn process_postorder(&self, _: &mut StyleContext<GeckoElement<'le>>, _: ...
  function needs_postorder_traversal (line 46) | fn needs_postorder_traversal() -> bool {
  function shared_context (line 50) | fn shared_context(&self) -> &SharedStyleContext<'recalc> {

FILE: style/gecko/url.rs
  type CssUrl (line 28) | pub struct CssUrl(pub Arc<CssUrlData>);
    method parse_with_cors_mode (line 107) | pub fn parse_with_cors_mode<'i, 't>(
    method parse_from_string (line 129) | pub fn parse_from_string<'i>(
    method new_from_untainted_string (line 150) | pub fn new_from_untainted_string(
    method new_from_string (line 159) | fn new_from_string(url: String, context: &ParserContext, cors_mode: Co...
    method is_invalid (line 195) | pub fn is_invalid(&self) -> bool {
    method is_fragment (line 202) | pub fn is_fragment(&self) -> bool {
    method as_str (line 209) | pub fn as_str(&self) -> &str {
  type CssUrlData (line 36) | pub struct CssUrlData {
    method is_fragment (line 217) | pub fn is_fragment(&self) -> bool {
    method as_str (line 227) | pub fn as_str(&self) -> &str {
  method eq (line 56) | fn eq(&self, other: &Self) -> bool {
  type NonLocalUriDependency (line 69) | pub enum NonLocalUriDependency {
    method scan (line 84) | fn scan(specified: &str) -> Self {
  method parse (line 233) | fn parse<'i, 't>(
  method size_of (line 244) | fn size_of(&self, _ops: &mut MallocSizeOfOps) -> usize {
  type LoadDataKey (line 256) | struct LoadDataKey(*const LoadDataSource);
  type LoadData (line 283) | pub struct LoadData {
  method drop (line 297) | fn drop(&mut self) {
  method default (line 303) | fn default() -> Self {
  type LoadDataSource (line 322) | pub enum LoadDataSource {
    method get (line 334) | pub unsafe fn get(&self) -> *const LoadData {
  method to_shmem (line 355) | fn to_shmem(&self, _builder: &mut SharedMemoryBuilder) -> to_shmem::Resu...
  type SpecifiedUrl (line 364) | pub type SpecifiedUrl = CssUrl;
  function shutdown (line 369) | pub fn shutdown() {
  type ComputedValue (line 374) | type ComputedValue = ComputedUrl;
  method to_computed_value (line 377) | fn to_computed_value(&self, _: &Context) -> Self::ComputedValue {
  method from_computed_value (line 382) | fn from_computed_value(computed: &Self::ComputedValue) -> Self {
  type ComputedUrl (line 393) | pub struct ComputedUrl(pub SpecifiedUrl);
    method serialize_with (line 396) | fn serialize_with<W>(
  method to_css (line 415) | fn to_css<W>(&self, dest: &mut CssWriter<W>) -> fmt::Result

FILE: style/gecko/wrapper.rs
  function elements_with_id (line 92) | fn elements_with_id<'a, 'le>(
  type GeckoDocument (line 112) | pub struct GeckoDocument<'ld>(pub &'ld structs::Document);
  type ConcreteNode (line 115) | type ConcreteNode = GeckoNode<'ld>;
  method as_node (line 118) | fn as_node(&self) -> Self::ConcreteNode {
  method is_html_document (line 123) | fn is_html_document(&self) -> bool {
  method quirks_mode (line 128) | fn quirks_mode(&self) -> QuirksMode {
  method elements_with_id (line 133) | fn elements_with_id<'a>(&self, id: &AtomIdent) -> Result<&'a [GeckoEleme...
  method shared_lock (line 142) | fn shared_lock(&self) -> &SharedRwLock {
  type GeckoShadowRoot (line 149) | pub struct GeckoShadowRoot<'lr>(pub &'lr structs::ShadowRoot);
  function fmt (line 152) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  method eq (line 160) | fn eq(&self, other: &Self) -> bool {
  type ConcreteNode (line 166) | type ConcreteNode = GeckoNode<'lr>;
  method as_node (line 169) | fn as_node(&self) -> Self::ConcreteNode {
  method host (line 174) | fn host(&self) -> GeckoElement<'lr> {
  method style_data (line 179) | fn style_data<'a>(&self) -> Option<&'a CascadeData>
  method elements_with_id (line 188) | fn elements_with_id<'a>(&self, id: &AtomIdent) -> Result<&'a [GeckoEleme...
  method parts (line 198) | fn parts<'a>(&self) -> &[<Self::ConcreteNode as TNode>::ConcreteElement]
  method implicit_scope_for_sheet (line 213) | fn implicit_scope_for_sheet(&self, sheet_index: usize) -> Option<Implici...
  type GeckoNode (line 231) | pub struct GeckoNode<'ln>(pub &'ln RawGeckoNode);
  method eq (line 235) | fn eq(&self, other: &Self) -> bool {
  function fmt (line 241) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  function is_document (line 264) | fn is_document(&self) -> bool {
  function is_shadow_root (line 271) | fn is_shadow_root(&self) -> bool {
  function from_content (line 276) | fn from_content(content: &'ln nsIContent) -> Self {
  function set_flags (line 281) | fn set_flags(&self, flags: u32) {
  function flags_atomic_for (line 285) | fn flags_atomic_for(flags: &Cell<u32>) -> &AtomicU32 {
  function flags_atomic (line 297) | fn flags_atomic(&self) -> &AtomicU32 {
  function flags (line 302) | fn flags(&self) -> u32 {
  function may_have_element_children (line 307) | fn may_have_element_children(&self) -> bool {
  function selector_flags_atomic (line 312) | fn selector_flags_atomic(&self) -> &AtomicU32 {
  function selector_flags (line 317) | fn selector_flags(&self) -> u32 {
  function set_selector_flags (line 322) | fn set_selector_flags(&self, flags: u32) {
  function node_info (line 328) | fn node_info(&self) -> &structs::NodeInfo {
  function bool_flags (line 336) | fn bool_flags(&self) -> u32 {
  function bool_flags (line 342) | fn bool_flags(&self) -> u32 {
  function get_bool_flag (line 347) | fn get_bool_flag(&self, flag: nsINode_BooleanFlag) -> bool {
  function is_in_shadow_tree (line 353) | fn is_in_shadow_tree(&self) -> bool {
  function flattened_tree_parent_is_parent (line 365) | fn flattened_tree_parent_is_parent(&self) -> bool {
  function flattened_tree_parent (line 391) | fn flattened_tree_parent(&self) -> Option<Self> {
  function contains_non_whitespace_content (line 414) | fn contains_non_whitespace_content(&self) -> bool {
  function prev_sibling_element (line 420) | pub fn prev_sibling_element(&self) -> Option<GeckoElement<'ln>> {
  function next_sibling_element (line 436) | pub fn next_sibling_element(&self) -> Option<GeckoElement<'ln>> {
  function last_child_element (line 452) | pub fn last_child_element(&self) -> Option<GeckoElement<'ln>> {
  method is_element (line 466) | fn is_element(&self) -> bool {
  method is_text_node (line 470) | fn is_text_node(&self) -> bool {
  type ConcreteDocument (line 478) | type ConcreteDocument = GeckoDocument<'ln>;
  type ConcreteShadowRoot (line 479) | type ConcreteShadowRoot = GeckoShadowRoot<'ln>;
  type ConcreteElement (line 480) | type ConcreteElement = GeckoElement<'ln>;
  method parent_node (line 483) | fn parent_node(&self) -> Option<Self> {
  method first_child (line 488) | fn first_child(&self) -> Option<Self> {
  method last_child (line 499) | fn last_child(&self) -> Option<Self> {
  method prev_sibling (line 504) | fn prev_sibling(&self) -> Option<Self> {
  method next_sibling (line 515) | fn next_sibling(&self) -> Option<Self> {
  method owner_doc (line 526) | fn owner_doc(&self) -> Self::ConcreteDocument {
  method is_in_document (line 532) | fn is_in_document(&self) -> bool {
  method traversal_parent (line 536) | fn traversal_parent(&self) -> Option<GeckoElement<'ln>> {
  method opaque (line 541) | fn opaque(&self) -> OpaqueNode {
  method debug_id (line 546) | fn debug_id(self) -> usize {
  method as_element (line 551) | fn as_element(&self) -> Option<GeckoElement<'ln>> {
  method as_document (line 562) | fn as_document(&self) -> Option<Self::ConcreteDocument> {
  method as_shadow_root (line 572) | fn as_shadow_root(&self) -> Option<Self::ConcreteShadowRoot> {
  type GeckoChildrenIterator (line 595) | pub enum GeckoChildrenIterator<'a> {
  method drop (line 604) | fn drop(&mut self) {
  type Item (line 614) | type Item = GeckoNode<'a>;
  method next (line 615) | fn next(&mut self) -> Option<GeckoNode<'a>> {
  type GeckoElement (line 638) | pub struct GeckoElement<'le>(pub &'le RawGeckoElement);
  function fmt (line 641) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  function get_data (line 658) | pub fn get_data(&self) -> Option<&ElementDataWrapper> {
  function has_any_animation (line 664) | pub fn has_any_animation(&self) -> bool {
  function has_attr_impl (line 670) | fn has_attr_impl(&self) -> bool {
  function attrs (line 676) | fn attrs(&self) -> &[structs::AttrArray_InternalAttr] {
  function get_part_attr (line 689) | fn get_part_attr(&self) -> Option<&structs::nsAttrValue> {
  function get_class_attr (line 697) | fn get_class_attr(&self) -> Option<&structs::nsAttrValue> {
  function may_have_anonymous_children (line 713) | fn may_have_anonymous_children(&self) -> bool {
  function flags (line 719) | fn flags(&self) -> u32 {
  function set_flags (line 724) | fn set_flags(&self, flags: u32) {
  function unset_flags (line 729) | unsafe fn unset_flags(&self, flags: u32) {
  function descendants_need_frames (line 737) | pub fn descendants_need_frames(&self) -> bool {
  function needs_frame (line 743) | pub fn needs_frame(&self) -> bool {
  function dom_slots (line 749) | fn dom_slots(&self) -> Option<&structs::FragmentOrElement_nsDOMSlots> {
  function extended_slots (line 756) | fn extended_slots(&self) -> Option<&structs::FragmentOrElement_nsExtende...
  function namespace_id (line 766) | fn namespace_id(&self) -> i32 {
  function has_id (line 771) | fn has_id(&self) -> bool {
  function state_internal (line 777) | fn state_internal(&self) -> u64 {
  function document_state (line 788) | fn document_state(&self) -> DocumentState {
  function may_have_class (line 793) | fn may_have_class(&self) -> bool {
  function has_properties (line 799) | fn has_properties(&self) -> bool {
  function may_have_style_attribute (line 806) | fn may_have_style_attribute(&self) -> bool {
  function note_explicit_hints (line 818) | pub unsafe fn note_explicit_hints(&self, restyle_hint: RestyleHint, chan...
  function is_root_of_native_anonymous_subtree (line 850) | fn is_root_of_native_anonymous_subtree(&self) -> bool {
  function in_native_anonymous_subtree (line 856) | fn in_native_anonymous_subtree(&self) -> bool {
  function in_ua_widget (line 862) | fn in_ua_widget(&self) -> bool {
  function css_transitions_info (line 866) | fn css_transitions_info(&self) -> FxHashMap<OwnedPropertyDeclarationId, ...
  function needs_transitions_update_per_property (line 883) | fn needs_transitions_update_per_property(
  function slow_selector_flags (line 921) | pub fn slow_selector_flags(&self) -> ElementSelectorFlags {
  function is_html_media_element (line 927) | pub fn is_html_media_element(&self) -> bool {
  function slow_selector_flags_from_node_selector_flags (line 935) | pub fn slow_selector_flags_from_node_selector_flags(flags: u32) -> Eleme...
  function selector_flags_to_node_flags (line 950) | fn selector_flags_to_node_flags(flags: ElementSelectorFlags) -> u32 {
  function get_animation_rule (line 987) | fn get_animation_rule(
  function namespace_id_to_atom (line 1014) | pub unsafe fn namespace_id_to_atom(id: i32) -> *mut nsAtom {
  type ConcreteNode (line 1022) | type ConcreteNode = GeckoNode<'le>;
  type TraversalChildrenIterator (line 1023) | type TraversalChildrenIterator = GeckoChildrenIterator<'le>;
  method implicit_scope_for_sheet_in_shadow_root (line 1025) | fn implicit_scope_for_sheet_in_shadow_root(
  method inheritance_parent (line 1046) | fn inheritance_parent(&self) -> Option<Self> {
  method traversal_children (line 1058) | fn traversal_children(&self) -> LayoutIterator<GeckoChildrenIterator<'le...
  method is_html_element (line 1080) | fn is_html_element(&self) -> bool {
  method is_mathml_element (line 1085) | fn is_mathml_element(&self) -> bool {
  method is_svg_element (line 1090) | fn is_svg_element(&self) -> bool {
  method is_xul_element (line 1095) | fn is_xul_element(&self) -> bool {
  method subtree_bloom_filter (line 1100) | fn subtree_bloom_filter(&self) -> u64 {
  method local_name (line 1105) | fn local_name(&self) -> &WeakAtom {
  method namespace (line 1110) | fn namespace(&self) -> &WeakNamespace {
  method query_container_size (line 1115) | fn query_container_size(&self, display: &Display) -> Size2D<Option<Au>> {
  method slotted_nodes (line 1136) | fn slotted_nodes(&self) -> &[Self::ConcreteNode] {
  method shadow_root (line 1160) | fn shadow_root(&self) -> Option<GeckoShadowRoot<'le>> {
  method note_highlight_pseudo_style_invalidated (line 1165) | fn note_highlight_pseudo_style_invalidated(&self) {
  method containing_shadow (line 1173) | fn containing_shadow(&self) -> Option<GeckoShadowRoot<'le>> {
  method each_anonymous_content_child (line 1181) | fn each_anonymous_content_child<F>(&self, mut f: F)
  method as_node (line 1204) | fn as_node(&self) -> Self::ConcreteNode {
  method owner_doc_matches_for_testing (line 1208) | fn owner_doc_matches_for_testing(&self, device: &Device) -> bool {
  method style_attribute (line 1212) | fn style_attribute(&self) -> Option<ArcBorrow<'_, Locked<PropertyDeclara...
  method unset_dirty_style_attribute (line 1223) | fn unset_dirty_style_attribute(&self) {
  method smil_override (line 1231) | fn smil_override(&self) -> Option<ArcBorrow<'_, Locked<PropertyDeclarati...
  method animation_rule (line 1243) | fn animation_rule(
  method transition_rule (line 1250) | fn transition_rule(
  method state (line 1258) | fn state(&self) -> ElementState {
  method has_part_attr (line 1263) | fn has_part_attr(&self) -> bool {
  method exports_any_part (line 1269) | fn exports_any_part(&self) -> bool {
  method id (line 1275) | fn id(&self) -> Option<&WeakAtom> {
  method each_attr_name (line 1282) | fn each_attr_name<F>(&self, mut callback: F)
  method each_class (line 1291) | fn each_class<F>(&self, callback: F)
  method each_custom_state (line 1304) | fn each_custom_state<F>(&self, mut callback: F)
  method each_exported_part (line 1318) | fn each_exported_part<F>(&self, name: &AtomIdent, callback: F)
  method each_part (line 1325) | fn each_part<F>(&self, callback: F)
  method has_snapshot (line 1338) | fn has_snapshot(&self) -> bool {
  method handled_snapshot (line 1343) | fn handled_snapshot(&self) -> bool {
  method set_handled_snapshot (line 1347) | unsafe fn set_handled_snapshot(&self) {
  method has_dirty_descendants (line 1353) | fn has_dirty_descendants(&self) -> bool {
  method set_dirty_descendants (line 1357) | unsafe fn set_dirty_descendants(&self) {
  method unset_dirty_descendants (line 1363) | unsafe fn unset_dirty_descendants(&self) {
  method has_animation_only_dirty_descendants (line 1368) | fn has_animation_only_dirty_descendants(&self) -> bool {
  method set_animation_only_dirty_descendants (line 1372) | unsafe fn set_animation_only_dirty_descendants(&self) {
  method unset_animation_only_dirty_descendants (line 1376) | unsafe fn unset_animation_only_dirty_descendants(&self) {
  method clear_descendant_bits (line 1380) | unsafe fn clear_descendant_bits(&self) {
  method is_visited_link (line 1388) | fn is_visited_link(&self) -> bool {
  method matches_user_and_content_rules (line 1396) | fn matches_user_and_content_rules(&self) -> bool {
  method implemented_pseudo_element (line 1401) | fn implemented_pseudo_element(&self) -> Option<PseudoElement> {
  method store_children_to_process (line 1422) | fn store_children_to_process(&self, _: isize) {
  method did_process_child (line 1426) | fn did_process_child(&self) -> isize {
  method ensure_data (line 1430) | unsafe fn ensure_data(&self) -> ElementDataMut<'_> {
  method clear_data (line 1439) | unsafe fn clear_data(&self) {
  method skip_item_display_fixup (line 1461) | fn skip_item_display_fixup(&self) -> bool {
  method may_have_animations (line 1470) | fn may_have_animations(&self) -> bool {
  method update_animations (line 1487) | fn update_animations(
  method has_animations (line 1514) | fn has_animations(&self, _: &SharedStyleContext) -> bool {
  method has_css_animations (line 1518) | fn has_css_animations(&self, _: &SharedStyleContext, _: Option<PseudoEle...
  method has_css_transitions (line 1522) | fn has_css_transitions(&self, _: &SharedStyleContext, _: Option<PseudoEl...
  method needs_transitions_update (line 1536) | fn needs_transitions_update(
  method has_data (line 1578) | fn has_data(&self) -> bool {
  method borrow_data (line 1583) | fn borrow_data(&self) -> Option<ElementDataRef<'_>> {
  method mutate_data (line 1588) | fn mutate_data(&self) -> Option<ElementDataMut<'_>> {
  method lang_attr (line 1593) | fn lang_attr(&self) -> Option<AttrValue> {
  method match_element_lang (line 1602) | fn match_element_lang(&self, override_lang: Option<Option<AttrValue>>, v...
  method is_html_document_body_element (line 1619) | fn is_html_document_body_element(&self) -> bool {
  method synthesize_view_transition_dynamic_rules (line 1631) | fn synthesize_view_transition_dynamic_rules<V>(&self, rules: &mut V)
  method synthesize_presentational_hints_for_legacy_attributes (line 1646) | fn synthesize_presentational_hints_for_legacy_attributes<V>(
  method has_selector_flags (line 1803) | fn has_selector_flags(&self, flags: ElementSelectorFlags) -> bool {
  method relative_selector_search_direction (line 1808) | fn relative_selector_search_direction(&self) -> ElementSelectorFlags {
  method get_attr (line 1824) | fn get_attr(&self, attr: &LocalName, namespace: &Namespace) -> Option<St...
  method eq (line 1844) | fn eq(&self, other: &Self) -> bool {
  method hash (line 1853) | fn hash<H: Hasher>(&self, state: &mut H) {
  type Impl (line 1859) | type Impl = SelectorImpl;
  function opaque (line 1862) | fn opaque(&self) -> OpaqueElement {
  function parent_element (line 1867) | fn parent_element(&self) -> Option<Self> {
  function parent_node_is_shadow_root (line 1873) | fn parent_node_is_shadow_root(&self) -> bool {
  function containing_shadow_host (line 1880) | fn containing_shadow_host(&self) -> Option<Self> {
  function is_pseudo_element (line 1886) | fn is_pseudo_element(&self) -> bool {
  function pseudo_element_originating_element (line 1891) | fn pseudo_element_originating_element(&self) -> Option<Self> {
  function assigned_slot (line 1908) | fn assigned_slot(&self) -> Option<Self> {
  function prev_sibling_element (line 1915) | fn prev_sibling_element(&self) -> Option<Self> {
  function next_sibling_element (line 1927) | fn next_sibling_element(&self) -> Option<Self> {
  function first_element_child (line 1939) | fn first_element_child(&self) -> Option<Self> {
  function apply_selector_flags (line 1950) | fn apply_selector_flags(&self, flags: ElementSelectorFlags) {
  function has_attr_in_no_namespace (line 1969) | fn has_attr_in_no_namespace(&self, local_name: &LocalName) -> bool {
  function attr_matches (line 1978) | fn attr_matches(
  function is_root (line 1988) | fn is_root(&self) -> bool {
  function is_empty (line 2008) | fn is_empty(&self) -> bool {
  function has_local_name (line 2016) | fn has_local_name(&self, name: &WeakAtom) -> bool {
  function has_namespace (line 2021) | fn has_namespace(&self, ns: &WeakNamespace) -> bool {
  function is_same_type (line 2026) | fn is_same_type(&self, other: &Self) -> bool {
  function match_non_ts_pseudo_class (line 2030) | fn match_non_ts_pseudo_class(
  function match_pseudo_element (line 2186) | fn match_pseudo_element(
  function is_link (line 2203) | fn is_link(&self) -> bool {
  function has_id (line 2208) | fn has_id(&self, id: &AtomIdent, case_sensitivity: CaseSensitivity) -> b...
  function is_part (line 2222) | fn is_part(&self, name: &AtomIdent) -> bool {
  function imported_part (line 2232) | fn imported_part(&self, name: &AtomIdent) -> Option<AtomIdent> {
  function has_class (line 2237) | fn has_class(&self, name: &AtomIdent, case_sensitivity: CaseSensitivity)...
  function has_custom_state (line 2247) | fn has_custom_state(&self, state: &AtomIdent) -> bool {
  function is_html_element_in_html_document (line 2261) | fn is_html_element_in_html_document(&self) -> bool {
  function is_html_slot_element (line 2266) | fn is_html_slot_element(&self) -> bool {
  function ignores_nth_child_selectors (line 2271) | fn ignores_nth_child_selectors(&self) -> bool {
  function add_element_unique_hashes (line 2275) | fn add_element_unique_hashes(&self, filter: &mut BloomFilter) -> bool {

FILE: style/gecko_bindings/sugar/ns_com_ptr.rs
  function raw (line 12) | pub fn raw(&self) -> *mut T {

FILE: style/gecko_bindings/sugar/ns_compatibility.rs
  method from (line 12) | fn from(mode: nsCompatibility) -> QuirksMode {

FILE: style/gecko_bindings/sugar/ns_style_auto_array.rs
  type Output (line 19) | type Output = T;
  function index (line 20) | fn index(&self, index: usize) -> &T {
  function index_mut (line 29) | fn index_mut(&mut self, index: usize) -> &mut T {
  function iter_mut (line 39) | pub fn iter_mut(&mut self) -> Chain<Once<&mut T>, IterMut<'_, T>> {
  function iter (line 44) | pub fn iter(&self) -> Chain<Once<&T>, Iter<'_, T>> {
  function len (line 52) | pub fn len(&self) -> usize {
  function ensure_len (line 59) | pub fn ensure_len(&mut self, len: usize) {
  function ensure_len (line 71) | pub fn ensure_len(&mut self, len: usize) {
  function ensure_len (line 83) | pub fn ensure_len(&mut self, len: usize) {
  function ensure_len (line 95) | pub fn ensure_len(&mut self, len: usize) {
  type Item (line 106) | type Item = &'a mut T;
  type IntoIter (line 107) | type IntoIter = Chain<Once<&'a mut T>, IterMut<'a, T>>;
  method into_iter (line 108) | fn into_iter(self) -> Self::IntoIter {

FILE: style/gecko_bindings/sugar/origin_flags.rs
  function assert_flags_match (line 11) | pub fn assert_flags_match() {
  method from (line 22) | fn from(flags: OriginFlags) -> Self {
  method from (line 28) | fn from(set: OriginSet) -> Self {

FILE: style/gecko_bindings/sugar/ownership.rs
  type Strong (line 19) | pub struct Strong<GeckoType> {
  function from (line 25) | fn from(arc: Arc<T>) -> Self {
  function from (line 34) | fn from(arc: Option<Arc<T>>) -> Self {
  function is_null (line 45) | pub fn is_null(&self) -> bool {
  function null (line 51) | pub fn null() -> Self {
  type Target (line 60) | type Target = T;
  method deref (line 61) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 67) | fn deref_mut<'a>(&'a mut self) -> &'a mut T {

FILE: style/gecko_bindings/sugar/refptr.rs
  type RefCounted (line 17) | pub unsafe trait RefCounted {
    method addref (line 19) | fn addref(&self);
    method release (line 21) | unsafe fn release(&self);
  type ThreadSafeRefCounted (line 25) | pub unsafe trait ThreadSafeRefCounted: RefCounted {}
  type RefPtr (line 29) | pub struct RefPtr<T: RefCounted> {
  function fmt (line 35) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  function from_addrefed (line 46) | pub unsafe fn from_addrefed(ptr: *mut T) -> Self {
  function is_null (line 55) | pub fn is_null(&self) -> bool {
  function null (line 60) | pub fn null() -> Self {
  function new (line 70) | pub unsafe fn new(ptr: *mut T) -> Self {
  function forget (line 82) | pub fn forget(self) -> structs::RefPtr<T> {
  function get (line 92) | pub fn get(&self) -> *mut T {
  function addref (line 97) | pub fn addref(&self) {
  function release (line 108) | pub unsafe fn release(&self) {
  type Target (line 116) | type Target = T;
  method deref (line 117) | fn deref(&self) -> &T {
  function to_safe (line 127) | pub unsafe fn to_safe(&self) -> RefPtr<T> {
  function into_safe (line 137) | pub unsafe fn into_safe(self) -> RefPtr<T> {
  function set (line 152) | pub unsafe fn set(&mut self, other: &Self) {
  function clear (line 163) | pub unsafe fn clear(&mut self) {
  function set_move (line 175) | pub fn set_move(&mut self, other: RefPtr<T>) {
  function null (line 187) | pub fn null() -> Self {
  function from_arc (line 195) | pub fn from_arc(s: Arc<T>) -> Self {
  function set_arc (line 203) | pub fn set_arc(&mut self, other: Arc<T>) {
  method drop (line 214) | fn drop(&mut self) {
  method clone (line 220) | fn clone(&self) -> Self {
  method eq (line 230) | fn eq(&self, other: &Self) -> bool {
  function addref_atom (line 281) | unsafe fn addref_atom(atom: *mut structs::nsAtom) {
  function release_atom (line 286) | unsafe fn release_atom(atom: *mut structs::nsAtom) {

FILE: style/gecko_string_cache/mod.rs
  type Atom (line 55) | pub struct Atom(NonZeroUsize);
    method deserialize (line 84) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    method borrow (line 127) | fn borrow(&self) -> &WeakAtom {
    method is_static (line 379) | fn is_static(&self) -> bool {
    method with (line 384) | pub unsafe fn with<F, R>(ptr: *const nsAtom, callback: F) -> R
    method from_index_unchecked (line 397) | pub const unsafe fn from_index_unchecked(index: u16) -> Self {
    method from_raw (line 404) | pub unsafe fn from_raw(ptr: *mut nsAtom) -> Self {
    method from_addrefed (line 415) | pub unsafe fn from_addrefed(ptr: *mut nsAtom) -> Self {
    method into_addrefed (line 422) | pub fn into_addrefed(self) -> *mut nsAtom {
    method fmt (line 479) | fn fmt(&self, w: &mut fmt::Formatter) -> fmt::Result {
    method fmt (line 485) | fn fmt(&self, w: &mut fmt::Formatter) -> fmt::Result {
    method from (line 492) | fn from(string: &str) -> Atom {
    method from (line 505) | fn from(slice: &[u16]) -> Atom {
    method from (line 512) | fn from(string: &nsAString) -> Atom {
    method from (line 519) | fn from(string: Cow<'a, str>) -> Atom {
    method from (line 526) | fn from(string: String) -> Atom {
  method serialize (line 58) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  type AtomStrVisitor (line 67) | struct AtomStrVisitor;
    type Value (line 69) | type Value = Atom;
    method expecting (line 71) | fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
    method visit_str (line 75) | fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
  type WeakAtom (line 96) | pub struct WeakAtom(nsAtom);
    method eq (line 157) | fn eq(&self, other: &Atom) -> bool {
    method new (line 169) | pub unsafe fn new<'a>(atom: *const nsAtom) -> &'a mut Self {
    method clone (line 175) | pub fn clone(&self) -> Atom {
    method get_hash (line 181) | pub fn get_hash(&self) -> u32 {
    method as_slice (line 187) | pub fn as_slice(&self) -> &[u16] {
    method chars (line 206) | fn chars(&self) -> DecodeUtf16<Cloned<slice::Iter<'_, u16>>> {
    method with_str (line 214) | pub fn with_str<F, Output>(&self, cb: F) -> Output
    method is_static (line 252) | pub fn is_static(&self) -> bool {
    method is_ascii_lowercase (line 258) | fn is_ascii_lowercase(&self) -> bool {
    method len (line 264) | pub fn len(&self) -> u32 {
    method is_empty (line 270) | pub fn is_empty(&self) -> bool {
    method as_ptr (line 276) | pub fn as_ptr(&self) -> *mut nsAtom {
    method to_ascii_lowercase (line 282) | pub fn to_ascii_lowercase(&self) -> Atom {
    method eq_ignore_ascii_case (line 308) | pub fn eq_ignore_ascii_case(&self, other: &Self) -> bool {
    method eq_ignore_ascii_case_slow (line 323) | fn eq_ignore_ascii_case_slow(&self, other: &Self) -> bool {
    method fmt (line 342) | fn fmt(&self, w: &mut fmt::Formatter) -> fmt::Result {
    method fmt (line 348) | fn fmt(&self, w: &mut fmt::Formatter) -> fmt::Result {
  constant STATIC_ATOM_COUNT (line 99) | const STATIC_ATOM_COUNT: usize = GkAtoms_Atoms_AtomsCount as usize;
  type Target (line 102) | type Target = WeakAtom;
  method deref (line 105) | fn deref(&self) -> &WeakAtom {
  method precomputed_hash (line 120) | fn precomputed_hash(&self) -> u32 {
  method to_shmem (line 133) | fn to_shmem(&self, _builder: &mut SharedMemoryBuilder) -> to_shmem::Resu...
  method eq (line 148) | fn eq(&self, other: &Self) -> bool {
  function make_handle (line 357) | unsafe fn make_handle(ptr: *const nsAtom) -> NonZeroUsize {
  function make_static_handle (line 367) | unsafe fn make_static_handle(ptr: *const nsStaticAtom) -> NonZeroUsize {
  method hash (line 430) | fn hash<H>(&self, state: &mut H)
  method hash (line 439) | fn hash<H>(&self, state: &mut H)
  method clone (line 449) | fn clone(&self) -> Atom {
  method drop (line 462) | fn drop(&mut self) {
  method default (line 473) | fn default() -> Self {

FILE: style/gecko_string_cache/namespace.rs
  type Namespace (line 41) | pub struct Namespace(pub Atom);
    method from (line 65) | fn from(s: &'a str) -> Self {
    method fmt (line 71) | fn fmt(&self, w: &mut fmt::Formatter) -> fmt::Result {
    method borrow (line 78) | fn borrow(&self) -> &WeakNamespace {
  method precomputed_hash (line 45) | fn precomputed_hash(&self) -> u32 {
  type WeakNamespace (line 52) | pub struct WeakNamespace(WeakAtom);
    method new (line 86) | pub unsafe fn new<'a>(atom: *mut nsAtom) -> &'a Self {
    method clone (line 93) | pub fn clone(&self) -> Namespace {
  type Target (line 55) | type Target = WeakNamespace;
  method deref (line 58) | fn deref(&self) -> &WeakNamespace {
  method eq (line 101) | fn eq(&self, other: &Self) -> bool {

FILE: style/global_style_data.rs
  type PlatformThreadHandle (line 23) | pub type PlatformThreadHandle = RawPthread;
  type PlatformThreadHandle (line 26) | pub type PlatformThreadHandle = RawHandle;
  type DummyThreadHandle (line 31) | pub struct DummyThreadHandle;
    method join (line 35) | pub fn join(&self) {
  type PlatformThreadHandle (line 41) | pub type PlatformThreadHandle = DummyThreadHandle;
  type GlobalStyleData (line 44) | pub struct GlobalStyleData {
  type StyleThreadPool (line 53) | pub struct StyleThreadPool {
    method shutdown (line 110) | pub fn shutdown() {
    method pool (line 131) | pub fn pool(&self) -> RwLockReadGuard<'_, Option<rayon::ThreadPool>> {
    method get_thread_handles (line 136) | pub fn get_thread_handles(handles: &mut ThinVec<PlatformThreadHandle>) {
  function thread_name (line 64) | fn thread_name(index: usize) -> String {
  function thread_spawn (line 77) | fn thread_spawn(options: rayon::ThreadBuilder) -> io::Result<()> {
  function thread_startup (line 90) | fn thread_startup(_index: usize) {
  function thread_shutdown (line 100) | fn thread_shutdown(_: usize) {
  function stylo_threads_pref (line 158) | fn stylo_threads_pref() -> i32 {
  function stylo_threads_pref (line 163) | fn stylo_threads_pref() -> i32 {
  constant STYLO_MAX_THREADS (line 169) | pub(crate) const STYLO_MAX_THREADS: usize = 6;

FILE: style/invalidation/element/document_state.rs
  type InvalidationMatchingData (line 25) | pub struct InvalidationMatchingData {
  method default (line 32) | fn default() -> Self {
  type DocumentStateInvalidationProcessor (line 41) | pub struct DocumentStateInvalidationProcessor<'a, 'b, E: TElement, I> {
  function new (line 52) | pub fn new(
  function check_outer_dependency (line 86) | fn check_outer_dependency(&mut self, _: &Dependency, _: E, _: Option<Opa...
  function collect_invalidations (line 94) | fn collect_invalidations(
  function matching_context (line 126) | fn matching_context(&mut self) -> &mut MatchingContext<'a, E::Impl> {
  function sibling_traversal_map (line 130) | fn sibling_traversal_map(&self) -> &SiblingTraversalMap<E> {
  function recursion_limit_exceeded (line 134) | fn recursion_limit_exceeded(&mut self, _: E) {
  function should_process_descendants (line 138) | fn should_process_descendants(&mut self, element: E) -> bool {
  function invalidated_descendants (line 145) | fn invalidated_descendants(&mut self, element: E, child: E) {
  function invalidated_self (line 149) | fn invalidated_self(&mut self, element: E) {
  function invalidated_sibling (line 153) | fn invalidated_sibling(&mut self, sibling: E, of: E) {

FILE: style/invalidation/element/element_wrapper.rs
  type ElementSnapshot (line 41) | pub trait ElementSnapshot: Sized {
    method state (line 43) | fn state(&self) -> Option<ElementState>;
    method has_attrs (line 46) | fn has_attrs(&self) -> bool;
    method debug_list_attributes (line 51) | fn debug_list_attributes(&self) -> String {
    method id_attr (line 57) | fn id_attr(&self) -> Option<&WeakAtom>;
    method has_class (line 61) | fn has_class(&self, name: &AtomIdent, case_sensitivity: CaseSensitivit...
    method is_part (line 65) | fn is_part(&self, name: &AtomIdent) -> bool;
    method imported_part (line 68) | fn imported_part(&self, name: &AtomIdent) -> Option<AtomIdent>;
    method each_class (line 72) | fn each_class<F>(&self, _: F)
    method has_custom_states (line 77) | fn has_custom_states(&self) -> bool;
    method has_custom_state (line 80) | fn has_custom_state(&self, state: &AtomIdent) -> bool;
    method each_custom_state (line 83) | fn each_custom_state<F>(&self, callback: F)
    method lang_attr (line 88) | fn lang_attr(&self) -> Option<AttrValue>;
  type ElementWrapper (line 94) | pub struct ElementWrapper<'a, E>
  function new (line 108) | pub fn new(el: E, snapshot_map: &'a SnapshotMap) -> Self {
  function snapshot (line 117) | pub fn snapshot(&self) -> Option<&'a Snapshot> {
  function state_changes (line 135) | pub fn state_changes(&self) -> ElementState {
  function get_lang (line 150) | fn get_lang(&self) -> Option<AttrValue> {
  function fmt (line 169) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  type Impl (line 179) | type Impl = SelectorImpl;
  method match_non_ts_pseudo_class (line 181) | fn match_non_ts_pseudo_class(
  method apply_selector_flags (line 257) | fn apply_selector_flags(&self, _flags: ElementSelectorFlags) {
  method match_pseudo_element (line 261) | fn match_pseudo_element(
  method is_link (line 269) | fn is_link(&self) -> bool {
  method opaque (line 276) | fn opaque(&self) -> OpaqueElement {
  method parent_element (line 280) | fn parent_element(&self) -> Option<Self> {
  method parent_node_is_shadow_root (line 285) | fn parent_node_is_shadow_root(&self) -> bool {
  method containing_shadow_host (line 289) | fn containing_shadow_host(&self) -> Option<Self> {
  method prev_sibling_element (line 294) | fn prev_sibling_element(&self) -> Option<Self> {
  method next_sibling_element (line 299) | fn next_sibli

[
  {
    "path": ".github/workflows/main.yml",
    "chars": 1782,
    "preview": "name: CI\n\non:\n  push:\n    branches: [\"main\"]\n  pull_request:\n  workflow_dispatch:\n  merge_group:\n    types: [checks_requ"
  },
  {
    "path": ".github/workflows/mirror-to-release-branch.yml",
    "chars": 730,
    "preview": "name: 🪞 Mirror `main`\non:\n  push:\n    branches:\n      - main\n\njobs:\n  mirror:\n    name: Mirror\n    runs-on: ubuntu-lates"
  },
  {
    "path": ".github/workflows/sync-upstream.yml",
    "chars": 500,
    "preview": "name: Sync upstream with mozilla-central\n\non:\n  schedule:\n    - cron: '0 13 * * *'\n  workflow_dispatch:\n\njobs:\n  sync:\n "
  },
  {
    "path": ".gitignore",
    "chars": 72,
    "preview": "/_cache/\n/_filtered/\n/target/\n/style/properties/__pycache__/\nCargo.lock\n"
  },
  {
    "path": "Cargo.toml",
    "chars": 1371,
    "preview": "[workspace]\nresolver = \"2\"\nmembers = [\n    \"stylo_atoms\",\n    \"stylo_dom\",\n    \"malloc_size_of\",\n    \"rustfmt.toml\",\n   "
  },
  {
    "path": "README.md",
    "chars": 7394,
    "preview": "Stylo\n=====\n\n**High-Performance CSS Style Engine**\n\n[![Build Status](https://github.com/servo/stylo/actions/workflows/ma"
  },
  {
    "path": "SYNCING.md",
    "chars": 1848,
    "preview": "# Syncing\n\nThis file documents the process of syncing this repository with the upstream copy of Stylo in mozilla-central"
  },
  {
    "path": "commit-from-merge.sh",
    "chars": 652,
    "preview": "#!/bin/sh\n# Usage: commit-from-merge.sh <path/to/servo/servo> <merge commit> [extra git-commit(1) arguments ...]\n# Given"
  },
  {
    "path": "commit-from-squashed.sh",
    "chars": 608,
    "preview": "#!/bin/sh\n# Usage: commit-from-squashed.sh <squashed commit> [extra git-commit(1) arguments ...]\n# Given a squashed comm"
  },
  {
    "path": "malloc_size_of/Cargo.toml",
    "chars": 651,
    "preview": "[package]\nname = \"stylo_malloc_size_of\"\nversion.workspace = true\nauthors = [\"The Servo Project Developers\"]\nlicense = \"M"
  },
  {
    "path": "malloc_size_of/LICENSE-APACHE",
    "chars": 10847,
    "preview": "                              Apache License\n                        Version 2.0, January 2004\n                     http"
  },
  {
    "path": "malloc_size_of/LICENSE-MIT",
    "chars": 1023,
    "preview": "Permission is hereby granted, free of charge, to any\nperson obtaining a copy of this software and associated\ndocumentati"
  },
  {
    "path": "malloc_size_of/lib.rs",
    "chars": 28520,
    "preview": "// Copyright 2016-2017 The Servo Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distri"
  },
  {
    "path": "rustfmt.toml",
    "chars": 57,
    "preview": "match_block_trailing_comma = true\nreorder_imports = true\n"
  },
  {
    "path": "selectors/CHANGES.md",
    "chars": 184,
    "preview": "- `parser.rs` no longer wraps values in quotes (`\"...\"`) but expects their `to_css` impl to already wrap it ([Gecko Bug "
  },
  {
    "path": "selectors/Cargo.toml",
    "chars": 868,
    "preview": "[package]\nname = \"selectors\"\nversion = \"0.38.0\"\nauthors = [\"The Servo Project Developers\"]\ndocumentation = \"https://docs"
  },
  {
    "path": "selectors/README.md",
    "chars": 1166,
    "preview": "rust-selectors\n==============\n\n* [![Build Status](https://github.com/servo/stylo/actions/workflows/main.yml/badge.svg)]("
  },
  {
    "path": "selectors/attr.rs",
    "chars": 6685,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "selectors/bloom.rs",
    "chars": 11810,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "selectors/build.rs",
    "chars": 1446,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "selectors/builder.rs",
    "chars": 16711,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "selectors/context.rs",
    "chars": 17280,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "selectors/kleene_value.rs",
    "chars": 3575,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "selectors/lib.rs",
    "chars": 643,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "selectors/matching.rs",
    "chars": 56962,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "selectors/nth_index_cache.rs",
    "chars": 3176,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "selectors/parser.rs",
    "chars": 176499,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "selectors/relative_selector/cache.rs",
    "chars": 2743,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "selectors/relative_selector/filter.rs",
    "chars": 6078,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "selectors/relative_selector/mod.rs",
    "chars": 238,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "selectors/sink.rs",
    "chars": 950,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "selectors/tree.rs",
    "chars": 6347,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "selectors/visitor.rs",
    "chars": 4884,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "servo_arc/Cargo.toml",
    "chars": 569,
    "preview": "[package]\nname = \"servo_arc\"\nversion = \"0.4.3\"\nauthors = [\"The Servo Project Developers\"]\nlicense = \"MIT OR Apache-2.0\"\n"
  },
  {
    "path": "servo_arc/LICENSE-APACHE",
    "chars": 10847,
    "preview": "                              Apache License\n                        Version 2.0, January 2004\n                     http"
  },
  {
    "path": "servo_arc/LICENSE-MIT",
    "chars": 1023,
    "preview": "Permission is hereby granted, free of charge, to any\nperson obtaining a copy of this software and associated\ndocumentati"
  },
  {
    "path": "servo_arc/lib.rs",
    "chars": 39440,
    "preview": "// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distrib"
  },
  {
    "path": "shell.nix",
    "chars": 201,
    "preview": "with import (builtins.fetchTarball {\n  url = \"https://github.com/NixOS/nixpkgs/archive/46ae0210ce163b3cba6c7da08840c1d63"
  },
  {
    "path": "start-rebase.sh",
    "chars": 333,
    "preview": "#!/bin/sh\n# Usage: start-rebase.sh <new base> [extra git-rebase(1) arguments ...]\n# Equivalent to git rebase --onto <new"
  },
  {
    "path": "style/Cargo.toml",
    "chars": 2846,
    "preview": "[package]\nname = \"stylo\"\nversion.workspace = true\nauthors = [\"The Servo Project Developers\"]\nlicense = \"MPL-2.0\"\nreposit"
  },
  {
    "path": "style/README.md",
    "chars": 195,
    "preview": "servo-style\n===========\n\nStyle system for Servo, using [rust-cssparser](https://github.com/servo/rust-cssparser) for par"
  },
  {
    "path": "style/applicable_declarations.rs",
    "chars": 10944,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/author_styles.rs",
    "chars": 2272,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/bezier.rs",
    "chars": 4873,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/bloom.rs",
    "chars": 14443,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/build.rs",
    "chars": 2759,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/build_gecko.rs",
    "chars": 13159,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/color/color_function.rs",
    "chars": 23454,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/color/component.rs",
    "chars": 7559,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/color/convert.rs",
    "chars": 29743,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/color/mix.rs",
    "chars": 20546,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/color/mod.rs",
    "chars": 25889,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/color/parsing.rs",
    "chars": 20020,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/color/to_css.rs",
    "chars": 10626,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/context.rs",
    "chars": 24822,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/counter_style/mod.rs",
    "chars": 26044,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/counter_style/predefined.rs",
    "chars": 1286,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/counter_style/update_predefined.py",
    "chars": 1094,
    "preview": "#!/usr/bin/env python\n\n# This Source Code Form is subject to the terms of the Mozilla Public\n# License, v. 2.0. If a cop"
  },
  {
    "path": "style/custom_properties.rs",
    "chars": 113999,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/custom_properties_map.rs",
    "chars": 9027,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/data.rs",
    "chars": 23574,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/device/gecko.rs",
    "chars": 18197,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/device/mod.rs",
    "chars": 11988,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/device/servo.rs",
    "chars": 17030,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/dom.rs",
    "chars": 38233,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/dom_apis.rs",
    "chars": 30153,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/driver.rs",
    "chars": 6484,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/error_reporting.rs",
    "chars": 21162,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/font_face.rs",
    "chars": 19181,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/font_metrics.rs",
    "chars": 4722,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/gecko/anon_boxes.toml",
    "chars": 2954,
    "preview": "# This Source Code Form is subject to the terms of the Mozilla Public\n# License, v. 2.0. If a copy of the MPL was not di"
  },
  {
    "path": "style/gecko/arc_types.rs",
    "chars": 5543,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/gecko/conversions.rs",
    "chars": 1979,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/gecko/data.rs",
    "chars": 7639,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/gecko/media_features.rs",
    "chars": 31449,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/gecko/mod.rs",
    "chars": 534,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/gecko/non_ts_pseudo_class_list.rs",
    "chars": 6538,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/gecko/pseudo_element.rs",
    "chars": 22903,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/gecko/pseudo_element_definition.mako.rs",
    "chars": 10419,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/gecko/pseudo_elements.py",
    "chars": 4518,
    "preview": "#!/usr/bin/env python\n\n# This Source Code Form is subject to the terms of the Mozilla Public\n# License, v. 2.0. If a cop"
  },
  {
    "path": "style/gecko/pseudo_elements.toml",
    "chars": 5989,
    "preview": "# This Source Code Form is subject to the terms of the Mozilla Public\n# License, v. 2.0. If a copy of the MPL was not di"
  },
  {
    "path": "style/gecko/regen_atoms.py",
    "chars": 4278,
    "preview": "#!/usr/bin/env python\n\n# This Source Code Form is subject to the terms of the Mozilla Public\n# License, v. 2.0. If a cop"
  },
  {
    "path": "style/gecko/restyle_damage.rs",
    "chars": 4029,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/gecko/selector_parser.rs",
    "chars": 24724,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/gecko/snapshot.rs",
    "chars": 6327,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/gecko/snapshot_helpers.rs",
    "chars": 10386,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/gecko/traversal.rs",
    "chars": 1749,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/gecko/url.rs",
    "chars": 13714,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/gecko/wrapper.rs",
    "chars": 79259,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/gecko_bindings/mod.rs",
    "chars": 929,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/gecko_bindings/sugar/mod.rs",
    "chars": 384,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/gecko_bindings/sugar/ns_com_ptr.rs",
    "chars": 432,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/gecko_bindings/sugar/ns_compatibility.rs",
    "chars": 733,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/gecko_bindings/sugar/ns_style_auto_array.rs",
    "chars": 3698,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/gecko_bindings/sugar/origin_flags.rs",
    "chars": 985,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/gecko_bindings/sugar/ownership.rs",
    "chars": 1632,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/gecko_bindings/sugar/refptr.rs",
    "chars": 7903,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/gecko_string_cache/mod.rs",
    "chars": 15084,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/gecko_string_cache/namespace.rs",
    "chars": 2460,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/global_style_data.rs",
    "chars": 7939,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/invalidation/element/document_state.rs",
    "chars": 5314,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/invalidation/element/element_wrapper.rs",
    "chars": 14390,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/invalidation/element/invalidation_map.rs",
    "chars": 60232,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/invalidation/element/invalidator.rs",
    "chars": 54334,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/invalidation/element/mod.rs",
    "chars": 454,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/invalidation/element/relative_selector.rs",
    "chars": 55753,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/invalidation/element/restyle_hints.rs",
    "chars": 8505,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/invalidation/element/state_and_attributes.rs",
    "chars": 27200,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/invalidation/media_queries.rs",
    "chars": 4414,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/invalidation/mod.rs",
    "chars": 351,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/invalidation/stylesheets.rs",
    "chars": 26170,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/invalidation/viewport_units.rs",
    "chars": 2105,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/lib.rs",
    "chars": 9183,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/logical_geometry.rs",
    "chars": 53249,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/macros.rs",
    "chars": 2052,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/matching.rs",
    "chars": 44347,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/media_queries/media_list.rs",
    "chars": 5935,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/media_queries/media_query.rs",
    "chars": 6424,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/media_queries/mod.rs",
    "chars": 436,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/parallel.rs",
    "chars": 8009,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/parser.rs",
    "chars": 8608,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/piecewise_linear.rs",
    "chars": 10178,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/properties/build.py",
    "chars": 3720,
    "preview": "# This Source Code Form is subject to the terms of the Mozilla Public\n# License, v. 2.0. If a copy of the MPL was not di"
  },
  {
    "path": "style/properties/cascade.rs",
    "chars": 56538,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/properties/computed_value_flags.rs",
    "chars": 7701,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/properties/counted_unknown_properties.py",
    "chars": 3261,
    "preview": "# This Source Code Form is subject to the terms of the Mozilla Public\n# License, v. 2.0. If a copy of the MPL was not di"
  },
  {
    "path": "style/properties/counter_style_descriptors.toml",
    "chars": 1249,
    "preview": "# This Source Code Form is subject to the terms of the Mozilla Public\n# License, v. 2.0. If a copy of the MPL was not di"
  },
  {
    "path": "style/properties/data.py",
    "chars": 47435,
    "preview": "# This Source Code Form is subject to the terms of the Mozilla Public\n# License, v. 2.0. If a copy of the MPL was not di"
  },
  {
    "path": "style/properties/declaration_block.rs",
    "chars": 62393,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/properties/font_face_descriptors.toml",
    "chars": 923,
    "preview": "# This Source Code Form is subject to the terms of the Mozilla Public\n# License, v. 2.0. If a copy of the MPL was not di"
  },
  {
    "path": "style/properties/gecko.mako.rs",
    "chars": 58832,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/properties/helpers/animated_properties.mako.rs",
    "chars": 29835,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/properties/helpers.mako.rs",
    "chars": 29777,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/properties/longhands.toml",
    "chars": 122101,
    "preview": "# This Source Code Form is subject to the terms of the Mozilla Public\n# License, v. 2.0. If a copy of the MPL was not di"
  },
  {
    "path": "style/properties/mod.rs",
    "chars": 59900,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/properties/properties.html.mako",
    "chars": 1006,
    "preview": "<!DOCTYPE html>\n<html lang=\"en\">\n<head>\n    <meta charset=\"utf-8\">\n    <meta name=\"viewport\" content=\"width=device-width"
  },
  {
    "path": "style/properties/properties.mako.rs",
    "chars": 117943,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/properties/property_descriptors.toml",
    "chars": 629,
    "preview": "# This Source Code Form is subject to the terms of the Mozilla Public\n# License, v. 2.0. If a copy of the MPL was not di"
  },
  {
    "path": "style/properties/shorthands.rs",
    "chars": 158158,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/properties/shorthands.toml",
    "chars": 18154,
    "preview": "[margin]\nsub_properties = [\"margin-top\", \"margin-right\", \"margin-bottom\", \"margin-left\"]\nspec = \"https://drafts.csswg.or"
  },
  {
    "path": "style/properties/vendored_python/markupsafe/LICENSE.txt",
    "chars": 1474,
    "preview": "Copyright 2010 Pallets\n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted p"
  },
  {
    "path": "style/properties/vendored_python/markupsafe/__init__.py",
    "chars": 13096,
    "preview": "# Vendored from https://github.com/pallets/markupsafe/blob/1251593f6b0e3b45f2cc8aba662622bc22d6a5e2/src/markupsafe/__ini"
  },
  {
    "path": "style/properties/view_transition_descriptors.toml",
    "chars": 320,
    "preview": "# This Source Code Form is subject to the terms of the Mozilla Public\n# License, v. 2.0. If a copy of the MPL was not di"
  },
  {
    "path": "style/properties_and_values/mod.rs",
    "chars": 365,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/properties_and_values/registry.rs",
    "chars": 2588,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/properties_and_values/rule.rs",
    "chars": 12334,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/properties_and_values/syntax/ascii.rs",
    "chars": 1527,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/properties_and_values/syntax/data_type.rs",
    "chars": 5242,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/properties_and_values/syntax/mod.rs",
    "chars": 13925,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/properties_and_values/value.rs",
    "chars": 26988,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/queries/condition.rs",
    "chars": 35675,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/queries/feature.rs",
    "chars": 7376,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/queries/feature_expression.rs",
    "chars": 42667,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/queries/mod.rs",
    "chars": 662,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/queries/values.rs",
    "chars": 1400,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/rule_cache.rs",
    "chars": 8417,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/rule_collector.rs",
    "chars": 18279,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/rule_tree/core.rs",
    "chars": 28141,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/rule_tree/level.rs",
    "chars": 10716,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/rule_tree/map.rs",
    "chars": 6120,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/rule_tree/mod.rs",
    "chars": 17065,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/rule_tree/source.rs",
    "chars": 1963,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/rule_tree/unsafe_box.rs",
    "chars": 1970,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/scoped_tls.rs",
    "chars": 2973,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/selector_map.rs",
    "chars": 29426,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/selector_parser.rs",
    "chars": 10085,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/servo/animation.rs",
    "chars": 72375,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/servo/attr.rs",
    "chars": 20892,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/servo/encoding_support.rs",
    "chars": 2662,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/servo/media_features.rs",
    "chars": 2693,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/servo/mod.rs",
    "chars": 493,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/servo/restyle_damage.rs",
    "chars": 8440,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/servo/selector_parser.rs",
    "chars": 35119,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/servo/shadow_parts.rs",
    "chars": 7488,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/servo/url.rs",
    "chars": 10362,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/shared_lock.rs",
    "chars": 11995,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/sharing/checks.rs",
    "chars": 7013,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/sharing/mod.rs",
    "chars": 36626,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/simple_buckets_map.rs",
    "chars": 1759,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/str.rs",
    "chars": 4716,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/style_adjuster.rs",
    "chars": 42232,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/style_resolver.rs",
    "chars": 21333,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/stylesheet_set.rs",
    "chars": 21531,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/stylesheets/appearance_base_rule.rs",
    "chars": 1922,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/stylesheets/container_rule.rs",
    "chars": 23570,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/stylesheets/counter_style_rule.rs",
    "chars": 280,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/stylesheets/document_rule.rs",
    "chars": 11141,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/stylesheets/font_face_rule.rs",
    "chars": 272,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/stylesheets/font_feature_values_rule.rs",
    "chars": 18228,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/stylesheets/font_palette_values_rule.rs",
    "chars": 9872,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/stylesheets/import_rule.rs",
    "chars": 8531,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/stylesheets/keyframes_rule.rs",
    "chars": 23343,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/stylesheets/layer_rule.rs",
    "chars": 7033,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/stylesheets/loader.rs",
    "chars": 1094,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/stylesheets/margin_rule.rs",
    "chars": 7195,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/stylesheets/media_rule.rs",
    "chars": 7137,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/stylesheets/mod.rs",
    "chars": 36009,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/stylesheets/namespace_rule.rs",
    "chars": 1440,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/stylesheets/nested_declarations_rule.rs",
    "chars": 1763,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  },
  {
    "path": "style/stylesheets/origin.rs",
    "chars": 7020,
    "preview": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not "
  }
]

// ... and 175 more files (download for full content)