Skip to main content

sk_css/
vars.rs

1//! Custom properties (`--x`) and `var()` / `env()` substitution: an inherited string map on the
2//! element, read at computed-value time. Substitution is textual; it differs from token-level only
3//! in strings and comments, and the scanner skips quoted strings.
4
5use std::collections::HashMap;
6use std::rc::Rc;
7
8/// `Eq` matters: `Rc<T>` equality short-circuits on pointer identity for `T: Eq`, and a node with
9/// no custom properties shares its parent's `Rc`, keeping the change test O(1).
10#[derive(Clone, Debug, Default, PartialEq, Eq)]
11pub struct Vars {
12    /// `Rc<str>` so a child overriding one property carries the other ~40 through by refcount bump,
13    /// not allocation.
14    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    /// Its own variant because an author cannot set an environment variable, so "declare it" is not
130    /// advice.
131    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
158/// `var()` can expand exponentially (`--a: var(--b) var(--b)` chained N deep is 2^N tokens), and a
159/// browser has its own limit for the same reason — better a named advisory than a hang.
160const 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
224/// `env()` names are ASCII case-sensitive identifiers; the indexed form has no members here, so a
225/// name with an index is unknown.
226fn 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
247/// `None` = unbalanced (the parser would have rejected the sheet, but an inline `style=""` string
248/// reaches us raw).
249fn 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
272/// A missing comma means "no fallback"; `var(--x,)` means "the empty fallback", which is valid CSS
273/// and NOT the same as no fallback.
274fn 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                        // A known variable the window does not define now: as routine as an unset var().
326                        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                // Routine, so silent: Tailwind's `--tw-shadow-colored` reads
384                // `var(--tw-shadow-color)`, set only by a `shadow-<color>` utility. Cycles and
385                // unknown `env()` are author mistakes and still speak.
386                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
404/// Fast path: Tailwind's universal block declares ~40 literals on every element, almost all equal
405/// to what was inherited, so the parent's `Rc` comes straight back; the general path resolves only
406/// the names declared here and merges sorted lists.
407fn inert(raw: &str, name: &str, parent: &Vars) -> bool {
408    find_subst(raw.as_bytes(), 0).is_none() && parent.get(name) == Some(raw)
409}
410
411/// CSS-wide keywords as a variable's value. `initial` must reset the channel, not substitute
412/// literally: `tailwindcss-animate` writes `--tw-enter-scale: initial`, and `translate3d(initial,
413/// ...)` would not parse and would discard the whole `transform`.
414enum 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}