Preserve unknown at rules as raw tokens

Closes parcel-bundler#227

Author: devongovett

src/lib.rs

@@ -19855,4 +19855,53 @@ mod tests {
       ParserError::UnexpectedToken(crate::properties::custom::Token::Ident("bar".into())),
     );
   }
+
+  #[test]
+  fn test_unknown_at_rules() {
+    minify_test("@foo;", "@foo;");
+    minify_test("@foo bar;", "@foo bar;");
+    minify_test("@foo (bar: baz);", "@foo (bar: baz);");
+    test(
+      r#"@foo test {
+      div {
+        color: red;
+      }
+    }"#,
+      indoc! {r#"
+      @foo test {
+        div { color: red; }
+      }
+      "#},
+    );
+    minify_test(
+      r#"@foo test {
+      div {
+        color: red;
+      }
+    }"#,
+      "@foo test{div { color: red; }}",
+    );
+    minify_test(
+      r#"@foo test {
+        foo: bar;
+      }"#,
+      "@foo test{foo: bar;}",
+    );
+    test(
+      r#"@foo {
+        foo: bar;
+      }"#,
+      indoc! {r#"
+      @foo {
+        foo: bar;
+      }
+      "#},
+    );
+    minify_test(
+      r#"@foo {
+        foo: bar;
+      }"#,
+      "@foo{foo: bar;}",
+    );
+  }
 }

src/parser.rs

@@ -1,6 +1,7 @@
 use crate::declaration::{parse_declaration, DeclarationBlock, DeclarationList};
 use crate::error::{Error, ParserError};
 use crate::media_query::*;
+use crate::properties::custom::TokenList;
 use crate::rules::container::{ContainerName, ContainerRule};
 use crate::rules::font_palette_values::FontPaletteValuesRule;
 use crate::rules::layer::{LayerBlockRule, LayerStatementRule};
@@ -20,6 +21,7 @@ use crate::rules::{
   page::{PageRule, PageSelector},
   style::StyleRule,
   supports::{SupportsCondition, SupportsRule},
+  unknown::UnknownAtRule,
   CssRule, CssRuleList, Location,
 };
 use crate::selector::{SelectorParser, Selectors};
@@ -144,6 +146,8 @@ pub enum AtRulePrelude<'i> {
   Property(DashedIdent<'i>),
   /// A @container prelude.
   Container(Option<ContainerName<'i>>, MediaCondition<'i>),
+  /// An unknown prelude.
+  Unknown(CowArcStr<'i>, TokenList<'i>),
 }
 
 impl<'a, 'o, 'i> AtRuleParser<'i> for TopLevelRuleParser<'a, 'o, 'i> {
@@ -276,6 +280,12 @@ impl<'a, 'o, 'i> AtRuleParser<'i> for TopLevelRuleParser<'a, 'o, 'i> {
         AtRuleParser::rule_without_block(&mut self.nested(), prelude, start)?
       }
       AtRulePrelude::Charset => CssRule::Ignored,
+      AtRulePrelude::Unknown(name, prelude) => CssRule::Unknown(UnknownAtRule {
+        name,
+        prelude,
+        block: None,
+        loc,
+      }),
       _ => return Err(()),
     };
 
@@ -461,7 +471,12 @@ impl<'a, 'o, 'b, 'i> AtRuleParser<'i> for NestedRuleParser<'a, 'o, 'i> {
         let condition = MediaCondition::parse(input, true)?;
         Ok(AtRulePrelude::Container(name, condition))
       },
-      _ => Err(input.new_error(BasicParseErrorKind::AtRuleInvalid(name)))
+      _ => {
+        self.options.warn(input.new_error(BasicParseErrorKind::AtRuleInvalid(name.clone())));
+        input.skip_whitespace();
+        let tokens = TokenList::parse(input, &self.options, 0)?;
+        Ok(AtRulePrelude::Unknown(name.into(), tokens))
+      }
     }
   }
 
@@ -575,6 +590,12 @@ impl<'a, 'o, 'b, 'i> AtRuleParser<'i> for NestedRuleParser<'a, 'o, 'i> {
         Err(input.new_unexpected_token_error(Token::CurlyBracketBlock))
       }
       AtRulePrelude::FontFeatureValues | AtRulePrelude::Nest(..) => unreachable!(),
+      AtRulePrelude::Unknown(name, prelude) => Ok(CssRule::Unknown(UnknownAtRule {
+        name,
+        prelude,
+        block: Some(TokenList::parse(input, &self.options, 0)?),
+        loc,
+      })),
     }
   }
 
@@ -589,6 +610,12 @@ impl<'a, 'o, 'b, 'i> AtRuleParser<'i> for NestedRuleParser<'a, 'o, 'i> {
 
         Ok(CssRule::LayerStatement(LayerStatementRule { names, loc }))
       }
+      AtRulePrelude::Unknown(name, prelude) => Ok(CssRule::Unknown(UnknownAtRule {
+        name,
+        prelude,
+        block: None,
+        loc,
+      })),
       _ => Err(()),
     }
   }

src/properties/custom.rs

@@ -38,7 +38,9 @@ impl<'i> CustomProperty<'i> {
     input: &mut Parser<'i, 't>,
     options: &ParserOptions,
   ) -> Result<Self, ParseError<'i, ParserError<'i>>> {
-    let value = TokenList::parse(input, options, 0)?;
+    let value = input.parse_until_before(Delimiter::Bang | Delimiter::Semicolon, |input| {
+      TokenList::parse(input, options, 0)
+    })?;
     Ok(CustomProperty { name, value })
   }
 }
@@ -65,7 +67,9 @@ impl<'i> UnparsedProperty<'i> {
     input: &mut Parser<'i, 't>,
     options: &ParserOptions,
   ) -> Result<Self, ParseError<'i, ParserError<'i>>> {
-    let value = TokenList::parse(input, options, 0)?;
+    let value = input.parse_until_before(Delimiter::Bang | Delimiter::Semicolon, |input| {
+      TokenList::parse(input, options, 0)
+    })?;
     Ok(UnparsedProperty { property_id, value })
   }
 
@@ -133,25 +137,23 @@ impl<'i> TokenList<'i> {
     options: &ParserOptions,
     depth: usize,
   ) -> Result<Self, ParseError<'i, ParserError<'i>>> {
-    input.parse_until_before(Delimiter::Bang | Delimiter::Semicolon, |input| {
-      let mut tokens = vec![];
-      TokenList::parse_into(input, &mut tokens, options, depth)?;
-
-      // Slice off leading and trailing whitespace if there are at least two tokens.
-      // If there is only one token, we must preserve it. e.g. `--foo: ;` is valid.
-      if tokens.len() >= 2 {
-        let mut slice = &tokens[..];
-        if matches!(tokens.first(), Some(token) if token.is_whitespace()) {
-          slice = &slice[1..];
-        }
-        if matches!(tokens.last(), Some(token) if token.is_whitespace()) {
-          slice = &slice[..slice.len() - 1];
-        }
-        return Ok(TokenList(slice.to_vec()));
+    let mut tokens = vec![];
+    TokenList::parse_into(input, &mut tokens, options, depth)?;
+
+    // Slice off leading and trailing whitespace if there are at least two tokens.
+    // If there is only one token, we must preserve it. e.g. `--foo: ;` is valid.
+    if tokens.len() >= 2 {
+      let mut slice = &tokens[..];
+      if matches!(tokens.first(), Some(token) if token.is_whitespace()) {
+        slice = &slice[1..];
       }
+      if matches!(tokens.last(), Some(token) if token.is_whitespace()) {
+        slice = &slice[..slice.len() - 1];
+      }
+      return Ok(TokenList(slice.to_vec()));
+    }
 
-      return Ok(TokenList(tokens));
-    })
+    return Ok(TokenList(tokens));
   }
 
   fn parse_into<'t>(

src/rules/mod.rs

@@ -52,6 +52,7 @@ pub mod page;
 pub mod property;
 pub mod style;
 pub mod supports;
+pub mod unknown;
 pub mod viewport;
 
 use self::font_palette_values::FontPaletteValuesRule;
@@ -86,6 +87,7 @@ use serde::Serialize;
 use std::collections::{HashMap, HashSet};
 use style::StyleRule;
 use supports::SupportsRule;
+use unknown::UnknownAtRule;
 use viewport::ViewportRule;
 
 pub(crate) trait ToCssWithContext<'a, 'i> {
@@ -163,6 +165,8 @@ pub enum CssRule<'i> {
   Container(ContainerRule<'i>),
   /// A placeholder for a rule that was removed.
   Ignored,
+  /// An unknown at-rule.
+  Unknown(UnknownAtRule<'i>),
 }
 
 impl<'a, 'i> ToCssWithContext<'a, 'i> for CssRule<'i> {
@@ -193,6 +197,7 @@ impl<'a, 'i> ToCssWithContext<'a, 'i> for CssRule<'i> {
       CssRule::LayerBlock(layer) => layer.to_css(dest),
       CssRule::Property(property) => property.to_css(dest),
       CssRule::Container(container) => container.to_css_with_context(dest, context),
+      CssRule::Unknown(unknown) => unknown.to_css(dest),
       CssRule::Ignored => Ok(()),
     }
   }

src/rules/unknown.rs

@@ -0,0 +1,51 @@
+//! An unknown at-rule.
+
+use super::Location;
+use crate::error::PrinterError;
+use crate::printer::Printer;
+use crate::properties::custom::TokenList;
+use crate::traits::ToCss;
+use crate::values::string::CowArcStr;
+
+/// An unknown at-rule, stored as raw tokens.
+#[derive(Debug, PartialEq, Clone)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub struct UnknownAtRule<'i> {
+  /// The name of the at-rule (without the @).
+  pub name: CowArcStr<'i>,
+  /// The prelude of the rule.
+  pub prelude: TokenList<'i>,
+  /// The contents of the block, if any.
+  pub block: Option<TokenList<'i>>,
+  /// The location of the rule in the source file.
+  pub loc: Location,
+}
+
+impl<'i> ToCss for UnknownAtRule<'i> {
+  fn to_css<W>(&self, dest: &mut Printer<W>) -> Result<(), PrinterError>
+  where
+    W: std::fmt::Write,
+  {
+    dest.add_mapping(self.loc);
+    dest.write_char('@')?;
+    dest.write_str(&self.name)?;
+
+    if !self.prelude.0.is_empty() {
+      dest.write_char(' ')?;
+      self.prelude.to_css(dest, false)?;
+    }
+
+    if let Some(block) = &self.block {
+      dest.whitespace()?;
+      dest.write_char('{')?;
+      dest.indent();
+      dest.newline()?;
+      block.to_css(dest, false)?;
+      dest.dedent();
+      dest.newline()?;
+      dest.write_char('}')
+    } else {
+      dest.write_char(';')
+    }
+  }
+}