cfsolve 0.1.1 → 0.1.2

data/vendor/cfsolve/src/stage2/analysis/outputs.rs

@@ -1,327 +0,0 @@
-//! Recovers result fields whose reference names are held in header registers rather than
-//! appearing among a probe's collection strings.
-
-use std::collections::{BTreeMap, BTreeSet};
-
-use indexmap::IndexMap;
-use swc_core::ecma::ast::BinaryOp;
-
-use crate::listing::Index;
-use crate::stage2::reference::{
-    COMPUTED_STYLE_MAP, FONT_CANVAS_OUTPUTS, FONT_DOM_OUTPUTS, FONT_FACE_OUTPUTS,
-    NATIVE_INSPECTION_OUTPUTS,
-};
-use crate::stage2::{registry::Kind, vocabulary::hashed_name};
-use crate::vm::{Constant, Term};
-
-#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
-enum Object {
-    Created(u32),
-    Property(u32),
-    Cell(u32),
-}
-
-#[derive(Default)]
-struct Fields(IndexMap<String, Vec<Term>>);
-
-impl Fields {
-    fn push(&mut self, name: &str, value: Option<Term>) {
-        self.0.entry(name.to_owned()).or_default().extend(value);
-    }
-
-    fn has(&self, position: usize, predicate: impl Fn(&Term) -> bool) -> bool {
-        self.0
-            .get_index(position)
-            .is_some_and(|(_, values)| values.iter().any(predicate))
-    }
-}
-
-pub(super) fn names(
-    index: &Index<'_>,
-    entry: u32,
-    reference: usize,
-    common: &BTreeSet<String>,
-) -> Vec<(String, &'static str)> {
-    let Some(
-        kind @ (Kind::NativeInspection
-        | Kind::FontEnumeration
-        | Kind::ComputedStyleHash
-        | Kind::Rects),
-    ) = Kind::from_reference(reference)
-    else {
-        return Vec::new();
-    };
-    let reached = index.reachable(entry);
-    if kind == Kind::Rects {
-        let roles = [
-            ("bottom", "Cmnj0"),
-            ("height", "VwYDD8"),
-            ("left", "knUS7"),
-            ("right", "cyNU4"),
-            ("top", "nCLYc7"),
-            ("width", "UCluM4"),
-            ("x", "YptYf3"),
-            ("y", "wAVRH3"),
-        ];
-        return roles
-            .into_iter()
-            .filter_map(|(property, reference)| {
-                let names: BTreeSet<_> = index
-                    .stores()
-                    .iter()
-                    .filter(|store| {
-                        reached.contains(&store.pc)
-                            && hashed_name(&store.key)
-                            && index.method(store.pc, &store.value).as_deref() == Some(property)
-                    })
-                    .map(|store| store.key.clone())
-                    .collect();
-                (names.len() == 1).then(|| (names.into_iter().next().unwrap(), reference))
-            })
-            .collect();
-    }
-    let mut groups = BTreeMap::<Object, Fields>::new();
-    for store in index
-        .stores()
-        .iter()
-        .filter(|store| reached.contains(&store.pc))
-    {
-        if !hashed_name(&store.key) || common.contains(&store.key) {
-            continue;
-        }
-        let Some((origin, object)) = index.dereference(store.pc, &Term::Reg(store.object)) else {
-            continue;
-        };
-        let object = match object {
-            Term::Object(_) => Object::Created(origin),
-            Term::Get(_, _) => Object::Property(origin),
-            Term::Cell(cell) => Object::Cell(cell),
-            _ => continue,
-        };
-        let value = index
-            .dereference(store.pc, &store.value)
-            .map(|(_, value)| value);
-        groups.entry(object).or_default().push(&store.key, value);
-    }
-    let mut pairs = Vec::new();
-    let mut pin = |candidates: Vec<&Fields>, names: &[&'static str]| {
-        if let [fields] = candidates.as_slice() {
-            pairs.extend(
-                fields
-                    .0
-                    .keys()
-                    .take(names.len())
-                    .cloned()
-                    .zip(names.iter().copied()),
-            );
-        }
-    };
-    match kind {
-        Kind::NativeInspection => pin(
-            groups
-                .iter()
-                .filter_map(|(object, fields)| {
-                    (matches!(object, Object::Property(_)) && fields.0.len() == 5).then_some(fields)
-                })
-                .collect(),
-            &NATIVE_INSPECTION_OUTPUTS,
-        ),
-        Kind::ComputedStyleHash => pin(
-            groups
-                .iter()
-                .filter_map(|(object, fields)| {
-                    (matches!(object, Object::Property(_)) && fields.0.len() == 1).then_some(fields)
-                })
-                .collect(),
-            &[COMPUTED_STYLE_MAP],
-        ),
-        Kind::FontEnumeration => {
-            // FontFace's fallback is a list, a count, a status, a hash and an error.
-            pin(
-                groups
-                    .iter()
-                    .filter_map(|(object, fields)| {
-                        (matches!(object, Object::Created(_))
-                            && fields.0.len() == 5
-                            && fields.has(
-                                0,
-                                |value| matches!(value, Term::Array(values) if values.is_empty()),
-                            )
-                            && fields.has(1, |value| {
-                                matches!(value, Term::Const(Constant::Number(0.0)))
-                            }))
-                        .then_some(fields)
-                    })
-                    .collect(),
-                &FONT_FACE_OUTPUTS,
-            );
-            // Canvas measurements have three array defaults.
-            pin(
-                groups
-                    .iter()
-                    .filter_map(|(object, fields)| {
-                        let arrays = (0..3).all(|position| {
-                            fields.has(
-                                position,
-                                |value| matches!(value, Term::Array(values) if values.is_empty()),
-                            )
-                        });
-                        (matches!(object, Object::Created(_)) && fields.0.len() == 3 && arrays)
-                            .then_some(fields)
-                    })
-                    .collect(),
-                &FONT_CANVAS_OUTPUTS,
-            );
-            // The DOM measurement callback writes an array and a sum into its shared result.
-            pin(
-                groups
-                    .iter()
-                    .filter_map(|(object, fields)| {
-                        (matches!(object, Object::Cell(_))
-                            && fields.0.len() == 2
-                            && fields.has(
-                                0,
-                                |value| matches!(value, Term::Array(values) if values.is_empty()),
-                            )
-                            && fields.has(1, |value| {
-                                matches!(value, Term::Binary(BinaryOp::Add, _, _))
-                            }))
-                        .then_some(fields)
-                    })
-                    .collect(),
-                &FONT_DOM_OUTPUTS,
-            );
-        }
-        _ => {}
-    }
-    pairs
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::vm::{Effect, Exit, Instruction, Listing, Path};
-
-    fn listing(groups: &[(Term, Vec<Term>)]) -> Listing {
-        let mut effects = Vec::new();
-        for (group, (object, values)) in groups.iter().enumerate() {
-            effects.push(Effect::Set(1, object.clone()));
-            for (position, value) in values.iter().enumerate() {
-                effects.push(Effect::SetProperty {
-                    object: Box::new(Term::Reg(1)),
-                    key: Box::new(Term::Const(Constant::String(format!(
-                        "_{:024x}",
-                        group * 10 + position
-                    )))),
-                    value: Box::new(value.clone()),
-                });
-            }
-        }
-        let count = effects.len();
-        let instructions = effects
-            .into_iter()
-            .enumerate()
-            .map(|(pc, effect)| {
-                (
-                    pc as u32,
-                    Instruction {
-                        pc: pc as u32,
-                        key: 0,
-                        opcode: 0,
-                        paths: vec![Path {
-                            conditions: vec![],
-                            effects: vec![effect],
-                            exit: if pc + 1 == count {
-                                Exit::Return
-                            } else {
-                                Exit::Next {
-                                    pc: pc as u32 + 1,
-                                    key: 0,
-                                }
-                            },
-                        }],
-                    },
-                )
-            })
-            .collect();
-        Listing {
-            instructions,
-            ..Listing::default()
-        }
-    }
-
-    #[test]
-    fn recovers_font_roles_from_distinct_object_shapes_and_rejects_ambiguity() {
-        let empty = Term::Array(vec![]);
-        let zero = Term::Const(Constant::Number(0.0));
-        let face = (
-            Term::Object(vec![]),
-            vec![
-                empty.clone(),
-                zero.clone(),
-                zero.clone(),
-                zero.clone(),
-                zero.clone(),
-            ],
-        );
-        let mut groups = vec![
-            face.clone(),
-            (Term::Object(vec![]), vec![empty.clone(); 3]),
-            (
-                Term::Cell(8),
-                vec![
-                    empty,
-                    Term::Binary(BinaryOp::Add, Box::new(Term::Reg(9)), Box::new(zero)),
-                ],
-            ),
-        ];
-        let reference = Kind::FontEnumeration.references()[0];
-        let program = listing(&groups);
-        let pairs = names(&Index::new(&program), 0, reference, &BTreeSet::new());
-        let expected: Vec<_> = FONT_FACE_OUTPUTS
-            .into_iter()
-            .chain(FONT_CANVAS_OUTPUTS)
-            .chain(FONT_DOM_OUTPUTS)
-            .collect();
-        assert_eq!(
-            pairs
-                .iter()
-                .map(|(_, reference)| *reference)
-                .collect::<Vec<_>>(),
-            expected
-        );
-        groups.push(face);
-        let program = listing(&groups);
-        let pairs = names(&Index::new(&program), 0, reference, &BTreeSet::new());
-        assert!(
-            pairs
-                .iter()
-                .all(|(_, field)| !FONT_FACE_OUTPUTS.contains(field))
-        );
-        assert_eq!(
-            pairs.len(),
-            FONT_CANVAS_OUTPUTS.len() + FONT_DOM_OUTPUTS.len()
-        );
-    }
-
-    #[test]
-    fn native_inspection_requires_a_unique_result_object() {
-        let object = Term::Get(
-            Box::new(Term::Cell(8)),
-            Box::new(Term::Const(Constant::String("result".into()))),
-        );
-        let group = (object, vec![Term::Const(Constant::Null); 5]);
-        let program = listing(std::slice::from_ref(&group));
-        let reference = Kind::NativeInspection.references()[0];
-        let pairs = names(&Index::new(&program), 0, reference, &BTreeSet::new());
-        assert_eq!(
-            pairs
-                .iter()
-                .map(|(_, reference)| *reference)
-                .collect::<Vec<_>>(),
-            NATIVE_INSPECTION_OUTPUTS
-        );
-        let program = listing(&[group.clone(), group]);
-        assert!(names(&Index::new(&program), 0, reference, &BTreeSet::new()).is_empty());
-    }
-}

data/vendor/cfsolve/src/stage2/probes/stylesheets.rs

@@ -1,249 +0,0 @@
-//! Replays captured CSSOM formatting after validating a stylesheet's structure.
-
-use anyhow::{Context, Result, bail, ensure};
-use regex::Regex;
-use serde::{Deserialize, Serialize};
-use sha2::{Digest, Sha256};
-use std::collections::BTreeMap;
-use std::sync::LazyLock;
-
-use crate::stage2::{
-    records::Probe,
-    reference::{STYLESHEET_DIGEST, STYLESHEET_MARKER},
-    vocabulary,
-};
-use crate::{
-    candidates,
-    js::{JsObject, json},
-};
-
-static SESSION_NAME: LazyLock<Regex> =
-    LazyLock::new(|| Regex::new(r"_[0-9a-fA-F]{24}|[A-Za-z]{3,5}[0-9]").unwrap());
-
-/// Source text paired with the rules the profile's browser exposed through CSSOM.
-#[derive(Clone, Debug, Deserialize, Serialize)]
-pub struct Sheet {
-    pub source: String,
-    pub rules: Vec<String>,
-}
-
-/// One captured stylesheet revision. Multiple revisions can share a device profile.
-#[derive(Clone, Debug, Deserialize, Serialize)]
-pub struct Snapshot {
-    pub sheets: Vec<Sheet>,
-}
-
-impl Snapshot {
-    pub fn capture(html: &str, rules: Vec<Vec<String>>) -> Result<Self> {
-        let sources = sources(html);
-        ensure!(
-            sources.len() == rules.len(),
-            "CSSOM rule lists do not match the iframe's stylesheets"
-        );
-        Ok(Self {
-            sheets: sources
-                .into_iter()
-                .zip(rules)
-                .map(|(source, rules)| Sheet { source, rules })
-                .collect(),
-        })
-    }
-
-    /// Requires identical text outside randomized names and a consistent one-to-one name map.
-    pub fn replay(&self, sources: &[String]) -> Result<Vec<Vec<String>>> {
-        ensure!(
-            sources.len() == self.sheets.len(),
-            "stylesheet count changed"
-        );
-        let mut names = BTreeMap::new();
-        let mut reverse = BTreeMap::new();
-        for (sheet, current) in self.sheets.iter().zip(sources) {
-            ensure!(
-                SESSION_NAME
-                    .split(&sheet.source)
-                    .eq(SESSION_NAME.split(current)),
-                "stylesheet structure changed"
-            );
-            for (old, new) in SESSION_NAME
-                .find_iter(&sheet.source)
-                .zip(SESSION_NAME.find_iter(current))
-            {
-                let (old, new) = (old.as_str(), new.as_str());
-                ensure!(
-                    names
-                        .insert(old, new)
-                        .is_none_or(|previous| previous == new),
-                    "inconsistent stylesheet name"
-                );
-                ensure!(
-                    reverse
-                        .insert(new, old)
-                        .is_none_or(|previous| previous == old),
-                    "ambiguous stylesheet name"
-                );
-            }
-        }
-        Ok(self
-            .sheets
-            .iter()
-            .map(|sheet| {
-                sheet
-                    .rules
-                    .iter()
-                    .map(|rule| {
-                        SESSION_NAME
-                            .replace_all(rule, |captures: &regex::Captures<'_>| {
-                                names
-                                    .get(&captures[0])
-                                    .copied()
-                                    .unwrap_or(&captures[0])
-                                    .to_owned()
-                            })
-                            .into_owned()
-                    })
-                    .collect()
-            })
-            .collect())
-    }
-}
-
-#[must_use]
-pub(crate) fn sources(html: &str) -> Vec<String> {
-    let document = scraper::Html::parse_document(html);
-    let selector = scraper::Selector::parse("style").unwrap();
-    document
-        .select(&selector)
-        .map(|style| style.inner_html())
-        .collect()
-}
-
-/// Updates the stored fields before replay translates reference names and arranges the record.
-pub(crate) fn refresh(
-    snapshots: &[Snapshot],
-    probe: &Probe,
-    html: &str,
-    fields: &mut JsObject,
-) -> Result<()> {
-    let markers = probe
-        .features
-        .iter()
-        .filter(|text| text.strip_prefix('.').is_some_and(vocabulary::is_name));
-    let marker = candidates::at_most_one_distinct(markers, "stylesheet marker")?
-        .context("no stylesheet marker")?;
-    let (digest, marker_css) = measurement(snapshots, html, marker)?;
-    for (field, value) in [(STYLESHEET_DIGEST, digest), (STYLESHEET_MARKER, marker_css)] {
-        *fields
-            .get_mut(field)
-            .with_context(|| format!("missing stylesheet field {field}"))? = json!(value);
-    }
-    Ok(())
-}
-
-fn measurement(snapshots: &[Snapshot], html: &str, marker: &str) -> Result<(String, String)> {
-    let sources = sources(html);
-    for snapshot in snapshots {
-        let Ok(sheets) = snapshot.replay(&sources) else {
-            continue;
-        };
-        let mut marker_text = None;
-        let mut measured = Vec::new();
-        for (index, rules) in sheets.iter().enumerate() {
-            let text = rules.join("|");
-            let indexed = format!("{text}{index}");
-            if text.contains(marker) {
-                ensure!(
-                    marker_text.replace(indexed).is_none(),
-                    "multiple marker stylesheets"
-                );
-            } else {
-                measured.push(indexed);
-            }
-        }
-        let marker_text = marker_text.context("the current marker stylesheet is absent")?;
-        let digest = format!("{:x}", Sha256::digest(measured.join("|").as_bytes()));
-        return Ok((digest[..32].to_owned(), marker_text));
-    }
-    bail!("no captured stylesheet revision matches the current iframe")
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn refreshes_names_in_browser_serialized_rules_without_running_a_browser() {
-        let snapshot = Snapshot {
-            sheets: vec![Sheet {
-                source: ".Abcd1{margin:0}.Abcd1 .Efgh2{color:red}".into(),
-                rules: vec![
-                    ".Abcd1 { margin: 0px; }".into(),
-                    ".Abcd1 .Efgh2 { color: red; }".into(),
-                ],
-            }],
-        };
-        assert_eq!(
-            snapshot
-                .replay(&[".Ijkl3{margin:0}.Ijkl3 .Mnop4{color:red}".into()])
-                .unwrap(),
-            [vec![
-                ".Ijkl3 { margin: 0px; }",
-                ".Ijkl3 .Mnop4 { color: red; }"
-            ]]
-        );
-        assert!(
-            snapshot
-                .replay(&[".Ijkl3{margin:1}.Ijkl3 .Mnop4{color:red}".into()])
-                .is_err()
-        );
-        assert!(
-            snapshot
-                .replay(&[".Ijkl3{margin:0}.Mnop4 .Qrst5{color:red}".into()])
-                .is_err()
-        );
-        assert!(
-            snapshot
-                .replay(&[".Ijkl3{margin:0}.Ijkl3 .Ijkl3{color:red}".into()])
-                .is_err()
-        );
-        assert!(snapshot.replay(&[]).is_err());
-    }
-
-    #[test]
-    fn measures_current_rules_and_excludes_the_marker_sheet() {
-        let html = "<style>.Abcd1{color:red}</style><style>.Efgh2{margin:0}</style>";
-        let snapshot = Snapshot::capture(
-            html,
-            vec![
-                vec![".Abcd1 { color: red; }".into()],
-                vec![".Efgh2 { margin: 0px; }".into()],
-            ],
-        )
-        .unwrap();
-        let fresh = "<style>.Ijkl3{color:red}</style><style>.Mnop4{margin:0}</style>";
-        let (hash, marker) = measurement(std::slice::from_ref(&snapshot), fresh, ".Mnop4").unwrap();
-        assert_eq!(
-            hash,
-            format!("{:x}", Sha256::digest(b".Ijkl3 { color: red; }0"))[..32]
-        );
-        assert_eq!(marker, ".Mnop4 { margin: 0px; }1");
-        assert!(measurement(&[snapshot], fresh, ".Missing5").is_err());
-        assert!(measurement(&[], fresh, ".Mnop4").is_err());
-        assert!(Snapshot::capture(html, vec![]).is_err());
-        let duplicate = Snapshot::capture(
-            "<style>.Abcd1{color:red}</style><style>.Abcd1{margin:0}</style>",
-            vec![
-                vec![".Abcd1 { color: red; }".into()],
-                vec![".Abcd1 { margin: 0px; }".into()],
-            ],
-        )
-        .unwrap();
-        assert!(
-            measurement(
-                &[duplicate],
-                "<style>.Abcd1{color:red}</style><style>.Abcd1{margin:0}</style>",
-                ".Abcd1"
-            )
-            .is_err()
-        );
-    }
-}