fix(searcher): skip strings, urls, and comments when detecting variable references

`VariableUsages::matches` previously did `value.contains("var(")` and a
naive substring scan for `--ident`, both of which fired on content that
sits inside string literals or `url(...)` tokens (e.g. `content: "var(--x)"`,
`url("file--name.png")`). It also matched `--ident` glued to the tail of a
preceding identifier (`font--name`).

Replace it with a single state-aware scanner that walks the value once,
skipping `"…"`/`'…'` strings, `/* … */` comments, and `url(…)` token
contents, and only fires on `var(`/`--ident` at a real token boundary.
Also accepts `Var(` / `URL(` case-insensitively to match CSS rules.

Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>

Author: jo16oh

crates/css-var-kit/src/searcher/conditions/variable_usages.rs

@@ -5,19 +5,92 @@ pub struct VariableUsages;
 
 impl SearchCondition for VariableUsages {
     fn matches(&self, prop: &Property) -> bool {
-        prop.value.raw.contains("var(") || has_dashed_ident(prop.value.raw.as_ref())
+        contains_variable_reference(prop.value.raw.as_ref())
     }
 }
 
-fn has_dashed_ident(value: &str) -> bool {
+fn contains_variable_reference(value: &str) -> bool {
     let bytes = value.as_bytes();
-    (0..bytes.len().saturating_sub(2)).any(|i| {
-        bytes[i] == b'-'
-            && bytes[i + 1] == b'-'
-            && (bytes[i + 2].is_ascii_alphanumeric()
-                || bytes[i + 2] == b'_'
-                || bytes[i + 2] == b'-')
-    })
+    let len = bytes.len();
+    let mut i = 0;
+    while i < len {
+        match bytes[i] {
+            b'"' | b'\'' => i = end_of_string(bytes, i),
+            b'/' if i + 1 < len && bytes[i + 1] == b'*' => i = end_of_comment(bytes, i),
+            b'u' | b'U' if at_token_boundary(bytes, i) && matches_func_open(bytes, i, b"url") => {
+                i = end_of_url(bytes, i + 4);
+            }
+            b'v' | b'V' if at_token_boundary(bytes, i) && matches_func_open(bytes, i, b"var") => {
+                return true;
+            }
+            b'-' if at_token_boundary(bytes, i)
+                && i + 2 < len
+                && bytes[i + 1] == b'-'
+                && is_ident_continue(bytes[i + 2]) =>
+            {
+                return true;
+            }
+            _ => i += 1,
+        }
+    }
+    false
+}
+
+fn at_token_boundary(bytes: &[u8], i: usize) -> bool {
+    i == 0 || !is_ident_continue(bytes[i - 1])
+}
+
+fn is_ident_continue(b: u8) -> bool {
+    b.is_ascii_alphanumeric() || b == b'_' || b == b'-' || b >= 0x80
+}
+
+fn matches_func_open(bytes: &[u8], i: usize, name: &[u8]) -> bool {
+    let end = i + name.len();
+    end < bytes.len() && bytes[i..end].eq_ignore_ascii_case(name) && bytes[end] == b'('
+}
+
+fn end_of_string(bytes: &[u8], start: usize) -> usize {
+    let quote = bytes[start];
+    let mut i = start + 1;
+    while i < bytes.len() {
+        match bytes[i] {
+            b'\\' if i + 1 < bytes.len() => i += 2,
+            b if b == quote => return i + 1,
+            _ => i += 1,
+        }
+    }
+    bytes.len()
+}
+
+fn end_of_comment(bytes: &[u8], start: usize) -> usize {
+    let mut i = start + 2;
+    while i + 1 < bytes.len() {
+        if bytes[i] == b'*' && bytes[i + 1] == b'/' {
+            return i + 2;
+        }
+        i += 1;
+    }
+    bytes.len()
+}
+
+fn end_of_url(bytes: &[u8], start: usize) -> usize {
+    let mut i = start;
+    let mut paren = 1i32;
+    while i < bytes.len() && paren > 0 {
+        match bytes[i] {
+            b'"' | b'\'' => i = end_of_string(bytes, i),
+            b'(' => {
+                paren += 1;
+                i += 1;
+            }
+            b')' => {
+                paren -= 1;
+                i += 1;
+            }
+            _ => i += 1,
+        }
+    }
+    i
 }
 
 #[cfg(test)]
@@ -62,4 +135,58 @@ mod tests {
     fn rejects_bare_double_dash() {
         assert!(!matches_value("--"));
     }
+
+    #[test]
+    fn rejects_dashed_ident_inside_double_quoted_string() {
+        assert!(!matches_value("\"--not-a-var\""));
+    }
+
+    #[test]
+    fn rejects_dashed_ident_inside_single_quoted_string() {
+        assert!(!matches_value("'--not-a-var'"));
+    }
+
+    #[test]
+    fn rejects_var_call_inside_string() {
+        assert!(!matches_value("\"var(--x)\""));
+    }
+
+    #[test]
+    fn rejects_dashed_ident_inside_quoted_url() {
+        assert!(!matches_value("url(\"file--name.png\")"));
+    }
+
+    #[test]
+    fn rejects_dashed_ident_inside_unquoted_url() {
+        assert!(!matches_value("url(file--name.png)"));
+    }
+
+    #[test]
+    fn rejects_var_call_inside_unquoted_url() {
+        assert!(!matches_value("url(var(--x))"));
+    }
+
+    #[test]
+    fn rejects_dashed_ident_glued_to_preceding_ident() {
+        // `font--name` is a single identifier-like token, not a `--name` reference.
+        assert!(!matches_value("font--name"));
+    }
+
+    #[test]
+    fn matches_var_call_uppercase() {
+        assert!(matches_value("VAR(--x)"));
+        assert!(matches_value("Var(--x)"));
+    }
+
+    #[test]
+    fn matches_real_var_alongside_string_with_dashes() {
+        assert!(matches_value("\"--decoy\" var(--real)"));
+    }
+
+    #[test]
+    fn rejects_dashed_ident_inside_block_comment() {
+        // Comments don't normally survive into the value (parser strips them),
+        // but be defensive.
+        assert!(!matches_value("/* --decoy */ red"));
+    }
 }