@prospective.co/procss 0.1.8

package/src/js_builder.rs

@@ -0,0 +1,59 @@
+// ┌───────────────────────────────────────────────────────────────────────────┐
+// │                                                                           │
+// │  ██████╗ ██████╗  ██████╗   Copyright (C) 2022, The Prospective Company   │
+// │  ██╔══██╗██╔══██╗██╔═══██╗                                                │
+// │  ██████╔╝██████╔╝██║   ██║  This file is part of the Procss library,      │
+// │  ██╔═══╝ ██╔══██╗██║   ██║  distributed under the terms of the            │
+// │  ██║     ██║  ██║╚██████╔╝  Apache License 2.0.  The full license can     │
+// │  ╚═╝     ╚═╝  ╚═╝ ╚═════╝   be found in the LICENSE file.                 │
+// │                                                                           │
+// └───────────────────────────────────────────────────────────────────────────┘
+
+use std::collections::HashMap;
+
+use wasm_bindgen::prelude::*;
+use wasm_bindgen::JsValue;
+
+/// An implementation of `BuildCss` which owns its data, suitable for use as an
+/// exported type in JavaScript.
+#[wasm_bindgen]
+pub struct BuildCss {
+    rootdir: String,
+    inputs: HashMap<String, String>,
+}
+
+#[wasm_bindgen]
+impl BuildCss {
+    #[wasm_bindgen(constructor)]
+    pub fn new(rootdir: String) -> Self {
+        BuildCss {
+            rootdir,
+            inputs: HashMap::default(),
+        }
+    }
+
+    pub fn add(&mut self, path: String, content: String) {
+        self.inputs.insert(path, content);
+    }
+
+    pub fn compile(&self) -> core::result::Result<JsValue, JsError> {
+        let mut build = crate::builder::BuildCss::new(self.rootdir.clone());
+        for (k, v) in self.inputs.iter() {
+            build.add_content(k, v.clone());
+        }
+
+        Ok(serde_wasm_bindgen::to_value(
+            &build.compile().into_jserr()?.as_strings().into_jserr()?,
+        )?)
+    }
+}
+
+trait IntoJsError<T> {
+    fn into_jserr(self) -> Result<T, wasm_bindgen::JsError>;
+}
+
+impl<T> IntoJsError<T> for Result<T, anyhow::Error> {
+    fn into_jserr(self) -> Result<T, wasm_bindgen::JsError> {
+        self.map_err(|x| JsError::from(x.root_cause()))
+    }
+}

package/src/lib.rs

@@ -0,0 +1,151 @@
+// ┌───────────────────────────────────────────────────────────────────────────┐
+// │                                                                           │
+// │  ██████╗ ██████╗  ██████╗   Copyright (C) 2022, The Prospective Company   │
+// │  ██╔══██╗██╔══██╗██╔═══██╗                                                │
+// │  ██████╔╝██████╔╝██║   ██║  This file is part of the Procss library,      │
+// │  ██╔═══╝ ██╔══██╗██║   ██║  distributed under the terms of the            │
+// │  ██║     ██║  ██║╚██████╔╝  Apache License 2.0.  The full license can     │
+// │  ╚═╝     ╚═╝  ╚═╝ ╚═════╝   be found in the LICENSE file.                 │
+// │                                                                           │
+// └───────────────────────────────────────────────────────────────────────────┘
+
+//! A simple CSS parsing and transformation framework. Procss can be used to
+//! quickly bundle a collection of CSS+ files, or write your own custom
+//! transforms.
+//!
+//! # Usage
+//!
+//! Procss's parser understands a nested superset of CSS (which we refer to as
+//! CSS+), similar to the [CSS nesting proposal](https://www.w3.org/TR/css-nesting-1/),
+//! or languages like [Sass](https://sass-lang.com).  Start with source CSS+
+//! as a [`str`], use [crate::parse] or [crate::parse_unchecked] to generate
+//! an [`ast::Tree`].
+//!
+//! ```
+//! use procss::{ast, parse};
+//!
+//! let ast = procss::parse("div{.open{color:red;}}").unwrap();
+//! ```
+//!
+//! The resulting [`ast::Tree`] can be converted to a de-nested [`ast::Css`]
+//! with the [`ast::Tree::flatten_tree`] method, which itself can then be
+//! rendered as a plain browser-readable CSS string via the
+//! [`RenderCss::as_css_string`] trait method.
+//!
+//! ```
+//! # use procss::{parse, ast};
+//! # let ast = procss::parse("div{.open{color:red;}}").unwrap();
+//! use procss::RenderCss;
+//!
+//! let flat: ast::Css = ast.flatten_tree();
+//! let css: String = flat.as_css_string();
+//! assert_eq!(css, "div .open{color:red;}");
+//! ```
+//!
+//! Intermediate structs [`ast::Css::transform`] amd [`ast::Tree::transform`]
+//! can be used to recursively mutate a tree for a variety of node structs in
+//! the [`ast`] module.  Some useful Example of such transforms can be
+//! found in the [`transformers`] module.
+//!
+//! ```
+//! # use procss::{parse, RenderCss};
+//! use procss::transformers;
+//!
+//! let test = "
+//! @mixin test {color: red;}
+//! div {@include test;}
+//! ";
+//!
+//! let mut ast = procss::parse(test).unwrap();
+//! transformers::apply_mixin(&mut ast);
+//! let flat = ast.flatten_tree().as_css_string();
+//! assert_eq!(flat, "div{color:red;}");
+//! ```
+//!
+//! For coordinating large builds on a tree of CSS files, the [`BuildCss`]
+//! struct can parse and minify, applying all transforms (including
+//! [`transformers::apply_import`]) as the compilation is left-folded over the
+//! inputs.
+//!
+//! ```no_run
+//! let mut build = procss::BuildCss::new("./src");
+//! build.add_file("controls/menu.scss");
+//! build.add_file("logout.scss"); // imports "controls/menu.scss"
+//! build.add_file("my_app.scss"); // imports "controls/menu.scss" and "logout.scss"
+//! build.compile().unwrap().write("./dist").unwrap();
+//! ```
+
+#![feature(assert_matches)]
+#![feature(path_file_prefix)]
+
+pub mod ast;
+mod builder;
+#[cfg(target_arch = "wasm32")]
+mod js_builder;
+mod parser;
+mod render;
+mod transform;
+pub mod transformers;
+mod utils;
+
+use self::ast::Tree;
+pub use self::builder::BuildCss;
+use self::parser::{unwrap_parse_error, ParseCss};
+pub use self::render::RenderCss;
+
+/// Parse CSS text to a [`Tree`] (where it can be further manipulated),
+/// capturing detailed error reporting for a moderate performance impact (using
+/// [`nom::error::VerboseError`]).
+///
+/// # Example
+///
+/// ```rust
+/// let ast = procss::parse("div { .open { color: red; }}").unwrap();
+/// ```
+pub fn parse(input: &str) -> anyhow::Result<Tree<'_>> {
+    let (_, tree) = Tree::parse(input).map_err(|err| unwrap_parse_error(input, err))?;
+    Ok(tree)
+}
+
+/// Parse CSS text to a [`Tree`], without capturing error details, for maximum
+/// performance without any error details when parsing fails.
+///
+/// # Example
+///
+/// ```rust
+/// let ast = procss::parse_unchecked("div { .open { color: red; }}").unwrap();
+/// ```
+pub fn parse_unchecked(input: &str) -> anyhow::Result<Tree<'_>> {
+    let (_, tree) = Tree::parse::<()>(input)?;
+    Ok(tree)
+}
+
+#[cfg(test)]
+mod tests {
+    use std::assert_matches::assert_matches;
+
+    use super::*;
+
+    #[test]
+    fn test_verbose_error() {
+        assert_matches!(
+            parse("div{color:red").map(|x| x.as_css_string()).as_deref(),
+            Err(_)
+        )
+    }
+
+    #[test]
+    fn test_parse_unchecked() {
+        assert_matches!(
+            parse_unchecked("div{color:red}")
+                .map(|x| x.as_css_string())
+                .as_deref(),
+            Ok("div{color:red;}")
+        )
+    }
+}
+
+// `iotest` feature flag stubs out disk-accessing and other performance
+// neutering function
+#[cfg(all(not(feature = "iotest"), test))]
+compile_error!("Feature 'iotest' must be enabled, rerun with:\n\n> cargo xtest");

package/src/main.rs

@@ -0,0 +1,40 @@
+// ┌───────────────────────────────────────────────────────────────────────────┐
+// │                                                                           │
+// │  ██████╗ ██████╗  ██████╗   Copyright (C) 2022, The Prospective Company   │
+// │  ██╔══██╗██╔══██╗██╔═══██╗                                                │
+// │  ██████╔╝██████╔╝██║   ██║  This file is part of the Procss library,      │
+// │  ██╔═══╝ ██╔══██╗██║   ██║  distributed under the terms of the            │
+// │  ██║     ██║  ██║╚██████╔╝  Apache License 2.0.  The full license can     │
+// │  ╚═╝     ╚═╝  ╚═╝ ╚═════╝   be found in the LICENSE file.                 │
+// │                                                                           │
+// └───────────────────────────────────────────────────────────────────────────┘
+
+/// This needs to be here or the wasm build will not export any library symbols.
+#[allow(unused_imports)]
+use procss::*;
+
+#[cfg(not(target_arch = "wasm32"))]
+mod init {
+    use std::path::Path;
+    use std::{env, fs};
+
+    use procss::*;
+
+    pub fn init() -> anyhow::Result<String> {
+        let args: Vec<String> = env::args().collect();
+        let contents = fs::read_to_string(Path::new(&args[1]));
+        let css = parse(&contents?)?.flatten_tree().as_css_string();
+        Ok(css)
+    }
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+fn main() {
+    match init::init() {
+        Ok(x) => println!("{}", x),
+        Err(x) => eprintln!("{}", x),
+    }
+}
+
+#[cfg(target_arch = "wasm32")]
+fn main() {}

package/src/parser.rs

@@ -0,0 +1,36 @@
+// ┌───────────────────────────────────────────────────────────────────────────┐
+// │                                                                           │
+// │  ██████╗ ██████╗  ██████╗   Copyright (C) 2022, The Prospective Company   │
+// │  ██╔══██╗██╔══██╗██╔═══██╗                                                │
+// │  ██████╔╝██████╔╝██║   ██║  This file is part of the Procss library,      │
+// │  ██╔═══╝ ██╔══██╗██║   ██║  distributed under the terms of the            │
+// │  ██║     ██║  ██║╚██████╔╝  Apache License 2.0.  The full license can     │
+// │  ╚═╝     ╚═╝  ╚═╝ ╚═════╝   be found in the LICENSE file.                 │
+// │                                                                           │
+// └───────────────────────────────────────────────────────────────────────────┘
+
+use anyhow::anyhow;
+use nom::error::{convert_error, ParseError, VerboseError};
+use nom::{Err, IResult};
+
+/// A trait for CSS AST types which can be parsed from a String.
+pub trait ParseCss<'a>
+where
+    Self: Sized,
+{
+    /// Parse an input string into the trait implementor, parameterized by an
+    /// invoker-chosen `E` error type which allows compile-time choice between
+    /// fast or debug parser implementations.
+    fn parse<E>(input: &'a str) -> IResult<&'a str, Self, E>
+    where
+        E: ParseError<&'a str>;
+}
+
+pub fn unwrap_parse_error(input: &str, err: Err<VerboseError<&str>>) -> anyhow::Error {
+    match err {
+        Err::Error(e) | Err::Failure(e) => {
+            anyhow!("Error parsing, unknown:\n{}", convert_error(input, e))
+        }
+        Err::Incomplete(needed) => anyhow!("Error parsing, unexpected input:\n {:?}", needed),
+    }
+}

package/src/render.rs

@@ -0,0 +1,84 @@
+// ┌───────────────────────────────────────────────────────────────────────────┐
+// │                                                                           │
+// │  ██████╗ ██████╗  ██████╗   Copyright (C) 2022, The Prospective Company   │
+// │  ██╔══██╗██╔══██╗██╔═══██╗                                                │
+// │  ██████╔╝██████╔╝██║   ██║  This file is part of the Procss library,      │
+// │  ██╔═══╝ ██╔══██╗██║   ██║  distributed under the terms of the            │
+// │  ██║     ██║  ██║╚██████╔╝  Apache License 2.0.  The full license can     │
+// │  ╚═╝     ╚═╝  ╚═╝ ╚═════╝   be found in the LICENSE file.                 │
+// │                                                                           │
+// └───────────────────────────────────────────────────────────────────────────┘
+
+use std::borrow::Cow;
+use std::fmt;
+
+/// A trick to etract the top-level `Formatter` when rendering to a string.
+struct Fix<F: Fn(&mut fmt::Formatter<'_>)>(F);
+
+impl<F: Fn(&mut fmt::Formatter<'_>)> fmt::Display for Fix<F> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        (self.0)(f);
+        Ok(())
+    }
+}
+
+// Another form of [`std::fmt::Display`] etc.  This one is explicitly for
+// generating valid CSS as a string.
+pub trait RenderCss {
+    fn render(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result;
+
+    /// Render `self` as a valid CSS [`String`], minified (with
+    /// non-interpretation-impacting whitespace removed).
+    fn as_css_string(&self) -> String {
+        format!(
+            "{}",
+            Fix(|fmt| {
+                self.render(fmt).unwrap();
+            })
+        )
+    }
+}
+
+impl<'a> RenderCss for &'a str {
+    fn render(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self)
+    }
+}
+
+impl<'a, T: RenderCss + Clone> RenderCss for Cow<'a, T> {
+    fn render(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.as_ref().render(f)
+    }
+}
+
+impl<T: RenderCss> RenderCss for Option<T> {
+    fn render(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Some(x) => x.render(f),
+            None => Ok(()),
+        }
+    }
+}
+
+impl RenderCss for () {
+    fn render(&self, _f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        Ok(())
+    }
+}
+
+impl<T: RenderCss> RenderCss for Vec<T> {
+    fn render(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        for x in self {
+            x.render(f)?;
+        }
+
+        Ok(())
+    }
+}
+
+impl<T: RenderCss, U: RenderCss> RenderCss for (T, U) {
+    fn render(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.0.render(f)?;
+        self.1.render(f)
+    }
+}

package/src/transform.rs

@@ -0,0 +1,14 @@
+// ┌───────────────────────────────────────────────────────────────────────────┐
+// │                                                                           │
+// │  ██████╗ ██████╗  ██████╗   Copyright (C) 2022, The Prospective Company   │
+// │  ██╔══██╗██╔══██╗██╔═══██╗                                                │
+// │  ██████╔╝██████╔╝██║   ██║  This file is part of the Procss library,      │
+// │  ██╔═══╝ ██╔══██╗██║   ██║  distributed under the terms of the            │
+// │  ██║     ██║  ██║╚██████╔╝  Apache License 2.0.  The full license can     │
+// │  ╚═╝     ╚═╝  ╚═╝ ╚═════╝   be found in the LICENSE file.                 │
+// │                                                                           │
+// └───────────────────────────────────────────────────────────────────────────┘
+
+pub trait TransformCss<T> {
+    fn transform_each<F: FnMut(&mut T)>(&mut self, f: &mut F);
+}

package/src/transformers/apply_import.rs

@@ -0,0 +1,53 @@
+// ┌───────────────────────────────────────────────────────────────────────────┐
+// │                                                                           │
+// │  ██████╗ ██████╗  ██████╗   Copyright (C) 2022, The Prospective Company   │
+// │  ██╔══██╗██╔══██╗██╔═══██╗                                                │
+// │  ██████╔╝██████╔╝██║   ██║  This file is part of the Procss library,      │
+// │  ██╔═══╝ ██╔══██╗██║   ██║  distributed under the terms of the            │
+// │  ██║     ██║  ██║╚██████╔╝  Apache License 2.0.  The full license can     │
+// │  ╚═╝     ╚═╝  ╚═╝ ╚═════╝   be found in the LICENSE file.                 │
+// │                                                                           │
+// └───────────────────────────────────────────────────────────────────────────┘
+
+use std::collections::HashMap;
+
+use super::filter_refs;
+use crate::ast::Ruleset::{self};
+use crate::ast::*;
+
+pub fn apply_import<'a, 'b>(assets: &'b HashMap<&str, Tree<'a>>) -> impl Fn(&mut Tree<'a>) + 'b {
+    |tree| {
+        tree.transform(|ruleset| {
+            let mut replace = None;
+            if let Ruleset::QualRule(QualRule(name, val)) = ruleset {
+                if *name == "import" {
+                    if let Some(val) = val {
+                        if val.starts_with('\"') {
+                            replace = assets.get(&val[1..val.len() - 1]).cloned();
+                            if replace.is_none() {
+                                panic!("File not found: '{}'", &val[1..val.len() - 1])
+                            }
+                        } else if val.starts_with("url(\"ref://") {
+                            replace = assets.get(&val[11..val.len() - 2]).cloned().map(|mut x| {
+                                filter_refs(&mut x);
+                                x
+                            });
+
+                            if replace.is_none() {
+                                panic!("File not found: '{}'", &val[1..val.len() - 1])
+                            }
+                        }
+                    }
+                }
+            }
+
+            if let Some(replace) = replace {
+                let rules: Vec<TreeRule<'a>> =
+                    replace.iter().cloned().map(TreeRule::Ruleset).collect();
+
+                *ruleset =
+                    Ruleset::SelectorRuleset(SelectorRuleset(Selector::default(), rules.clone()))
+            }
+        });
+    }
+}

package/src/transformers/apply_mixin.rs

@@ -0,0 +1,73 @@
+// ┌───────────────────────────────────────────────────────────────────────────┐
+// │                                                                           │
+// │  ██████╗ ██████╗  ██████╗   Copyright (C) 2022, The Prospective Company   │
+// │  ██╔══██╗██╔══██╗██╔═══██╗                                                │
+// │  ██████╔╝██████╔╝██║   ██║  This file is part of the Procss library,      │
+// │  ██╔═══╝ ██╔══██╗██║   ██║  distributed under the terms of the            │
+// │  ██║     ██║  ██║╚██████╔╝  Apache License 2.0.  The full license can     │
+// │  ╚═╝     ╚═╝  ╚═╝ ╚═════╝   be found in the LICENSE file.                 │
+// │                                                                           │
+// └───────────────────────────────────────────────────────────────────────────┘
+
+use std::collections::HashMap;
+
+use crate::ast::Ruleset::{self};
+use crate::ast::*;
+
+/// Apply any in-scope mixin (defined using `@mixin`) to any `@include` in the
+/// [`Tree`] `input`.  Similar to [Sass `@mixin`](https://sass-lang.com/documentation/at-rules/mixin)
+///
+/// # Example
+///
+/// ```
+/// # use procss::{parse, transformers::apply_mixin, RenderCss};
+/// let css = "
+/// @mixin test {
+///     opacity: 0;
+/// }
+/// div.open {
+///     color: red;
+///     @include test;
+/// }
+/// ";
+/// let mut tree = parse(css).unwrap();
+/// apply_mixin(&mut tree);
+/// let css = tree.flatten_tree().as_css_string();
+/// assert_eq!(css, "div.open{color:red;}div.open{opacity:0;}");
+/// ```
+pub fn apply_mixin<'a>(tree: &mut Tree<'a>) {
+    let mut mixins: HashMap<&'a str, Vec<TreeRule<'a>>> = HashMap::new();
+    tree.transform(|ruleset| {
+        if let Ruleset::QualRuleset(crate::ast::QualRuleset(QualRule(name, Some(val)), props)) = ruleset {
+            if *name == "mixin"  {
+                mixins.insert(val.trim(), props.clone());
+            }
+        }
+
+        if matches!(ruleset,  Ruleset::QualRuleset(QualRuleset(QualRule(name, _), _)) if *name == "mixin") {
+            *ruleset = Ruleset::SelectorRuleset(SelectorRuleset(Selector::default(), vec![]))
+        }
+    });
+
+    let mut count = 5;
+    while count > 0 {
+        let mut changed = false;
+        tree.transform(|ruleset| {
+            for (header, props) in mixins.iter() {
+                if matches!(ruleset, Ruleset::QualRule(QualRule("include", Some(val))) if val == header ) {
+                    changed = true;
+                    *ruleset = Ruleset::SelectorRuleset(SelectorRuleset(
+                        Selector::default(),
+                        props.clone().into_iter().collect(),
+                    ))
+                }
+            }
+        });
+
+        if !changed {
+            count = 0;
+        } else {
+            count -= 1;
+        }
+    }
+}

package/src/transformers/apply_var.rs

@@ -0,0 +1,41 @@
+// ┌───────────────────────────────────────────────────────────────────────────┐
+// │                                                                           │
+// │  ██████╗ ██████╗  ██████╗   Copyright (C) 2022, The Prospective Company   │
+// │  ██╔══██╗██╔══██╗██╔═══██╗                                                │
+// │  ██████╔╝██████╔╝██║   ██║  This file is part of the Procss library,      │
+// │  ██╔═══╝ ██╔══██╗██║   ██║  distributed under the terms of the            │
+// │  ██║     ██║  ██║╚██████╔╝  Apache License 2.0.  The full license can     │
+// │  ╚═╝     ╚═╝  ╚═╝ ╚═════╝   be found in the LICENSE file.                 │
+// │                                                                           │
+// └───────────────────────────────────────────────────────────────────────────┘
+
+use std::collections::HashMap;
+
+use crate::ast::Ruleset::{self};
+use crate::ast::*;
+
+pub fn apply_var<'a>(tree: &mut Tree<'a>) {
+    let mut mixins: HashMap<&'a str, &'a str> = HashMap::new();
+    tree.transform(|ruleset| {
+        let mut is_mixin = false;
+        if let Ruleset::QualRule(QualRule(name, Some(val))) = ruleset {
+            if let Some(val) = val.strip_prefix(':') {
+                mixins.insert(name, val);
+                is_mixin = true;
+            }
+        }
+
+        if is_mixin {
+            *ruleset = Ruleset::QualRuleset(QualRuleset(QualRule("", None), vec![]))
+        }
+    });
+
+    let mut mixins = mixins.iter().collect::<Vec<_>>();
+    mixins.sort_by(|(x, _), (a, _)| x.len().cmp(&a.len()));
+    mixins.reverse();
+    tree.transform(|rule: &mut Rule| {
+        for (var, val) in mixins.iter() {
+            rule.value = rule.value.replace(&format!("@{}", var), val).into();
+        }
+    });
+}

package/src/transformers/dedupe.rs

@@ -0,0 +1,35 @@
+// ┌───────────────────────────────────────────────────────────────────────────┐
+// │                                                                           │
+// │  ██████╗ ██████╗  ██████╗   Copyright (C) 2022, The Prospective Company   │
+// │  ██╔══██╗██╔══██╗██╔═══██╗                                                │
+// │  ██████╔╝██████╔╝██║   ██║  This file is part of the Procss library,      │
+// │  ██╔═══╝ ██╔══██╗██║   ██║  distributed under the terms of the            │
+// │  ██║     ██║  ██║╚██████╔╝  Apache License 2.0.  The full license can     │
+// │  ╚═╝     ╚═╝  ╚═╝ ╚═════╝   be found in the LICENSE file.                 │
+// │                                                                           │
+// └───────────────────────────────────────────────────────────────────────────┘
+
+use crate::ast::Ruleset::{self};
+use crate::ast::*;
+
+pub fn dedupe(css: &mut Css) {
+    let mut res = vec![];
+    let reduced = css.iter().cloned().reduce(|x, y| match (x, y) {
+        (Ruleset::QualRule(x), Ruleset::QualRule(y)) if x == y => Ruleset::QualRule(x),
+        (Ruleset::SelectorRuleset(x), Ruleset::SelectorRuleset(y)) if x.0 == y.0 => {
+            let mut tail = x.1.clone();
+            tail.extend(y.1);
+            Ruleset::SelectorRuleset(SelectorRuleset(x.0.clone(), tail))
+        }
+        x => {
+            res.push(x.0);
+            x.1
+        }
+    });
+
+    if let Some(reduced) = reduced {
+        res.push(reduced.clone());
+    }
+
+    *css = crate::ast::Css(res)
+}

package/src/transformers/filter_refs.rs

@@ -0,0 +1,27 @@
+// ┌───────────────────────────────────────────────────────────────────────────┐
+// │                                                                           │
+// │  ██████╗ ██████╗  ██████╗   Copyright (C) 2022, The Prospective Company   │
+// │  ██╔══██╗██╔══██╗██╔═══██╗                                                │
+// │  ██████╔╝██████╔╝██║   ██║  This file is part of the Procss library,      │
+// │  ██╔═══╝ ██╔══██╗██║   ██║  distributed under the terms of the            │
+// │  ██║     ██║  ██║╚██████╔╝  Apache License 2.0.  The full license can     │
+// │  ╚═╝     ╚═╝  ╚═╝ ╚═════╝   be found in the LICENSE file.                 │
+// │                                                                           │
+// └───────────────────────────────────────────────────────────────────────────┘
+
+use crate::ast::Ruleset::{self};
+use crate::ast::*;
+
+pub fn filter_refs(tree: &mut Tree) {
+    *tree = Tree(
+        tree.iter()
+            .cloned()
+            .filter(|y| match y {
+                Ruleset::SelectorRuleset(_) => false,
+                Ruleset::QualRule(_) => true,
+                Ruleset::QualRuleset(_) => true,
+                Ruleset::QualNestedRuleset(_) => true,
+            })
+            .collect(),
+    )
+}

package/src/transformers/flat_self.rs

@@ -0,0 +1,30 @@
+// ┌───────────────────────────────────────────────────────────────────────────┐
+// │                                                                           │
+// │  ██████╗ ██████╗  ██████╗   Copyright (C) 2022, The Prospective Company   │
+// │  ██╔══██╗██╔══██╗██╔═══██╗                                                │
+// │  ██████╔╝██████╔╝██║   ██║  This file is part of the Procss library,      │
+// │  ██╔═══╝ ██╔══██╗██║   ██║  distributed under the terms of the            │
+// │  ██║     ██║  ██║╚██████╔╝  Apache License 2.0.  The full license can     │
+// │  ╚═╝     ╚═╝  ╚═╝ ╚═════╝   be found in the LICENSE file.                 │
+// │                                                                           │
+// └───────────────────────────────────────────────────────────────────────────┘
+
+use crate::ast::{Css, SelectorPath};
+use crate::transform::*;
+
+/// Remove `&` references from a flattened `Css`.
+pub(crate) fn flat_self(css: &mut Css) {
+    css.transform_each(&mut |x: &mut SelectorPath| {
+        let res = match x {
+            SelectorPath::Cons(..) => None,
+            SelectorPath::PartialCons(_, tail) if !tail.is_empty() => {
+                Some(SelectorPath::Cons(tail.remove(0).1, tail.clone()))
+            }
+            _ => None,
+        };
+
+        if let Some(y) = res {
+            *x = y;
+        }
+    });
+}