1use super::feature::{Evaluator, QueryFeatureDescription};
9use super::feature::{FeatureFlags, KeywordDiscriminant};
10use crate::context::QuirksMode;
11use crate::custom_properties::{
12 ComputedSubstitutionFunctions, VariableValue as CustomVariableValue,
13};
14use crate::derives::*;
15use crate::dom::AttributeTracker;
16use crate::parser::{Parse, ParserContext};
17use crate::properties::CSSWideKeyword;
18use crate::properties_and_values::value::{ComputedValueComponent as Component, ValueInner};
19use crate::selector_map::PrecomputedHashSet;
20use crate::str::{starts_with_ignore_ascii_case, string_as_ascii_lowercase};
21use crate::stylesheets::container_rule::AttrReferenceSet;
22use crate::stylesheets::{CssRuleType, Origin, UrlExtraData};
23use crate::substitution::{self, SubstitutionFunctionKind};
24use crate::values::DashedIdent;
25use crate::values::computed::{self, CSSPixelLength, ToComputedValue};
26use crate::values::specified::{
27 Angle, Integer, Length, Number, Percentage, Ratio, Resolution, Time,
28};
29use crate::{Atom, Zero};
30use cssparser::{Parser, Token};
31use selectors::kleene_value::KleeneValue;
32use std::cmp::Ordering;
33use std::fmt::{self, Write};
34use style_traits::{CssWriter, ParseError, ParsingMode, StyleParseErrorKind, ToCss};
35
36#[derive(Clone, Copy, Debug, Eq, MallocSizeOf, PartialEq, ToShmem)]
38pub enum FeatureType {
39 Media,
41 Container,
43}
44
45impl FeatureType {
46 fn features(&self) -> &'static [QueryFeatureDescription] {
47 #[cfg(feature = "gecko")]
48 use crate::gecko::media_features::MEDIA_FEATURES;
49 #[cfg(feature = "servo")]
50 use crate::servo::media_features::MEDIA_FEATURES;
51
52 use crate::stylesheets::container_rule::CONTAINER_FEATURES;
53
54 match *self {
55 FeatureType::Media => &MEDIA_FEATURES,
56 FeatureType::Container => &CONTAINER_FEATURES,
57 }
58 }
59
60 fn find_feature(&self, name: &Atom) -> Option<(usize, &'static QueryFeatureDescription)> {
61 self.features()
62 .iter()
63 .enumerate()
64 .find(|(_, f)| f.name == *name)
65 }
66}
67
68#[derive(Clone, Copy, Debug, Eq, MallocSizeOf, PartialEq, ToShmem)]
70enum LegacyRange {
71 Min,
73 Max,
75}
76
77#[derive(Clone, Copy, Debug, Eq, MallocSizeOf, PartialEq, ToShmem)]
79pub enum Operator {
80 Equal,
82 GreaterThan,
84 GreaterThanEqual,
86 LessThan,
88 LessThanEqual,
90}
91
92impl ToCss for Operator {
93 fn to_css<W>(&self, dest: &mut CssWriter<W>) -> fmt::Result
94 where
95 W: fmt::Write,
96 {
97 dest.write_str(match *self {
98 Self::Equal => "=",
99 Self::LessThan => "<",
100 Self::LessThanEqual => "<=",
101 Self::GreaterThan => ">",
102 Self::GreaterThanEqual => ">=",
103 })
104 }
105}
106
107impl Operator {
108 fn is_compatible_with(self, right_op: Self) -> bool {
109 match self {
112 Self::Equal => false,
113 Self::GreaterThan | Self::GreaterThanEqual => {
114 matches!(right_op, Self::GreaterThan | Self::GreaterThanEqual)
115 },
116 Self::LessThan | Self::LessThanEqual => {
117 matches!(right_op, Self::LessThan | Self::LessThanEqual)
118 },
119 }
120 }
121
122 fn evaluate(&self, cmp: Ordering) -> bool {
123 match *self {
124 Self::Equal => cmp == Ordering::Equal,
125 Self::GreaterThan => cmp == Ordering::Greater,
126 Self::GreaterThanEqual => cmp == Ordering::Equal || cmp == Ordering::Greater,
127 Self::LessThan => cmp == Ordering::Less,
128 Self::LessThanEqual => cmp == Ordering::Equal || cmp == Ordering::Less,
129 }
130 }
131
132 fn parse(input: &mut Parser) -> Result<Self, ParseError> {
133 let operator = match *input.next()? {
134 Token::Delim('=') => return Ok(Operator::Equal),
135 Token::Delim('>') => Operator::GreaterThan,
136 Token::Delim('<') => Operator::LessThan,
137 _ => return Err(ParseError::unexpected_token()),
138 };
139
140 let parsed_equal = input
149 .try_parse(|i| {
150 let t = i.next_including_whitespace().map_err(|_| ())?;
151 if !matches!(t, Token::Delim('=')) {
152 return Err(());
153 }
154 Ok(())
155 })
156 .is_ok();
157
158 if !parsed_equal {
159 return Ok(operator);
160 }
161
162 Ok(match operator {
163 Operator::GreaterThan => Operator::GreaterThanEqual,
164 Operator::LessThan => Operator::LessThanEqual,
165 _ => unreachable!(),
166 })
167 }
168}
169
170#[derive(Clone, Debug, MallocSizeOf, ToShmem, PartialEq)]
171enum QueryFeatureExpressionKind {
172 Empty,
174
175 Single(QueryExpressionValue),
177
178 LegacyRange(LegacyRange, QueryExpressionValue),
180
181 Range {
184 left: Option<(Operator, QueryExpressionValue)>,
185 right: Option<(Operator, QueryExpressionValue)>,
186 },
187}
188
189impl QueryFeatureExpressionKind {
190 fn evaluate<T>(
193 &self,
194 context_value: T,
195 mut compute: impl FnMut(&QueryExpressionValue) -> T,
196 ) -> bool
197 where
198 T: PartialOrd + Zero,
199 {
200 match *self {
201 Self::Empty => !context_value.is_zero(),
202 Self::Single(ref value) => {
203 let value = compute(value);
204 let cmp = match context_value.partial_cmp(&value) {
205 Some(c) => c,
206 None => return false,
207 };
208 cmp == Ordering::Equal
209 },
210 Self::LegacyRange(ref range, ref value) => {
211 let value = compute(value);
212 let cmp = match context_value.partial_cmp(&value) {
213 Some(c) => c,
214 None => return false,
215 };
216 cmp == Ordering::Equal
217 || match range {
218 LegacyRange::Min => cmp == Ordering::Greater,
219 LegacyRange::Max => cmp == Ordering::Less,
220 }
221 },
222 Self::Range {
223 ref left,
224 ref right,
225 } => {
226 debug_assert!(left.is_some() || right.is_some());
227 if let Some((op, value)) = left {
228 let value = compute(value);
229 let cmp = match value.partial_cmp(&context_value) {
230 Some(c) => c,
231 None => return false,
232 };
233 if !op.evaluate(cmp) {
234 return false;
235 }
236 }
237 if let Some((op, value)) = right {
238 let value = compute(value);
239 let cmp = match context_value.partial_cmp(&value) {
240 Some(c) => c,
241 None => return false,
242 };
243 if !op.evaluate(cmp) {
244 return false;
245 }
246 }
247 true
248 },
249 }
250 }
251
252 fn non_ranged_value(&self) -> Option<&QueryExpressionValue> {
254 match *self {
255 Self::Empty => None,
256 Self::Single(ref v) => Some(v),
257 Self::LegacyRange(..) | Self::Range { .. } => {
258 debug_assert!(false, "Unexpected ranged value in non-ranged feature!");
259 None
260 },
261 }
262 }
263}
264
265#[derive(Clone, Debug, MallocSizeOf, ToShmem, PartialEq)]
268pub struct QueryFeatureExpression {
269 feature_type: FeatureType,
270 feature_index: usize,
271 kind: QueryFeatureExpressionKind,
272}
273
274impl ToCss for QueryFeatureExpression {
275 fn to_css<W>(&self, dest: &mut CssWriter<W>) -> fmt::Result
276 where
277 W: fmt::Write,
278 {
279 dest.write_char('(')?;
280
281 match self.kind {
282 QueryFeatureExpressionKind::Empty => self.write_name(dest)?,
283 QueryFeatureExpressionKind::Single(ref v)
284 | QueryFeatureExpressionKind::LegacyRange(_, ref v) => {
285 self.write_name(dest)?;
286 dest.write_str(": ")?;
287 v.to_css(dest, Some(self))?;
288 },
289 QueryFeatureExpressionKind::Range {
290 ref left,
291 ref right,
292 } => {
293 if let Some((op, val)) = left {
294 val.to_css(dest, Some(self))?;
295 dest.write_char(' ')?;
296 op.to_css(dest)?;
297 dest.write_char(' ')?;
298 }
299 self.write_name(dest)?;
300 if let Some((op, val)) = right {
301 dest.write_char(' ')?;
302 op.to_css(dest)?;
303 dest.write_char(' ')?;
304 val.to_css(dest, Some(self))?;
305 }
306 },
307 }
308 dest.write_char(')')
309 }
310}
311
312fn consume_operation_or_colon(input: &mut Parser) -> Result<Option<Operator>, ParseError> {
313 if input.try_parse(|input| input.expect_colon()).is_ok() {
314 return Ok(None);
315 }
316 Operator::parse(input).map(Some)
317}
318
319#[allow(unused_variables)]
320fn disabled_by_pref(feature: &Atom, context: &ParserContext) -> bool {
321 #[cfg(feature = "gecko")]
322 {
323 if *feature == atom!("prefers-reduced-transparency") {
326 return !context.chrome_rules_enabled()
327 && !crate::pref!("layout.css.prefers-reduced-transparency.enabled");
328 }
329
330 if *feature == atom!("inverted-colors") {
333 return !context.chrome_rules_enabled()
334 && !crate::pref!("layout.css.inverted-colors.enabled");
335 }
336 }
337 false
338}
339
340impl QueryFeatureExpression {
341 fn new(
342 feature_type: FeatureType,
343 feature_index: usize,
344 kind: QueryFeatureExpressionKind,
345 ) -> Self {
346 debug_assert!(feature_index < feature_type.features().len());
347 Self {
348 feature_type,
349 feature_index,
350 kind,
351 }
352 }
353
354 fn write_name<W>(&self, dest: &mut CssWriter<W>) -> fmt::Result
355 where
356 W: fmt::Write,
357 {
358 let feature = self.feature();
359 if feature.flags.contains(FeatureFlags::WEBKIT_PREFIX) {
360 dest.write_str("-webkit-")?;
361 }
362
363 if let QueryFeatureExpressionKind::LegacyRange(range, _) = self.kind {
364 match range {
365 LegacyRange::Min => dest.write_str("min-")?,
366 LegacyRange::Max => dest.write_str("max-")?,
367 }
368 }
369
370 write!(dest, "{}", feature.name)?;
372
373 Ok(())
374 }
375
376 fn feature(&self) -> &'static QueryFeatureDescription {
377 &self.feature_type.features()[self.feature_index]
378 }
379
380 pub fn feature_flags(&self) -> FeatureFlags {
382 self.feature().flags
383 }
384
385 fn parse_feature_name(
386 context: &ParserContext,
387 input: &mut Parser,
388 feature_type: FeatureType,
389 ) -> Result<(usize, Option<LegacyRange>), ParseError> {
390 let mut flags = FeatureFlags::empty();
391 let ident = input.expect_ident()?;
392
393 if context.chrome_rules_enabled() {
394 flags.insert(FeatureFlags::CHROME_AND_UA_ONLY);
395 }
396
397 let mut feature_name = &**ident;
398 if starts_with_ignore_ascii_case(feature_name, "-webkit-") {
399 feature_name = &feature_name[8..];
400 flags.insert(FeatureFlags::WEBKIT_PREFIX);
401 }
402
403 let range = if starts_with_ignore_ascii_case(feature_name, "min-") {
404 feature_name = &feature_name[4..];
405 Some(LegacyRange::Min)
406 } else if starts_with_ignore_ascii_case(feature_name, "max-") {
407 feature_name = &feature_name[4..];
408 Some(LegacyRange::Max)
409 } else {
410 None
411 };
412
413 let atom = Atom::from(string_as_ascii_lowercase(feature_name));
414 let (feature_index, feature) = match feature_type.find_feature(&atom) {
415 Some((i, f)) => (i, f),
416 None => {
417 return Err(ParseError::custom(
418 StyleParseErrorKind::MediaQueryExpectedFeatureName,
419 ));
420 },
421 };
422
423 if disabled_by_pref(&feature.name, context)
424 || !flags.contains(feature.flags.parsing_requirements())
425 || (range.is_some() && !feature.allows_ranges())
426 {
427 return Err(ParseError::custom(
428 StyleParseErrorKind::MediaQueryExpectedFeatureName,
429 ));
430 }
431
432 Ok((feature_index, range))
433 }
434
435 fn parse_multi_range_syntax(
440 context: &ParserContext,
441 input: &mut Parser,
442 feature_type: FeatureType,
443 ) -> Result<Self, ParseError> {
444 let start = input.state();
445
446 let feature_index = loop {
450 if let Ok((index, range)) = Self::parse_feature_name(context, input, feature_type) {
452 if range.is_some() {
453 return Err(ParseError::custom(StyleParseErrorKind::UnspecifiedError));
455 }
456 break index;
457 }
458 if input.is_exhausted() {
459 return Err(ParseError::custom(StyleParseErrorKind::UnspecifiedError));
460 }
461 };
462
463 input.reset(&start);
464
465 let feature = &feature_type.features()[feature_index];
466 let left_val = QueryExpressionValue::parse(feature, context, input)?;
467 let left_op = Operator::parse(input)?;
468
469 {
470 let (parsed_index, _) = Self::parse_feature_name(context, input, feature_type)?;
471 debug_assert_eq!(
472 parsed_index, feature_index,
473 "How did we find a different feature?"
474 );
475 }
476
477 let right_op = input.try_parse(Operator::parse).ok();
478 let right = match right_op {
479 Some(op) => {
480 if !left_op.is_compatible_with(op) {
481 return Err(ParseError::custom(StyleParseErrorKind::UnspecifiedError));
482 }
483 Some((op, QueryExpressionValue::parse(feature, context, input)?))
484 },
485 None => None,
486 };
487 Ok(Self::new(
488 feature_type,
489 feature_index,
490 QueryFeatureExpressionKind::Range {
491 left: Some((left_op, left_val)),
492 right,
493 },
494 ))
495 }
496
497 pub fn parse_in_parenthesis_block(
499 context: &ParserContext,
500 input: &mut Parser,
501 feature_type: FeatureType,
502 ) -> Result<Self, ParseError> {
503 let (feature_index, range) =
504 match input.try_parse(|input| Self::parse_feature_name(context, input, feature_type)) {
505 Ok(v) => v,
506 Err(e) => {
507 if let Ok(expr) = Self::parse_multi_range_syntax(context, input, feature_type) {
508 return Ok(expr);
509 }
510 return Err(e);
511 },
512 };
513 let operator = input.try_parse(consume_operation_or_colon);
514 let operator = match operator {
515 Err(..) => {
516 if range.is_some() {
522 return Err(ParseError::custom(
523 StyleParseErrorKind::RangedExpressionWithNoValue,
524 ));
525 }
526
527 return Ok(Self::new(
528 feature_type,
529 feature_index,
530 QueryFeatureExpressionKind::Empty,
531 ));
532 },
533 Ok(operator) => operator,
534 };
535
536 let feature = &feature_type.features()[feature_index];
537
538 let value = QueryExpressionValue::parse(feature, context, input)
539 .map_err(|_| ParseError::custom(StyleParseErrorKind::MediaQueryExpectedFeatureValue))?;
540
541 let kind = match range {
542 Some(range) => {
543 if operator.is_some() {
544 return Err(ParseError::custom(
545 StyleParseErrorKind::MediaQueryUnexpectedOperator,
546 ));
547 }
548 QueryFeatureExpressionKind::LegacyRange(range, value)
549 },
550 None => match operator {
551 Some(operator) => {
552 if !feature.allows_ranges() {
553 return Err(ParseError::custom(
554 StyleParseErrorKind::MediaQueryUnexpectedOperator,
555 ));
556 }
557 QueryFeatureExpressionKind::Range {
558 left: None,
559 right: Some((operator, value)),
560 }
561 },
562 None => QueryFeatureExpressionKind::Single(value),
563 },
564 };
565
566 Ok(Self::new(feature_type, feature_index, kind))
567 }
568
569 pub fn matches(&self, context: &computed::Context) -> KleeneValue {
571 macro_rules! expect {
572 ($variant:ident, $v:expr) => {
573 match *$v {
574 QueryExpressionValue::$variant(ref v) => v,
575 _ => unreachable!("Unexpected QueryExpressionValue"),
576 }
577 };
578 }
579
580 KleeneValue::from(match self.feature().evaluator {
581 Evaluator::Length(eval) => {
582 let v = eval(context);
583 self.kind
584 .evaluate(v, |v| expect!(Length, v).to_computed_value(context))
585 },
586 Evaluator::OptionalLength(eval) => {
587 let v = match eval(context) {
588 Some(v) => v,
589 None => return KleeneValue::Unknown,
590 };
591 self.kind
592 .evaluate(v, |v| expect!(Length, v).to_computed_value(context))
593 },
594 Evaluator::Integer(eval) => {
595 let v = eval(context);
596 self.kind
597 .evaluate(v, |v| expect!(Integer, v).to_computed_value(context))
598 },
599 Evaluator::Float(eval) => {
600 let v = eval(context);
601 self.kind
602 .evaluate(v, |v| expect!(Float, v).to_computed_value(context))
603 },
604 Evaluator::NumberRatio(eval) => {
605 let ratio = eval(context);
606 self.kind.evaluate(ratio, |v| {
611 expect!(NumberRatio, v)
612 .to_computed_value(context)
613 .used_value()
614 })
615 },
616 Evaluator::OptionalNumberRatio(eval) => {
617 let ratio = match eval(context) {
618 Some(v) => v,
619 None => return KleeneValue::Unknown,
620 };
621 self.kind.evaluate(ratio, |v| {
623 expect!(NumberRatio, v)
624 .to_computed_value(context)
625 .used_value()
626 })
627 },
628 Evaluator::Resolution(eval) => {
629 let v = eval(context).dppx();
630 self.kind.evaluate(v, |v| {
631 expect!(Resolution, v).to_computed_value(context).dppx()
632 })
633 },
634 Evaluator::Enumerated { evaluator, .. } => {
635 let computed = self
636 .kind
637 .non_ranged_value()
638 .map(|v| *expect!(Enumerated, v));
639 return evaluator(context, computed);
640 },
641 Evaluator::BoolInteger(eval) => {
642 let computed = self
643 .kind
644 .non_ranged_value()
645 .map(|v| expect!(BoolInteger, v).to_computed_value(context));
646 let boolean = eval(context);
647 computed.map_or(boolean, |v| v == boolean as i32)
648 },
649 })
650 }
651}
652
653#[derive(Clone, Debug, MallocSizeOf, PartialEq, ToShmem)]
662pub enum QueryExpressionValue {
663 Length(Length),
665 Integer(Integer),
667 Float(Number),
669 BoolInteger(Integer),
671 NumberRatio(Ratio),
674 Resolution(Resolution),
676 Enumerated(KeywordDiscriminant),
679 Keyword(CSSWideKeyword),
682 Percentage(Percentage),
684 Angle(Angle),
686 Time(Time),
688 Custom(DashedIdent),
690 Function(Box<CustomVariableValue>),
694}
695
696impl QueryExpressionValue {
697 fn to_css<W>(
698 &self,
699 dest: &mut CssWriter<W>,
700 for_expr: Option<&QueryFeatureExpression>,
701 ) -> fmt::Result
702 where
703 W: fmt::Write,
704 {
705 match *self {
706 QueryExpressionValue::Length(ref l) => l.to_css(dest),
707 QueryExpressionValue::Integer(ref v) => v.to_css(dest),
708 QueryExpressionValue::Float(ref v) => v.to_css(dest),
709 QueryExpressionValue::BoolInteger(ref v) => v.to_css(dest),
710 QueryExpressionValue::NumberRatio(ref ratio) => ratio.to_css(dest),
711 QueryExpressionValue::Resolution(ref r) => r.to_css(dest),
712 QueryExpressionValue::Keyword(k) => k.to_css(dest),
713 QueryExpressionValue::Percentage(ref v) => v.to_css(dest),
714 QueryExpressionValue::Angle(ref v) => v.to_css(dest),
715 QueryExpressionValue::Time(ref v) => v.to_css(dest),
716 QueryExpressionValue::Custom(ref v) => v.to_css(dest),
717 QueryExpressionValue::Function(ref f) => f.to_css(dest),
718 QueryExpressionValue::Enumerated(value) => match for_expr
719 .expect("caller should have passed for_expr")
720 .feature()
721 .evaluator
722 {
723 Evaluator::Enumerated { serializer, .. } => dest.write_str(&serializer(value)),
724 _ => unreachable!(),
725 },
726 }
727 }
728
729 fn parse(
730 for_feature: &QueryFeatureDescription,
731 context: &ParserContext,
732 input: &mut Parser,
733 ) -> Result<QueryExpressionValue, ParseError> {
734 Ok(match for_feature.evaluator {
735 Evaluator::OptionalLength(..) | Evaluator::Length(..) => {
736 let length = Length::parse(context, input)?;
737 QueryExpressionValue::Length(length)
738 },
739 Evaluator::Integer(..) => {
740 let integer = Integer::parse(context, input)?;
741 QueryExpressionValue::Integer(integer)
742 },
743 Evaluator::BoolInteger(..) => {
744 let integer = Integer::parse(context, input)?;
745 if matches!(integer.resolve(), Some(v) if v != 0 && v != 1) {
746 return Err(ParseError::custom(StyleParseErrorKind::UnspecifiedError));
747 }
748 QueryExpressionValue::BoolInteger(integer)
749 },
750 Evaluator::Float(..) => {
751 let number = Number::parse(context, input)?;
752 QueryExpressionValue::Float(number)
753 },
754 Evaluator::OptionalNumberRatio(..) | Evaluator::NumberRatio(..) => {
755 use crate::values::specified::Ratio as SpecifiedRatio;
756 let ratio = SpecifiedRatio::parse(context, input)?;
757 QueryExpressionValue::NumberRatio(ratio)
758 },
759 Evaluator::Resolution(..) => {
760 QueryExpressionValue::Resolution(Resolution::parse(context, input)?)
761 },
762 Evaluator::Enumerated { parser, .. } => {
763 QueryExpressionValue::Enumerated(parser(context, input)?)
764 },
765 })
766 }
767
768 fn parse_for_style_range(
774 context: &ParserContext,
775 input: &mut Parser,
776 ) -> Result<Self, ParseError> {
777 if let Ok(number) = input.try_parse(|i| Number::parse(context, i)) {
778 return Ok(Self::Float(number));
779 }
780 if let Ok(percent) = input.try_parse(|i| Percentage::parse(context, i)) {
781 return Ok(Self::Percentage(percent));
782 }
783 if let Ok(length) = input.try_parse(|i| Length::parse(context, i)) {
784 return Ok(Self::Length(length));
785 }
786 if let Ok(angle) = input.try_parse(|i| Angle::parse(context, i)) {
787 return Ok(Self::Angle(angle));
788 }
789 if let Ok(time) = input.try_parse(|i| Time::parse(context, i)) {
790 return Ok(Self::Time(time));
791 }
792 if let Ok(resolution) = input.try_parse(|i| Resolution::parse(context, i)) {
793 return Ok(Self::Resolution(resolution));
794 }
795 if let Ok(ident) = input.try_parse(|i| DashedIdent::parse(context, i)) {
796 return Ok(Self::Custom(ident));
797 }
798 if let Ok(keyword) = input.try_parse(|i| CSSWideKeyword::parse(i)) {
799 return Ok(Self::Keyword(keyword));
800 }
801 input.skip_whitespace();
802 let start = input.position();
803 if let Ok(Token::Function(name)) = input.next() {
804 let parse_func = |input: &mut Parser| -> Result<CustomVariableValue, ParseError> {
807 input.parse_nested_block(|i| i.expect_no_error_token().map_err(Into::into))?;
808 CustomVariableValue::parse(context, &mut Parser::new(input.slice_from(start)))
809 };
810
811 if SubstitutionFunctionKind::from_ident(name).is_ok() {
812 return Ok(Self::Function(Box::new(parse_func(input)?)));
813 }
814 }
815 Err(ParseError::custom(StyleParseErrorKind::UnspecifiedError))
816 }
817
818 fn collect_attribute_references(&self, references: &mut AttrReferenceSet) {
819 if let Self::Function(f) = self {
820 f.collect_attribute_references(references)
821 }
822 }
823}
824
825#[derive(Clone, Debug, MallocSizeOf, ToShmem, PartialEq)]
827pub enum QueryStyleRange {
828 #[allow(missing_docs)]
831 StyleRange2 {
832 value1: QueryExpressionValue,
833 op1: Operator,
834 value2: QueryExpressionValue,
835 },
836
837 #[allow(missing_docs)]
840 StyleRange3 {
841 value1: QueryExpressionValue,
842 op1: Operator,
843 value2: QueryExpressionValue,
844 op2: Operator,
845 value3: QueryExpressionValue,
846 },
847}
848
849impl ToCss for QueryStyleRange {
850 fn to_css<W>(&self, dest: &mut CssWriter<W>) -> fmt::Result
851 where
852 W: fmt::Write,
853 {
854 match self {
855 Self::StyleRange2 {
856 value1,
857 op1,
858 value2,
859 } => {
860 value1.to_css(dest, None)?;
861 dest.write_char(' ')?;
862 op1.to_css(dest)?;
863 dest.write_char(' ')?;
864 value2.to_css(dest, None)
865 },
866 Self::StyleRange3 {
867 value1,
868 op1,
869 value2,
870 op2,
871 value3,
872 } => {
873 value1.to_css(dest, None)?;
874 dest.write_char(' ')?;
875 op1.to_css(dest)?;
876 dest.write_char(' ')?;
877 value2.to_css(dest, None)?;
878 dest.write_char(' ')?;
879 op2.to_css(dest)?;
880 dest.write_char(' ')?;
881 value3.to_css(dest, None)
882 },
883 }
884 }
885}
886
887impl QueryStyleRange {
888 pub fn parse(context: &ParserContext, input: &mut Parser) -> Result<Self, ParseError> {
896 let value1 = QueryExpressionValue::parse_for_style_range(context, input)?;
897 let op1 = Operator::parse(input)?;
898 let value2 = QueryExpressionValue::parse_for_style_range(context, input)?;
899
900 if let Ok(op2) = input.try_parse(|i| Operator::parse(i))
901 && op1.is_compatible_with(op2)
902 {
903 let value3 = QueryExpressionValue::parse_for_style_range(context, input)?;
904 return Ok(Self::StyleRange3 {
905 value1,
906 op1,
907 value2,
908 op2,
909 value3,
910 });
911 }
912
913 Ok(Self::StyleRange2 {
914 value1,
915 op1,
916 value2,
917 })
918 }
919
920 pub fn evaluate(
922 &self,
923 context: &computed::Context,
924 attribute_tracker: &mut AttributeTracker,
925 ) -> KleeneValue {
926 match self {
927 QueryStyleRange::StyleRange2 {
928 value1,
929 op1,
930 value2,
931 } => Self::compare_values(
932 Self::resolve_value(
933 value1,
934 context,
935 attribute_tracker,
936 &mut PrecomputedHashSet::default(),
937 )
938 .as_ref(),
939 Self::resolve_value(
940 value2,
941 context,
942 attribute_tracker,
943 &mut PrecomputedHashSet::default(),
944 )
945 .as_ref(),
946 )
947 .is_some_and(|c| op1.evaluate(c))
948 .into(),
949
950 QueryStyleRange::StyleRange3 {
951 value1,
952 op1,
953 value2,
954 op2,
955 value3,
956 } => {
957 let v1 = Self::resolve_value(
958 value1,
959 context,
960 attribute_tracker,
961 &mut PrecomputedHashSet::default(),
962 );
963 let v2 = Self::resolve_value(
964 value2,
965 context,
966 attribute_tracker,
967 &mut PrecomputedHashSet::default(),
968 );
969 Self::compare_values(v1.as_ref(), v2.as_ref())
970 .is_some_and(|c1| {
971 op1.evaluate(c1)
972 && Self::compare_values(
973 v2.as_ref(),
974 Self::resolve_value(
975 value3,
976 context,
977 attribute_tracker,
978 &mut PrecomputedHashSet::default(),
979 )
980 .as_ref(),
981 )
982 .is_some_and(|c2| op2.evaluate(c2))
983 })
984 .into()
985 },
986 }
987 }
988
989 fn resolve_value(
991 value: &QueryExpressionValue,
992 context: &computed::Context,
993 attribute_tracker: &mut AttributeTracker,
994 visited_set: &mut PrecomputedHashSet<DashedIdent>,
995 ) -> Option<Component> {
996 match value {
997 QueryExpressionValue::Custom(ident) => {
998 let name = ident.undashed();
1001 let stylist = context
1002 .builder
1003 .stylist
1004 .expect("container queries should have a stylist around");
1005 let registration = stylist.get_custom_property_registration(&name);
1006 let current_value = context
1007 .inherited_custom_properties()
1008 .get(registration, &name)?;
1009 match ¤t_value.v {
1010 ValueInner::Component(component) => Some(component.clone()),
1011 ValueInner::Universal(v) => {
1012 if visited_set.insert(ident.clone()) {
1016 Self::resolve_universal(
1017 &v.css,
1018 &v.url_data,
1019 context,
1020 attribute_tracker,
1021 visited_set,
1022 )
1023 } else {
1024 None
1025 }
1026 },
1027 ValueInner::List(_) => {
1028 debug_assert!(false, "We don't parse list values in style queries");
1029 None
1030 },
1031 }
1032 },
1033 QueryExpressionValue::Function(value) => {
1034 let sub_funcs = ComputedSubstitutionFunctions::new(
1035 Some(context.inherited_custom_properties().clone()),
1036 None,
1037 );
1038 let stylist = context
1039 .builder
1040 .stylist
1041 .expect("container queries should have a stylist around");
1042 let substituted = substitution::substitute(
1043 value,
1044 None,
1045 &sub_funcs,
1046 stylist,
1047 context,
1048 attribute_tracker,
1049 )
1050 .ok()?;
1051 Self::resolve_universal(
1052 &substituted.css,
1053 &value.url_data,
1054 context,
1055 attribute_tracker,
1056 visited_set,
1057 )
1058 },
1059 QueryExpressionValue::Length(v) => {
1060 Some(Component::Length(v.to_computed_value(context)))
1061 },
1062 QueryExpressionValue::Float(v) => Some(Component::Number(v.to_computed_value(context))),
1063 QueryExpressionValue::Resolution(v) => {
1064 Some(Component::Resolution(v.to_computed_value(context)))
1065 },
1066 QueryExpressionValue::Percentage(v) => {
1067 Some(Component::Percentage(v.to_computed_value(context)))
1068 },
1069 QueryExpressionValue::Angle(v) => Some(Component::Angle(v.to_computed_value(context))),
1070 QueryExpressionValue::Time(v) => Some(Component::Time(v.to_computed_value(context))),
1071 QueryExpressionValue::Keyword(_) => None,
1074 _ => {
1075 debug_assert!(false, "unexpected value type in style range");
1076 None
1077 },
1078 }
1079 }
1080
1081 fn resolve_universal(
1088 css_text: &str,
1089 url_data: &UrlExtraData,
1090 context: &computed::Context,
1091 attribute_tracker: &mut AttributeTracker,
1092 visited_set: &mut PrecomputedHashSet<DashedIdent>,
1093 ) -> Option<Component> {
1094 let parser_context = ParserContext::new(
1095 Origin::Author,
1096 url_data,
1097 Some(CssRuleType::Container),
1098 ParsingMode::DEFAULT,
1099 QuirksMode::NoQuirks,
1100 Default::default(),
1101 None,
1102 None,
1103 Default::default(),
1104 );
1105 QueryExpressionValue::parse_for_style_range(&parser_context, &mut Parser::new(css_text))
1106 .ok()
1107 .and_then(|parsed| {
1108 Self::resolve_value(&parsed, context, attribute_tracker, visited_set)
1109 })
1110 }
1111
1112 fn compare_values(value1: Option<&Component>, value2: Option<&Component>) -> Option<Ordering> {
1113 let value1 = value1?;
1114 let value2 = value2?;
1115 match (value1, value2) {
1116 (Component::Length(v1), Component::Length(v2)) => v1.partial_cmp(v2),
1117 (Component::Number(v1), Component::Number(v2)) => v1.partial_cmp(v2),
1118 (Component::Resolution(v1), Component::Resolution(v2)) => {
1119 v1.dppx().partial_cmp(&v2.dppx())
1120 },
1121 (Component::Percentage(v1), Component::Percentage(v2)) => v1.partial_cmp(v2),
1122 (Component::Angle(v1), Component::Angle(v2)) => v1.partial_cmp(v2),
1123 (Component::Time(v1), Component::Time(v2)) => v1.partial_cmp(v2),
1124 (Component::Length(v1), Component::Number(v2)) => {
1125 if v2.is_zero() {
1126 v1.partial_cmp(&CSSPixelLength::zero())
1127 } else {
1128 None
1129 }
1130 },
1131 (Component::Number(v1), Component::Length(v2)) => {
1132 if v1.is_zero() {
1133 CSSPixelLength::zero().partial_cmp(v2)
1134 } else {
1135 None
1136 }
1137 },
1138 _ => None,
1139 }
1140 }
1141
1142 pub fn collect_attribute_references(&self, references: &mut AttrReferenceSet) {
1145 match self {
1146 QueryStyleRange::StyleRange2 {
1147 value1,
1148 op1: _,
1149 value2,
1150 } => {
1151 value1.collect_attribute_references(references);
1152 value2.collect_attribute_references(references);
1153 },
1154 QueryStyleRange::StyleRange3 {
1155 value1,
1156 op1: _,
1157 value2,
1158 op2: _,
1159 value3,
1160 } => {
1161 value1.collect_attribute_references(references);
1162 value2.collect_attribute_references(references);
1163 value3.collect_attribute_references(references);
1164 },
1165 }
1166 }
1167}