cfsolve 0.1.1 → 0.1.2

data/vendor/cfsolve/src/stage2/vocabulary.rs

@@ -13,11 +13,11 @@ use std::ops::Range;
 
 use rustc_hash::FxHashMap;
 
-use super::reference::{EXPANDED_REFERENCE, REFERENCE};
+use super::reference::REFERENCE;
 use crate::js::{JsObject, JsValue};
 
 /// Session names and the reference names they stand for.
-#[derive(Clone, Debug)]
+#[derive(Debug)]
 pub struct Vocabulary {
     /// One-to-one name mapping for the whole program.
     global: Names,
@@ -39,7 +39,7 @@ pub struct Candidate {
 }
 
 /// A one-to-one map between session and reference names.
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 struct Names {
     to_reference: HashMap<String, String>,
     to_session: HashMap<String, String>,
@@ -76,97 +76,31 @@ impl Names {
 }
 
 impl Vocabulary {
-    pub(crate) fn extend_expanded<S: AsRef<[String]>>(&mut self, session: &[S]) {
-        let session = without_common_names(&expand_lists(session));
-        let public: HashSet<&str> = REFERENCE
-            .probes
-            .iter()
-            .flatten()
-            .chain(EXPANDED_REFERENCE.probes.iter().flatten())
-            .map(String::as_str)
-            .collect();
-        let clean: Vec<Vec<String>> = session
-            .iter()
-            .map(|strings| {
-                strings
-                    .iter()
-                    .filter(|text| {
-                        !is_log_message(text)
-                            && !text.contains('\0')
-                            && !text.starts_with("ÿÿ")
-                            && (alignment_name(text) || public.contains(text.as_str()))
-                    })
-                    .cloned()
-                    .collect()
-            })
-            .collect();
-        self.align(&clean, &EXPANDED_REFERENCE.probes, true);
-    }
-
     /// Infers name mappings from each probe's collection strings.
     #[must_use]
     pub fn infer<S: AsRef<[String]>>(session: &[S]) -> Self {
         Self::between(session, &REFERENCE.probes)
     }
 
-    pub(crate) fn between<S: AsRef<[String]>>(session: &[S], reference: &[Vec<String>]) -> Self {
-        let encoded_names = session
-            .iter()
-            .any(|probe| probe.as_ref().iter().any(|name| hashed_name(name)))
-            || reference.iter().flatten().any(|name| hashed_name(name));
+    fn between<S: AsRef<[String]>>(session: &[S], reference: &[Vec<String>]) -> Self {
         let (partners, candidates) = pair_probes(session, reference);
-        let mut vocabulary = Self {
-            global: Names::default(),
-            probes: vec![Names::default(); session.len()],
-            partners,
-            candidates,
-        };
-        if encoded_names {
-            let session = expand_lists(session);
-            let reference = expand_lists(reference);
-            let (expanded, candidates) = pair_probes(&session, &reference);
-            for (index, partner) in expanded.into_iter().enumerate() {
-                if vocabulary.partners[index].is_none()
-                    && partner.is_some()
-                    && !vocabulary.partners.contains(&partner)
-                {
-                    vocabulary.partners[index] = partner;
-                    vocabulary.candidates[index] = candidates[index];
-                }
-            }
-            vocabulary.align(
-                &without_common_names(&session),
-                &without_common_names(&reference),
-                true,
-            );
-        } else {
-            vocabulary.align(session, reference, false);
-        }
-        vocabulary
-    }
-
-    fn align<S: AsRef<[String]>>(
-        &mut self,
-        session: &[S],
-        reference: &[Vec<String>],
-        encoded: bool,
-    ) {
         let mut all = Votes::new();
-        for (position, strings) in session.iter().enumerate() {
-            let Some(partner) = self.partner(position) else {
-                continue;
-            };
+        let mut probes = Vec::with_capacity(session.len());
+        for (index, strings) in session.iter().enumerate() {
             let mut votes = Votes::new();
-            for pair in aligned_names(strings.as_ref(), &reference[partner - 1], encoded) {
-                *votes.entry(pair).or_default() += 1;
-                *all.entry(pair).or_default() += 1;
-            }
-            for (session, reference) in Names::one_to_one(&votes).to_reference {
-                self.probes[position].pair(session, reference);
+            if let Some(partner) = partners[index] {
+                for pair in aligned_names(strings.as_ref(), &reference[partner - 1]) {
+                    *votes.entry(pair).or_default() += 1;
+                    *all.entry(pair).or_default() += 1;
+                }
             }
+            probes.push(Names::one_to_one(&votes));
         }
-        for (session, reference) in Names::one_to_one(&all).to_reference {
-            self.global.pair(session, reference);
+        Self {
+            global: Names::one_to_one(&all),
+            probes,
+            partners,
+            candidates,
         }
     }
 
@@ -187,76 +121,6 @@ impl Vocabulary {
         }
     }
 
-    pub(crate) fn refine_outputs(
-        &mut self,
-        position: usize,
-        features: &[String],
-        writes: &[String],
-        internal: &[String],
-        common: &HashSet<&str>,
-        wanted: &[String],
-    ) {
-        let Some(partner) = self.partner(position) else {
-            return;
-        };
-        if !writes.iter().any(|name| hashed_name(name)) {
-            return;
-        }
-        let candidates: Vec<String> = writes
-            .iter()
-            .filter(|name| {
-                let reference = self.to_reference(position, name);
-                if !hashed_name(name)
-                    || common.contains(name.as_str())
-                    || (internal.contains(name) && !wanted.iter().any(|field| field == reference))
-                {
-                    return false;
-                }
-                reference == name.as_str() || wanted.iter().any(|field| field == reference)
-            })
-            .cloned()
-            .collect();
-        if candidates.len() == wanted.len()
-            && wanted.iter().zip(&candidates).all(|(name, candidate)| {
-                let mapped = self.to_session(position, name);
-                mapped == name || mapped == candidate
-            })
-        {
-            self.pin(
-                position,
-                candidates
-                    .iter()
-                    .cloned()
-                    .zip(wanted.iter().map(String::as_str)),
-            );
-        }
-        let keep = |text: &String, names: &[String]| !alignment_name(text) || names.contains(text);
-        let session: Vec<String> = features
-            .iter()
-            .filter(|text| keep(text, &candidates))
-            .cloned()
-            .collect();
-        let reference: Vec<String> = REFERENCE.probes[partner - 1]
-            .iter()
-            .filter(|text| keep(text, wanted))
-            .cloned()
-            .collect();
-        let mut votes = Votes::new();
-        for pair in aligned_names(&session, &reference, true) {
-            if candidates.iter().any(|name| name == pair.0)
-                && wanted.iter().any(|name| name == pair.1)
-            {
-                *votes.entry(pair).or_default() += 1;
-            }
-        }
-        for (session, reference) in Names::one_to_one(&votes).to_reference {
-            let mapped = self.to_session(position, &reference);
-            if mapped == reference || !writes.iter().any(|name| name == mapped) {
-                self.pin(position, [(session, reference.as_str())]);
-            }
-        }
-    }
-
     /// The number of the reference probe the session probe at `index` was paired with.
     #[must_use]
     pub fn partner(&self, index: usize) -> Option<usize> {
@@ -300,116 +164,28 @@ impl Vocabulary {
     }
 
     pub fn rewrite_to_reference(&self, index: usize, object: &mut JsObject) {
-        rewrite_object(object, &|text| {
-            rewrite_text(text, &|name| {
-                self.find(index, |names| &names.to_reference, name)
-            });
+        rewrite_object(object, &|name| {
+            self.find(index, |names| &names.to_reference, name)
         });
     }
 
     pub fn rewrite_to_session(&self, index: usize, object: &mut JsObject) {
-        rewrite_object(object, &|text| {
-            rewrite_text(text, &|name| {
-                self.find(index, |names| &names.to_session, name)
-            });
+        rewrite_object(object, &|name| {
+            self.find(index, |names| &names.to_session, name)
         });
     }
 }
 
-fn expand_lists<S: AsRef<[String]>>(probes: &[S]) -> Vec<Vec<String>> {
-    probes
-        .iter()
-        .map(|probe| {
-            let decoded: HashMap<&str, String> = probe
-                .as_ref()
-                .windows(2)
-                .filter_map(|pair| {
-                    let text = if pair[1] == "decodeURIComponent" {
-                        &pair[0]
-                    } else if pair[0] == "decodeURIComponent" {
-                        &pair[1]
-                    } else {
-                        return None;
-                    };
-                    let bytes = text.as_bytes();
-                    if bytes.iter().enumerate().any(|(at, byte)| {
-                        *byte == b'%'
-                            && !bytes
-                                .get(at + 1..at + 3)
-                                .is_some_and(|hex| hex.iter().all(u8::is_ascii_hexdigit))
-                    }) {
-                        return None;
-                    }
-                    let decoded = percent_encoding::percent_decode_str(text)
-                        .decode_utf8()
-                        .ok()?;
-                    (decoded != text.as_str()).then(|| (text.as_str(), decoded.into_owned()))
-                })
-                .collect();
-            let prepared: Vec<_> = probe
-                .as_ref()
-                .iter()
-                .map(|text| decoded.get(text.as_str()).unwrap_or(text).clone())
-                .collect();
-            let mut strings = prepared.as_slice();
-            let mut expanded = Vec::new();
-            while !strings.is_empty() {
-                if let [list, separator, method, ..] = strings
-                    && method == "split"
-                    && separator.chars().count() == 1
-                {
-                    let parts: Vec<_> = list.split(separator).collect();
-                    if parts.len() >= 3
-                        && parts.iter().all(|part| !part.is_empty())
-                        && (list.len() > 32 || parts.iter().all(|part| is_name(part)))
-                    {
-                        expanded.extend(parts.into_iter().map(str::to_owned));
-                        strings = &strings[3..];
-                        continue;
-                    }
-                }
-                expanded.push(strings[0].clone());
-                strings = &strings[1..];
-            }
-            expanded
-        })
-        .collect()
-}
-
-/// Inline decoders expose wrapper names previously held only in header registers.
-/// Those names belong to the common envelope and cannot align probe-specific fields.
-fn without_common_names<S: AsRef<[String]>>(probes: &[S]) -> Vec<Vec<String>> {
-    let mut common: HashSet<&str> = probes
-        .first()
-        .into_iter()
-        .flat_map(|probe| probe.as_ref())
-        .map(String::as_str)
-        .filter(|text| is_name(text))
-        .collect();
-    if probes.len() < 3 {
-        common.clear();
-    }
-    for probe in probes.iter().skip(1) {
-        common.retain(|name| probe.as_ref().iter().any(|text| text == name));
-    }
-    probes
-        .iter()
-        .map(|probe| {
-            probe
-                .as_ref()
-                .iter()
-                .filter(|text| !common.contains(text.as_str()))
-                .cloned()
-                .collect()
-        })
-        .collect()
-}
-
-/// Visits string values and object keys, preserving the recorded field order.
-fn rewrite(value: &mut JsValue, rename: &impl Fn(&mut String)) {
+/// Renames strings and object keys using `rename`, including randomized names inside longer
+/// strings, such as a list of names or a style rule's selector.
+fn rewrite<'a>(value: &mut JsValue, rename: &impl Fn(&str) -> Option<&'a String>) {
     match value {
         JsValue::String(text) => {
-            rename(text);
+            if let Some(name) = rename(text) {
+                *text = name.clone();
+            } else if let Some(renamed) = rename_embedded(text, rename) {
+                *text = renamed;
+            }
         }
         JsValue::Array(items) => {
             for item in items {
@@ -421,50 +197,34 @@ fn rewrite(value: &mut JsValue, rename: &impl Fn(&mut String)) {
     }
 }
 
-pub(crate) fn rewrite_object(object: &mut JsObject, rename: &impl Fn(&mut String)) {
-    for (mut key, mut item) in mem::take(object) {
-        rewrite(&mut item, rename);
-        rename(&mut key);
-        object.insert(key, item);
+/// Renames each randomized name `text` contains, wherever it starts. Names can adjoin other
+/// hex digits, as in `_<name><hash>_<name>`, so matches need no boundary. Returns `None` if
+/// nothing was renamed.
+fn rename_embedded<'a>(text: &str, rename: &impl Fn(&str) -> Option<&'a String>) -> Option<String> {
+    const LENGTH: usize = 25;
+    let mut renamed = String::with_capacity(text.len());
+    let mut copied = 0;
+    for (at, _) in text.match_indices('_') {
+        let candidate = text.get(at..at + LENGTH).filter(|name| is_hex_name(name));
+        if at >= copied
+            && let Some(name) = candidate.and_then(rename)
+        {
+            renamed.push_str(&text[copied..at]);
+            renamed.push_str(name);
+            copied = at + LENGTH;
+        }
     }
+    (copied > 0).then(|| {
+        renamed.push_str(&text[copied..]);
+        renamed
+    })
 }
 
-/// Session names also occur inside error messages, markup, property paths and digest inputs.
-/// Read replacements from the original string so a replacement is never renamed twice.
-fn rewrite_text<'a>(text: &mut String, rename: &impl Fn(&str) -> Option<&'a String>) {
-    if let Some(name) = rename(text) {
-        *text = name.clone();
-        return;
-    }
-    let mut result = String::with_capacity(text.len());
-    let mut at = 0;
-    while at < text.len() {
-        let rest = &text[at..];
-        let found = [25, 9, 8, 7, 6, 5, 4].into_iter().find_map(|length| {
-            let name = rest.get(..length)?;
-            let identifier = |c: char| c.is_alphanumeric() || matches!(c, '_' | '$');
-            let before = !text[..at].chars().next_back().is_some_and(identifier);
-            let after = !rest[length..].chars().next().is_some_and(identifier);
-            // Fingerprint strings can concatenate a name with a digest or counter. Keep
-            // those edge matches; inside a string, require a complete identifier.
-            if !hashed_name(name) && at != 0 && at + length != text.len() && !(before && after) {
-                return None;
-            }
-            is_name(name)
-                .then(|| rename(name))
-                .flatten()
-                .map(|replacement| (length, replacement))
-        });
-        if let Some((length, replacement)) = found {
-            result.push_str(replacement);
-            at += length;
-        } else {
-            let character = rest.chars().next().unwrap();
-            result.push(character);
-            at += character.len_utf8();
-        }
+fn rewrite_object<'a>(object: &mut JsObject, rename: &impl Fn(&str) -> Option<&'a String>) {
+    for (key, mut item) in mem::take(object) {
+        rewrite(&mut item, rename);
+        object.insert(rename(&key).cloned().unwrap_or(key), item);
     }
-    *text = result;
 }
 
 /// Chooses each name's pair with the most votes. Breaks ties by pair ordering so results are
@@ -577,11 +337,7 @@ fn is_log_message(text: &str) -> bool {
 /// Aligns probe string sequences and pairs names between shared anchors. Requires equal counts
 /// on both sides. Also compares differing strings at matching positions to recover embedded
 /// names.
-fn aligned_names<'a>(
-    session: &'a [String],
-    reference: &'a [String],
-    encoded: bool,
-) -> Vec<(&'a str, &'a str)> {
+fn aligned_names<'a>(session: &'a [String], reference: &'a [String]) -> Vec<(&'a str, &'a str)> {
     // Collapse repeated API loads so duplicate reads for one call do not split runs used to
     // align neighboring output names.
     let mut session: Vec<&str> = session.iter().map(String::as_str).collect();
@@ -597,16 +353,15 @@ fn aligned_names<'a>(
         .collect();
     let mut pairs = Vec::new();
     let (mut i, mut j) = (0, 0);
-    let name = if encoded { alignment_name } else { is_name };
     for run in matching_runs(&session, &reference) {
         let (mut left_names, left_texts): (Vec<_>, Vec<_>) = session[i..run.session]
             .iter()
             .copied()
-            .partition(|text| name(text));
+            .partition(|text| is_name(text));
         let (mut right_names, right_texts): (Vec<_>, Vec<_>) = reference[j..run.reference]
             .iter()
             .copied()
-            .partition(|text| name(text));
+            .partition(|text| is_name(text));
         // Repeats of a name in a row count once, even across non-name text.
         left_names.dedup();
         right_names.dedup();
@@ -646,18 +401,20 @@ fn embedded_names<'a>(session: &'a str, reference: &'a str) -> Vec<(&'a str, &'a
     names
 }
 
-/// Splits a string into alternating runs of ASCII letters and digits, and other characters.
+/// Splits a string into alternating runs of name bytes (see [`is_name_byte`]) and other bytes.
 fn tokens(text: &str) -> Vec<&str> {
     text.as_bytes()
-        .chunk_by(|left, right| {
-            (left.is_ascii_alphanumeric() || *left == b'_')
-                == (right.is_ascii_alphanumeric() || *right == b'_')
-        })
+        .chunk_by(|left, right| is_name_byte(*left) == is_name_byte(*right))
         // Boundaries fall only beside ASCII, never inside a UTF-8 character.
         .map(|part| std::str::from_utf8(part).expect("runs split only beside ASCII bytes"))
         .collect()
 }
 
+/// Name characters, including the `_` that starts hex names.
+fn is_name_byte(byte: u8) -> bool {
+    byte.is_ascii_alphanumeric() || byte == b'_'
+}
+
 /// A run of strings the session and reference sequences share.
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
 struct Run {
@@ -741,44 +498,27 @@ fn longest_run(
     best
 }
 
-/// Whether a string could be one of the program's randomized names.
-fn alignment_name(text: &str) -> bool {
-    if matches!(
-        text,
-        "Array"
-            | "Boolean"
-            | "Date"
-            | "Error"
-            | "Function"
-            | "JSON"
-            | "Math"
-            | "Number"
-            | "Object"
-            | "Promise"
-            | "Reflect"
-            | "String"
-            | "Symbol"
-    ) {
-        return false;
-    }
-    is_name(text)
-}
-
-pub(crate) fn hashed_name(text: &str) -> bool {
-    text.strip_prefix('_')
-        .is_some_and(|hex| hex.len() == 24 && hex.bytes().all(|byte| byte.is_ascii_hexdigit()))
+/// Whether a string could be one of the program's randomized names: four to nine letters and
+/// digits such as `XNWt6`, or a hex name (see [`is_hex_name`]).
+fn is_name(text: &str) -> bool {
+    is_hex_name(text)
+        || ((4..=9).contains(&text.len())
+            && text.starts_with(|c: char| c.is_ascii_alphabetic())
+            && text.chars().all(|c| c.is_ascii_alphanumeric())
+            && text
+                .chars()
+                .any(|c| c.is_ascii_uppercase() || c.is_ascii_digit()))
 }
 
-pub(crate) fn is_name(text: &str) -> bool {
-    if hashed_name(text) {
-        return true;
-    }
-    (4..=9).contains(&text.len())
-        && text.starts_with(|c: char| c.is_ascii_alphabetic())
-        && text.chars().all(|c| c.is_ascii_alphanumeric())
-        && text
-            .chars()
-            .any(|c| c.is_ascii_uppercase() || c.is_ascii_digit())
+/// Whether `text` is a randomized name in the form newer builds use: `_` and 24 lowercase hex
+/// digits, such as `_2b78d2cde0fa83bfaec4edae`.
+pub(crate) fn is_hex_name(text: &str) -> bool {
+    text.strip_prefix('_').is_some_and(|hex| {
+        hex.len() == 24
+            && hex
+                .bytes()
+                .all(|byte| matches!(byte, b'0'..=b'9' | b'a'..=b'f'))
+    })
 }
 
 #[cfg(test)]
@@ -786,72 +526,42 @@ mod tests {
     use super::*;
     use crate::js::json;
 
-    #[test]
-    fn rewrites_embedded_names_once_and_preserves_unicode() {
-        let names = HashMap::from([
-            ("_0123456789abcdef01234567".to_owned(), "Abcd1".to_owned()),
-            ("Abcd1".to_owned(), "Efgh2".to_owned()),
-        ]);
-        let mut text = "é😀<p>_0123456789abcdef01234567</p>o.Abcd1".to_owned();
-        rewrite_text(&mut text, &|name| names.get(name));
-        assert_eq!(text, "é😀<p>Abcd1</p>o.Efgh2");
-        for original in ["abcAbcd1xyz", "prefix_Abcd1_suffix", "$Abcd1$", "πAbcd1中"] {
-            let mut opaque = original.to_owned();
-            rewrite_text(&mut opaque, &|name| names.get(name));
-            assert_eq!(opaque, original);
-        }
-        let mut fingerprint = "Abcd1611".to_owned();
-        rewrite_text(&mut fingerprint, &|name| names.get(name));
-        assert_eq!(fingerprint, "Efgh2611");
-    }
-
     #[test]
     fn token_boundaries_preserve_non_ascii_markup() {
+        // `_` belongs to names, as in hex names.
         assert_eq!(tokens("é😀Aa12-中_foo"), ["é😀", "Aa12", "-中", "_foo"]);
     }
 
-    fn strings(text: &str) -> Vec<String> {
-        text.split(' ').map(str::to_owned).collect()
-    }
-
-    #[test]
-    fn packed_names_align_in_both_directions_across_identifier_formats() {
-        let packed = "%41%61%61%61%31%7c%42%62%62%62%32%7c%43%63%63%63%33";
-        let short = [strings(&format!(
-            "Intl ListFormat style long type disjunction format {packed} decodeURIComponent {packed} | split | format Result1"
-        ))];
-        let hashed = [strings(
-            "Intl ListFormat style long type disjunction format _111111111111111111111111 _222222222222222222222222 _333333333333333333333333 format _444444444444444444444444",
-        )];
-        for (session, reference, expected) in [
-            (&short, &hashed, ("Aaaa1", "_111111111111111111111111")),
-            (&hashed, &short, ("_111111111111111111111111", "Aaaa1")),
-        ] {
-            let vocabulary = Vocabulary::between(session, reference);
-            assert_eq!(vocabulary.to_reference(0, expected.0), expected.1);
-            assert_eq!(vocabulary.to_session(0, expected.1), expected.0);
-        }
-    }
-
     #[test]
-    fn expands_only_valid_decoded_name_lists() {
-        let valid = "%41%61%61%61%31%7c%42%62%62%62%32%7c%43%63%63%63%33";
-        let features = strings(&format!("{valid} decodeURIComponent {valid} | split"));
-        let expanded = expand_lists(&[features]);
-        assert_eq!(&expanded[0][2..], ["Aaaa1", "Bbbb2", "Cccc3"]);
-        let fonts = vec![
-            strings("Sample Sans|Sample Serif|Sample Monospace").join(" "),
-            "|".into(),
-            "split".into(),
-        ];
+    fn renames_names_inside_longer_strings() {
+        let name = |digit: &str| format!("_{}", digit.repeat(24));
+        let (a, b, c, x, y) = (name("a"), name("b"), name("c"), name("1"), name("2"));
+        let rename = |name: &str| match name {
+            name if name == a => Some(&x),
+            name if name == b => Some(&y),
+            _ => None,
+        };
+        let mut value = json!({
+            "list": format!("{a}, {b}, or {c}"),
+            "rule": format!(".{a} {{ color: red; }}"),
+            "joined": format!("{a}c52d060a{b}"),
+            "whole": a.clone(),
+        });
+        rewrite(&mut value, &rename);
         assert_eq!(
-            expand_lists(&[fonts])[0],
-            ["Sample Sans", "Sample Serif", "Sample Monospace"]
+            value,
+            json!({
+                "list": format!("{x}, {y}, or {c}"),
+                "rule": format!(".{x} {{ color: red; }}"),
+                "joined": format!("{x}c52d060a{y}"),
+                "whole": x.clone(),
+            }),
+            "names without a pair stay, and names adjoining hex digits are renamed"
         );
-        for text in ["%41%", "%41%xx", "%FF", "Aaaa1|Bbbb2", "Aaaa1||Cccc3"] {
-            let features = strings(&format!("{text} decodeURIComponent {text} | split"));
-            assert_eq!(expand_lists(std::slice::from_ref(&features))[0], features);
-        }
+    }
+
+    fn strings(text: &str) -> Vec<String> {
+        text.split(' ').map(str::to_owned).collect()
     }
 
     #[test]
@@ -899,7 +609,7 @@ mod tests {
         ];
         for (session, reference, expected) in cases {
             assert_eq!(
-                aligned_names(&strings(session), &strings(reference), false),
+                aligned_names(&strings(session), &strings(reference)),
                 expected
             );
         }

data/vendor/cfsolve/src/stage2.rs

@@ -9,6 +9,7 @@
 //! are assembled from recovered [`payload::Layout`] data.
 
 pub mod analysis;
+mod audit_globals;
 pub(crate) mod benchmark;
 pub mod call_stack;
 pub(crate) mod challenge_page;
@@ -20,7 +21,7 @@ pub mod records;
 pub(crate) mod reference;
 pub mod registry;
 pub mod replay;
-pub(crate) mod session_names;
+mod stylesheets;
 pub mod trace;
 pub mod vocabulary;
 mod worker_timing;