mirror of
https://github.com/hanzoai/esbuild.git
synced 2026-09-24 16:58:50 +00:00
457 lines
24 KiB
Go
457 lines
24 KiB
Go
package css_printer
|
|
|
|
import (
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/evanw/esbuild/internal/ast"
|
|
"github.com/evanw/esbuild/internal/config"
|
|
"github.com/evanw/esbuild/internal/css_parser"
|
|
"github.com/evanw/esbuild/internal/logger"
|
|
"github.com/evanw/esbuild/internal/test"
|
|
)
|
|
|
|
func expectPrintedCommon(t *testing.T, name string, contents string, expected string, options Options) {
|
|
t.Helper()
|
|
t.Run(name, func(t *testing.T) {
|
|
t.Helper()
|
|
log := logger.NewDeferLog(logger.DeferLogNoVerboseOrDebug, nil)
|
|
tree := css_parser.Parse(log, test.SourceForTest(contents), css_parser.OptionsFromConfig(config.LoaderCSS, &config.Options{
|
|
MinifyWhitespace: options.MinifyWhitespace,
|
|
}))
|
|
msgs := log.Done()
|
|
var text strings.Builder
|
|
for _, msg := range msgs {
|
|
if msg.Kind == logger.Error {
|
|
text.WriteString(msg.String(logger.OutputOptions{}, logger.TerminalInfo{}))
|
|
}
|
|
}
|
|
test.AssertEqualWithDiff(t, text.String(), "")
|
|
symbols := ast.NewSymbolMap(1)
|
|
symbols.SymbolsForSource[0] = tree.Symbols
|
|
result := Print(tree, symbols, options)
|
|
test.AssertEqualWithDiff(t, string(result.CSS), expected)
|
|
})
|
|
}
|
|
|
|
func expectPrinted(t *testing.T, contents string, expected string) {
|
|
t.Helper()
|
|
expectPrintedCommon(t, contents, contents, expected, Options{})
|
|
}
|
|
|
|
func expectPrintedMinify(t *testing.T, contents string, expected string) {
|
|
t.Helper()
|
|
expectPrintedCommon(t, contents+" [minified]", contents, expected, Options{
|
|
MinifyWhitespace: true,
|
|
})
|
|
}
|
|
|
|
func expectPrintedASCII(t *testing.T, contents string, expected string) {
|
|
t.Helper()
|
|
expectPrintedCommon(t, contents+" [ascii]", contents, expected, Options{
|
|
ASCIIOnly: true,
|
|
})
|
|
}
|
|
|
|
func expectPrintedString(t *testing.T, stringValue string, expected string) {
|
|
t.Helper()
|
|
t.Run(stringValue, func(t *testing.T) {
|
|
t.Helper()
|
|
p := printer{}
|
|
p.printQuoted(stringValue, 0)
|
|
test.AssertEqualWithDiff(t, string(p.css), expected)
|
|
})
|
|
}
|
|
|
|
func TestStringQuote(t *testing.T) {
|
|
expectPrintedString(t, "", "\"\"")
|
|
expectPrintedString(t, "foo", "\"foo\"")
|
|
expectPrintedString(t, "f\"o", "'f\"o'")
|
|
expectPrintedString(t, "f'\"'o", "\"f'\\\"'o\"")
|
|
expectPrintedString(t, "f\"'\"o", "'f\"\\'\"o'")
|
|
expectPrintedString(t, "f\\o", "\"f\\\\o\"")
|
|
expectPrintedString(t, "f\ro", "\"f\\do\"")
|
|
expectPrintedString(t, "f\no", "\"f\\ao\"")
|
|
expectPrintedString(t, "f\fo", "\"f\\co\"")
|
|
expectPrintedString(t, "f\r\no", "\"f\\d\\ao\"")
|
|
expectPrintedString(t, "f\r0", "\"f\\d 0\"")
|
|
expectPrintedString(t, "f\n0", "\"f\\a 0\"")
|
|
expectPrintedString(t, "f\n ", "\"f\\a \"")
|
|
expectPrintedString(t, "f\n\t", "\"f\\a \t\"")
|
|
expectPrintedString(t, "f\nf", "\"f\\a f\"")
|
|
expectPrintedString(t, "f\nF", "\"f\\a F\"")
|
|
expectPrintedString(t, "f\ng", "\"f\\ag\"")
|
|
expectPrintedString(t, "f\nG", "\"f\\aG\"")
|
|
expectPrintedString(t, "f\x01o", "\"f\x01o\"")
|
|
expectPrintedString(t, "f\to", "\"f\to\"")
|
|
|
|
expectPrintedString(t, "</script>", "\"</script>\"")
|
|
expectPrintedString(t, "</style>", "\"<\\/style>\"")
|
|
expectPrintedString(t, "</style", "\"<\\/style\"")
|
|
expectPrintedString(t, "</STYLE", "\"<\\/STYLE\"")
|
|
expectPrintedString(t, "</StYlE", "\"<\\/StYlE\"")
|
|
expectPrintedString(t, ">/style", "\">/style\"")
|
|
expectPrintedString(t, ">/STYLE", "\">/STYLE\"")
|
|
expectPrintedString(t, ">/StYlE", "\">/StYlE\"")
|
|
}
|
|
|
|
func TestURLQuote(t *testing.T) {
|
|
expectPrinted(t, "* { background: url('foo') }", "* {\n background: url(foo);\n}\n")
|
|
expectPrinted(t, "* { background: url('f o') }", "* {\n background: url(f\\ o);\n}\n")
|
|
expectPrinted(t, "* { background: url('f o') }", "* {\n background: url(\"f o\");\n}\n")
|
|
expectPrinted(t, "* { background: url('foo)') }", "* {\n background: url(foo\\));\n}\n")
|
|
expectPrinted(t, "* { background: url('(foo') }", "* {\n background: url(\\(foo);\n}\n")
|
|
expectPrinted(t, "* { background: url('(foo)') }", "* {\n background: url(\"(foo)\");\n}\n")
|
|
expectPrinted(t, "* { background: url('\"foo\"') }", "* {\n background: url('\"foo\"');\n}\n")
|
|
}
|
|
|
|
func TestImportant(t *testing.T) {
|
|
expectPrinted(t, "a { b: c!important }", "a {\n b: c !important;\n}\n")
|
|
expectPrinted(t, "a { b: c!important; }", "a {\n b: c !important;\n}\n")
|
|
expectPrinted(t, "a { b: c! important }", "a {\n b: c !important;\n}\n")
|
|
expectPrinted(t, "a { b: c! important; }", "a {\n b: c !important;\n}\n")
|
|
expectPrinted(t, "a { b: c ! important }", "a {\n b: c !important;\n}\n")
|
|
expectPrinted(t, "a { b: c ! important; }", "a {\n b: c !important;\n}\n")
|
|
expectPrinted(t, "a { b: c !IMPORTANT; }", "a {\n b: c !important;\n}\n")
|
|
expectPrinted(t, "a { b: c !ImPoRtAnT; }", "a {\n b: c !important;\n}\n")
|
|
expectPrintedMinify(t, "a { b: c !important }", "a{b:c!important}")
|
|
}
|
|
|
|
func TestSelector(t *testing.T) {
|
|
expectPrintedMinify(t, "a + b c > d ~ e{}", "a+b c>d~e{}")
|
|
|
|
expectPrinted(t, ":unknown( x (a+b), 'c' ) {}", ":unknown(x (a+b), \"c\") {\n}\n")
|
|
expectPrinted(t, ":unknown( x (a-b), 'c' ) {}", ":unknown(x (a-b), \"c\") {\n}\n")
|
|
expectPrinted(t, ":unknown( x (a,b), 'c' ) {}", ":unknown(x (a, b), \"c\") {\n}\n")
|
|
expectPrinted(t, ":unknown( x ( a + b ), 'c' ) {}", ":unknown(x (a + b), \"c\") {\n}\n")
|
|
expectPrinted(t, ":unknown( x ( a - b ), 'c' ) {}", ":unknown(x (a - b), \"c\") {\n}\n")
|
|
expectPrinted(t, ":unknown( x ( a , b ), 'c' ) {}", ":unknown(x (a, b), \"c\") {\n}\n")
|
|
|
|
expectPrintedMinify(t, ":unknown( x (a+b), 'c' ) {}", ":unknown(x (a+b),\"c\"){}")
|
|
expectPrintedMinify(t, ":unknown( x (a-b), 'c' ) {}", ":unknown(x (a-b),\"c\"){}")
|
|
expectPrintedMinify(t, ":unknown( x (a,b), 'c' ) {}", ":unknown(x (a,b),\"c\"){}")
|
|
expectPrintedMinify(t, ":unknown( x ( a + b ), 'c' ) {}", ":unknown(x (a + b),\"c\"){}")
|
|
expectPrintedMinify(t, ":unknown( x ( a - b ), 'c' ) {}", ":unknown(x (a - b),\"c\"){}")
|
|
expectPrintedMinify(t, ":unknown( x ( a , b ), 'c' ) {}", ":unknown(x (a,b),\"c\"){}")
|
|
|
|
// ":foo()" is a parse error, but should ideally still be preserved so they don't accidentally become valid
|
|
expectPrinted(t, ":is {}", ":is {\n}\n")
|
|
expectPrinted(t, ":is() {}", ":is() {\n}\n")
|
|
expectPrinted(t, ":hover {}", ":hover {\n}\n")
|
|
expectPrinted(t, ":hover() {}", ":hover() {\n}\n")
|
|
expectPrintedMinify(t, ":is {}", ":is{}")
|
|
expectPrintedMinify(t, ":is() {}", ":is(){}")
|
|
expectPrintedMinify(t, ":hover {}", ":hover{}")
|
|
expectPrintedMinify(t, ":hover() {}", ":hover(){}")
|
|
}
|
|
|
|
func TestNestedSelector(t *testing.T) {
|
|
expectPrintedMinify(t, "a { &b {} }", "a{&b{}}")
|
|
expectPrintedMinify(t, "a { & b {} }", "a{& b{}}")
|
|
expectPrintedMinify(t, "a { & :b {} }", "a{& :b{}}")
|
|
expectPrintedMinify(t, "& a & b & c {}", "& a & b & c{}")
|
|
}
|
|
|
|
func TestBadQualifiedRules(t *testing.T) {
|
|
expectPrinted(t, ";", "; {\n}\n")
|
|
expectPrinted(t, "$bad: rule;", "$bad: rule; {\n}\n")
|
|
expectPrinted(t, "a {}; b {};", "a {\n}\n; b {\n}\n; {\n}\n")
|
|
expectPrinted(t, "a { div.major { color: blue } color: red }", "a {\n div.major {\n color: blue;\n }\n color: red;\n}\n")
|
|
expectPrinted(t, "a { div:hover { color: blue } color: red }", "a {\n div:hover {\n color: blue;\n }\n color: red;\n}\n")
|
|
expectPrinted(t, "a { div:hover { color: blue }; color: red }", "a {\n div:hover {\n color: blue;\n }\n color: red;\n}\n")
|
|
|
|
expectPrinted(t, "$bad{ color: red }", "$bad {\n color: red;\n}\n")
|
|
expectPrinted(t, "$bad { color: red }", "$bad {\n color: red;\n}\n")
|
|
expectPrinted(t, "$bad foo{ color: red }", "$bad foo {\n color: red;\n}\n")
|
|
expectPrinted(t, "$bad foo { color: red }", "$bad foo {\n color: red;\n}\n")
|
|
|
|
expectPrintedMinify(t, "$bad{ color: red }", "$bad{color:red}")
|
|
expectPrintedMinify(t, "$bad { color: red }", "$bad{color:red}")
|
|
expectPrintedMinify(t, "$bad foo{ color: red }", "$bad foo{color:red}")
|
|
expectPrintedMinify(t, "$bad foo { color: red }", "$bad foo{color:red}")
|
|
}
|
|
|
|
func TestDeclaration(t *testing.T) {
|
|
expectPrinted(t, "* { unknown: x (a+b) }", "* {\n unknown: x (a+b);\n}\n")
|
|
expectPrinted(t, "* { unknown: x (a-b) }", "* {\n unknown: x (a-b);\n}\n")
|
|
expectPrinted(t, "* { unknown: x (a,b) }", "* {\n unknown: x (a, b);\n}\n")
|
|
expectPrinted(t, "* { unknown: x ( a + b ) }", "* {\n unknown: x (a + b);\n}\n")
|
|
expectPrinted(t, "* { unknown: x ( a - b ) }", "* {\n unknown: x (a - b);\n}\n")
|
|
expectPrinted(t, "* { unknown: x ( a , b ) }", "* {\n unknown: x (a, b);\n}\n")
|
|
|
|
expectPrintedMinify(t, "* { unknown: x (a+b) }", "*{unknown:x (a+b)}")
|
|
expectPrintedMinify(t, "* { unknown: x (a-b) }", "*{unknown:x (a-b)}")
|
|
expectPrintedMinify(t, "* { unknown: x (a,b) }", "*{unknown:x (a,b)}")
|
|
expectPrintedMinify(t, "* { unknown: x ( a + b ) }", "*{unknown:x (a + b)}")
|
|
expectPrintedMinify(t, "* { unknown: x ( a - b ) }", "*{unknown:x (a - b)}")
|
|
expectPrintedMinify(t, "* { unknown: x ( a , b ) }", "*{unknown:x (a,b)}")
|
|
|
|
// Pretty-print long lists in declarations
|
|
expectPrinted(t, "a { b: c, d }", "a {\n b: c, d;\n}\n")
|
|
expectPrinted(t, "a { b: c, (d, e) }", "a {\n b: c, (d, e);\n}\n")
|
|
expectPrinted(t, "a { b: c, d, e }", "a {\n b:\n c,\n d,\n e;\n}\n")
|
|
expectPrinted(t, "a { b: c, (d, e), f }", "a {\n b:\n c,\n (d, e),\n f;\n}\n")
|
|
|
|
expectPrintedMinify(t, "a { b: c, d }", "a{b:c,d}")
|
|
expectPrintedMinify(t, "a { b: c, (d, e) }", "a{b:c,(d,e)}")
|
|
expectPrintedMinify(t, "a { b: c, d, e }", "a{b:c,d,e}")
|
|
expectPrintedMinify(t, "a { b: c, (d, e), f }", "a{b:c,(d,e),f}")
|
|
}
|
|
|
|
func TestVerbatimWhitespace(t *testing.T) {
|
|
expectPrinted(t, "*{--x:}", "* {\n --x:;\n}\n")
|
|
expectPrinted(t, "*{--x: }", "* {\n --x: ;\n}\n")
|
|
expectPrinted(t, "* { --x:; }", "* {\n --x:;\n}\n")
|
|
expectPrinted(t, "* { --x: ; }", "* {\n --x: ;\n}\n")
|
|
|
|
expectPrintedMinify(t, "*{--x:}", "*{--x:}")
|
|
expectPrintedMinify(t, "*{--x: }", "*{--x: }")
|
|
expectPrintedMinify(t, "* { --x:; }", "*{--x:}")
|
|
expectPrintedMinify(t, "* { --x: ; }", "*{--x: }")
|
|
|
|
expectPrinted(t, "*{--x:!important}", "* {\n --x:!important;\n}\n")
|
|
expectPrinted(t, "*{--x: !important}", "* {\n --x: !important;\n}\n")
|
|
expectPrinted(t, "*{ --x:!important }", "* {\n --x:!important;\n}\n")
|
|
expectPrinted(t, "*{ --x: !important }", "* {\n --x: !important;\n}\n")
|
|
expectPrinted(t, "* { --x:!important; }", "* {\n --x:!important;\n}\n")
|
|
expectPrinted(t, "* { --x: !important; }", "* {\n --x: !important;\n}\n")
|
|
expectPrinted(t, "* { --x:! important ; }", "* {\n --x:!important;\n}\n")
|
|
expectPrinted(t, "* { --x: ! important ; }", "* {\n --x: !important;\n}\n")
|
|
|
|
expectPrintedMinify(t, "*{--x:!important}", "*{--x:!important}")
|
|
expectPrintedMinify(t, "*{--x: !important}", "*{--x: !important}")
|
|
expectPrintedMinify(t, "*{ --x:!important }", "*{--x:!important}")
|
|
expectPrintedMinify(t, "*{ --x: !important }", "*{--x: !important}")
|
|
expectPrintedMinify(t, "* { --x:!important; }", "*{--x:!important}")
|
|
expectPrintedMinify(t, "* { --x: !important; }", "*{--x: !important}")
|
|
expectPrintedMinify(t, "* { --x:! important ; }", "*{--x:!important}")
|
|
expectPrintedMinify(t, "* { --x: ! important ; }", "*{--x: !important}")
|
|
|
|
expectPrinted(t, "* { --x:y; }", "* {\n --x:y;\n}\n")
|
|
expectPrinted(t, "* { --x: y; }", "* {\n --x: y;\n}\n")
|
|
expectPrinted(t, "* { --x:y ; }", "* {\n --x:y ;\n}\n")
|
|
expectPrinted(t, "* { --x:y, ; }", "* {\n --x:y, ;\n}\n")
|
|
expectPrinted(t, "* { --x: var(y,); }", "* {\n --x: var(y,);\n}\n")
|
|
expectPrinted(t, "* { --x: var(y, ); }", "* {\n --x: var(y, );\n}\n")
|
|
|
|
expectPrintedMinify(t, "* { --x:y; }", "*{--x:y}")
|
|
expectPrintedMinify(t, "* { --x: y; }", "*{--x: y}")
|
|
expectPrintedMinify(t, "* { --x:y ; }", "*{--x:y }")
|
|
expectPrintedMinify(t, "* { --x:y, ; }", "*{--x:y, }")
|
|
expectPrintedMinify(t, "* { --x: var(y,); }", "*{--x: var(y,)}")
|
|
expectPrintedMinify(t, "* { --x: var(y, ); }", "*{--x: var(y, )}")
|
|
|
|
expectPrinted(t, "* { --x:(y); }", "* {\n --x:(y);\n}\n")
|
|
expectPrinted(t, "* { --x:(y) ; }", "* {\n --x:(y) ;\n}\n")
|
|
expectPrinted(t, "* { --x: (y); }", "* {\n --x: (y);\n}\n")
|
|
expectPrinted(t, "* { --x:(y ); }", "* {\n --x:(y );\n}\n")
|
|
expectPrinted(t, "* { --x:( y); }", "* {\n --x:( y);\n}\n")
|
|
|
|
expectPrintedMinify(t, "* { --x:(y); }", "*{--x:(y)}")
|
|
expectPrintedMinify(t, "* { --x:(y) ; }", "*{--x:(y) }")
|
|
expectPrintedMinify(t, "* { --x: (y); }", "*{--x: (y)}")
|
|
expectPrintedMinify(t, "* { --x:(y ); }", "*{--x:(y )}")
|
|
expectPrintedMinify(t, "* { --x:( y); }", "*{--x:( y)}")
|
|
|
|
expectPrinted(t, "* { --x:f(y); }", "* {\n --x:f(y);\n}\n")
|
|
expectPrinted(t, "* { --x:f(y) ; }", "* {\n --x:f(y) ;\n}\n")
|
|
expectPrinted(t, "* { --x: f(y); }", "* {\n --x: f(y);\n}\n")
|
|
expectPrinted(t, "* { --x:f(y ); }", "* {\n --x:f(y );\n}\n")
|
|
expectPrinted(t, "* { --x:f( y); }", "* {\n --x:f( y);\n}\n")
|
|
|
|
expectPrintedMinify(t, "* { --x:f(y); }", "*{--x:f(y)}")
|
|
expectPrintedMinify(t, "* { --x:f(y) ; }", "*{--x:f(y) }")
|
|
expectPrintedMinify(t, "* { --x: f(y); }", "*{--x: f(y)}")
|
|
expectPrintedMinify(t, "* { --x:f(y ); }", "*{--x:f(y )}")
|
|
expectPrintedMinify(t, "* { --x:f( y); }", "*{--x:f( y)}")
|
|
|
|
expectPrinted(t, "* { --x:[y]; }", "* {\n --x:[y];\n}\n")
|
|
expectPrinted(t, "* { --x:[y] ; }", "* {\n --x:[y] ;\n}\n")
|
|
expectPrinted(t, "* { --x: [y]; }", "* {\n --x: [y];\n}\n")
|
|
expectPrinted(t, "* { --x:[y ]; }", "* {\n --x:[y ];\n}\n")
|
|
expectPrinted(t, "* { --x:[ y]; }", "* {\n --x:[ y];\n}\n")
|
|
|
|
expectPrintedMinify(t, "* { --x:[y]; }", "*{--x:[y]}")
|
|
expectPrintedMinify(t, "* { --x:[y] ; }", "*{--x:[y] }")
|
|
expectPrintedMinify(t, "* { --x: [y]; }", "*{--x: [y]}")
|
|
expectPrintedMinify(t, "* { --x:[y ]; }", "*{--x:[y ]}")
|
|
expectPrintedMinify(t, "* { --x:[ y]; }", "*{--x:[ y]}")
|
|
|
|
// These cases temporarily behaved like qualified rules, but now they're back to being declarations
|
|
expectPrinted(t, "* { --x:{y}; }", "* {\n --x:{y};\n}\n")
|
|
expectPrinted(t, "* { --x:{y} ; }", "* {\n --x:{y} ;\n}\n")
|
|
expectPrinted(t, "* { --x: {y}; }", "* {\n --x: {y};\n}\n")
|
|
expectPrinted(t, "* { --x:{y }; }", "* {\n --x:{y };\n}\n")
|
|
expectPrinted(t, "* { --x:{ y}; }", "* {\n --x:{ y};\n}\n")
|
|
|
|
// These cases temporarily behaved like qualified rules, but now they're back to being declarations
|
|
expectPrintedMinify(t, "* { --x:{y}; }", "*{--x:{y}}")
|
|
expectPrintedMinify(t, "* { --x:{y} ; }", "*{--x:{y} }")
|
|
expectPrintedMinify(t, "* { --x: {y}; }", "*{--x: {y}}")
|
|
expectPrintedMinify(t, "* { --x:{y }; }", "*{--x:{y }}")
|
|
expectPrintedMinify(t, "* { --x:{ y}; }", "*{--x:{ y}}")
|
|
|
|
expectPrintedMinify(t, "@supports ( --x : y , z ) { a { color: red; } }", "@supports ( --x : y , z ){a{color:red}}")
|
|
expectPrintedMinify(t, "@supports ( --x : ) { a { color: red; } }", "@supports ( --x : ){a{color:red}}")
|
|
expectPrintedMinify(t, "@supports (--x: ) { a { color: red; } }", "@supports (--x: ){a{color:red}}")
|
|
expectPrintedMinify(t, "@supports ( --x y , z ) { a { color: red; } }", "@supports (--x y,z){a{color:red}}")
|
|
expectPrintedMinify(t, "@supports ( --x ) { a { color: red; } }", "@supports (--x){a{color:red}}")
|
|
expectPrintedMinify(t, "@supports ( ) { a { color: red; } }", "@supports (){a{color:red}}")
|
|
expectPrintedMinify(t, "@supports ( . --x : y , z ) { a { color: red; } }", "@supports (. --x : y,z){a{color:red}}")
|
|
}
|
|
|
|
func TestAtRule(t *testing.T) {
|
|
expectPrintedMinify(t, "@unknown;", "@unknown;")
|
|
expectPrintedMinify(t, "@unknown x;", "@unknown x;")
|
|
expectPrintedMinify(t, "@unknown{}", "@unknown{}")
|
|
expectPrintedMinify(t, "@unknown{\na: b;\nc: d;\n}", "@unknown{a: b; c: d;}")
|
|
|
|
expectPrinted(t, "@unknown x{}", "@unknown x {}\n")
|
|
expectPrinted(t, "@unknown x {}", "@unknown x {}\n")
|
|
expectPrintedMinify(t, "@unknown x{}", "@unknown x{}")
|
|
expectPrintedMinify(t, "@unknown x {}", "@unknown x{}")
|
|
|
|
expectPrinted(t, "@unknown x ( a + b ) ;", "@unknown x (a + b);\n")
|
|
expectPrinted(t, "@unknown x ( a - b ) ;", "@unknown x (a - b);\n")
|
|
expectPrinted(t, "@unknown x ( a , b ) ;", "@unknown x (a, b);\n")
|
|
expectPrintedMinify(t, "@unknown x ( a + b ) ;", "@unknown x (a + b);")
|
|
expectPrintedMinify(t, "@unknown x ( a - b ) ;", "@unknown x (a - b);")
|
|
expectPrintedMinify(t, "@unknown x ( a , b ) ;", "@unknown x (a,b);")
|
|
}
|
|
|
|
func TestAtCharset(t *testing.T) {
|
|
expectPrinted(t, "@charset \"UTF-8\";", "@charset \"UTF-8\";\n")
|
|
expectPrintedMinify(t, "@charset \"UTF-8\";", "@charset \"UTF-8\";")
|
|
}
|
|
|
|
func TestAtImport(t *testing.T) {
|
|
expectPrinted(t, "@import\"foo.css\";", "@import \"foo.css\";\n")
|
|
expectPrinted(t, "@import \"foo.css\";", "@import \"foo.css\";\n")
|
|
expectPrinted(t, "@import url(foo.css);", "@import \"foo.css\";\n")
|
|
expectPrinted(t, "@import url(\"foo.css\");", "@import \"foo.css\";\n")
|
|
expectPrinted(t, "@import url(\"foo.css\") (a < 1);", "@import \"foo.css\" (a < 1);\n")
|
|
expectPrinted(t, "@import url(\"foo.css\") supports(foo) (a < 1);", "@import \"foo.css\" supports(foo) (a < 1);\n")
|
|
expectPrinted(t, "@import url(\"foo.css\") layer;", "@import \"foo.css\" layer;\n")
|
|
expectPrinted(t, "@import url(\"foo.css\") layer (a < 1);", "@import \"foo.css\" layer (a < 1);\n")
|
|
expectPrinted(t, "@import url(\"foo.css\") layer supports(foo);", "@import \"foo.css\" layer supports(foo);\n")
|
|
expectPrinted(t, "@import url(\"foo.css\") layer supports(foo) (a < 1);", "@import \"foo.css\" layer supports(foo) (a < 1);\n")
|
|
|
|
expectPrintedMinify(t, "@import\"foo.css\";", "@import\"foo.css\";")
|
|
expectPrintedMinify(t, "@import \"foo.css\";", "@import\"foo.css\";")
|
|
expectPrintedMinify(t, "@import url(foo.css);", "@import\"foo.css\";")
|
|
expectPrintedMinify(t, "@import url(\"foo.css\");", "@import\"foo.css\";")
|
|
expectPrintedMinify(t, "@import url(\"foo.css\") (a < 1);", "@import\"foo.css\"(a<1);")
|
|
expectPrintedMinify(t, "@import url(\"foo.css\") supports(foo) (a < 1);", "@import\"foo.css\"supports(foo) (a<1);")
|
|
expectPrintedMinify(t, "@import url(\"foo.css\") layer;", "@import\"foo.css\"layer;")
|
|
expectPrintedMinify(t, "@import url(\"foo.css\") layer (a < 1);", "@import\"foo.css\"layer (a<1);")
|
|
expectPrintedMinify(t, "@import url(\"foo.css\") layer supports(foo);", "@import\"foo.css\"layer supports(foo);")
|
|
expectPrintedMinify(t, "@import url(\"foo.css\") layer supports(foo) (a < 1);", "@import\"foo.css\"layer supports(foo) (a<1);")
|
|
}
|
|
|
|
func TestAtKeyframes(t *testing.T) {
|
|
expectPrintedMinify(t, "@keyframes name { 0%, 50% { color: red } 25%, 75% { color: blue } }",
|
|
"@keyframes name{0%,50%{color:red}25%,75%{color:blue}}")
|
|
expectPrintedMinify(t, "@keyframes name { from { color: red } to { color: blue } }",
|
|
"@keyframes name{from{color:red}to{color:blue}}")
|
|
}
|
|
|
|
func TestAtMedia(t *testing.T) {
|
|
expectPrinted(t, "@media screen { div { color: red } }", "@media screen {\n div {\n color: red;\n }\n}\n")
|
|
expectPrinted(t, "@media screen{div{color:red}}", "@media screen {\n div {\n color: red;\n }\n}\n")
|
|
expectPrintedMinify(t, "@media screen { div { color: red } }", "@media screen{div{color:red}}")
|
|
expectPrintedMinify(t, "@media screen{div{color:red}}", "@media screen{div{color:red}}")
|
|
|
|
expectPrintedMinify(t, "@media (a) {div{color:red}}", "@media(a){div{color:red}}")
|
|
expectPrintedMinify(t, "@media (a) or (b) {div{color:red}}", "@media(a)or (b){div{color:red}}")
|
|
expectPrintedMinify(t, "@media (a) and (b) {div{color:red}}", "@media(a)and (b){div{color:red}}")
|
|
expectPrintedMinify(t, "@media not a {div{color:red}}", "@media not a{div{color:red}}")
|
|
expectPrintedMinify(t, "@media not a and (b) and (c) {div{color:red}}", "@media not a and (b)and (c){div{color:red}}")
|
|
expectPrintedMinify(t, "@media not (a) {div{color:red}}", "@media not (a){div{color:red}}")
|
|
expectPrintedMinify(t, "@media not ( (a) or (b) ) {div{color:red}}", "@media not ((a)or (b)){div{color:red}}")
|
|
expectPrintedMinify(t, "@media not ( (a) and (b) ) {div{color:red}}", "@media not ((a)and (b)){div{color:red}}")
|
|
|
|
expectPrintedMinify(t, "@media (width < 2px) {div{color:red}}", "@media(width<2px){div{color:red}}")
|
|
expectPrintedMinify(t, "@media (1px < width) {div{color:red}}", "@media(1px<width){div{color:red}}")
|
|
expectPrintedMinify(t, "@media (1px < width < 2px) {div{color:red}}", "@media(1px<width<2px){div{color:red}}")
|
|
expectPrintedMinify(t, "@media junk(1, 2, 3) {div{color:red}}", "@media junk(1,2,3){div{color:red}}")
|
|
}
|
|
|
|
func TestAtScope(t *testing.T) {
|
|
expectPrinted(t, "@scope { div { color: red } }", "@scope {\n div {\n color: red;\n }\n}\n")
|
|
expectPrinted(t, "@scope (a, .b) to (c > *) { div { color: red } }", "@scope (a, .b) to (c > *) {\n div {\n color: red;\n }\n}\n")
|
|
|
|
expectPrintedMinify(t, "@scope { div { color: red } }", "@scope{div{color:red}}")
|
|
expectPrintedMinify(t, "@scope (a, .b) to (c > *) { div { color: red } }", "@scope(a,.b)to (c>*){div{color:red}}")
|
|
}
|
|
|
|
func TestAtFontFace(t *testing.T) {
|
|
expectPrinted(t, "@font-face { font-family: 'Open Sans'; src: url('OpenSans.woff') format('woff') }",
|
|
"@font-face {\n font-family: \"Open Sans\";\n src: url(OpenSans.woff) format(\"woff\");\n}\n")
|
|
expectPrintedMinify(t, "@font-face { font-family: 'Open Sans'; src: url('OpenSans.woff') format('woff') }",
|
|
"@font-face{font-family:\"Open Sans\";src:url(OpenSans.woff) format(\"woff\")}")
|
|
}
|
|
|
|
func TestAtPage(t *testing.T) {
|
|
expectPrinted(t, "@page { margin: 1cm }", "@page {\n margin: 1cm;\n}\n")
|
|
expectPrinted(t, "@page :first { margin: 1cm }", "@page :first {\n margin: 1cm;\n}\n")
|
|
expectPrintedMinify(t, "@page { margin: 1cm }", "@page{margin:1cm}")
|
|
expectPrintedMinify(t, "@page :first { margin: 1cm }", "@page :first{margin:1cm}")
|
|
}
|
|
|
|
func TestMsGridColumnsWhitespace(t *testing.T) {
|
|
// Must not insert a space between the "]" and the "("
|
|
expectPrinted(t, "div { -ms-grid-columns: (1fr)[3] }", "div {\n -ms-grid-columns: (1fr)[3];\n}\n")
|
|
expectPrinted(t, "div { -ms-grid-columns: 1fr (20px 1fr)[3] }", "div {\n -ms-grid-columns: 1fr (20px 1fr)[3];\n}\n")
|
|
expectPrintedMinify(t, "div { -ms-grid-columns: (1fr)[3] }", "div{-ms-grid-columns:(1fr)[3]}")
|
|
expectPrintedMinify(t, "div { -ms-grid-columns: 1fr (20px 1fr)[3] }", "div{-ms-grid-columns:1fr (20px 1fr)[3]}")
|
|
}
|
|
|
|
func TestASCII(t *testing.T) {
|
|
expectPrintedASCII(t, "* { background: url(🐈) }", "* {\n background: url(\\1f408);\n}\n")
|
|
expectPrintedASCII(t, "* { background: url(🐈6) }", "* {\n background: url(\\1f408 6);\n}\n")
|
|
expectPrintedASCII(t, "* { background: url('🐈') }", "* {\n background: url(\\1f408);\n}\n")
|
|
expectPrintedASCII(t, "* { background: url('🐈6') }", "* {\n background: url(\\1f408 6);\n}\n")
|
|
expectPrintedASCII(t, "* { background: url('(🐈)') }", "* {\n background: url(\"(\\1f408)\");\n}\n")
|
|
expectPrintedASCII(t, "* { background: url('(🐈6)') }", "* {\n background: url(\"(\\1f408 6)\");\n}\n")
|
|
|
|
expectPrintedASCII(t, "div { 🐈: 🐈('🐈') }", "div {\n \\1f408: \\1f408(\"\\1f408\");\n}\n")
|
|
expectPrintedASCII(t, "div { 🐈 : 🐈 ('🐈 ') }", "div {\n \\1f408: \\1f408 (\"\\1f408 \");\n}\n")
|
|
expectPrintedASCII(t, "div { 🐈6: 🐈6('🐈6') }", "div {\n \\1f408 6: \\1f408 6(\"\\1f408 6\");\n}\n")
|
|
|
|
expectPrintedASCII(t, "@🐈;", "@\\1f408;\n")
|
|
expectPrintedASCII(t, "@🐈 {}", "@\\1f408 {}\n")
|
|
expectPrintedASCII(t, "@🐈 x {}", "@\\1f408 x {}\n")
|
|
|
|
expectPrintedASCII(t, "#🐈#x {}", "#\\1f408#x {\n}\n")
|
|
expectPrintedASCII(t, "#🐈 #x {}", "#\\1f408 #x {\n}\n")
|
|
expectPrintedASCII(t, "#🐈::x {}", "#\\1f408::x {\n}\n")
|
|
expectPrintedASCII(t, "#🐈 ::x {}", "#\\1f408 ::x {\n}\n")
|
|
|
|
expectPrintedASCII(t, ".🐈.x {}", ".\\1f408.x {\n}\n")
|
|
expectPrintedASCII(t, ".🐈 .x {}", ".\\1f408 .x {\n}\n")
|
|
expectPrintedASCII(t, ".🐈::x {}", ".\\1f408::x {\n}\n")
|
|
expectPrintedASCII(t, ".🐈 ::x {}", ".\\1f408 ::x {\n}\n")
|
|
|
|
expectPrintedASCII(t, "🐈|🐈.x {}", "\\1f408|\\1f408.x {\n}\n")
|
|
expectPrintedASCII(t, "🐈|🐈 .x {}", "\\1f408|\\1f408 .x {\n}\n")
|
|
expectPrintedASCII(t, "🐈|🐈::x {}", "\\1f408|\\1f408::x {\n}\n")
|
|
expectPrintedASCII(t, "🐈|🐈 ::x {}", "\\1f408|\\1f408 ::x {\n}\n")
|
|
|
|
expectPrintedASCII(t, "::🐈:x {}", "::\\1f408:x {\n}\n")
|
|
expectPrintedASCII(t, "::🐈 :x {}", "::\\1f408 :x {\n}\n")
|
|
|
|
expectPrintedASCII(t, "[🐈] {}", "[\\1f408] {\n}\n")
|
|
expectPrintedASCII(t, "[🐈=🐈] {}", "[\\1f408=\\1f408] {\n}\n")
|
|
expectPrintedASCII(t, "[🐈|🐈=🐈] {}", "[\\1f408|\\1f408=\\1f408] {\n}\n")
|
|
|
|
// A space must be consumed after an escaped code point even with six digits
|
|
expectPrintedASCII(t, ".\\10FFF abc:after { content: '\\10FFF abc' }", ".\\10fff abc:after {\n content: \"\\10fff abc\";\n}\n")
|
|
expectPrintedASCII(t, ".\U00010FFFabc:after { content: '\U00010FFFabc' }", ".\\10fff abc:after {\n content: \"\\10fff abc\";\n}\n")
|
|
expectPrintedASCII(t, ".\\10FFFFabc:after { content: '\\10FFFFabc' }", ".\\10ffffabc:after {\n content: \"\\10ffffabc\";\n}\n")
|
|
expectPrintedASCII(t, ".\\10FFFF abc:after { content: '\\10FFFF abc' }", ".\\10ffffabc:after {\n content: \"\\10ffffabc\";\n}\n")
|
|
expectPrintedASCII(t, ".\U0010FFFFabc:after { content: '\U0010FFFFabc' }", ".\\10ffffabc:after {\n content: \"\\10ffffabc\";\n}\n")
|
|
|
|
// This character should always be escaped
|
|
expectPrinted(t, ".\\FEFF:after { content: '\uFEFF' }", ".\\feff:after {\n content: \"\\feff\";\n}\n")
|
|
}
|