From 1000548a2fea99bfc978c971db543c82ebb8fc16 Mon Sep 17 00:00:00 2001
From: Ryan Fowler <ryan.fowler19@gmail.com>
Date: Mon, 26 Jan 2026 20:17:36 -0800
Subject: [PATCH] Add formatting support for CSS

---
 README.md                    |   2 +-
 docs/USAGE.md                |   1 +
 internal/fetch/fetch.go      |   7 +
 internal/format/css.go       | 941 +++++++++++++++++++++++++++++++++++
 internal/format/css_test.go  | 646 ++++++++++++++++++++++++
 internal/format/html.go      |  24 +-
 internal/format/html_test.go | 132 +++++
 7 files changed, 1748 insertions(+), 5 deletions(-)
 create mode 100644 internal/format/css.go
 create mode 100644 internal/format/css_test.go

diff --git a/README.md b/README.md
index 23a0495..380667e 100644
--- a/README.md
+++ b/README.md
@@ -6,7 +6,7 @@
 
 ### Features include:
 
-- **Response formatting**: automatically formats and colors output (json, html, csv, msgpack, protobuf, xml, etc.)
+- **Response formatting**: automatically formats and colors output (json, html, xml, css, csv, msgpack, protobuf, etc.)
 - **Image rendering**: render images directly in your terminal
 - **Compression**: automatic gzip and zstd response body decompression
 - **Authentication**: support for Basic Auth, Bearer Token, and AWS Signature V4
diff --git a/docs/USAGE.md b/docs/USAGE.md
index 39b8d32..ff26455 100644
--- a/docs/USAGE.md
+++ b/docs/USAGE.md
@@ -336,6 +336,7 @@ Supported formats for automatic formatting and syntax highlighting:
 - JSON (`application/json`)
 - HTML (`text/html`)
 - XML (`application/xml`, `text/xml`)
+- CSS (`text/css`)
 - CSV (`text/csv`)
 - MessagePack (`application/msgpack`)
 - NDJSON/JSONLines (`application/x-ndjson`)
diff --git a/internal/fetch/fetch.go b/internal/fetch/fetch.go
index 5d78180..a461798 100644
--- a/internal/fetch/fetch.go
+++ b/internal/fetch/fetch.go
@@ -28,6 +28,7 @@ type ContentType int
 
 const (
 	TypeUnknown ContentType = iota
+	TypeCSS
 	TypeCSV
 	TypeHTML
 	TypeImage
@@ -286,6 +287,10 @@ func formatResponse(ctx context.Context, r *Request, resp *http.Response) (io.Re
 	}
 
 	switch contentType {
+	case TypeCSS:
+		if format.FormatCSS(buf, p) == nil {
+			buf = p.Bytes()
+		}
 	case TypeCSV:
 		if format.FormatCSV(buf, p) == nil {
 			buf = p.Bytes()
@@ -357,6 +362,8 @@ func getContentType(headers http.Header) ContentType {
 			}
 		case "text":
 			switch subtype {
+			case "css":
+				return TypeCSS
 			case "csv":
 				return TypeCSV
 			case "html":
diff --git a/internal/format/css.go b/internal/format/css.go
new file mode 100644
index 0000000..8b793e8
--- /dev/null
+++ b/internal/format/css.go
@@ -0,0 +1,941 @@
+package format
+
+import "github.com/ryanfowler/fetch/internal/core"
+
+// CSS token types
+type cssTokenType int
+
+const (
+	cssTokenEOF        cssTokenType = iota
+	cssTokenIdent                   // property names, selectors, keywords
+	cssTokenHash                    // #id selectors
+	cssTokenAtKeyword               // @media, @import, @keyframes
+	cssTokenString                  // "..." or '...'
+	cssTokenNumber                  // 123, 1.5
+	cssTokenDimension               // 10px, 2em, 100%
+	cssTokenFunction                // calc(, rgba(, url(
+	cssTokenComment                 // /* ... */
+	cssTokenDelim                   // single chars: { } : ; , . > + ~ * [ ] ( )
+	cssTokenWhitespace              // spaces, tabs, newlines
+)
+
+// cssToken represents a single token from the CSS input.
+type cssToken struct {
+	typ   cssTokenType
+	value string
+}
+
+// cssTokenizer tokenizes CSS input byte by byte.
+type cssTokenizer struct {
+	input []byte
+	pos   int
+}
+
+func newCSSTokenizer(input []byte) *cssTokenizer {
+	return &cssTokenizer{input: input}
+}
+
+func (t *cssTokenizer) peek() byte {
+	if t.pos >= len(t.input) {
+		return 0
+	}
+	return t.input[t.pos]
+}
+
+func (t *cssTokenizer) peekN(n int) byte {
+	if t.pos+n >= len(t.input) {
+		return 0
+	}
+	return t.input[t.pos+n]
+}
+
+func (t *cssTokenizer) advance() byte {
+	if t.pos >= len(t.input) {
+		return 0
+	}
+	b := t.input[t.pos]
+	t.pos++
+	return b
+}
+
+func (t *cssTokenizer) next() cssToken {
+	// Skip whitespace, but return a whitespace token if any was found
+	if t.consumeWhitespace() {
+		return cssToken{typ: cssTokenWhitespace, value: " "}
+	}
+
+	if t.pos >= len(t.input) {
+		return cssToken{typ: cssTokenEOF}
+	}
+
+	c := t.peek()
+
+	// Comment
+	if c == '/' && t.peekN(1) == '*' {
+		return t.scanComment()
+	}
+
+	// String
+	if c == '"' || c == '\'' {
+		return t.scanString(c)
+	}
+
+	// At-keyword
+	if c == '@' {
+		return t.scanAtKeyword()
+	}
+
+	// Hash (ID selector)
+	if c == '#' {
+		return t.scanHash()
+	}
+
+	// Number or dimension
+	if isDigit(c) || (c == '.' && isDigit(t.peekN(1))) || (c == '-' && (isDigit(t.peekN(1)) || t.peekN(1) == '.')) {
+		return t.scanNumber()
+	}
+
+	// Identifier or function
+	if isIdentStart(c) || c == '-' || c == '_' {
+		return t.scanIdentOrFunction()
+	}
+
+	// Single character delimiters
+	t.advance()
+	return cssToken{typ: cssTokenDelim, value: string(c)}
+}
+
+func (t *cssTokenizer) consumeWhitespace() bool {
+	found := false
+	for t.pos < len(t.input) {
+		c := t.peek()
+		if c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == '\f' {
+			t.advance()
+			found = true
+		} else {
+			break
+		}
+	}
+	return found
+}
+
+func (t *cssTokenizer) scanComment() cssToken {
+	start := t.pos
+	t.advance() // consume /
+	t.advance() // consume *
+
+	for t.pos < len(t.input) {
+		if t.peek() == '*' && t.peekN(1) == '/' {
+			t.advance() // consume *
+			t.advance() // consume /
+			break
+		}
+		t.advance()
+	}
+
+	return cssToken{typ: cssTokenComment, value: string(t.input[start:t.pos])}
+}
+
+func (t *cssTokenizer) scanString(quote byte) cssToken {
+	start := t.pos
+	t.advance() // consume opening quote
+
+	for t.pos < len(t.input) {
+		c := t.peek()
+		if c == quote {
+			t.advance()
+			break
+		}
+		if c == '\\' {
+			t.advance() // consume backslash
+			if t.pos < len(t.input) {
+				t.advance() // consume escaped char
+			}
+			continue
+		}
+		if c == '\n' || c == '\r' {
+			// Unterminated string
+			break
+		}
+		t.advance()
+	}
+
+	return cssToken{typ: cssTokenString, value: string(t.input[start:t.pos])}
+}
+
+func (t *cssTokenizer) scanAtKeyword() cssToken {
+	start := t.pos
+	t.advance() // consume @
+
+	for t.pos < len(t.input) {
+		c := t.peek()
+		if isIdentChar(c) {
+			t.advance()
+		} else {
+			break
+		}
+	}
+
+	return cssToken{typ: cssTokenAtKeyword, value: string(t.input[start:t.pos])}
+}
+
+func (t *cssTokenizer) scanHash() cssToken {
+	start := t.pos
+	t.advance() // consume #
+
+	for t.pos < len(t.input) {
+		c := t.peek()
+		if isIdentChar(c) {
+			t.advance()
+		} else {
+			break
+		}
+	}
+
+	return cssToken{typ: cssTokenHash, value: string(t.input[start:t.pos])}
+}
+
+func (t *cssTokenizer) scanNumber() cssToken {
+	start := t.pos
+
+	// Optional sign
+	if t.peek() == '-' || t.peek() == '+' {
+		t.advance()
+	}
+
+	// Integer part
+	for t.pos < len(t.input) && isDigit(t.peek()) {
+		t.advance()
+	}
+
+	// Decimal part
+	if t.peek() == '.' && isDigit(t.peekN(1)) {
+		t.advance() // consume .
+		for t.pos < len(t.input) && isDigit(t.peek()) {
+			t.advance()
+		}
+	}
+
+	// Check for unit (makes it a dimension)
+	if isIdentStart(t.peek()) || t.peek() == '%' {
+		if t.peek() == '%' {
+			t.advance()
+		} else {
+			for t.pos < len(t.input) && isIdentChar(t.peek()) {
+				t.advance()
+			}
+		}
+		return cssToken{typ: cssTokenDimension, value: string(t.input[start:t.pos])}
+	}
+
+	return cssToken{typ: cssTokenNumber, value: string(t.input[start:t.pos])}
+}
+
+func (t *cssTokenizer) scanIdentOrFunction() cssToken {
+	start := t.pos
+
+	// Allow leading - or --
+	for t.peek() == '-' {
+		t.advance()
+	}
+
+	for t.pos < len(t.input) {
+		c := t.peek()
+		if isIdentChar(c) {
+			t.advance()
+		} else {
+			break
+		}
+	}
+
+	value := string(t.input[start:t.pos])
+
+	// Check if it's a function (followed by open paren)
+	if t.peek() == '(' {
+		t.advance()
+		return cssToken{typ: cssTokenFunction, value: value + "("}
+	}
+
+	return cssToken{typ: cssTokenIdent, value: value}
+}
+
+func isDigit(c byte) bool {
+	return c >= '0' && c <= '9'
+}
+
+func isIdentStart(c byte) bool {
+	return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_' || c >= 0x80
+}
+
+func isIdentChar(c byte) bool {
+	return isIdentStart(c) || isDigit(c) || c == '-'
+}
+
+// cssFormatter formats CSS tokens with pretty-printing and colors.
+type cssFormatter struct {
+	tok       *cssTokenizer
+	printer   *core.Printer
+	indent    int
+	current   cssToken
+	atNewline bool
+	wroteRule bool // tracks if we've written any top-level rules (for blank line separation)
+}
+
+// FormatCSS formats the provided CSS to the Printer.
+func FormatCSS(buf []byte, p *core.Printer) error {
+	return FormatCSSIndented(buf, p, 0)
+}
+
+// FormatCSSIndented formats CSS with a base indentation level.
+// Used for formatting CSS embedded in HTML <style> tags.
+func FormatCSSIndented(buf []byte, p *core.Printer, baseIndent int) error {
+	if len(buf) == 0 {
+		return nil
+	}
+
+	f := &cssFormatter{
+		tok:       newCSSTokenizer(buf),
+		printer:   p,
+		indent:    baseIndent,
+		atNewline: true,
+	}
+	f.advance()
+	return f.format()
+}
+
+func (f *cssFormatter) advance() {
+	f.current = f.tok.next()
+}
+
+func (f *cssFormatter) skipWhitespace() {
+	for f.current.typ == cssTokenWhitespace {
+		f.advance()
+	}
+}
+
+func (f *cssFormatter) format() error {
+	for f.current.typ != cssTokenEOF {
+		f.skipWhitespace()
+		if f.current.typ == cssTokenEOF {
+			break
+		}
+
+		if f.current.typ == cssTokenComment {
+			// Add blank line between top-level rules
+			if f.indent == 0 && f.wroteRule {
+				f.printer.WriteString("\n")
+			}
+			f.formatComment()
+			f.wroteRule = true
+			continue
+		}
+
+		if f.current.typ == cssTokenAtKeyword {
+			// Add blank line between top-level rules
+			if f.indent == 0 && f.wroteRule {
+				f.printer.WriteString("\n")
+			}
+			f.formatAtRule()
+			continue
+		}
+
+		// Must be a qualified rule (selector + declaration block)
+		// Add blank line between top-level rules
+		if f.indent == 0 && f.wroteRule {
+			f.printer.WriteString("\n")
+		}
+		f.formatQualifiedRule()
+	}
+
+	return nil
+}
+
+func (f *cssFormatter) formatComment() {
+	f.writeIndent()
+	f.printer.Set(core.Dim)
+	f.printer.WriteString(f.current.value)
+	f.printer.Reset()
+	f.printer.WriteString("\n")
+	f.atNewline = true
+	f.advance()
+}
+
+func (f *cssFormatter) formatAtRule() {
+	f.writeIndent()
+
+	// Write at-keyword
+	f.printer.Set(core.Bold)
+	f.printer.Set(core.Blue)
+	f.printer.WriteString(f.current.value)
+	f.printer.Reset()
+	f.advance()
+
+	// Collect the prelude (everything until { or ;)
+	f.formatAtRulePrelude()
+
+	f.skipWhitespace()
+
+	if f.current.typ == cssTokenDelim && f.current.value == "{" {
+		// Block at-rule (e.g., @media, @keyframes)
+		f.printer.WriteString(" {\n")
+		f.atNewline = true
+		f.advance()
+		f.indent++
+
+		// Parse contents
+		f.formatAtRuleBody()
+
+		f.indent--
+		f.writeIndent()
+		f.printer.WriteString("}\n")
+		f.atNewline = true
+		// Advance past the closing brace
+		if f.current.typ == cssTokenDelim && f.current.value == "}" {
+			f.advance()
+		}
+		if f.indent == 0 {
+			f.wroteRule = true
+		}
+	} else if f.current.typ == cssTokenDelim && f.current.value == ";" {
+		// Statement at-rule (e.g., @import, @charset)
+		f.printer.WriteString(";\n")
+		f.atNewline = true
+		f.advance()
+		if f.indent == 0 {
+			f.wroteRule = true
+		}
+	} else {
+		// No terminator found, just newline
+		f.printer.WriteString("\n")
+		f.atNewline = true
+	}
+}
+
+func (f *cssFormatter) formatAtRulePrelude() {
+	needSpace := false
+	parenDepth := 0
+
+	for f.current.typ != cssTokenEOF {
+		if f.current.typ == cssTokenDelim {
+			if f.current.value == "{" || f.current.value == ";" {
+				break
+			}
+			if f.current.value == "(" {
+				parenDepth++
+				f.printer.WriteString("(")
+				f.advance()
+				needSpace = false
+				continue
+			}
+			if f.current.value == ")" {
+				parenDepth--
+				f.printer.WriteString(")")
+				f.advance()
+				needSpace = true
+				continue
+			}
+			if f.current.value == "," {
+				f.printer.WriteString(",")
+				f.advance()
+				needSpace = true
+				continue
+			}
+			if f.current.value == ":" {
+				f.printer.WriteString(":")
+				f.advance()
+				needSpace = false
+				continue
+			}
+		}
+
+		if f.current.typ == cssTokenWhitespace {
+			f.advance()
+			if parenDepth == 0 {
+				needSpace = true
+			}
+			continue
+		}
+
+		if needSpace {
+			f.printer.WriteString(" ")
+			needSpace = false
+		}
+
+		f.formatValueToken()
+	}
+}
+
+func (f *cssFormatter) formatAtRuleBody() {
+	for f.current.typ != cssTokenEOF {
+		f.skipWhitespace()
+		if f.current.typ == cssTokenEOF {
+			break
+		}
+
+		if f.current.typ == cssTokenDelim && f.current.value == "}" {
+			break
+		}
+
+		if f.current.typ == cssTokenComment {
+			f.formatComment()
+			continue
+		}
+
+		if f.current.typ == cssTokenAtKeyword {
+			f.formatAtRule()
+			continue
+		}
+
+		// Either a nested rule or a declaration
+		// In @keyframes, selectors can be percentages (0%, 100%) or keywords (from, to)
+		f.formatQualifiedRule()
+	}
+}
+
+func (f *cssFormatter) formatQualifiedRule() {
+	f.writeIndent()
+
+	// Format selector
+	f.formatSelector()
+
+	f.skipWhitespace()
+
+	if f.current.typ == cssTokenDelim && f.current.value == "{" {
+		f.printer.WriteString(" {\n")
+		f.atNewline = true
+		f.advance()
+		f.indent++
+
+		f.formatDeclarationBlock()
+
+		f.indent--
+		f.writeIndent()
+		f.printer.WriteString("}\n")
+		f.atNewline = true
+		// Advance past the closing brace
+		if f.current.typ == cssTokenDelim && f.current.value == "}" {
+			f.advance()
+		}
+		if f.indent == 0 {
+			f.wroteRule = true
+		}
+	}
+}
+
+func (f *cssFormatter) formatSelector() {
+	needSpace := false
+	bracketDepth := 0
+
+	for f.current.typ != cssTokenEOF {
+		if f.current.typ == cssTokenDelim {
+			if f.current.value == "{" {
+				break
+			}
+			if f.current.value == "[" {
+				bracketDepth++
+				f.printer.Set(core.Bold)
+				f.printer.Set(core.Blue)
+				f.printer.WriteString("[")
+				f.printer.Reset()
+				f.advance()
+				needSpace = false
+				continue
+			}
+			if f.current.value == "]" {
+				bracketDepth--
+				f.printer.Set(core.Bold)
+				f.printer.Set(core.Blue)
+				f.printer.WriteString("]")
+				f.printer.Reset()
+				f.advance()
+				needSpace = true
+				continue
+			}
+			if f.current.value == "," {
+				f.printer.WriteString(",")
+				f.advance()
+				needSpace = true
+				continue
+			}
+			// Combinators: > + ~
+			if f.current.value == ">" || f.current.value == "+" || f.current.value == "~" {
+				if needSpace {
+					f.printer.WriteString(" ")
+				}
+				f.printer.Set(core.Bold)
+				f.printer.Set(core.Blue)
+				f.printer.WriteString(f.current.value)
+				f.printer.Reset()
+				f.advance()
+				needSpace = true
+				continue
+			}
+			// Other selector parts: . * :
+			if f.current.value == "." || f.current.value == "*" || f.current.value == ":" {
+				if needSpace && f.current.value != ":" {
+					f.printer.WriteString(" ")
+				}
+				f.printer.Set(core.Bold)
+				f.printer.Set(core.Blue)
+				f.printer.WriteString(f.current.value)
+				f.printer.Reset()
+				f.advance()
+				needSpace = false
+				continue
+			}
+			// = for attribute selectors
+			if f.current.value == "=" {
+				f.printer.Set(core.Bold)
+				f.printer.Set(core.Blue)
+				f.printer.WriteString("=")
+				f.printer.Reset()
+				f.advance()
+				needSpace = false
+				continue
+			}
+		}
+
+		if f.current.typ == cssTokenWhitespace {
+			f.advance()
+			if bracketDepth == 0 {
+				needSpace = true
+			}
+			continue
+		}
+
+		if needSpace {
+			f.printer.WriteString(" ")
+			needSpace = false
+		}
+
+		// Selector elements
+		switch f.current.typ {
+		case cssTokenIdent:
+			f.printer.Set(core.Bold)
+			f.printer.Set(core.Blue)
+			f.printer.WriteString(f.current.value)
+			f.printer.Reset()
+			f.advance()
+			needSpace = false
+		case cssTokenHash:
+			f.printer.Set(core.Bold)
+			f.printer.Set(core.Blue)
+			f.printer.WriteString(f.current.value)
+			f.printer.Reset()
+			f.advance()
+			needSpace = false
+		case cssTokenString:
+			f.printer.Set(core.Green)
+			f.printer.WriteString(f.current.value)
+			f.printer.Reset()
+			f.advance()
+			needSpace = false
+		case cssTokenFunction:
+			// For pseudo-class functions like :not()
+			f.printer.Set(core.Bold)
+			f.printer.Set(core.Blue)
+			f.printer.WriteString(f.current.value)
+			f.printer.Reset()
+			f.advance()
+			f.formatFunctionArgs()
+			needSpace = false
+		case cssTokenDimension, cssTokenNumber:
+			// For @keyframes selectors like 0%, 100%
+			f.printer.Set(core.Bold)
+			f.printer.Set(core.Blue)
+			f.printer.WriteString(f.current.value)
+			f.printer.Reset()
+			f.advance()
+			needSpace = false
+		default:
+			f.advance()
+		}
+	}
+}
+
+func (f *cssFormatter) formatDeclarationBlock() {
+	for f.current.typ != cssTokenEOF {
+		f.skipWhitespace()
+		if f.current.typ == cssTokenEOF {
+			break
+		}
+
+		if f.current.typ == cssTokenDelim && f.current.value == "}" {
+			break
+		}
+
+		if f.current.typ == cssTokenComment {
+			f.formatComment()
+			continue
+		}
+
+		// Property declaration
+		if f.current.typ == cssTokenIdent {
+			f.formatDeclaration()
+		} else {
+			// Skip unexpected tokens
+			f.advance()
+		}
+	}
+}
+
+func (f *cssFormatter) formatDeclaration() {
+	f.writeIndent()
+
+	// Property name
+	f.printer.Set(core.Cyan)
+	f.printer.WriteString(f.current.value)
+	f.printer.Reset()
+	f.advance()
+
+	f.skipWhitespace()
+
+	// Colon
+	if f.current.typ == cssTokenDelim && f.current.value == ":" {
+		f.printer.WriteString(": ")
+		f.advance()
+	}
+
+	// Property value
+	f.formatValue()
+
+	f.skipWhitespace()
+
+	// Semicolon
+	if f.current.typ == cssTokenDelim && f.current.value == ";" {
+		f.printer.WriteString(";\n")
+		f.atNewline = true
+		f.advance()
+	} else if f.current.typ == cssTokenDelim && f.current.value == "}" {
+		// Missing semicolon before closing brace (lenient)
+		f.printer.WriteString(";\n")
+		f.atNewline = true
+	} else {
+		f.printer.WriteString("\n")
+		f.atNewline = true
+	}
+}
+
+func (f *cssFormatter) formatValue() {
+	needSpace := false
+	parenDepth := 0
+
+	for f.current.typ != cssTokenEOF {
+		if f.current.typ == cssTokenDelim {
+			if f.current.value == ";" || f.current.value == "}" {
+				break
+			}
+			if f.current.value == "(" {
+				parenDepth++
+				f.printer.WriteString("(")
+				f.advance()
+				needSpace = false
+				continue
+			}
+			if f.current.value == ")" {
+				parenDepth--
+				f.printer.WriteString(")")
+				f.advance()
+				needSpace = true
+				continue
+			}
+			if f.current.value == "," {
+				f.printer.WriteString(",")
+				f.advance()
+				needSpace = true
+				continue
+			}
+			if f.current.value == "/" {
+				f.printer.WriteString("/")
+				f.advance()
+				needSpace = false
+				continue
+			}
+		}
+
+		if f.current.typ == cssTokenWhitespace {
+			f.advance()
+			needSpace = true
+			continue
+		}
+
+		if needSpace {
+			f.printer.WriteString(" ")
+			needSpace = false
+		}
+
+		f.formatValueToken()
+	}
+}
+
+func (f *cssFormatter) formatValueToken() {
+	switch f.current.typ {
+	case cssTokenIdent:
+		// Check for !important
+		if f.current.value == "important" {
+			f.printer.Set(core.Green)
+			f.printer.WriteString(f.current.value)
+			f.printer.Reset()
+		} else {
+			f.printer.Set(core.Green)
+			f.printer.WriteString(f.current.value)
+			f.printer.Reset()
+		}
+		f.advance()
+	case cssTokenNumber, cssTokenDimension:
+		f.printer.Set(core.Green)
+		f.printer.WriteString(f.current.value)
+		f.printer.Reset()
+		f.advance()
+	case cssTokenString:
+		f.printer.Set(core.Green)
+		f.printer.WriteString(f.current.value)
+		f.printer.Reset()
+		f.advance()
+	case cssTokenHash:
+		f.printer.Set(core.Green)
+		f.printer.WriteString(f.current.value)
+		f.printer.Reset()
+		f.advance()
+	case cssTokenFunction:
+		f.printer.Set(core.Green)
+		f.printer.WriteString(f.current.value)
+		f.printer.Reset()
+		f.advance()
+		f.formatFunctionArgsValue()
+	case cssTokenDelim:
+		if f.current.value == "!" {
+			f.printer.Set(core.Green)
+			f.printer.WriteString("!")
+			f.printer.Reset()
+			f.advance()
+		} else {
+			f.advance()
+		}
+	default:
+		f.advance()
+	}
+}
+
+func (f *cssFormatter) formatFunctionArgs() {
+	depth := 1
+	for f.current.typ != cssTokenEOF && depth > 0 {
+		if f.current.typ == cssTokenDelim && f.current.value == "(" {
+			depth++
+			f.printer.Set(core.Bold)
+			f.printer.Set(core.Blue)
+			f.printer.WriteString("(")
+			f.printer.Reset()
+			f.advance()
+			continue
+		}
+		if f.current.typ == cssTokenDelim && f.current.value == ")" {
+			depth--
+			f.printer.Set(core.Bold)
+			f.printer.Set(core.Blue)
+			f.printer.WriteString(")")
+			f.printer.Reset()
+			f.advance()
+			continue
+		}
+		if f.current.typ == cssTokenWhitespace {
+			f.advance()
+			continue
+		}
+
+		// Selector elements inside function
+		switch f.current.typ {
+		case cssTokenIdent:
+			f.printer.Set(core.Bold)
+			f.printer.Set(core.Blue)
+			f.printer.WriteString(f.current.value)
+			f.printer.Reset()
+			f.advance()
+		case cssTokenHash:
+			f.printer.Set(core.Bold)
+			f.printer.Set(core.Blue)
+			f.printer.WriteString(f.current.value)
+			f.printer.Reset()
+			f.advance()
+		case cssTokenDelim:
+			if f.current.value == "." || f.current.value == ":" || f.current.value == "*" {
+				f.printer.Set(core.Bold)
+				f.printer.Set(core.Blue)
+				f.printer.WriteString(f.current.value)
+				f.printer.Reset()
+			}
+			f.advance()
+		default:
+			f.advance()
+		}
+	}
+}
+
+func (f *cssFormatter) formatFunctionArgsValue() {
+	depth := 1
+	needSpace := false
+
+	for f.current.typ != cssTokenEOF && depth > 0 {
+		if f.current.typ == cssTokenDelim && f.current.value == "(" {
+			depth++
+			f.printer.WriteString("(")
+			f.advance()
+			needSpace = false
+			continue
+		}
+		if f.current.typ == cssTokenDelim && f.current.value == ")" {
+			depth--
+			f.printer.WriteString(")")
+			f.advance()
+			needSpace = true
+			continue
+		}
+		if f.current.typ == cssTokenDelim && f.current.value == "," {
+			f.printer.WriteString(",")
+			f.advance()
+			needSpace = true
+			continue
+		}
+		if f.current.typ == cssTokenDelim && f.current.value == "/" {
+			f.printer.WriteString("/")
+			f.advance()
+			needSpace = false
+			continue
+		}
+		if f.current.typ == cssTokenWhitespace {
+			f.advance()
+			needSpace = true
+			continue
+		}
+
+		if needSpace {
+			f.printer.WriteString(" ")
+			needSpace = false
+		}
+
+		switch f.current.typ {
+		case cssTokenIdent, cssTokenNumber, cssTokenDimension:
+			f.printer.WriteString(f.current.value)
+			f.advance()
+		case cssTokenString:
+			f.printer.WriteString(f.current.value)
+			f.advance()
+		case cssTokenHash:
+			f.printer.WriteString(f.current.value)
+			f.advance()
+		case cssTokenFunction:
+			f.printer.WriteString(f.current.value)
+			f.advance()
+			f.formatFunctionArgsValue()
+		default:
+			f.advance()
+		}
+	}
+}
+
+func (f *cssFormatter) writeIndent() {
+	if f.atNewline {
+		writeIndent(f.printer, f.indent)
+		f.atNewline = false
+	}
+}
diff --git a/internal/format/css_test.go b/internal/format/css_test.go
new file mode 100644
index 0000000..f9a32f8
--- /dev/null
+++ b/internal/format/css_test.go
@@ -0,0 +1,646 @@
+package format
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/ryanfowler/fetch/internal/core"
+)
+
+func TestFormatCSS(t *testing.T) {
+	tests := []struct {
+		name    string
+		input   string
+		wantErr bool
+	}{
+		{
+			name:    "empty input",
+			input:   "",
+			wantErr: false,
+		},
+		{
+			name:    "simple rule",
+			input:   "body { color: red; }",
+			wantErr: false,
+		},
+		{
+			name:    "minified CSS",
+			input:   "body{color:red;margin:0}.container{display:flex}",
+			wantErr: false,
+		},
+		{
+			name:    "multiple declarations",
+			input:   "div { color: red; font-size: 14px; margin: 10px; }",
+			wantErr: false,
+		},
+		{
+			name:    "class selector",
+			input:   ".container { width: 100%; }",
+			wantErr: false,
+		},
+		{
+			name:    "id selector",
+			input:   "#header { height: 60px; }",
+			wantErr: false,
+		},
+		{
+			name:    "descendant combinator",
+			input:   "div p { color: blue; }",
+			wantErr: false,
+		},
+		{
+			name:    "child combinator",
+			input:   "div > p { color: green; }",
+			wantErr: false,
+		},
+		{
+			name:    "adjacent sibling combinator",
+			input:   "h1 + p { margin-top: 0; }",
+			wantErr: false,
+		},
+		{
+			name:    "general sibling combinator",
+			input:   "h1 ~ p { color: gray; }",
+			wantErr: false,
+		},
+		{
+			name:    "attribute selector",
+			input:   `input[type="text"] { border: 1px solid black; }`,
+			wantErr: false,
+		},
+		{
+			name:    "pseudo-class",
+			input:   "a:hover { color: red; }",
+			wantErr: false,
+		},
+		{
+			name:    "pseudo-element",
+			input:   "p::first-line { font-weight: bold; }",
+			wantErr: false,
+		},
+		{
+			name:    "complex selector",
+			input:   "div.container > p.intro:first-child { color: blue; }",
+			wantErr: false,
+		},
+		{
+			name:    "@import",
+			input:   `@import url("style.css");`,
+			wantErr: false,
+		},
+		{
+			name:    "@charset",
+			input:   `@charset "UTF-8";`,
+			wantErr: false,
+		},
+		{
+			name:    "@media",
+			input:   "@media screen and (min-width: 768px) { .container { width: 750px; } }",
+			wantErr: false,
+		},
+		{
+			name:    "@keyframes",
+			input:   "@keyframes slide { from { left: 0; } to { left: 100px; } }",
+			wantErr: false,
+		},
+		{
+			name:    "@font-face",
+			input:   `@font-face { font-family: "MyFont"; src: url("font.woff2"); }`,
+			wantErr: false,
+		},
+		{
+			name:    "comment",
+			input:   "/* This is a comment */ body { color: red; }",
+			wantErr: false,
+		},
+		{
+			name:    "multiline comment",
+			input:   "/* Multi\nline\ncomment */ div { margin: 0; }",
+			wantErr: false,
+		},
+		{
+			name:    "color hex",
+			input:   "div { color: #ff0000; }",
+			wantErr: false,
+		},
+		{
+			name:    "color rgb",
+			input:   "div { color: rgb(255, 0, 0); }",
+			wantErr: false,
+		},
+		{
+			name:    "color rgba",
+			input:   "div { background: rgba(0, 0, 0, 0.5); }",
+			wantErr: false,
+		},
+		{
+			name:    "color hsl",
+			input:   "div { color: hsl(120, 100%, 50%); }",
+			wantErr: false,
+		},
+		{
+			name:    "calc function",
+			input:   "div { width: calc(100% - 20px); }",
+			wantErr: false,
+		},
+		{
+			name:    "var function",
+			input:   "div { color: var(--main-color); }",
+			wantErr: false,
+		},
+		{
+			name:    "url function",
+			input:   "div { background: url(image.png); }",
+			wantErr: false,
+		},
+		{
+			name:    "url function quoted",
+			input:   `div { background: url("image.png"); }`,
+			wantErr: false,
+		},
+		{
+			name:    "dimensions",
+			input:   "div { width: 100px; height: 50%; margin: 1em; padding: 2rem; }",
+			wantErr: false,
+		},
+		{
+			name:    "important",
+			input:   "div { color: red !important; }",
+			wantErr: false,
+		},
+		{
+			name:    "vendor prefix",
+			input:   "div { -webkit-transform: rotate(45deg); }",
+			wantErr: false,
+		},
+		{
+			name:    "custom property",
+			input:   ":root { --main-color: #06c; }",
+			wantErr: false,
+		},
+		{
+			name:    "missing semicolon",
+			input:   "div { color: red }",
+			wantErr: false,
+		},
+		{
+			name:    "multiple selectors",
+			input:   "h1, h2, h3 { font-weight: bold; }",
+			wantErr: false,
+		},
+		{
+			name:    "nested media query",
+			input:   "@media print { @page { margin: 1cm; } body { font-size: 12pt; } }",
+			wantErr: false,
+		},
+		{
+			name:    "universal selector",
+			input:   "* { box-sizing: border-box; }",
+			wantErr: false,
+		},
+		{
+			name:    "not pseudo-class",
+			input:   "p:not(.special) { color: gray; }",
+			wantErr: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			p := core.NewHandle(core.ColorOff).Stderr()
+			err := FormatCSS([]byte(tt.input), p)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("FormatCSS() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestFormatCSSOutput(t *testing.T) {
+	input := "body{color:red;margin:0}.container{display:flex}"
+	p := core.NewHandle(core.ColorOff).Stderr()
+	err := FormatCSS([]byte(input), p)
+	if err != nil {
+		t.Fatalf("FormatCSS() error = %v", err)
+	}
+
+	output := string(p.Bytes())
+	// Check that all values are present
+	for _, want := range []string{"body", "color", "red", "margin", "0", "container", "display", "flex"} {
+		if !strings.Contains(output, want) {
+			t.Errorf("output should contain %q, got: %s", want, output)
+		}
+	}
+	// Check for proper formatting (braces on separate lines)
+	if !strings.Contains(output, "{\n") {
+		t.Errorf("output should have opening braces followed by newline, got: %s", output)
+	}
+	if !strings.Contains(output, "}\n") {
+		t.Errorf("output should have closing braces followed by newline, got: %s", output)
+	}
+}
+
+func TestFormatCSSIndentation(t *testing.T) {
+	input := "body{color:red}"
+	p := core.NewHandle(core.ColorOff).Stderr()
+	err := FormatCSS([]byte(input), p)
+	if err != nil {
+		t.Fatalf("FormatCSS() error = %v", err)
+	}
+
+	output := string(p.Bytes())
+	lines := strings.Split(strings.TrimRight(output, "\n"), "\n")
+
+	// Expect:
+	// body {
+	//   color: red;
+	// }
+	if len(lines) != 3 {
+		t.Fatalf("expected 3 lines, got %d: %q", len(lines), output)
+	}
+
+	if !strings.HasPrefix(lines[0], "body") {
+		t.Errorf("first line should start with 'body', got: %q", lines[0])
+	}
+	if !strings.HasPrefix(lines[1], "  ") {
+		t.Errorf("second line should be indented, got: %q", lines[1])
+	}
+	if lines[2] != "}" {
+		t.Errorf("third line should be '}', got: %q", lines[2])
+	}
+}
+
+func TestFormatCSSMediaQuery(t *testing.T) {
+	input := "@media(min-width:768px){.container{width:750px}}"
+	p := core.NewHandle(core.ColorOff).Stderr()
+	err := FormatCSS([]byte(input), p)
+	if err != nil {
+		t.Fatalf("FormatCSS() error = %v", err)
+	}
+
+	output := string(p.Bytes())
+	// Should have @media at the start
+	if !strings.HasPrefix(output, "@media") {
+		t.Errorf("output should start with '@media', got: %s", output)
+	}
+	// Should contain the nested selector
+	if !strings.Contains(output, ".container") {
+		t.Errorf("output should contain '.container', got: %s", output)
+	}
+	// Should have nested indentation
+	if !strings.Contains(output, "    width") {
+		t.Errorf("output should have nested indentation for property, got: %s", output)
+	}
+}
+
+func TestFormatCSSComment(t *testing.T) {
+	input := "/* comment */ body { color: red; }"
+	p := core.NewHandle(core.ColorOff).Stderr()
+	err := FormatCSS([]byte(input), p)
+	if err != nil {
+		t.Fatalf("FormatCSS() error = %v", err)
+	}
+
+	output := string(p.Bytes())
+	if !strings.Contains(output, "/* comment */") {
+		t.Errorf("output should preserve comment, got: %s", output)
+	}
+}
+
+func TestFormatCSSEmpty(t *testing.T) {
+	p := core.NewHandle(core.ColorOff).Stderr()
+	err := FormatCSS([]byte(""), p)
+	if err != nil {
+		t.Fatalf("FormatCSS() error = %v", err)
+	}
+	if len(p.Bytes()) != 0 {
+		t.Errorf("expected empty output for empty input, got: %q", string(p.Bytes()))
+	}
+}
+
+func TestCSSTokenizer(t *testing.T) {
+	tests := []struct {
+		name      string
+		input     string
+		wantTypes []cssTokenType
+	}{
+		{
+			name:      "empty",
+			input:     "",
+			wantTypes: []cssTokenType{cssTokenEOF},
+		},
+		{
+			name:      "identifier",
+			input:     "body",
+			wantTypes: []cssTokenType{cssTokenIdent, cssTokenEOF},
+		},
+		{
+			name:      "hash",
+			input:     "#id",
+			wantTypes: []cssTokenType{cssTokenHash, cssTokenEOF},
+		},
+		{
+			name:      "at-keyword",
+			input:     "@media",
+			wantTypes: []cssTokenType{cssTokenAtKeyword, cssTokenEOF},
+		},
+		{
+			name:      "string double quote",
+			input:     `"hello"`,
+			wantTypes: []cssTokenType{cssTokenString, cssTokenEOF},
+		},
+		{
+			name:      "string single quote",
+			input:     `'hello'`,
+			wantTypes: []cssTokenType{cssTokenString, cssTokenEOF},
+		},
+		{
+			name:      "number",
+			input:     "123",
+			wantTypes: []cssTokenType{cssTokenNumber, cssTokenEOF},
+		},
+		{
+			name:      "dimension",
+			input:     "10px",
+			wantTypes: []cssTokenType{cssTokenDimension, cssTokenEOF},
+		},
+		{
+			name:      "percentage",
+			input:     "50%",
+			wantTypes: []cssTokenType{cssTokenDimension, cssTokenEOF},
+		},
+		{
+			name:      "function",
+			input:     "calc(",
+			wantTypes: []cssTokenType{cssTokenFunction, cssTokenEOF},
+		},
+		{
+			name:      "comment",
+			input:     "/* comment */",
+			wantTypes: []cssTokenType{cssTokenComment, cssTokenEOF},
+		},
+		{
+			name:      "delimiters",
+			input:     "{}:;",
+			wantTypes: []cssTokenType{cssTokenDelim, cssTokenDelim, cssTokenDelim, cssTokenDelim, cssTokenEOF},
+		},
+		{
+			name:      "whitespace",
+			input:     "  \t\n",
+			wantTypes: []cssTokenType{cssTokenWhitespace, cssTokenEOF},
+		},
+		{
+			name:      "simple rule",
+			input:     "body { color: red; }",
+			wantTypes: []cssTokenType{cssTokenIdent, cssTokenWhitespace, cssTokenDelim, cssTokenWhitespace, cssTokenIdent, cssTokenDelim, cssTokenWhitespace, cssTokenIdent, cssTokenDelim, cssTokenWhitespace, cssTokenDelim, cssTokenEOF},
+		},
+		{
+			name:      "custom property",
+			input:     "--main-color",
+			wantTypes: []cssTokenType{cssTokenIdent, cssTokenEOF},
+		},
+		{
+			name:      "negative number",
+			input:     "-10px",
+			wantTypes: []cssTokenType{cssTokenDimension, cssTokenEOF},
+		},
+		{
+			name:      "decimal number",
+			input:     "1.5em",
+			wantTypes: []cssTokenType{cssTokenDimension, cssTokenEOF},
+		},
+		{
+			name:      "vendor prefix",
+			input:     "-webkit-transform",
+			wantTypes: []cssTokenType{cssTokenIdent, cssTokenEOF},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tok := newCSSTokenizer([]byte(tt.input))
+			var gotTypes []cssTokenType
+
+			for {
+				token := tok.next()
+				gotTypes = append(gotTypes, token.typ)
+				if token.typ == cssTokenEOF {
+					break
+				}
+			}
+
+			if len(gotTypes) != len(tt.wantTypes) {
+				t.Fatalf("got %d tokens, want %d tokens\ngot: %v\nwant: %v", len(gotTypes), len(tt.wantTypes), gotTypes, tt.wantTypes)
+			}
+
+			for i, got := range gotTypes {
+				if got != tt.wantTypes[i] {
+					t.Errorf("token %d: got type %v, want %v", i, got, tt.wantTypes[i])
+				}
+			}
+		})
+	}
+}
+
+func TestCSSTokenizerValues(t *testing.T) {
+	tests := []struct {
+		name      string
+		input     string
+		wantValue string
+	}{
+		{
+			name:      "identifier",
+			input:     "body",
+			wantValue: "body",
+		},
+		{
+			name:      "hash",
+			input:     "#header",
+			wantValue: "#header",
+		},
+		{
+			name:      "at-keyword",
+			input:     "@media",
+			wantValue: "@media",
+		},
+		{
+			name:      "string",
+			input:     `"hello world"`,
+			wantValue: `"hello world"`,
+		},
+		{
+			name:      "string with escape",
+			input:     `"hello\"world"`,
+			wantValue: `"hello\"world"`,
+		},
+		{
+			name:      "dimension",
+			input:     "10px",
+			wantValue: "10px",
+		},
+		{
+			name:      "comment",
+			input:     "/* test */",
+			wantValue: "/* test */",
+		},
+		{
+			name:      "function",
+			input:     "rgba(",
+			wantValue: "rgba(",
+		},
+		{
+			name:      "custom property",
+			input:     "--color",
+			wantValue: "--color",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tok := newCSSTokenizer([]byte(tt.input))
+			token := tok.next()
+			if token.value != tt.wantValue {
+				t.Errorf("got value %q, want %q", token.value, tt.wantValue)
+			}
+		})
+	}
+}
+
+func TestFormatCSSKeyframes(t *testing.T) {
+	input := "@keyframes fadeIn { 0% { opacity: 0; } 100% { opacity: 1; } }"
+	p := core.NewHandle(core.ColorOff).Stderr()
+	err := FormatCSS([]byte(input), p)
+	if err != nil {
+		t.Fatalf("FormatCSS() error = %v", err)
+	}
+
+	output := string(p.Bytes())
+	if !strings.Contains(output, "@keyframes") {
+		t.Errorf("output should contain '@keyframes', got: %s", output)
+	}
+	if !strings.Contains(output, "0%") {
+		t.Errorf("output should contain '0%%', got: %s", output)
+	}
+	if !strings.Contains(output, "100%") {
+		t.Errorf("output should contain '100%%', got: %s", output)
+	}
+	if !strings.Contains(output, "opacity") {
+		t.Errorf("output should contain 'opacity', got: %s", output)
+	}
+}
+
+func TestFormatCSSComplexSelector(t *testing.T) {
+	input := "div.container > ul.nav li.item:hover a { color: blue; }"
+	p := core.NewHandle(core.ColorOff).Stderr()
+	err := FormatCSS([]byte(input), p)
+	if err != nil {
+		t.Fatalf("FormatCSS() error = %v", err)
+	}
+
+	output := string(p.Bytes())
+	for _, want := range []string{"div", ".container", ">", "ul", ".nav", "li", ".item", ":hover", "a"} {
+		if !strings.Contains(output, want) {
+			t.Errorf("output should contain %q, got: %s", want, output)
+		}
+	}
+}
+
+func TestFormatCSSFontFace(t *testing.T) {
+	input := `@font-face { font-family: "Open Sans"; src: url("opensans.woff2") format("woff2"); font-weight: 400; }`
+	p := core.NewHandle(core.ColorOff).Stderr()
+	err := FormatCSS([]byte(input), p)
+	if err != nil {
+		t.Fatalf("FormatCSS() error = %v", err)
+	}
+
+	output := string(p.Bytes())
+	if !strings.Contains(output, "@font-face") {
+		t.Errorf("output should contain '@font-face', got: %s", output)
+	}
+	if !strings.Contains(output, "font-family") {
+		t.Errorf("output should contain 'font-family', got: %s", output)
+	}
+	if !strings.Contains(output, "Open Sans") {
+		t.Errorf("output should contain 'Open Sans', got: %s", output)
+	}
+}
+
+func TestFormatCSSCalc(t *testing.T) {
+	input := "div { width: calc(100% - 20px); height: calc(50vh + 10px); }"
+	p := core.NewHandle(core.ColorOff).Stderr()
+	err := FormatCSS([]byte(input), p)
+	if err != nil {
+		t.Fatalf("FormatCSS() error = %v", err)
+	}
+
+	output := string(p.Bytes())
+	if !strings.Contains(output, "calc(") {
+		t.Errorf("output should contain 'calc(', got: %s", output)
+	}
+	if !strings.Contains(output, "100%") {
+		t.Errorf("output should contain '100%%', got: %s", output)
+	}
+}
+
+func TestFormatCSSBlankLinesBetweenRules(t *testing.T) {
+	input := ".a{color:red}.b{color:blue}"
+	p := core.NewHandle(core.ColorOff).Stderr()
+	err := FormatCSS([]byte(input), p)
+	if err != nil {
+		t.Fatalf("FormatCSS() error = %v", err)
+	}
+
+	output := string(p.Bytes())
+	// Should have blank line between rules (}\n\n.)
+	if !strings.Contains(output, "}\n\n.") {
+		t.Errorf("output should have blank line between rules, got: %q", output)
+	}
+}
+
+func TestFormatCSSTrailingNewline(t *testing.T) {
+	tests := []struct {
+		name  string
+		input string
+	}{
+		{"single rule", "body{color:red}"},
+		{"multiple rules", ".a{color:red}.b{color:blue}"},
+		{"with media query", "@media screen{.a{color:red}}"},
+		{"with import", `@import url("style.css");`},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			p := core.NewHandle(core.ColorOff).Stderr()
+			err := FormatCSS([]byte(tt.input), p)
+			if err != nil {
+				t.Fatalf("FormatCSS() error = %v", err)
+			}
+
+			output := string(p.Bytes())
+			// Should end with exactly one newline
+			if !strings.HasSuffix(output, "\n") {
+				t.Errorf("output should end with newline, got: %q", output)
+			}
+			if strings.HasSuffix(output, "\n\n") {
+				t.Errorf("output should not end with double newline, got: %q", output)
+			}
+		})
+	}
+}
+
+func TestFormatCSSCustomProperties(t *testing.T) {
+	input := ":root { --primary-color: #06c; --spacing: 1rem; } .element { color: var(--primary-color); padding: var(--spacing); }"
+	p := core.NewHandle(core.ColorOff).Stderr()
+	err := FormatCSS([]byte(input), p)
+	if err != nil {
+		t.Fatalf("FormatCSS() error = %v", err)
+	}
+
+	output := string(p.Bytes())
+	if !strings.Contains(output, "--primary-color") {
+		t.Errorf("output should contain '--primary-color', got: %s", output)
+	}
+	if !strings.Contains(output, "var(") {
+		t.Errorf("output should contain 'var(', got: %s", output)
+	}
+}
diff --git a/internal/format/html.go b/internal/format/html.go
index 58ea49c..9d3a313 100644
--- a/internal/format/html.go
+++ b/internal/format/html.go
@@ -253,10 +253,26 @@ func FormatHTML(buf []byte, w *core.Printer) error {
 			}
 
 			if inRawText || inPreserveWS {
-				// Preserve content exactly.
-				w.Set(core.Green)
-				w.Write(text)
-				w.Reset()
+				if len(stack) > 0 && stack[len(stack)-1].tagName == "style" {
+					// Format CSS content inside <style> tags.
+					w.WriteString("\n")
+					trimmedText := bytes.TrimSpace(text)
+					if len(trimmedText) > 0 {
+						if FormatCSSIndented(trimmedText, w, len(stack)) != nil {
+							// Fallback to raw output on error.
+							w.Set(core.Green)
+							w.Write(text)
+							w.Reset()
+						}
+					}
+					// Mark parent as having block content so closing tag is indented.
+					stack[len(stack)-1].hasBlockChild = true
+				} else {
+					// Preserve content exactly (script tags, etc.).
+					w.Set(core.Green)
+					w.Write(text)
+					w.Reset()
+				}
 			} else {
 				// Skip text that is only whitespace (formatting whitespace in source).
 				// For text with content, normalize by trimming leading/trailing whitespace
diff --git a/internal/format/html_test.go b/internal/format/html_test.go
index 1863a0b..f857cc3 100644
--- a/internal/format/html_test.go
+++ b/internal/format/html_test.go
@@ -316,6 +316,138 @@ func TestFormatHTMLPlanExample(t *testing.T) {
 	}
 }
 
+func TestFormatHTMLEmbeddedCSS(t *testing.T) {
+	t.Run("basic embedded CSS", func(t *testing.T) {
+		input := `<style>body{color:red}</style>`
+		p := core.NewHandle(core.ColorOff).Stderr()
+		err := FormatHTML([]byte(input), p)
+		if err != nil {
+			t.Fatalf("FormatHTML() error = %v", err)
+		}
+
+		output := string(p.Bytes())
+		// Should contain formatted CSS with body selector and color property.
+		if !strings.Contains(output, "body") {
+			t.Errorf("output should contain 'body', got: %s", output)
+		}
+		if !strings.Contains(output, "color") {
+			t.Errorf("output should contain 'color', got: %s", output)
+		}
+		if !strings.Contains(output, "red") {
+			t.Errorf("output should contain 'red', got: %s", output)
+		}
+	})
+
+	t.Run("nested HTML with style", func(t *testing.T) {
+		input := `<html><head><style>.a{margin:0}</style></head></html>`
+		p := core.NewHandle(core.ColorOff).Stderr()
+		err := FormatHTML([]byte(input), p)
+		if err != nil {
+			t.Fatalf("FormatHTML() error = %v", err)
+		}
+
+		output := string(p.Bytes())
+		// Should contain formatted CSS.
+		if !strings.Contains(output, ".a") {
+			t.Errorf("output should contain '.a', got: %s", output)
+		}
+		if !strings.Contains(output, "margin") {
+			t.Errorf("output should contain 'margin', got: %s", output)
+		}
+	})
+
+	t.Run("empty style tag", func(t *testing.T) {
+		input := `<style></style>`
+		p := core.NewHandle(core.ColorOff).Stderr()
+		err := FormatHTML([]byte(input), p)
+		if err != nil {
+			t.Fatalf("FormatHTML() error = %v", err)
+		}
+
+		output := string(p.Bytes())
+		// Should just have the style tags.
+		if !strings.Contains(output, "<style>") {
+			t.Errorf("output should contain '<style>', got: %s", output)
+		}
+		if !strings.Contains(output, "</style>") {
+			t.Errorf("output should contain '</style>', got: %s", output)
+		}
+	})
+
+	t.Run("whitespace-only style", func(t *testing.T) {
+		input := `<style>
+   </style>`
+		p := core.NewHandle(core.ColorOff).Stderr()
+		err := FormatHTML([]byte(input), p)
+		if err != nil {
+			t.Fatalf("FormatHTML() error = %v", err)
+		}
+
+		output := string(p.Bytes())
+		// Should contain style tags but no CSS content other than newlines.
+		if !strings.Contains(output, "<style>") {
+			t.Errorf("output should contain '<style>', got: %s", output)
+		}
+	})
+
+	t.Run("script tag unchanged", func(t *testing.T) {
+		input := `<script>var x = 1;</script>`
+		p := core.NewHandle(core.ColorOff).Stderr()
+		err := FormatHTML([]byte(input), p)
+		if err != nil {
+			t.Fatalf("FormatHTML() error = %v", err)
+		}
+
+		output := string(p.Bytes())
+		// Script content should be preserved as-is.
+		if !strings.Contains(output, "var x = 1;") {
+			t.Errorf("script content should be preserved, got: %s", output)
+		}
+	})
+
+	t.Run("multiple style tags", func(t *testing.T) {
+		input := `<style>.a{}</style><style>.b{}</style>`
+		p := core.NewHandle(core.ColorOff).Stderr()
+		err := FormatHTML([]byte(input), p)
+		if err != nil {
+			t.Fatalf("FormatHTML() error = %v", err)
+		}
+
+		output := string(p.Bytes())
+		// Both should be formatted.
+		if !strings.Contains(output, ".a") {
+			t.Errorf("output should contain '.a', got: %s", output)
+		}
+		if !strings.Contains(output, ".b") {
+			t.Errorf("output should contain '.b', got: %s", output)
+		}
+	})
+
+	t.Run("complex CSS in nested HTML", func(t *testing.T) {
+		input := `<html><head><style>body{color:red;margin:0}.container{display:flex}</style></head></html>`
+		p := core.NewHandle(core.ColorOff).Stderr()
+		err := FormatHTML([]byte(input), p)
+		if err != nil {
+			t.Fatalf("FormatHTML() error = %v", err)
+		}
+
+		output := string(p.Bytes())
+		// Should contain formatted CSS with multiple rules.
+		if !strings.Contains(output, "body") {
+			t.Errorf("output should contain 'body', got: %s", output)
+		}
+		if !strings.Contains(output, ".container") {
+			t.Errorf("output should contain '.container', got: %s", output)
+		}
+		if !strings.Contains(output, "display") {
+			t.Errorf("output should contain 'display', got: %s", output)
+		}
+		if !strings.Contains(output, "flex") {
+			t.Errorf("output should contain 'flex', got: %s", output)
+		}
+	})
+}
+
 func TestEscapeHTMLAttrValue(t *testing.T) {
 	tests := []struct {
 		name  string