The design language that makes your AI harness better at design.
JavaScript
//! Port of css-tree 3.2.1 `lib/generator/` (`csstree.generate(node)` in the
//! default "safe" mode) for the node types the parser subset produces.
//!
//! The generator emits tokens and inserts a single space between two
//! adjacent tokens only where re-tokenizing would otherwise merge them
//! (`token-before.js` safe pairs). Raw / Combinator / TypeSelector /
//! Operator / UnicodeRange / AnPlusB values are re-tokenized and emitted
//! verbatim (auto-whitespace suppressed inside the chunk).
use super::ast::Node;
use super::strings::{encode_string, encode_url};
use super::tokenizer::*;
const PLUSSIGN: u32 = 0x2B;
const HYPHENMINUS: u32 = 0x2D;
const REVERSESOLIDUS: u32 = 0x5C;
/// token-before.js `code(type, value)`.
fn code(ty: TokenType, value: &str) -> u32 {
if ty == DELIM {
let c = value.chars().next().map(|c| c as u32).unwrap_or(0);
let c = std::cmp::min(c, 0x80) << 6;
return c << 1;
}
(ty as u32) << 1
}
fn code_char(c: char) -> u32 {
(std::cmp::min(c as u32, 0x80) << 6) << 1
}
/// The `safePairs` set as (prevCode, nextCode) keys.
fn safe_pairs() -> &'static std::collections::HashSet<u64> {
use once_cell::sync::Lazy;
static SET: Lazy<std::collections::HashSet<u64>> = Lazy::new(|| {
#[derive(Clone, Copy)]
enum K {
T(TokenType),
C(char),
}
use K::*;
let pairs: &[(K, K)] = &[
(T(IDENT), T(IDENT)),
(T(IDENT), T(FUNCTION)),
(T(IDENT), T(URL)),
(T(IDENT), T(BAD_URL)),
(T(IDENT), C('-')),
(T(IDENT), T(NUMBER)),
(T(IDENT), T(PERCENTAGE)),
(T(IDENT), T(DIMENSION)),
(T(IDENT), T(CDC)),
(T(IDENT), T(LEFT_PARENTHESIS)),
(T(AT_KEYWORD), T(IDENT)),
(T(AT_KEYWORD), T(FUNCTION)),
(T(AT_KEYWORD), T(URL)),
(T(AT_KEYWORD), T(BAD_URL)),
(T(AT_KEYWORD), C('-')),
(T(AT_KEYWORD), T(NUMBER)),
(T(AT_KEYWORD), T(PERCENTAGE)),
(T(AT_KEYWORD), T(DIMENSION)),
(T(AT_KEYWORD), T(CDC)),
(T(HASH), T(IDENT)),
(T(HASH), T(FUNCTION)),
(T(HASH), T(URL)),
(T(HASH), T(BAD_URL)),
(T(HASH), C('-')),
(T(HASH), T(NUMBER)),
(T(HASH), T(PERCENTAGE)),
(T(HASH), T(DIMENSION)),
(T(HASH), T(CDC)),
(T(DIMENSION), T(IDENT)),
(T(DIMENSION), T(FUNCTION)),
(T(DIMENSION), T(URL)),
(T(DIMENSION), T(BAD_URL)),
(T(DIMENSION), C('-')),
(T(DIMENSION), T(NUMBER)),
(T(DIMENSION), T(PERCENTAGE)),
(T(DIMENSION), T(DIMENSION)),
(T(DIMENSION), T(CDC)),
(C('#'), T(IDENT)),
(C('#'), T(FUNCTION)),
(C('#'), T(URL)),
(C('#'), T(BAD_URL)),
(C('#'), C('-')),
(C('#'), T(NUMBER)),
(C('#'), T(PERCENTAGE)),
(C('#'), T(DIMENSION)),
(C('#'), T(CDC)),
(C('-'), T(IDENT)),
(C('-'), T(FUNCTION)),
(C('-'), T(URL)),
(C('-'), T(BAD_URL)),
(C('-'), C('-')),
(C('-'), T(NUMBER)),
(C('-'), T(PERCENTAGE)),
(C('-'), T(DIMENSION)),
(C('-'), T(CDC)),
(T(NUMBER), T(IDENT)),
(T(NUMBER), T(FUNCTION)),
(T(NUMBER), T(URL)),
(T(NUMBER), T(BAD_URL)),
(T(NUMBER), T(NUMBER)),
(T(NUMBER), T(PERCENTAGE)),
(T(NUMBER), T(DIMENSION)),
(T(NUMBER), C('%')),
(T(NUMBER), T(CDC)),
(C('@'), T(IDENT)),
(C('@'), T(FUNCTION)),
(C('@'), T(URL)),
(C('@'), T(BAD_URL)),
(C('@'), C('-')),
(C('@'), T(CDC)),
(C('.'), T(NUMBER)),
(C('.'), T(PERCENTAGE)),
(C('.'), T(DIMENSION)),
(C('+'), T(NUMBER)),
(C('+'), T(PERCENTAGE)),
(C('+'), T(DIMENSION)),
(C('/'), C('*')),
// safe-mode additions
(T(IDENT), T(HASH)),
(T(DIMENSION), T(HASH)),
(T(HASH), T(HASH)),
(T(AT_KEYWORD), T(LEFT_PARENTHESIS)),
(T(AT_KEYWORD), T(STRING)),
(T(AT_KEYWORD), T(COLON)),
(T(PERCENTAGE), T(PERCENTAGE)),
(T(PERCENTAGE), T(DIMENSION)),
(T(PERCENTAGE), T(FUNCTION)),
(T(PERCENTAGE), C('-')),
(T(RIGHT_PARENTHESIS), T(IDENT)),
(T(RIGHT_PARENTHESIS), T(FUNCTION)),
(T(RIGHT_PARENTHESIS), T(PERCENTAGE)),
(T(RIGHT_PARENTHESIS), T(DIMENSION)),
(T(RIGHT_PARENTHESIS), T(HASH)),
(T(RIGHT_PARENTHESIS), C('-')),
];
let k = |x: K| -> u32 {
match x {
T(t) => (t as u32) << 1,
C(c) => code_char(c),
}
};
pairs
.iter()
.map(|(a, b)| ((k(*a) as u64) << 16) | k(*b) as u64)
.collect()
});
&SET
}
/// token-before.js `safe(prevCode, type, value)`: returns the next code with
/// bit 0 set when a space must be emitted first.
fn token_before_safe(prev_code: u32, ty: TokenType, value: &str) -> u32 {
let next_code = code(ty, value);
let next_char_code = value.chars().next().map(|c| c as u32).unwrap_or(0);
let key = |next: u32| -> u64 { (((prev_code & 0xFFFE) as u64) << 16) | next as u64 };
let emit_ws = if (next_char_code == HYPHENMINUS && ty != IDENT && ty != FUNCTION && ty != CDC)
|| next_char_code == PLUSSIGN
{
safe_pairs().contains(&key(next_char_code << 7))
} else {
safe_pairs().contains(&key(next_code))
};
next_code | u32::from(emit_ws)
}
pub struct Generator {
buffer: String,
prev_code: u32,
}
impl Generator {
fn token(&mut self, ty: TokenType, value: &str, suppress_auto_white_space: bool) {
self.prev_code = token_before_safe(self.prev_code, ty, value);
if !suppress_auto_white_space && (self.prev_code & 1) != 0 {
self.buffer.push(' ');
}
self.buffer.push_str(value);
if ty == DELIM && value.chars().next().map(|c| c as u32) == Some(REVERSESOLIDUS) {
self.buffer.push('\n');
}
}
fn tok(&mut self, ty: TokenType, value: &str) {
self.token(ty, value, false);
}
/// `this.tokenize(raw)`: re-tokenize and emit each token verbatim; only
/// the first may receive auto whitespace.
fn tokenize(&mut self, raw: &str) {
let chars: Vec<char> = raw.chars().collect();
let mut tokens: Vec<(TokenType, usize, usize)> = Vec::new();
tokenize(&chars, |ty, start, end| tokens.push((ty, start, end)));
for (ty, start, end) in tokens {
let value: String = chars[start..end].iter().collect();
self.token(ty, &value, start != 0);
}
}
fn children(&mut self, children: &[Node]) {
for c in children {
self.node(c);
}
}
fn children_with(&mut self, children: &[Node], delimiter: fn(&mut Generator, &Node)) {
let mut prev: Option<&Node> = None;
for c in children {
if let Some(p) = prev {
delimiter(self, p);
}
self.node(c);
prev = Some(c);
}
}
pub fn node(&mut self, node: &Node) {
match node {
Node::StyleSheet { children } => self.children(children),
Node::Rule { prelude, block } => {
self.node(prelude);
self.node(block);
}
Node::Atrule {
name,
prelude,
block,
} => {
self.tok(AT_KEYWORD, &format!("@{}", name));
if let Some(p) = prelude {
self.node(p);
}
match block {
Some(b) => self.node(b),
None => self.tok(SEMICOLON, ";"),
}
}
Node::Block { children } => {
self.tok(LEFT_CURLY_BRACKET, "{");
self.children_with(children, |g, prev| {
if matches!(prev, Node::Declaration { .. }) {
g.tok(SEMICOLON, ";");
}
});
self.tok(RIGHT_CURLY_BRACKET, "}");
}
Node::Declaration {
important,
property,
value,
} => {
self.tok(IDENT, property);
self.tok(COLON, ":");
self.node(value);
match important {
super::ast::Important::No => {}
super::ast::Important::Yes => {
self.tok(DELIM, "!");
self.tok(IDENT, "important");
}
super::ast::Important::Other(s) => {
self.tok(DELIM, "!");
self.tok(IDENT, s);
}
}
}
Node::Raw { value } => self.tokenize(value),
Node::Comment { value } => self.tok(COMMENT, &format!("/*{}*/", value)),
Node::Cdo => self.tok(CDO, "<!--"),
Node::Cdc => self.tok(CDC, "-->"),
Node::Value { children } => self.children(children),
Node::WhiteSpace { value } => self.tok(WHITESPACE, value),
Node::Hash { value } => self.tok(HASH, &format!("#{}", value)),
Node::Operator { value } => self.tokenize(value),
Node::Parentheses { children } => {
self.tok(LEFT_PARENTHESIS, "(");
self.children(children);
self.tok(RIGHT_PARENTHESIS, ")");
}
Node::Brackets { children } => {
self.tok(DELIM, "[");
self.children(children);
self.tok(DELIM, "]");
}
Node::Str { value } => self.tok(STRING, &encode_string(value)),
Node::Dimension { value, unit } => self.tok(DIMENSION, &format!("{}{}", value, unit)),
Node::Percentage { value } => self.tok(PERCENTAGE, &format!("{}%", value)),
Node::Number { value } => self.tok(NUMBER, value),
Node::Function { name, children } => {
self.tok(FUNCTION, &format!("{}(", name));
self.children(children);
self.tok(RIGHT_PARENTHESIS, ")");
}
Node::Url { value } => self.tok(URL, &encode_url(value)),
Node::Identifier { name } => self.tok(IDENT, name),
Node::UnicodeRange { value } => self.tokenize(value),
Node::SelectorList { children } => {
self.children_with(children, |g, _| g.tok(COMMA, ","));
}
Node::Selector { children } => self.children(children),
Node::TypeSelector { name } => self.tokenize(name),
Node::ClassSelector { name } => {
self.tok(DELIM, ".");
self.tok(IDENT, name);
}
Node::IdSelector { name } => {
// Delim instead of Hash: css-tree's hack to avoid a space
// between an ident and an id selector in safe mode.
self.tok(DELIM, &format!("#{}", name));
}
Node::AttributeSelector {
name,
matcher,
value,
flags,
} => {
self.tok(DELIM, "[");
self.node(name);
if let Some(m) = matcher {
self.tokenize(m);
if let Some(v) = value {
self.node(v);
}
}
if let Some(f) = flags {
self.tok(IDENT, f);
}
self.tok(DELIM, "]");
}
Node::PseudoClassSelector { name, children } => {
self.tok(COLON, ":");
match children {
None => self.tok(IDENT, name),
Some(c) => {
self.tok(FUNCTION, &format!("{}(", name));
self.children(c);
self.tok(RIGHT_PARENTHESIS, ")");
}
}
}
Node::PseudoElementSelector { name, children } => {
self.tok(COLON, ":");
self.tok(COLON, ":");
match children {
None => self.tok(IDENT, name),
Some(c) => {
self.tok(FUNCTION, &format!("{}(", name));
self.children(c);
self.tok(RIGHT_PARENTHESIS, ")");
}
}
}
Node::Combinator { name } => self.tokenize(name),
Node::NestingSelector => self.tok(DELIM, "&"),
Node::Nth { nth, selector } => {
self.node(nth);
if let Some(s) = selector {
self.tok(IDENT, "of");
self.node(s);
}
}
Node::AnPlusB { a, b } => {
if let Some(a) = a.as_deref().filter(|s| !s.is_empty()) {
let a_str = match a {
"+1" | "1" => "n".to_string(),
"-1" => "-n".to_string(),
_ => format!("{}n", a),
};
match b.as_deref().filter(|s| !s.is_empty()) {
Some(b) => {
let b_str = if b.starts_with('-') || b.starts_with('+') {
b.to_string()
} else {
format!("+{}", b)
};
self.tokenize(&format!("{}{}", a_str, b_str));
}
None => self.tokenize(&a_str),
}
} else {
// JS `this.tokenize(node.b)`; b is a string here.
let b = b.clone().unwrap_or_default();
self.tokenize(&b);
}
}
}
}
}
/// `csstree.generate(node)`.
pub fn generate(node: &Node) -> String {
let mut g = Generator {
buffer: String::new(),
prev_code: 0,
};
g.node(node);
g.buffer
}
/// `csstree.generate(value)` for a declaration value, with one deliberate
/// divergence from css-tree: at the top level, a number, percentage or
/// dimension that follows another one or a function keeps the space before
/// it. css-tree drops that space where re-tokenizing gives the same tokens
/// (`0 -8px` -> `0-8px`, `-1px +2px` -> `-1px+2px`, `10% 0` -> `10%0`,
/// `var(--x) 0` -> `var(--x)0`), but the static cascade splits shorthand
/// values on whitespace, so `margin: 0 0 0 -8px` would reach it as three
/// values ending in a merged `0-8px`. Inside a function the text stays as
/// css-tree writes it.
pub fn generate_declaration_value(node: &Node) -> String {
let Node::Value { children } = node else {
return generate(node);
};
let mut g = Generator {
buffer: String::new(),
prev_code: 0,
};
let mut prev_numeric = false;
let mut prev_function = false;
for child in children {
let numeric = matches!(
child,
Node::Number { .. } | Node::Dimension { .. } | Node::Percentage { .. }
);
let separate = (prev_numeric || prev_function) && numeric;
let start = g.buffer.len();
g.node(child);
if separate && !g.buffer[start..].starts_with(' ') {
g.buffer.insert(start, ' ');
}
prev_numeric = numeric;
prev_function = matches!(child, Node::Function { .. });
}
g.buffer
}