1use std::collections::HashMap;
6use std::rc::Rc;
7
8#[derive(Clone, Debug, Default, PartialEq, Eq)]
11pub struct Vars {
12 entries: Vec<(Rc<str>, Rc<str>)>,
15}
16
17impl Vars {
18 pub fn is_empty(&self) -> bool {
19 self.entries.is_empty()
20 }
21
22 pub fn len(&self) -> usize {
23 self.entries.len()
24 }
25
26 pub fn get(&self, name: &str) -> Option<&str> {
27 self.entries
28 .binary_search_by(|(k, _)| (**k).cmp(name))
29 .ok()
30 .map(|i| &*self.entries[i].1)
31 }
32
33 pub fn iter(&self) -> impl Iterator<Item = (&str, &str)> {
34 self.entries.iter().map(|(k, v)| (&**k, &**v))
35 }
36}
37
38pub(crate) fn resolve_registered(
39 parent: &Rc<Vars>,
40 own: &[&(String, String)],
41 registrations: &[crate::registered::PercentageRegistration],
42 env: &crate::Env,
43 diagnostics: &mut Vec<String>,
44) -> Rc<Vars> {
45 if registrations.is_empty() {
46 return resolve(parent, own, env, diagnostics);
47 }
48 let defaults_needed = registrations.iter().any(|r| {
49 if r.inherits {
50 parent.get(&r.name).is_none()
51 } else {
52 parent.get(&r.name).and_then(crate::registered::percentage) != Some(r.initial)
53 }
54 });
55 let owns_registered = own
56 .iter()
57 .any(|(name, _)| registrations.iter().any(|r| r.name == *name));
58 if !defaults_needed && !owns_registered {
59 return resolve(parent, own, env, diagnostics);
60 }
61 let defaults: Vec<(String, String)> = registrations
62 .iter()
63 .filter(|r| !r.inherits || parent.get(&r.name).is_none())
64 .map(|r| (r.name.clone(), format!("{}%", r.initial * 100.)))
65 .collect();
66 let basis = resolve(
67 parent,
68 &defaults.iter().collect::<Vec<_>>(),
69 env,
70 diagnostics,
71 );
72 let declarations: Vec<(String, String)> = own
73 .iter()
74 .map(|(name, raw)| {
75 let Some(registration) = registrations.iter().find(|r| r.name == *name) else {
76 return (name.clone(), raw.clone());
77 };
78 let keyword = raw.trim();
79 let value = if keyword.eq_ignore_ascii_case("inherit") {
80 parent
81 .get(name)
82 .map(str::to_owned)
83 .unwrap_or_else(|| format!("{}%", registration.initial * 100.))
84 } else if keyword.eq_ignore_ascii_case("initial")
85 || (!registration.inherits
86 && ["unset", "revert", "revert-layer"]
87 .iter()
88 .any(|v| keyword.eq_ignore_ascii_case(v)))
89 {
90 format!("{}%", registration.initial * 100.)
91 } else {
92 raw.clone()
93 };
94 (name.clone(), value)
95 })
96 .collect();
97 let computed = resolve(
98 &basis,
99 &declarations.iter().collect::<Vec<_>>(),
100 env,
101 diagnostics,
102 );
103 let invalid: Vec<(String, String)> = registrations
104 .iter()
105 .filter(|r| {
106 computed
107 .get(&r.name)
108 .and_then(crate::registered::percentage)
109 .is_none()
110 })
111 .map(|r| {
112 (
113 r.name.clone(),
114 basis.get(&r.name).unwrap_or("0%").to_owned(),
115 )
116 })
117 .collect();
118 resolve(
119 &computed,
120 &invalid.iter().collect::<Vec<_>>(),
121 env,
122 diagnostics,
123 )
124}
125
126#[derive(Debug, Clone, PartialEq, Eq)]
127pub(crate) enum VarError {
128 Unresolved(String),
129 UnknownEnv(String),
132 Cycle(String),
133 TooLarge,
134}
135
136impl VarError {
137 pub(crate) fn describe(&self) -> String {
138 match self {
139 VarError::Unresolved(name) => format!(
140 "`var({name})` is not set on this element or any ancestor and the reference has no \
141 fallback"
142 ),
143 VarError::UnknownEnv(name) => format!(
144 "`env({name})` is not an environment variable this host publishes — supported: \
145 titlebar-area-x | -y | -width | -height, safe-area-inset-top | -right | -bottom \
146 | -left. Give it a fallback (`env({name}, 0px)`) if it is optional"
147 ),
148 VarError::Cycle(name) => {
149 format!("`{name}` takes part in a var() reference cycle")
150 }
151 VarError::TooLarge => {
152 format!("substitution expanded past {MAX_EXPANSION} characters")
153 }
154 }
155 }
156}
157
158const MAX_EXPANSION: usize = 64 * 1024;
161
162fn is_ident_byte(b: u8) -> bool {
163 b.is_ascii_alphanumeric() || b == b'-' || b == b'_' || b == b'\\' || b >= 0x80
164}
165
166fn skip_string(bytes: &[u8], i: usize) -> usize {
167 let quote = bytes[i];
168 let mut j = i + 1;
169 while j < bytes.len() {
170 match bytes[j] {
171 b'\\' => j += 2,
172 b if b == quote => return j + 1,
173 _ => j += 1,
174 }
175 }
176 bytes.len()
177}
178
179#[derive(Clone, Copy, PartialEq, Eq, Debug)]
180enum Subst {
181 Var,
182 Env,
183}
184
185fn is_fn_at(bytes: &[u8], i: usize, name: &[u8]) -> bool {
186 let end = i + name.len();
187 if end >= bytes.len() || bytes[end] != b'(' {
188 return false;
189 }
190 if i > 0 && is_ident_byte(bytes[i - 1]) {
191 return false;
192 }
193 bytes[i..end]
194 .iter()
195 .zip(name)
196 .all(|(a, b)| a.eq_ignore_ascii_case(b))
197}
198
199fn find_subst(bytes: &[u8], from: usize) -> Option<(usize, Subst)> {
200 let mut i = from;
201 while i < bytes.len() {
202 if matches!(bytes[i], b'"' | b'\'') {
203 i = skip_string(bytes, i);
204 continue;
205 }
206 if is_fn_at(bytes, i, b"var") {
207 return Some((i, Subst::Var));
208 }
209 if is_fn_at(bytes, i, b"env") {
210 return Some((i, Subst::Env));
211 }
212 i += 1;
213 }
214 None
215}
216
217const TITLEBAR_AREA: [&str; 4] = [
218 "titlebar-area-x",
219 "titlebar-area-y",
220 "titlebar-area-width",
221 "titlebar-area-height",
222];
223
224fn env_value(name: &str, env: &crate::Env) -> Option<String> {
227 let px = |v: f32| {
228 if v == v.trunc() && v.is_finite() {
229 format!("{}px", v as i64)
230 } else {
231 format!("{v}px")
232 }
233 };
234 let s = env.safe_area_insets;
235 if let Some(i) = TITLEBAR_AREA.iter().position(|n| *n == name) {
236 return env.titlebar_area.map(|t| px(t[i]));
237 }
238 Some(match name {
239 "safe-area-inset-top" => px(s[0]),
240 "safe-area-inset-right" => px(s[1]),
241 "safe-area-inset-bottom" => px(s[2]),
242 "safe-area-inset-left" => px(s[3]),
243 _ => return None,
244 })
245}
246
247fn matching_paren(bytes: &[u8], open: usize) -> Option<usize> {
250 let mut depth = 0usize;
251 let mut i = open;
252 while i < bytes.len() {
253 match bytes[i] {
254 b'"' | b'\'' => {
255 i = skip_string(bytes, i);
256 continue;
257 }
258 b'(' => depth += 1,
259 b')' => {
260 depth -= 1;
261 if depth == 0 {
262 return Some(i);
263 }
264 }
265 _ => {}
266 }
267 i += 1;
268 }
269 None
270}
271
272fn split_var_args(inner: &str) -> (&str, Option<&str>) {
275 let bytes = inner.as_bytes();
276 let mut depth = 0usize;
277 let mut i = 0;
278 while i < bytes.len() {
279 match bytes[i] {
280 b'"' | b'\'' => {
281 i = skip_string(bytes, i);
282 continue;
283 }
284 b'(' => depth += 1,
285 b')' => depth = depth.saturating_sub(1),
286 b',' if depth == 0 => return (inner[..i].trim(), Some(inner[i + 1..].trim_start())),
287 _ => {}
288 }
289 i += 1;
290 }
291 (inner.trim(), None)
292}
293
294pub(crate) fn substitute(
295 text: &str,
296 env: &crate::Env,
297 lookup: &mut dyn FnMut(&str) -> Result<Option<String>, VarError>,
298) -> Result<String, VarError> {
299 if find_subst(text.as_bytes(), 0).is_none() {
300 return Ok(text.to_string());
301 }
302 let mut out = String::with_capacity(text.len());
303 let mut cursor = 0usize;
304 let bytes = text.as_bytes();
305 while let Some((open, kind)) = find_subst(bytes, cursor) {
306 let paren = open + 3;
307 let Some(close) = matching_paren(bytes, paren) else {
308 break;
309 };
310 out.push_str(&text[cursor..open]);
311 let (name, fallback) = split_var_args(&text[paren + 1..close]);
312 let resolved = match kind {
313 Subst::Var => lookup(name)?,
314 Subst::Env => env_value(name, env),
315 };
316 match resolved {
317 Some(value) => out.push_str(&value),
318 None => match fallback {
319 Some(f) => out.push_str(&substitute(f, env, lookup)?),
320 None => {
321 return Err(match kind {
322 Subst::Env if !TITLEBAR_AREA.contains(&name) => {
323 VarError::UnknownEnv(name.to_string())
324 }
325 Subst::Var | Subst::Env => VarError::Unresolved(name.to_string()),
327 });
328 }
329 },
330 }
331 if out.len() > MAX_EXPANSION {
332 return Err(VarError::TooLarge);
333 }
334 cursor = close + 1;
335 }
336 out.push_str(&text[cursor..]);
337 Ok(out)
338}
339
340pub(crate) fn substitute_with(
341 text: &str,
342 vars: &Vars,
343 env: &crate::Env,
344) -> Result<String, VarError> {
345 substitute(text, env, &mut |name| {
346 Ok(vars.get(name).map(str::to_string))
347 })
348}
349
350enum Slot<'a> {
351 Raw(&'a str),
352 Done(String),
353 Busy,
354 Dropped,
355}
356
357fn force<'a>(
358 slots: &mut HashMap<&'a str, Slot<'a>>,
359 parent: &Vars,
360 env: &crate::Env,
361 name: &str,
362 diagnostics: &mut Vec<String>,
363) -> Result<Option<String>, VarError> {
364 match slots.get(name) {
365 None => Ok(parent.get(name).map(str::to_string)),
366 Some(Slot::Dropped) => Ok(None),
367 Some(Slot::Done(v)) => Ok(Some(v.clone())),
368 Some(Slot::Busy) => Err(VarError::Cycle(name.to_string())),
369 Some(Slot::Raw(_)) => {
370 let (key, raw) = match slots.get_key_value(name) {
371 Some((k, Slot::Raw(raw))) => (*k, *raw),
372 _ => unreachable!("checked Raw above"),
373 };
374 slots.insert(key, Slot::Busy);
375 let resolved = substitute(raw, env, &mut |inner| {
376 force(slots, parent, env, inner, diagnostics)
377 });
378 match resolved {
379 Ok(value) => {
380 slots.insert(key, Slot::Done(value.clone()));
381 Ok(Some(value))
382 }
383 Err(VarError::Unresolved(_)) => {
387 slots.insert(key, Slot::Dropped);
388 Ok(None)
389 }
390 Err(e) => {
391 diagnostics.push(format!(
392 "`{name}` is invalid at computed-value time — {} (the custom property is \
393 treated as unset on this element and everything under it)",
394 e.describe()
395 ));
396 slots.insert(key, Slot::Dropped);
397 Ok(None)
398 }
399 }
400 }
401 }
402}
403
404fn inert(raw: &str, name: &str, parent: &Vars) -> bool {
408 find_subst(raw.as_bytes(), 0).is_none() && parent.get(name) == Some(raw)
409}
410
411enum Wide {
415 Initial,
416 Inherited,
417}
418
419fn wide_keyword(raw: &str) -> Option<Wide> {
420 let raw = raw.trim();
421 if raw.eq_ignore_ascii_case("initial") {
422 return Some(Wide::Initial);
423 }
424 if ["inherit", "unset", "revert", "revert-layer"]
425 .iter()
426 .any(|k| raw.eq_ignore_ascii_case(k))
427 {
428 return Some(Wide::Inherited);
429 }
430 None
431}
432
433pub(crate) fn resolve(
434 parent: &Rc<Vars>,
435 own: &[&(String, String)],
436 env: &crate::Env,
437 diagnostics: &mut Vec<String>,
438) -> Rc<Vars> {
439 if own.is_empty() {
440 return parent.clone();
441 }
442 if own.iter().all(|(name, raw)| inert(raw, name, parent)) {
443 return parent.clone();
444 }
445
446 let mut folded: Vec<(&str, &str)> = Vec::with_capacity(own.len());
447 let mut seen: std::collections::HashSet<&str> =
448 std::collections::HashSet::with_capacity(own.len());
449 for (name, raw) in own.iter().rev() {
450 if !seen.insert(name.as_str()) {
451 continue;
452 }
453 match wide_keyword(raw) {
454 Some(Wide::Inherited) => continue,
455 Some(Wide::Initial) => folded.push((name.as_str(), raw.as_str())),
456 None => {
457 if !inert(raw, name, parent) {
458 folded.push((name.as_str(), raw.as_str()));
459 }
460 }
461 }
462 }
463 if folded.is_empty() {
464 return parent.clone();
465 }
466
467 let mut slots: HashMap<&str, Slot<'_>> = HashMap::with_capacity(folded.len());
468 for (name, raw) in &folded {
469 slots.insert(
470 name,
471 match wide_keyword(raw) {
472 Some(Wide::Initial) => Slot::Dropped,
473 _ => Slot::Raw(raw),
474 },
475 );
476 }
477 for (name, _) in &folded {
478 if let Err(e) = force(&mut slots, parent, env, name, diagnostics) {
479 diagnostics.push(format!(
480 "`{name}` is invalid at computed-value time — {}",
481 e.describe()
482 ));
483 slots.insert(name, Slot::Dropped);
484 }
485 }
486
487 let mut mine: Vec<(&str, String)> = slots
488 .into_iter()
489 .filter_map(|(k, v)| match v {
490 Slot::Done(value) => Some((k, value)),
491 _ => None,
492 })
493 .collect();
494 mine.sort_by(|a, b| a.0.cmp(b.0));
495 let declared: std::collections::HashSet<&str> = folded.iter().map(|(n, _)| *n).collect();
496
497 let mut entries: Vec<(Rc<str>, Rc<str>)> =
498 Vec::with_capacity(parent.entries.len() + mine.len());
499 let mut mine_iter = mine.into_iter().peekable();
500 for (k, v) in &parent.entries {
501 while mine_iter.peek().is_some_and(|(mk, _)| *mk < &**k) {
502 let (mk, mv) = mine_iter.next().unwrap();
503 entries.push((mk.into(), mv.into()));
504 }
505 if declared.contains(&**k) {
506 if mine_iter.peek().is_some_and(|(mk, _)| *mk == &**k) {
507 let (mk, mv) = mine_iter.next().unwrap();
508 entries.push((mk.into(), mv.into()));
509 }
510 continue;
511 }
512 entries.push((k.clone(), v.clone()));
513 }
514 for (mk, mv) in mine_iter {
515 entries.push((mk.into(), mv.into()));
516 }
517
518 if entries == parent.entries {
519 return parent.clone();
520 }
521 Rc::new(Vars { entries })
522}
523
524#[cfg(test)]
525mod tests {
526 use super::*;
527
528 fn vars(pairs: &[(&str, &str)]) -> Rc<Vars> {
529 let own: Vec<(String, String)> = pairs
530 .iter()
531 .map(|(k, v)| (k.to_string(), v.to_string()))
532 .collect();
533 let mut d = Vec::new();
534 resolve(
535 &Rc::new(Vars::default()),
536 &refs(&own),
537 &crate::Env::default(),
538 &mut d,
539 )
540 }
541
542 fn refs(own: &[(String, String)]) -> Vec<&(String, String)> {
543 own.iter().collect()
544 }
545
546 #[test]
547 fn the_css_wide_keywords_are_keywords_for_a_custom_property_too() {
548 let v = vars(&[("--tw-enter-scale", "initial")]);
549 assert_eq!(v.get("--tw-enter-scale"), None, "`initial` is not a value");
550 assert_eq!(
551 substitute_with(
552 "scale3d(var(--tw-enter-scale, 1), 1, 1)",
553 &v,
554 &crate::Env::default()
555 )
556 .unwrap(),
557 "scale3d(1, 1, 1)",
558 "so `var()` takes the fallback"
559 );
560
561 let parent = vars(&[("--x", "9")]);
562 let own = vec![("--x".to_string(), "initial".to_string())];
563 let mut d = Vec::new();
564 let child = resolve(&parent, &refs(&own), &crate::Env::default(), &mut d);
565 assert_eq!(
566 child.get("--x"),
567 None,
568 "CSS Variables §3: no inheritance rescue"
569 );
570 assert!(d.is_empty(), "and it is not an error: {d:?}");
571
572 for keyword in ["inherit", "unset", "revert", "REVERT-LAYER"] {
573 let own = vec![("--x".to_string(), keyword.to_string())];
574 let child = resolve(
575 &parent,
576 &refs(&own),
577 &crate::Env::default(),
578 &mut Vec::new(),
579 );
580 assert_eq!(child.get("--x"), Some("9"), "{keyword}");
581 }
582 }
583
584 #[test]
585 fn a_custom_property_may_reference_another() {
586 let v = vars(&[("--a", "10px"), ("--b", "var(--a) var(--a)")]);
587 assert_eq!(v.get("--b"), Some("10px 10px"));
588 }
589
590 #[test]
591 fn declaration_order_does_not_matter_for_resolution() {
592 let v = vars(&[("--b", "var(--a)"), ("--a", "red")]);
593 assert_eq!(v.get("--b"), Some("red"));
594 }
595
596 #[test]
597 fn fallbacks_apply_only_when_unset() {
598 let v = vars(&[
599 ("--a", "1"),
600 ("--x", "var(--a, 9)"),
601 ("--y", "var(--nope, 9)"),
602 ]);
603 assert_eq!(v.get("--x"), Some("1"));
604 assert_eq!(v.get("--y"), Some("9"));
605 }
606
607 #[test]
608 fn a_fallbackless_missing_reference_invalidates_the_declaration() {
609 let own = vec![("--x".to_string(), "var(--nope)".to_string())];
610 let mut d = Vec::new();
611 let v = resolve(
612 &Rc::new(Vars::default()),
613 &refs(&own),
614 &crate::Env::default(),
615 &mut d,
616 );
617 assert_eq!(v.get("--x"), None);
618 assert!(d.is_empty(), "{d:?}");
619 }
620
621 #[test]
622 fn cycles_drop_the_properties() {
623 let own = vec![
624 ("--a".to_string(), "var(--b)".to_string()),
625 ("--b".to_string(), "var(--a)".to_string()),
626 ];
627 let mut d = Vec::new();
628 let v = resolve(
629 &Rc::new(Vars::default()),
630 &refs(&own),
631 &crate::Env::default(),
632 &mut d,
633 );
634 assert!(v.get("--a").is_none() && v.get("--b").is_none(), "{v:?}");
635 }
636
637 #[test]
638 fn inheritance_overrides_by_name_and_shares_the_rc_when_nothing_is_declared() {
639 let parent = vars(&[("--a", "1"), ("--b", "2")]);
640 let mut d = Vec::new();
641 let same = resolve(&parent, &[], &crate::Env::default(), &mut d);
642 assert!(Rc::ptr_eq(&parent, &same));
643
644 let own = vec![("--b".to_string(), "9".to_string())];
645 let child = resolve(&parent, &refs(&own), &crate::Env::default(), &mut d);
646 assert_eq!(child.get("--a"), Some("1"));
647 assert_eq!(child.get("--b"), Some("9"));
648 assert_eq!(parent.get("--b"), Some("2"));
649 }
650
651 #[test]
652 fn redeclaring_the_inherited_value_shares_the_parents_map() {
653 let parent = vars(&[("--a", "1"), ("--b", "0 0 #0000")]);
654 let mut d = Vec::new();
655 let same = vec![
656 ("--a".to_string(), "1".to_string()),
657 ("--b".to_string(), "0 0 #0000".to_string()),
658 ];
659 let child = resolve(&parent, &refs(&same), &crate::Env::default(), &mut d);
660 assert!(
661 Rc::ptr_eq(&parent, &child),
662 "identical declarations must not rebuild the map"
663 );
664
665 let differs = vec![
666 ("--a".to_string(), "1".to_string()),
667 ("--b".to_string(), "2".to_string()),
668 ];
669 let child = resolve(&parent, &refs(&differs), &crate::Env::default(), &mut d);
670 assert!(!Rc::ptr_eq(&parent, &child));
671 assert_eq!(child.get("--a"), Some("1"));
672 assert_eq!(child.get("--b"), Some("2"));
673 }
674
675 #[test]
676 fn dropping_inert_declarations_respects_last_wins() {
677 let parent = vars(&[("--a", "1")]);
678 let mut d = Vec::new();
679
680 let later_differs = vec![
681 ("--a".to_string(), "1".to_string()),
682 ("--a".to_string(), "2".to_string()),
683 ];
684 assert_eq!(
685 resolve(
686 &parent,
687 &refs(&later_differs),
688 &crate::Env::default(),
689 &mut d
690 )
691 .get("--a"),
692 Some("2")
693 );
694
695 let later_matches = vec![
696 ("--a".to_string(), "2".to_string()),
697 ("--a".to_string(), "1".to_string()),
698 ];
699 let child = resolve(
700 &parent,
701 &refs(&later_matches),
702 &crate::Env::default(),
703 &mut d,
704 );
705 assert_eq!(child.get("--a"), Some("1"));
706 assert!(
707 Rc::ptr_eq(&parent, &child),
708 "the winning declaration is inert"
709 );
710 }
711
712 #[test]
713 fn a_var_reference_never_takes_the_identical_fast_path() {
714 let parent = vars(&[("--b", "red"), ("--a", "var(--b)")]);
715 let mut d = Vec::new();
716 let own = vec![("--a".to_string(), "var(--b)".to_string())];
717 let child = resolve(&parent, &refs(&own), &crate::Env::default(), &mut d);
718 assert_eq!(child.get("--a"), Some("red"));
719 }
720
721 #[test]
722 fn an_invalid_declaration_shadows_the_inherited_value() {
723 let parent = vars(&[("--keep", "k"), ("--x", "inherited")]);
724 let mut d = Vec::new();
725 let own = vec![("--x".to_string(), "var(--nope)".to_string())];
726 let child = resolve(&parent, &refs(&own), &crate::Env::default(), &mut d);
727 assert_eq!(
728 child.get("--x"),
729 None,
730 "the parent's value must not come back"
731 );
732 assert_eq!(child.get("--keep"), Some("k"));
733 }
734
735 #[test]
736 fn the_merged_map_stays_sorted() {
737 let parent = vars(&[("--m", "m"), ("--z", "z")]);
738 let mut d = Vec::new();
739 let own = vec![
740 ("--zz".to_string(), "9".to_string()),
741 ("--a".to_string(), "1".to_string()),
742 ("--m".to_string(), "2".to_string()),
743 ];
744 let child = resolve(&parent, &refs(&own), &crate::Env::default(), &mut d);
745 let names: Vec<&str> = child.iter().map(|(k, _)| k).collect();
746 assert_eq!(names, vec!["--a", "--m", "--z", "--zz"]);
747 assert_eq!(child.get("--a"), Some("1"));
748 assert_eq!(child.get("--m"), Some("2"));
749 assert_eq!(child.get("--z"), Some("z"));
750 assert_eq!(child.get("--zz"), Some("9"));
751 }
752
753 #[test]
754 fn an_override_is_seen_by_the_elements_own_references() {
755 let parent = vars(&[("--hue", "10")]);
756 let mut d = Vec::new();
757 let own = vec![
758 ("--hue".to_string(), "200".to_string()),
759 ("--color".to_string(), "hsl(var(--hue) 50% 50%)".to_string()),
760 ];
761 let child = resolve(&parent, &refs(&own), &crate::Env::default(), &mut d);
762 assert_eq!(child.get("--color"), Some("hsl(200 50% 50%)"));
763 }
764
765 #[test]
766 fn substitution_skips_strings_and_identifier_tails() {
767 let v = vars(&[("--a", "X")]);
768 assert_eq!(
769 substitute_with(r#"content: "var(--a)""#, &v, &crate::Env::default()).unwrap(),
770 r#"content: "var(--a)""#
771 );
772 assert_eq!(
773 substitute_with("my-var(--a)", &v, &crate::Env::default()).unwrap(),
774 "my-var(--a)"
775 );
776 assert_eq!(
777 substitute_with("VAR(--a)", &v, &crate::Env::default()).unwrap(),
778 "X"
779 );
780 }
781
782 #[test]
783 fn nested_fallbacks_resolve() {
784 let v = vars(&[("--b", "blue")]);
785 assert_eq!(
786 substitute_with("var(--a, var(--b, red))", &v, &crate::Env::default()).unwrap(),
787 "blue"
788 );
789 assert_eq!(
790 substitute_with("var(--a, var(--z, red))", &v, &crate::Env::default()).unwrap(),
791 "red"
792 );
793 }
794
795 #[test]
796 fn the_fallback_split_is_top_level_only() {
797 let v = vars(&[]);
798 assert_eq!(
799 substitute_with("var(--a, rgb(1, 2, 3))", &v, &crate::Env::default()).unwrap(),
800 "rgb(1, 2, 3)"
801 );
802 }
803
804 #[test]
805 fn an_empty_fallback_is_not_the_same_as_no_fallback() {
806 let v = vars(&[]);
807 assert_eq!(
808 substitute_with("var(--a,)", &v, &crate::Env::default()).unwrap(),
809 ""
810 );
811 assert!(matches!(
812 substitute_with("var(--a)", &v, &crate::Env::default()),
813 Err(VarError::Unresolved(_))
814 ));
815 }
816
817 #[test]
818 fn the_tailwind_ring_compound_substitutes() {
819 let v = vars(&[
820 ("--tw-ring-inset", ""),
821 ("--tw-ring-offset-width", "2px"),
822 ("--tw-ring-offset-color", "#fff"),
823 ("--tw-ring-color", "rgb(59 130 246 / 0.5)"),
824 (
825 "--tw-ring-offset-shadow",
826 "var(--tw-ring-inset) 0 0 0 var(--tw-ring-offset-width) var(--tw-ring-offset-color)",
827 ),
828 (
829 "--tw-ring-shadow",
830 "var(--tw-ring-inset) 0 0 0 calc(2px + var(--tw-ring-offset-width)) var(--tw-ring-color)",
831 ),
832 ]);
833 let shadow = substitute_with(
834 "var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow, 0 0 #0000)",
835 &v,
836 &crate::Env::default(),
837 )
838 .unwrap();
839 assert_eq!(
840 shadow,
841 " 0 0 0 2px #fff, 0 0 0 calc(2px + 2px) rgb(59 130 246 / 0.5), 0 0 #0000"
842 );
843 }
844}