cataract 0.2.3 → 0.2.5

data/ext/cataract/css_parser.c

@@ -12,6 +12,11 @@
 
 #include "cataract.h"
 #include <string.h>
+#include <stdint.h>
+
+// Use uint8_t for boolean flags to reduce struct size and improve cache efficiency
+// (int is 4 bytes, uint8_t is 1 byte - saves 27 bytes across 9 flags)
+#define BOOLEAN uint8_t
 
 // Parser context passed through recursive calls
 typedef struct {
@@ -19,13 +24,29 @@ typedef struct {
     VALUE media_index;        // Hash: Symbol => Array of rule IDs
     VALUE selector_lists;     // Hash: list_id => Array of rule IDs
     VALUE imports_array;      // Array of ImportStatement structs
+    VALUE media_queries;      // Array of MediaQuery structs
+    VALUE media_query_lists;  // Hash: list_id => Array of MediaQuery IDs
     int rule_id_counter;      // Next rule ID (0-indexed)
     int next_selector_list_id; // Next selector list ID (0-indexed)
+    int media_query_id_counter; // Next MediaQuery ID (0-indexed)
+    int next_media_query_list_id; // Next media query list ID (0-indexed)
     int media_query_count;    // Safety limit for media queries
     st_table *media_cache;    // Parse-time cache: string => parsed media types
-    int has_nesting;          // Set to 1 if any nested rules are created
-    int selector_lists_enabled; // Parser option: track selector lists (1=enabled, 0=disabled)
-    int depth;                // Current recursion depth (safety limit)
+    BOOLEAN has_nesting;      // Set to 1 if any nested rules are created
+    BOOLEAN selector_lists_enabled; // Parser option: track selector lists (1=enabled, 0=disabled)
+    BOOLEAN depth;            // Current recursion depth (safety limit)
+    // URL conversion options
+    VALUE base_uri;           // Base URI for resolving relative URLs (Qnil if disabled)
+    VALUE uri_resolver;       // Proc to call for URL resolution (Qnil for default)
+    BOOLEAN absolute_paths;   // Whether to convert relative URLs to absolute
+    // Parse error checking options
+    VALUE css_string;         // Full CSS string for error position calculation
+    BOOLEAN check_empty_values; // Raise error on empty declaration values
+    BOOLEAN check_malformed_declarations; // Raise error on declarations without colons
+    BOOLEAN check_invalid_selectors; // Raise error on empty/malformed selectors
+    BOOLEAN check_invalid_selector_syntax; // Raise error on syntax violations (.. ## etc)
+    BOOLEAN check_malformed_at_rules; // Raise error on @media/@supports without conditions
+    BOOLEAN check_unclosed_blocks; // Raise error on missing closing braces
 } ParserContext;
 
 // Macro to skip CSS comments /* ... */
@@ -55,6 +76,20 @@ static inline const char* find_matching_brace(const char *start, const char *end
     return p;
 }
 
+// Find matching closing brace with strict error checking
+// Input: start = position after opening '{', end = limit, check_unclosed = whether to raise error
+// Returns: pointer to matching '}' (raises error if not found and check_unclosed is true)
+static inline const char* find_matching_brace_strict(const char *start, const char *end, int check_unclosed) {
+    const char *closing_brace = find_matching_brace(start, end);
+
+    // Check if we found the closing brace
+    if (check_unclosed && closing_brace >= end) {
+        rb_raise(eParseError, "Unclosed block: missing closing brace");
+    }
+
+    return closing_brace;
+}
+
 // Find matching closing paren
 // Input: start = position after opening '(', end = limit
 // Returns: pointer to matching ')' (or end if not found)
@@ -70,6 +105,99 @@ static inline const char* find_matching_paren(const char *start, const char *end
     return p;
 }
 
+// Helper function to raise ParseError with automatic position calculation
+// Does not return - raises error and exits
+__attribute__((noreturn))
+static void raise_parse_error_at(ParserContext *ctx, const char *error_pos, const char *message, const char *error_type) {
+    const char *css = RSTRING_PTR(ctx->css_string);
+    long pos = error_pos - css;
+
+    // Build keyword args hash
+    VALUE kwargs = rb_hash_new();
+    rb_hash_aset(kwargs, ID2SYM(rb_intern("css")), ctx->css_string);
+    rb_hash_aset(kwargs, ID2SYM(rb_intern("pos")), LONG2NUM(pos));
+    rb_hash_aset(kwargs, ID2SYM(rb_intern("type")), ID2SYM(rb_intern(error_type)));
+
+    // Create ParseError instance
+    VALUE msg_str = rb_str_new_cstr(message);
+    VALUE argv[2] = {msg_str, kwargs};
+    VALUE error = rb_funcallv_kw(eParseError, rb_intern("new"), 2, argv, RB_PASS_KEYWORDS);
+
+    // Raise the error
+    rb_exc_raise(error);
+}
+
+// Check if a selector contains only valid CSS selector characters and sequences
+// Returns 1 if valid, 0 if invalid
+// Valid characters: a-z A-Z 0-9 - _ . # [ ] : * > + ~ ( ) ' " = ^ $ | \ & % / whitespace
+static inline int is_valid_selector(const char *start, const char *end) {
+    const char *p = start;
+    while (p < end) {
+        unsigned char c = (unsigned char)*p;
+
+        // Check for invalid character sequences
+        if (p + 1 < end) {
+            // Double dot (..) is invalid
+            if (c == '.' && *(p + 1) == '.') {
+                return 0;
+            }
+            // Double hash (##) is invalid
+            if (c == '#' && *(p + 1) == '#') {
+                return 0;
+            }
+        }
+
+        // Alphanumeric
+        if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9')) {
+            p++;
+            continue;
+        }
+
+        // Whitespace
+        if (c == ' ' || c == '\t' || c == '\n' || c == '\r') {
+            p++;
+            continue;
+        }
+
+        // Valid CSS selector special characters
+        switch (c) {
+            case '-':  // Hyphen (in identifiers, attribute selectors)
+            case '_':  // Underscore (in identifiers)
+            case '.':  // Class selector
+            case '#':  // ID selector
+            case '[':  // Attribute selector start
+            case ']':  // Attribute selector end
+            case ':':  // Pseudo-class/element (:: is valid for pseudo-elements)
+            case '*':  // Universal selector, attribute operator
+            case '>':  // Child combinator
+            case '+':  // Adjacent sibling combinator
+            case '~':  // General sibling combinator
+            case '(':  // Pseudo-class function
+            case ')':  // Pseudo-class function end
+            case '\'': // String in attribute selector
+            case '"':  // String in attribute selector
+            case '=':  // Attribute operator
+            case '^':  // Attribute operator ^=
+            case '$':  // Attribute operator $=
+            case '|':  // Attribute operator |=, namespace separator
+            case '\\': // Escape character
+            case '&':  // Nesting selector
+            case '%':  // Sometimes used in selectors
+            case '/':  // Sometimes used in selectors
+            case '!':  // Negation (though rare)
+            case ',':  // List separator (shouldn't be here after splitting, but allow it)
+                p++;
+                break;
+
+            default:
+                // Invalid character found
+                return 0;
+        }
+    }
+
+    return 1;
+}
+
 // Lowercase property name (CSS property names are ASCII-only)
 // Non-static so merge_new.c can use it
 VALUE lowercase_property(VALUE property_str) {
@@ -169,7 +297,7 @@ static VALUE resolve_nested_selector(VALUE parent_selector, const char *nested_s
     long parent_len = RSTRING_LEN(parent_selector);
 
     // Check if nested selector contains &
-    int has_ampersand = 0;
+    BOOLEAN has_ampersand = 0;
     for (long i = 0; i < nested_len; i++) {
         if (nested_sel[i] == '&') {
             has_ampersand = 1;
@@ -384,12 +512,188 @@ static void update_media_index(ParserContext *ctx, VALUE media_sym, int rule_id)
     }
 
     // Add to full query symbol (after media types for insertion order)
-    add_to_media_index(ctx->media_index, media_sym, rule_id);
+    // BUT: skip if it contains a comma (comma-separated list like "screen, print")
+    // because we already added each individual type above
+    int has_comma = 0;
+    for (long i = 0; i < query_len; i++) {
+        if (query[i] == ',') {
+            has_comma = 1;
+            break;
+        }
+    }
+    if (!has_comma) {
+        add_to_media_index(ctx->media_index, media_sym, rule_id);
+    }
 
     // Guard media_str since we extracted C pointer and called extract_media_types (which allocates)
     RB_GC_GUARD(media_str);
 }
 
+// Helper struct for passing arguments to resolver callback
+typedef struct {
+    VALUE uri_resolver;
+    VALUE base_uri;
+    VALUE url_str;
+} ResolverArgs;
+
+// Callback for rb_protect to call the resolver proc
+static VALUE call_resolver(VALUE arg) {
+    ResolverArgs *args = (ResolverArgs *)arg;
+    return rb_funcall(args->uri_resolver, rb_intern("call"), 2, args->base_uri, args->url_str);
+}
+
+/*
+ * Convert relative URLs in a CSS value to absolute URLs
+ *
+ * Scans for url() patterns and resolves relative URLs using the resolver proc.
+ * Returns a new Ruby string with resolved URLs, or the original if no conversion needed.
+ */
+static VALUE convert_urls_in_value(VALUE value_str, VALUE base_uri, VALUE uri_resolver) {
+    const char *val = RSTRING_PTR(value_str);
+    long len = RSTRING_LEN(value_str);
+
+    // Quick check: does value contain 'url('?
+    const char *url_check = val;
+    int has_url = 0;
+    while (url_check < val + len - 3) {
+        if ((*url_check == 'u' || *url_check == 'U') &&
+            (*(url_check + 1) == 'r' || *(url_check + 1) == 'R') &&
+            (*(url_check + 2) == 'l' || *(url_check + 2) == 'L') &&
+            *(url_check + 3) == '(') {
+            has_url = 1;
+            break;
+        }
+        url_check++;
+    }
+    if (!has_url) return value_str;
+
+    // Build result string
+    VALUE result = rb_str_new("", 0);
+    const char *pos = val;
+
+    while (pos < val + len) {
+        // Look for 'url(' - case insensitive
+        if (pos + 3 < val + len &&
+            (*pos == 'u' || *pos == 'U') &&
+            (*(pos + 1) == 'r' || *(pos + 1) == 'R') &&
+            (*(pos + 2) == 'l' || *(pos + 2) == 'L') &&
+            *(pos + 3) == '(') {
+
+            // Append 'url('
+            rb_str_cat(result, "url(", 4);
+            pos += 4;
+
+            // Skip whitespace after (
+            while (pos < val + len && IS_WHITESPACE(*pos)) pos++;
+
+            // Determine quote character (if any)
+            char quote = 0;
+            if (pos < val + len && (*pos == '\'' || *pos == '"')) {
+                quote = *pos;
+                pos++;
+            }
+
+            // Find end of URL
+            const char *url_start = pos;
+            if (quote) {
+                // Quoted URL - find closing quote
+                while (pos < val + len && *pos != quote) {
+                    if (*pos == '\\' && pos + 1 < val + len) {
+                        pos += 2;  // Skip escaped char
+                    } else {
+                        pos++;
+                    }
+                }
+            } else {
+                // Unquoted URL - find ) or whitespace
+                while (pos < val + len && *pos != ')' && !IS_WHITESPACE(*pos)) {
+                    pos++;
+                }
+            }
+            const char *url_end = pos;
+
+            // Extract URL string
+            long url_len = url_end - url_start;
+            VALUE url_str = rb_str_new(url_start, url_len);
+
+            // Check if URL needs resolution (is relative)
+            int needs_resolution = 0;
+            if (url_len > 0) {
+                // Check for absolute URLs or data URIs that don't need resolution
+                const char *u = url_start;
+                if ((url_len >= 5 && strncmp(u, "data:", 5) == 0) ||
+                    (url_len >= 7 && strncmp(u, "http://", 7) == 0) ||
+                    (url_len >= 8 && strncmp(u, "https://", 8) == 0) ||
+                    (url_len >= 2 && strncmp(u, "//", 2) == 0) ||
+                    (url_len >= 1 && *u == '#')) {  // Fragment reference
+                    needs_resolution = 0;
+                } else {
+                    needs_resolution = 1;
+                }
+            }
+
+            if (needs_resolution) {
+                // Resolve using the resolver proc (always provided by Ruby side)
+                // Wrap in rb_protect to catch exceptions
+                ResolverArgs args = { uri_resolver, base_uri, url_str };
+                int state = 0;
+                VALUE resolved = rb_protect(call_resolver, (VALUE)&args, &state);
+
+                if (state) {
+                    // Exception occurred - preserve original URL
+                    rb_set_errinfo(Qnil);  // Clear exception
+                    if (quote) {
+                        rb_str_cat(result, &quote, 1);
+                        rb_str_append(result, url_str);
+                        rb_str_cat(result, &quote, 1);
+                    } else {
+                        rb_str_append(result, url_str);
+                    }
+                } else {
+                    // Output with single quotes (canonical format)
+                    rb_str_cat(result, "'", 1);
+                    rb_str_append(result, resolved);
+                    rb_str_cat(result, "'", 1);
+                }
+
+                RB_GC_GUARD(resolved);
+            } else {
+                // Keep original URL with original quoting
+                if (quote) {
+                    rb_str_cat(result, &quote, 1);
+                    rb_str_append(result, url_str);
+                    rb_str_cat(result, &quote, 1);
+                } else {
+                    rb_str_append(result, url_str);
+                }
+            }
+
+            RB_GC_GUARD(url_str);
+
+            // Skip closing quote if present
+            if (quote && pos < val + len && *pos == quote) {
+                pos++;
+            }
+
+            // Skip whitespace before )
+            while (pos < val + len && IS_WHITESPACE(*pos)) pos++;
+
+            // Skip closing )
+            if (pos < val + len && *pos == ')') {
+                rb_str_cat(result, ")", 1);
+                pos++;
+            }
+        } else {
+            // Regular character - append to result
+            rb_str_cat(result, pos, 1);
+            pos++;
+        }
+    }
+
+    RB_GC_GUARD(result);
+    return result;
+}
+
 /*
  * Parse declaration block into array of Declaration structs
  *
@@ -403,7 +707,7 @@ static void update_media_index(ParserContext *ctx, VALUE media_sym, int rule_id)
  *   - Values containing parentheses (e.g., url(...), rgba(...))
  *   - !important flag
  */
-static VALUE parse_declarations(const char *start, const char *end) {
+static VALUE parse_declarations(const char *start, const char *end, ParserContext *ctx) {
     VALUE declarations = rb_ary_new();
 
     const char *pos = start;
@@ -422,6 +726,46 @@ static VALUE parse_declarations(const char *start, const char *end) {
 
         // Malformed declaration - skip to next semicolon to recover
         if (pos >= end || *pos != ':') {
+            if (ctx->check_malformed_declarations) {
+                // Extract property text for error message
+                const char *prop_text_end = pos;
+                trim_trailing(prop_start, &prop_text_end);
+                long prop_text_len = prop_text_end - prop_start;
+
+                const char *css = RSTRING_PTR(ctx->css_string);
+                long error_pos = prop_start - css;
+
+                if (prop_text_len == 0) {
+                    // Build keyword args hash
+                    VALUE kwargs = rb_hash_new();
+                    rb_hash_aset(kwargs, ID2SYM(rb_intern("css")), ctx->css_string);
+                    rb_hash_aset(kwargs, ID2SYM(rb_intern("pos")), LONG2NUM(error_pos));
+                    rb_hash_aset(kwargs, ID2SYM(rb_intern("type")), ID2SYM(rb_intern("malformed_declaration")));
+
+                    VALUE msg_str = rb_str_new_cstr("Malformed declaration: missing property name");
+                    VALUE argv[2] = {msg_str, kwargs};
+                    VALUE error = rb_funcallv_kw(eParseError, rb_intern("new"), 2, argv, RB_PASS_KEYWORDS);
+                    rb_exc_raise(error);
+                } else {
+                    // Limit property name to 200 chars in error message
+                    int display_len = (prop_text_len > 200) ? 200 : (int)prop_text_len;
+                    char error_msg[256];
+                    snprintf(error_msg, sizeof(error_msg),
+                           "Malformed declaration: missing colon after '%.*s'",
+                           display_len, prop_start);
+
+                    // Build keyword args hash
+                    VALUE kwargs = rb_hash_new();
+                    rb_hash_aset(kwargs, ID2SYM(rb_intern("css")), ctx->css_string);
+                    rb_hash_aset(kwargs, ID2SYM(rb_intern("pos")), LONG2NUM(error_pos));
+                    rb_hash_aset(kwargs, ID2SYM(rb_intern("type")), ID2SYM(rb_intern("malformed_declaration")));
+
+                    VALUE msg_str = rb_str_new_cstr(error_msg);
+                    VALUE argv[2] = {msg_str, kwargs};
+                    VALUE error = rb_funcallv_kw(eParseError, rb_intern("new"), 2, argv, RB_PASS_KEYWORDS);
+                    rb_exc_raise(error);
+                }
+            }
             while (pos < end && *pos != ';') pos++;
             if (pos < end) pos++;  // Skip the semicolon
             continue;
@@ -461,7 +805,7 @@ static VALUE parse_declarations(const char *start, const char *end) {
         trim_trailing(val_start, &val_end);
 
         // Check for !important
-        int is_important = 0;
+        BOOLEAN is_important = 0;
         if (val_end - val_start >= 10) {  // strlen("!important") = 10
             const char *check = val_end - 10;
             while (check < val_end && IS_WHITESPACE(*check)) check++;
@@ -483,6 +827,34 @@ static VALUE parse_declarations(const char *start, const char *end) {
         // Final trim
         trim_trailing(val_start, &val_end);
 
+        // Check for empty value
+        if (val_end <= val_start && ctx->check_empty_values) {
+            long prop_len = prop_end - prop_start;
+            const char *css = RSTRING_PTR(ctx->css_string);
+            long error_pos = val_start - css;
+
+            // Build error message
+            int display_len = (prop_len > 200) ? 200 : (int)prop_len;
+            char error_msg[256];
+            snprintf(error_msg, sizeof(error_msg),
+                   "Empty value for property '%.*s'",
+                   display_len, prop_start);
+
+            // Build keyword args hash
+            VALUE kwargs = rb_hash_new();
+            rb_hash_aset(kwargs, ID2SYM(rb_intern("css")), ctx->css_string);
+            rb_hash_aset(kwargs, ID2SYM(rb_intern("pos")), LONG2NUM(error_pos));
+            rb_hash_aset(kwargs, ID2SYM(rb_intern("type")), ID2SYM(rb_intern("empty_value")));
+
+            // Create ParseError instance: ParseError.new(message, **kwargs)
+            VALUE msg_str = rb_str_new_cstr(error_msg);
+            VALUE argv[2] = {msg_str, kwargs};
+            VALUE error = rb_funcallv_kw(eParseError, rb_intern("new"), 2, argv, RB_PASS_KEYWORDS);
+
+            // Raise the error
+            rb_exc_raise(error);
+        }
+
         // Skip if value is empty
         if (val_end > val_start) {
             long prop_len = prop_end - prop_start;
@@ -513,6 +885,11 @@ static VALUE parse_declarations(const char *start, const char *end) {
             }
             VALUE value = rb_utf8_str_new(val_start, val_len);
 
+            // Convert relative URLs to absolute if enabled
+            if (ctx && ctx->absolute_paths && !NIL_P(ctx->base_uri)) {
+                value = convert_urls_in_value(value, ctx->base_uri, ctx->uri_resolver);
+            }
+
             // Create Declaration struct
             VALUE decl = rb_struct_new(cDeclaration,
                 property,
@@ -531,7 +908,7 @@ static VALUE parse_declarations(const char *start, const char *end) {
 
 // Forward declarations
 static void parse_css_recursive(ParserContext *ctx, const char *css, const char *pe,
-                                 VALUE parent_media_sym, VALUE parent_selector, VALUE parent_rule_id);
+                                 VALUE parent_media_sym, VALUE parent_selector, VALUE parent_rule_id, int parent_media_query_id);
 static VALUE combine_media_queries(VALUE parent, VALUE child);
 
 /*
@@ -630,7 +1007,7 @@ static VALUE intern_media_query_safe(ParserContext *ctx, const char *query_str,
  * Returns: Array of declarations (only the declarations, not nested rules)
  */
 static VALUE parse_mixed_block(ParserContext *ctx, const char *start, const char *end,
-                                VALUE parent_selector, VALUE parent_rule_id, VALUE parent_media_sym) {
+                                VALUE parent_selector, VALUE parent_rule_id, VALUE parent_media_sym, int parent_media_query_id) {
     // Check recursion depth to prevent stack overflow
     if (ctx->depth > MAX_PARSE_DEPTH) {
         rb_raise(eDepthError,
@@ -661,23 +1038,109 @@ static VALUE parse_mixed_block(ParserContext *ctx, const char *start, const char
             }
             if (media_query_end >= end) break;
 
-            // Extract media query
+            // Extract media query string
             const char *media_query_start = media_start;
             const char *media_query_end_trimmed = media_query_end;
             trim_trailing(media_query_start, &media_query_end_trimmed);
-            VALUE media_sym = intern_media_query_safe(ctx, media_query_start, media_query_end_trimmed - media_query_start);
+
+            // Parse media query and create MediaQuery object
+            const char *mq_ptr = media_query_start;
+            VALUE media_type;
+            VALUE media_conditions = Qnil;
+
+            if (*mq_ptr == '(') {
+                // Starts with '(' - just conditions, type defaults to :all
+                media_type = ID2SYM(rb_intern("all"));
+                media_conditions = rb_utf8_str_new(mq_ptr, media_query_end_trimmed - mq_ptr);
+            } else {
+                // Extract media type (first word)
+                const char *type_start = mq_ptr;
+                while (mq_ptr < media_query_end_trimmed && !IS_WHITESPACE(*mq_ptr) && *mq_ptr != '(') mq_ptr++;
+                VALUE type_str = rb_utf8_str_new(type_start, mq_ptr - type_start);
+                media_type = ID2SYM(rb_intern_str(type_str));
+
+                // Skip "and" keyword if present
+                while (mq_ptr < media_query_end_trimmed && IS_WHITESPACE(*mq_ptr)) mq_ptr++;
+                if (mq_ptr + 3 <= media_query_end_trimmed && strncmp(mq_ptr, "and", 3) == 0) {
+                    mq_ptr += 3;
+                    while (mq_ptr < media_query_end_trimmed && IS_WHITESPACE(*mq_ptr)) mq_ptr++;
+                }
+                if (mq_ptr < media_query_end_trimmed) {
+                    media_conditions = rb_utf8_str_new(mq_ptr, media_query_end_trimmed - mq_ptr);
+                }
+            }
+
+            // Create MediaQuery object
+            VALUE media_query = rb_struct_new(cMediaQuery,
+                INT2FIX(ctx->media_query_id_counter),
+                media_type,
+                media_conditions
+            );
+            rb_ary_push(ctx->media_queries, media_query);
+            int nested_media_query_id = ctx->media_query_id_counter;
+            ctx->media_query_id_counter++;
 
             p = media_query_end + 1;  // Skip {
 
             // Find matching closing brace
             const char *media_block_start = p;
-            const char *media_block_end = find_matching_brace(p, end);
+            const char *media_block_end = find_matching_brace_strict(p, end, ctx->check_unclosed_blocks);
             p = media_block_end;
 
             if (p < end) p++;  // Skip }
 
-            // Combine media queries: parent + child
-            VALUE combined_media_sym = combine_media_queries(parent_media_sym, media_sym);
+            // Handle combining media queries when parent has media too
+            int combined_media_query_id = nested_media_query_id;
+            if (parent_media_query_id >= 0) {
+                // Get parent MediaQuery
+                VALUE parent_mq = rb_ary_entry(ctx->media_queries, parent_media_query_id);
+
+                // This should never happen - parent_media_query_id should always be valid
+                if (NIL_P(parent_mq)) {
+                    rb_raise(eParseError,
+                        "Invalid parent_media_query_id: %d (not found in media_queries array)",
+                        parent_media_query_id);
+                }
+
+                VALUE parent_type = rb_struct_aref(parent_mq, INT2FIX(1)); // type field
+                VALUE parent_conditions = rb_struct_aref(parent_mq, INT2FIX(2)); // conditions field
+
+                // Combine: parent conditions + " and " + child conditions
+                VALUE combined_conditions;
+                if (!NIL_P(parent_conditions) && !NIL_P(media_conditions)) {
+                    combined_conditions = rb_str_new_cstr("");
+                    rb_str_append(combined_conditions, parent_conditions);
+                    rb_str_cat2(combined_conditions, " and ");
+                    rb_str_append(combined_conditions, media_conditions);
+                } else if (!NIL_P(parent_conditions)) {
+                    combined_conditions = parent_conditions;
+                } else {
+                    combined_conditions = media_conditions;
+                }
+
+                // Determine combined type (if parent is :all, use child type; if child is :all, use parent type; if both have types, use parent type)
+                VALUE combined_type;
+                ID all_id = rb_intern("all");
+                if (SYM2ID(parent_type) == all_id) {
+                    combined_type = media_type;
+                } else {
+                    combined_type = parent_type;
+                }
+
+                // Create combined MediaQuery
+                VALUE combined_mq = rb_struct_new(cMediaQuery,
+                    INT2FIX(ctx->media_query_id_counter),
+                    combined_type,
+                    combined_conditions
+                );
+                rb_ary_push(ctx->media_queries, combined_mq);
+                combined_media_query_id = ctx->media_query_id_counter;
+                ctx->media_query_id_counter++;
+
+                // Guard combined_conditions since we built it with rb_str_new_cstr/rb_str_append
+                // and it's used in rb_struct_new above (rb_ary_push could trigger GC)
+                RB_GC_GUARD(combined_conditions);
+            }
 
             // Parse the block with parse_mixed_block to support further nesting
             // Create a rule ID for this media rule
@@ -690,10 +1153,11 @@ static VALUE parse_mixed_block(ParserContext *ctx, const char *start, const char
             // Parse mixed block (may contain declarations and/or nested @media)
             ctx->depth++;
             VALUE media_declarations = parse_mixed_block(ctx, media_block_start, media_block_end,
-                                                        parent_selector, INT2FIX(media_rule_id), combined_media_sym);
+                                                        parent_selector, INT2FIX(media_rule_id), Qnil, combined_media_query_id);
             ctx->depth--;
 
             // Create rule with the parent selector and declarations, associated with combined media query
+            VALUE media_query_id_val = INT2FIX(combined_media_query_id);
             VALUE rule = rb_struct_new(cRule,
                 INT2FIX(media_rule_id),
                 parent_selector,
@@ -701,7 +1165,8 @@ static VALUE parse_mixed_block(ParserContext *ctx, const char *start, const char
                 Qnil,  // specificity
                 parent_rule_id,  // Link to parent for nested @media serialization
                 Qnil,  // nesting_style (nil for @media nesting)
-                Qnil   // selector_list_id
+                Qnil,  // selector_list_id
+                media_query_id_val  // media_query_id from parent context
             );
 
             // Mark that we have nesting (only set once)
@@ -711,7 +1176,13 @@ static VALUE parse_mixed_block(ParserContext *ctx, const char *start, const char
 
             // Replace placeholder with actual rule
             rb_ary_store(ctx->rules_array, parent_pos, rule);
-            update_media_index(ctx, combined_media_sym, media_rule_id);
+
+            // Update media_index using the MediaQuery's type symbol
+            VALUE combined_mq = rb_ary_entry(ctx->media_queries, combined_media_query_id);
+            if (!NIL_P(combined_mq)) {
+                VALUE mq_type = rb_struct_aref(combined_mq, INT2FIX(1)); // type field
+                update_media_index(ctx, mq_type, media_rule_id);
+            }
 
             continue;
         }
@@ -739,7 +1210,7 @@ static VALUE parse_mixed_block(ParserContext *ctx, const char *start, const char
             // Example: "& .child { font: 14px; }"
             //                     ^nested_block_start  ^nested_block_end (at })
             const char *nested_block_start = p;
-            const char *nested_block_end = find_matching_brace(p, end);
+            const char *nested_block_end = find_matching_brace_strict(p, end, ctx->check_unclosed_blocks);
             p = nested_block_end;
 
             if (p < end) p++;  // Skip }
@@ -770,13 +1241,18 @@ static VALUE parse_mixed_block(ParserContext *ctx, const char *start, const char
                         // Get rule ID
                         int rule_id = ctx->rule_id_counter++;
 
+                        // Reserve position in rules array (ensures sequential IDs match array indices)
+                        long rule_position = RARRAY_LEN(ctx->rules_array);
+                        rb_ary_push(ctx->rules_array, Qnil);  // Placeholder
+
                         // Recursively parse nested block
                         ctx->depth++;
                         VALUE nested_declarations = parse_mixed_block(ctx, nested_block_start, nested_block_end,
-                                                                     resolved_selector, INT2FIX(rule_id), parent_media_sym);
+                                                                     resolved_selector, INT2FIX(rule_id), parent_media_sym, parent_media_query_id);
                         ctx->depth--;
 
                         // Create rule for nested selector
+                        VALUE media_query_id_val = (parent_media_query_id >= 0) ? INT2FIX(parent_media_query_id) : Qnil;
                         VALUE rule = rb_struct_new(cRule,
                             INT2FIX(rule_id),
                             resolved_selector,
@@ -784,7 +1260,8 @@ static VALUE parse_mixed_block(ParserContext *ctx, const char *start, const char
                             Qnil,  // specificity
                             parent_rule_id,
                             nesting_style,
-                            Qnil   // selector_list_id
+                            Qnil,  // selector_list_id
+                            media_query_id_val  // media_query_id from parent context
                         );
 
                         // Mark that we have nesting (only set once)
@@ -792,7 +1269,8 @@ static VALUE parse_mixed_block(ParserContext *ctx, const char *start, const char
                             ctx->has_nesting = 1;
                         }
 
-                        rb_ary_push(ctx->rules_array, rule);
+                        // Replace placeholder with actual rule
+                        rb_ary_store(ctx->rules_array, rule_position, rule);
                         update_media_index(ctx, parent_media_sym, rule_id);
                     }
 
@@ -821,7 +1299,7 @@ static VALUE parse_mixed_block(ParserContext *ctx, const char *start, const char
         trim_leading(&p, end);
 
         const char *val_start = p;
-        int important = 0;
+        BOOLEAN important = 0;
 
         // Find end of value (semicolon or closing brace or end)
         while (p < end && *p != ';' && *p != '}') p++;
@@ -874,6 +1352,11 @@ static VALUE parse_mixed_block(ParserContext *ctx, const char *start, const char
             }
             VALUE value = rb_utf8_str_new(val_start, val_len);
 
+            // Convert relative URLs to absolute if enabled
+            if (ctx->absolute_paths && !NIL_P(ctx->base_uri)) {
+                value = convert_urls_in_value(value, ctx->base_uri, ctx->uri_resolver);
+            }
+
             VALUE decl = rb_struct_new(cDeclaration,
                 property,
                 value,
@@ -956,6 +1439,7 @@ static void parse_import_statement(ParserContext *ctx, const char **p_ptr, const
 
     // Check for optional media query (everything until semicolon)
     VALUE media = Qnil;
+    VALUE media_query_id_val = Qnil;
     if (p < pe && *p != ';') {
         const char *media_start = p;
 
@@ -970,8 +1454,73 @@ static void parse_import_statement(ParserContext *ctx, const char **p_ptr, const
         }
 
         if (media_end > media_start) {
-            VALUE media_str = rb_utf8_str_new(media_start, media_end - media_start);
-            media = ID2SYM(rb_intern_str(media_str));
+            // media field should be a String, not a Symbol
+            media = rb_utf8_str_new(media_start, media_end - media_start);
+
+            // Split comma-separated media queries (same as @media blocks)
+            VALUE media_query_ids = rb_ary_new();
+
+            const char *query_start = media_start;
+            for (const char *p_comma = media_start; p_comma <= media_end; p_comma++) {
+                if (p_comma == media_end || *p_comma == ',') {
+                    const char *query_end = p_comma;
+
+                    // Trim whitespace from this query
+                    while (query_start < query_end && IS_WHITESPACE(*query_start)) query_start++;
+                    while (query_end > query_start && IS_WHITESPACE(*(query_end - 1))) query_end--;
+
+                    if (query_start < query_end) {
+                        // Parse this individual media query
+                        const char *mq_ptr = query_start;
+                        VALUE media_type;
+                        VALUE media_conditions = Qnil;
+
+                        if (*mq_ptr == '(') {
+                            // Starts with '(' - just conditions, type defaults to :all
+                            media_type = ID2SYM(rb_intern("all"));
+                            media_conditions = rb_utf8_str_new(mq_ptr, query_end - mq_ptr);
+                        } else {
+                            // Extract media type (first word)
+                            const char *type_start = mq_ptr;
+                            while (mq_ptr < query_end && !IS_WHITESPACE(*mq_ptr) && *mq_ptr != '(') mq_ptr++;
+                            VALUE type_str = rb_utf8_str_new(type_start, mq_ptr - type_start);
+                            media_type = ID2SYM(rb_intern_str(type_str));
+
+                            // Skip whitespace
+                            while (mq_ptr < query_end && IS_WHITESPACE(*mq_ptr)) mq_ptr++;
+
+                            // Check if there are conditions (rest of string)
+                            if (mq_ptr < query_end) {
+                                media_conditions = rb_utf8_str_new(mq_ptr, query_end - mq_ptr);
+                            }
+                        }
+
+                        // Create MediaQuery struct
+                        VALUE media_query = rb_struct_new(cMediaQuery,
+                            INT2FIX(ctx->media_query_id_counter),
+                            media_type,
+                            media_conditions
+                        );
+
+                        rb_ary_push(ctx->media_queries, media_query);
+                        rb_ary_push(media_query_ids, INT2FIX(ctx->media_query_id_counter));
+                        ctx->media_query_id_counter++;
+                    }
+
+                    // Move to start of next query
+                    query_start = p_comma + 1;
+                }
+            }
+
+            // If multiple queries, track them as a list
+            if (RARRAY_LEN(media_query_ids) > 1) {
+                int media_query_list_id = ctx->next_media_query_list_id;
+                rb_hash_aset(ctx->media_query_lists, INT2FIX(media_query_list_id), media_query_ids);
+                ctx->next_media_query_list_id++;
+            }
+
+            // Use first query ID for the import statement
+            media_query_id_val = rb_ary_entry(media_query_ids, 0);
         }
     }
 
@@ -983,12 +1532,13 @@ static void parse_import_statement(ParserContext *ctx, const char **p_ptr, const
         INT2FIX(ctx->rule_id_counter),
         url,
         media,
+        media_query_id_val,
         Qfalse);
 
     DEBUG_PRINTF("[IMPORT_STMT] Created import: id=%d, url=%s, media=%s\n",
                  ctx->rule_id_counter,
                  RSTRING_PTR(url),
-                 NIL_P(media) ? "nil" : RSTRING_PTR(rb_sym2str(media)));
+                 NIL_P(media) ? "nil" : RSTRING_PTR(media));
 
     rb_ary_push(ctx->imports_array, import_stmt);
     ctx->rule_id_counter++;
@@ -1008,7 +1558,7 @@ static void parse_import_statement(ParserContext *ctx, const char **p_ptr, const
  * parent_rule_id:   Parent rule ID (Fixnum) for nested rules (or Qnil for top-level)
  */
 static void parse_css_recursive(ParserContext *ctx, const char *css, const char *pe,
-                                 VALUE parent_media_sym, VALUE parent_selector, VALUE parent_rule_id) {
+                                 VALUE parent_media_sym, VALUE parent_selector, VALUE parent_rule_id, int parent_media_query_id) {
     // Check recursion depth to prevent stack overflow
     if (ctx->depth > MAX_PARSE_DEPTH) {
         rb_raise(eDepthError,
@@ -1070,26 +1620,150 @@ static void parse_css_recursive(ParserContext *ctx, const char *css, const char
             // Trim
             trim_trailing(mq_start, &mq_end);
 
+            // Check for empty media query
+            if (mq_end <= mq_start) {
+                if (ctx->check_malformed_at_rules) {
+                    raise_parse_error_at(ctx, mq_start, "Malformed @media: missing media query", "malformed_at_rule");
+                } else {
+                    // Empty media query with check disabled - skip @media wrapper and parse contents as regular rules
+                    if (p >= pe || *p != '{') {
+                        continue;  // Malformed structure
+                    }
+                    p++;  // Skip opening {
+                    const char *block_start = p;
+                    const char *block_end = find_matching_brace_strict(p, pe, ctx->check_unclosed_blocks);
+                    p = block_end;
+
+                    // Parse block contents with NO media query context
+                    ctx->depth++;
+                    parse_css_recursive(ctx, block_start, block_end, parent_media_sym, NO_PARENT_SELECTOR, NO_PARENT_RULE_ID, parent_media_query_id);
+                    ctx->depth--;
+
+                    if (p < pe && *p == '}') p++;
+                    continue;
+                }
+            }
+
             if (p >= pe || *p != '{') {
                 continue;  // Malformed
             }
 
-            // Intern media query
-            VALUE child_media_sym = intern_media_query_safe(ctx, mq_start, mq_end - mq_start);
+            // Split comma-separated media queries (e.g., "screen, print" -> ["screen", "print"])
+            // Per W3C spec, comma acts as logical OR - each query is independent
+            VALUE media_query_ids = rb_ary_new();
+
+            const char *query_start = mq_start;
+            for (const char *p_comma = mq_start; p_comma <= mq_end; p_comma++) {
+                if (p_comma == mq_end || *p_comma == ',') {
+                    const char *query_end = p_comma;
+
+                    // Trim whitespace from this query
+                    while (query_start < query_end && IS_WHITESPACE(*query_start)) query_start++;
+                    while (query_end > query_start && IS_WHITESPACE(*(query_end - 1))) query_end--;
+
+                    if (query_start < query_end) {
+                        // Parse this individual media query
+                        const char *mq_ptr = query_start;
+                        VALUE media_type;
+                        VALUE media_conditions = Qnil;
+
+                        if (*mq_ptr == '(') {
+                            // Starts with '(' - just conditions, type defaults to :all
+                            media_type = ID2SYM(rb_intern("all"));
+                            media_conditions = rb_utf8_str_new(mq_ptr, query_end - mq_ptr);
+                        } else {
+                            // Extract media type (first word, stopping at whitespace, comma, or '(')
+                            const char *type_start = mq_ptr;
+                            while (mq_ptr < query_end && !IS_WHITESPACE(*mq_ptr) && *mq_ptr != '(') mq_ptr++;
+                            VALUE type_str = rb_utf8_str_new(type_start, mq_ptr - type_start);
+                            media_type = ID2SYM(rb_intern_str(type_str));
+
+                            // Skip whitespace and "and" keyword if present
+                            while (mq_ptr < query_end && IS_WHITESPACE(*mq_ptr)) mq_ptr++;
+                            if (mq_ptr + 3 <= query_end && strncmp(mq_ptr, "and", 3) == 0) {
+                                mq_ptr += 3;
+                                while (mq_ptr < query_end && IS_WHITESPACE(*mq_ptr)) mq_ptr++;
+                            }
+
+                            // Rest is conditions
+                            if (mq_ptr < query_end) {
+                                media_conditions = rb_utf8_str_new(mq_ptr, query_end - mq_ptr);
+                            }
+                        }
+
+                        // Create MediaQuery object for this query
+                        VALUE media_query = rb_struct_new(cMediaQuery,
+                            INT2FIX(ctx->media_query_id_counter),
+                            media_type,
+                            media_conditions
+                        );
+                        rb_ary_push(ctx->media_queries, media_query);
+                        rb_ary_push(media_query_ids, INT2FIX(ctx->media_query_id_counter));
+                        ctx->media_query_id_counter++;
+                    }
+
+                    // Move to start of next query
+                    query_start = p_comma + 1;
+                }
+            }
 
-            // Combine with parent
+            // If multiple queries, track them as a list for serialization
+            int media_query_list_id = -1;
+            if (RARRAY_LEN(media_query_ids) > 1) {
+                media_query_list_id = ctx->next_media_query_list_id;
+                rb_hash_aset(ctx->media_query_lists, INT2FIX(media_query_list_id), media_query_ids);
+                ctx->next_media_query_list_id++;
+            }
+
+            // Use first query ID as the primary one for rules in this block
+            int current_media_query_id = FIX2INT(rb_ary_entry(media_query_ids, 0));
+
+            // Handle nested @media by combining with parent
+            if (parent_media_query_id >= 0) {
+                VALUE parent_mq = rb_ary_entry(ctx->media_queries, parent_media_query_id);
+                VALUE parent_type = rb_struct_aref(parent_mq, INT2FIX(1)); // type field
+                VALUE parent_conditions = rb_struct_aref(parent_mq, INT2FIX(2)); // conditions field
+
+                // Get child media query (first one in the list)
+                VALUE child_mq = rb_ary_entry(ctx->media_queries, current_media_query_id);
+                VALUE child_conditions = rb_struct_aref(child_mq, INT2FIX(2)); // conditions field
+
+                // Combined type is parent's type (outermost wins, child type ignored)
+                VALUE combined_type = parent_type;
+                VALUE combined_conditions;
+
+                if (!NIL_P(parent_conditions) && !NIL_P(child_conditions)) {
+                    combined_conditions = rb_sprintf("%"PRIsVALUE" and %"PRIsVALUE, parent_conditions, child_conditions);
+                } else if (!NIL_P(parent_conditions)) {
+                    combined_conditions = parent_conditions;
+                } else {
+                    combined_conditions = child_conditions;
+                }
+
+                VALUE combined_mq = rb_struct_new(cMediaQuery,
+                    INT2FIX(ctx->media_query_id_counter),
+                    combined_type,
+                    combined_conditions
+                );
+                rb_ary_push(ctx->media_queries, combined_mq);
+                current_media_query_id = ctx->media_query_id_counter;
+                ctx->media_query_id_counter++;
+            }
+
+            // For backwards compat, also create symbol (will be removed later)
+            VALUE child_media_sym = intern_media_query_safe(ctx, mq_start, mq_end - mq_start);
             VALUE combined_media_sym = combine_media_queries(parent_media_sym, child_media_sym);
 
             p++;  // Skip opening {
 
             // Find matching closing brace
             const char *block_start = p;
-            const char *block_end = find_matching_brace(p, pe);
+            const char *block_end = find_matching_brace_strict(p, pe, ctx->check_unclosed_blocks);
             p = block_end;
 
-            // Recursively parse @media block with combined media context
+            // Recursively parse @media block with new media query context
             ctx->depth++;
-            parse_css_recursive(ctx, block_start, block_end, combined_media_sym, NO_PARENT_SELECTOR, NO_PARENT_RULE_ID);
+            parse_css_recursive(ctx, block_start, block_end, combined_media_sym, NO_PARENT_SELECTOR, NO_PARENT_RULE_ID, current_media_query_id);
             ctx->depth--;
 
             if (p < pe && *p == '}') p++;
@@ -1111,13 +1785,22 @@ static void parse_css_recursive(ParserContext *ctx, const char *css, const char
             long at_name_len = at_name_end - at_start;
 
             // Check if this is a conditional group rule
-            int is_conditional_group =
+            BOOLEAN is_conditional_group =
                 (at_name_len == 8 && strncmp(at_start, "supports", 8) == 0) ||
                 (at_name_len == 5 && strncmp(at_start, "layer", 5) == 0) ||
                 (at_name_len == 9 && strncmp(at_start, "container", 9) == 0) ||
                 (at_name_len == 5 && strncmp(at_start, "scope", 5) == 0);
 
             if (is_conditional_group) {
+                // Check if this rule requires a condition
+                BOOLEAN requires_condition =
+                    (at_name_len == 8 && strncmp(at_start, "supports", 8) == 0) ||
+                    (at_name_len == 9 && strncmp(at_start, "container", 9) == 0);
+
+                // Extract condition (between at-rule name and opening brace)
+                const char *cond_start = at_name_end;
+                while (cond_start < pe && IS_WHITESPACE(*cond_start)) cond_start++;
+
                 // Skip to opening brace
                 p = at_name_end;
                 while (p < pe && *p != '{') p++;
@@ -1126,16 +1809,27 @@ static void parse_css_recursive(ParserContext *ctx, const char *css, const char
                     continue;  // Malformed
                 }
 
+                // Trim condition
+                const char *cond_end = p;
+                while (cond_end > cond_start && IS_WHITESPACE(*(cond_end - 1))) cond_end--;
+
+                // Check for missing condition
+                if (requires_condition && cond_end <= cond_start && ctx->check_malformed_at_rules) {
+                    char error_msg[100];
+                    snprintf(error_msg, sizeof(error_msg), "Malformed @%.*s: missing condition", (int)at_name_len, at_start);
+                    raise_parse_error_at(ctx, at_start - 1, error_msg, "malformed_at_rule");
+                }
+
                 p++;  // Skip opening {
 
                 // Find matching closing brace
                 const char *block_start = p;
-                const char *block_end = find_matching_brace(p, pe);
+                const char *block_end = find_matching_brace_strict(p, pe, ctx->check_unclosed_blocks);
                 p = block_end;
 
                 // Recursively parse block content (preserve parent media context)
                 ctx->depth++;
-                parse_css_recursive(ctx, block_start, block_end, parent_media_sym, parent_selector, parent_rule_id);
+                parse_css_recursive(ctx, block_start, block_end, parent_media_sym, parent_selector, parent_rule_id, parent_media_query_id);
                 ctx->depth--;
 
                 if (p < pe && *p == '}') p++;
@@ -1144,7 +1838,7 @@ static void parse_css_recursive(ParserContext *ctx, const char *css, const char
 
             // Check for @keyframes (contains <rule-list>)
             // TODO: Test perf gains by using RB_UNLIKELY(is_keyframes) wrapper
-            int is_keyframes =
+            BOOLEAN is_keyframes =
                 (at_name_len == 9 && strncmp(at_start, "keyframes", 9) == 0) ||
                 (at_name_len == 17 && strncmp(at_start, "-webkit-keyframes", 17) == 0) ||
                 (at_name_len == 13 && strncmp(at_start, "-moz-keyframes", 13) == 0);
@@ -1169,7 +1863,7 @@ static void parse_css_recursive(ParserContext *ctx, const char *css, const char
 
                 // Find matching closing brace
                 const char *block_start = p;
-                const char *block_end = find_matching_brace(p, pe);
+                const char *block_end = find_matching_brace_strict(p, pe, ctx->check_unclosed_blocks);
                 p = block_end;
 
                 // Parse keyframe blocks as rules (from/to/0%/50% etc)
@@ -1186,7 +1880,7 @@ static void parse_css_recursive(ParserContext *ctx, const char *css, const char
                     .selector_lists_enabled = ctx->selector_lists_enabled,
                     .depth = 0
                 };
-                parse_css_recursive(&nested_ctx, block_start, block_end, NO_PARENT_MEDIA, NO_PARENT_SELECTOR, NO_PARENT_RULE_ID);
+                parse_css_recursive(&nested_ctx, block_start, block_end, NO_PARENT_MEDIA, NO_PARENT_SELECTOR, NO_PARENT_RULE_ID, NO_MEDIA_QUERY_ID);
 
                 // Get rule ID and increment
                 int rule_id = ctx->rule_id_counter++;
@@ -1196,7 +1890,9 @@ static void parse_css_recursive(ParserContext *ctx, const char *css, const char
                     INT2FIX(rule_id),
                     selector,
                     nested_ctx.rules_array,  // Array of Rule (keyframe blocks)
-                    Qnil);
+                    Qnil,  // specificity
+                    Qnil   // media_query_id
+                );
 
                 // Add to rules array
                 rb_ary_push(ctx->rules_array, at_rule);
@@ -1216,7 +1912,7 @@ static void parse_css_recursive(ParserContext *ctx, const char *css, const char
             }
 
             // Check for @font-face (contains <declaration-list>)
-            int is_font_face = (at_name_len == 9 && strncmp(at_start, "font-face", 9) == 0);
+            BOOLEAN is_font_face = (at_name_len == 9 && strncmp(at_start, "font-face", 9) == 0);
 
             if (is_font_face) {
                 // Build selector string: "@font-face"
@@ -1238,11 +1934,11 @@ static void parse_css_recursive(ParserContext *ctx, const char *css, const char
 
                 // Find matching closing brace
                 const char *decl_start = p;
-                const char *decl_end = find_matching_brace(p, pe);
+                const char *decl_end = find_matching_brace_strict(p, pe, ctx->check_unclosed_blocks);
                 p = decl_end;
 
                 // Parse declarations
-                VALUE declarations = parse_declarations(decl_start, decl_end);
+                VALUE declarations = parse_declarations(decl_start, decl_end, ctx);
 
                 // Get rule ID and increment
                 int rule_id = ctx->rule_id_counter++;
@@ -1252,7 +1948,9 @@ static void parse_css_recursive(ParserContext *ctx, const char *css, const char
                     INT2FIX(rule_id),
                     selector,
                     declarations,  // Array of Declaration
-                    Qnil);
+                    Qnil,  // specificity
+                    Qnil   // media_query_id
+                );
 
                 // Add to rules array
                 rb_ary_push(ctx->rules_array, at_rule);
@@ -1274,6 +1972,10 @@ static void parse_css_recursive(ParserContext *ctx, const char *css, const char
 
         // Opening brace
         if (*p == '{') {
+            // Check for empty selector (opening brace with no selector before it)
+            if (ctx->check_invalid_selectors && brace_depth == 0 && selector_start == NULL) {
+                raise_parse_error_at(ctx, p, "Invalid selector: empty selector", "invalid_selector");
+            }
             if (brace_depth == 0 && selector_start != NULL) {
                 decl_start = p + 1;
             }
@@ -1289,7 +1991,7 @@ static void parse_css_recursive(ParserContext *ctx, const char *css, const char
                 // We've found a complete CSS rule block - now determine if it has nesting
                 // Example: .parent { color: red; & .child { font-size: 14px; } }
                 //          ^selector_start    ^decl_start                    ^p (at })
-                int has_nesting = has_nested_selectors(decl_start, p);
+                BOOLEAN has_nesting = has_nested_selectors(decl_start, p);
 
                 // Get selector string
                 const char *sel_end = decl_start - 1;
@@ -1297,9 +1999,26 @@ static void parse_css_recursive(ParserContext *ctx, const char *css, const char
                     sel_end--;
                 }
 
+                // Check for empty selector
+                if (ctx->check_invalid_selectors && sel_end <= selector_start) {
+                    const char *css = RSTRING_PTR(ctx->css_string);
+                    long error_pos = selector_start - css;
+
+                    // Build keyword args hash
+                    VALUE kwargs = rb_hash_new();
+                    rb_hash_aset(kwargs, ID2SYM(rb_intern("css")), ctx->css_string);
+                    rb_hash_aset(kwargs, ID2SYM(rb_intern("pos")), LONG2NUM(error_pos));
+                    rb_hash_aset(kwargs, ID2SYM(rb_intern("type")), ID2SYM(rb_intern("invalid_selector")));
+
+                    VALUE msg_str = rb_str_new_cstr("Invalid selector: empty selector");
+                    VALUE argv[2] = {msg_str, kwargs};
+                    VALUE error = rb_funcallv_kw(eParseError, rb_intern("new"), 2, argv, RB_PASS_KEYWORDS);
+                    rb_exc_raise(error);
+                }
+
                 if (!has_nesting) {
                     // FAST PATH: No nesting - parse as pure declarations
-                    VALUE declarations = parse_declarations(decl_start, p);
+                    VALUE declarations = parse_declarations(decl_start, p, ctx);
 
                     // Split on commas to handle multi-selector rules
                     // Example: ".a, .b, .c { color: red; }" creates 3 separate rules
@@ -1343,6 +2062,37 @@ static void parse_css_recursive(ParserContext *ctx, const char *css, const char
                             }
 
                             if (seg_end_ptr > seg_start) {
+                                // Check for invalid selectors
+                                if (ctx->check_invalid_selectors) {
+                                    // Check if selector starts with combinator
+                                    char first_char = *seg_start;
+                                    if (first_char == '>' || first_char == '+' || first_char == '~') {
+                                        const char *css = RSTRING_PTR(ctx->css_string);
+                                        long error_pos = seg_start - css;
+
+                                        char error_msg[256];
+                                        snprintf(error_msg, sizeof(error_msg),
+                                               "Invalid selector: selector cannot start with combinator '%c'",
+                                               first_char);
+
+                                        // Build keyword args hash
+                                        VALUE kwargs = rb_hash_new();
+                                        rb_hash_aset(kwargs, ID2SYM(rb_intern("css")), ctx->css_string);
+                                        rb_hash_aset(kwargs, ID2SYM(rb_intern("pos")), LONG2NUM(error_pos));
+                                        rb_hash_aset(kwargs, ID2SYM(rb_intern("type")), ID2SYM(rb_intern("invalid_selector")));
+
+                                        VALUE msg_str = rb_str_new_cstr(error_msg);
+                                        VALUE argv[2] = {msg_str, kwargs};
+                                        VALUE error = rb_funcallv_kw(eParseError, rb_intern("new"), 2, argv, RB_PASS_KEYWORDS);
+                                        rb_exc_raise(error);
+                                    }
+                                }
+
+                                // Check for invalid selector syntax (whitelist validation)
+                                if (ctx->check_invalid_selector_syntax && !is_valid_selector(seg_start, seg_end_ptr)) {
+                                    raise_parse_error_at(ctx, seg_start, "Invalid selector syntax: selector contains invalid characters", "invalid_selector_syntax");
+                                }
+
                                 VALUE selector = rb_utf8_str_new(seg_start, seg_end_ptr - seg_start);
 
                                 // Resolve against parent if nested
@@ -1390,6 +2140,7 @@ static void parse_css_recursive(ParserContext *ctx, const char *css, const char
                                 }
 
                                 // Create Rule
+                                VALUE media_query_id_val = (parent_media_query_id >= 0) ? INT2FIX(parent_media_query_id) : Qnil;
                                 VALUE rule = rb_struct_new(cRule,
                                     INT2FIX(rule_id),
                                     resolved_selector,
@@ -1397,7 +2148,8 @@ static void parse_css_recursive(ParserContext *ctx, const char *css, const char
                                     Qnil,  // specificity
                                     parent_id_val,
                                     nesting_style_val,
-                                    selector_list_id_val
+                                    selector_list_id_val,
+                                    media_query_id_val  // media_query_id from parent context
                                 );
 
                                 // Track rule in selector list if applicable
@@ -1414,6 +2166,9 @@ static void parse_css_recursive(ParserContext *ctx, const char *css, const char
 
                                 // Update media index
                                 update_media_index(ctx, parent_media_sym, rule_id);
+                            } else if (ctx->check_invalid_selector_syntax && selector_count > 1) {
+                                // Empty selector in comma-separated list (e.g., "h1, , h3")
+                                raise_parse_error_at(ctx, seg_start, "Invalid selector syntax: empty selector in comma-separated list", "invalid_selector_syntax");
                             }
 
                             seg_start = seg + 1;
@@ -1499,7 +2254,7 @@ static void parse_css_recursive(ParserContext *ctx, const char *css, const char
                                 // Nested rules will be added AFTER the placeholder
                                 ctx->depth++;
                                 VALUE parent_declarations = parse_mixed_block(ctx, decl_start, p,
-                                                                             resolved_current, INT2FIX(current_rule_id), parent_media_sym);
+                                                                             resolved_current, INT2FIX(current_rule_id), parent_media_sym, parent_media_query_id);
                                 ctx->depth--;
 
                                 // Determine selector_list_id value
@@ -1507,6 +2262,7 @@ static void parse_css_recursive(ParserContext *ctx, const char *css, const char
 
                                 // Create parent rule and replace placeholder
                                 // Always create the rule (even if empty) to avoid edge cases
+                                VALUE media_query_id_val = (parent_media_query_id >= 0) ? INT2FIX(parent_media_query_id) : Qnil;
                                 VALUE rule = rb_struct_new(cRule,
                                     INT2FIX(current_rule_id),
                                     resolved_current,
@@ -1514,7 +2270,8 @@ static void parse_css_recursive(ParserContext *ctx, const char *css, const char
                                     Qnil,  // specificity
                                     current_parent_id,
                                     current_nesting_style,
-                                    selector_list_id_val
+                                    selector_list_id_val,
+                                    media_query_id_val  // media_query_id from parent context
                                 );
 
                                 // Track rule in selector list if applicable
@@ -1553,6 +2310,11 @@ static void parse_css_recursive(ParserContext *ctx, const char *css, const char
 
         p++;
     }
+
+    // Check for unclosed blocks at end of parsing
+    if (ctx->check_unclosed_blocks && brace_depth > 0) {
+        rb_raise(eParseError, "Unclosed block: missing closing brace");
+    }
 }
 
 /*
@@ -1586,7 +2348,48 @@ VALUE parse_css_new_impl(VALUE css_string, VALUE parser_options, int rule_id_off
 
     // Read parser options
     VALUE selector_lists_opt = rb_hash_aref(parser_options, ID2SYM(rb_intern("selector_lists")));
-    int selector_lists_enabled = (NIL_P(selector_lists_opt) || RTEST(selector_lists_opt)) ? 1 : 0;
+    BOOLEAN selector_lists_enabled = (NIL_P(selector_lists_opt) || RTEST(selector_lists_opt)) ? 1 : 0;
+
+    // URL conversion options
+    VALUE base_uri = rb_hash_aref(parser_options, ID2SYM(rb_intern("base_uri")));
+    VALUE absolute_paths_opt = rb_hash_aref(parser_options, ID2SYM(rb_intern("absolute_paths")));
+    VALUE uri_resolver = rb_hash_aref(parser_options, ID2SYM(rb_intern("uri_resolver")));
+    BOOLEAN absolute_paths = RTEST(absolute_paths_opt) ? 1 : 0;
+
+    // Parse error options
+    VALUE raise_parse_errors_opt = rb_hash_aref(parser_options, ID2SYM(rb_intern("raise_parse_errors")));
+    BOOLEAN check_empty_values = 0;
+    BOOLEAN check_malformed_declarations = 0;
+    BOOLEAN check_invalid_selectors = 0;
+    BOOLEAN check_invalid_selector_syntax = 0;
+    BOOLEAN check_malformed_at_rules = 0;
+    BOOLEAN check_unclosed_blocks = 0;
+
+    if (RTEST(raise_parse_errors_opt)) {
+        if (TYPE(raise_parse_errors_opt) == T_HASH) {
+            // Hash of specific error types
+            VALUE empty_values_opt = rb_hash_aref(raise_parse_errors_opt, ID2SYM(rb_intern("empty_values")));
+            VALUE malformed_declarations_opt = rb_hash_aref(raise_parse_errors_opt, ID2SYM(rb_intern("malformed_declarations")));
+            VALUE invalid_selectors_opt = rb_hash_aref(raise_parse_errors_opt, ID2SYM(rb_intern("invalid_selectors")));
+            VALUE invalid_selector_syntax_opt = rb_hash_aref(raise_parse_errors_opt, ID2SYM(rb_intern("invalid_selector_syntax")));
+            VALUE malformed_at_rules_opt = rb_hash_aref(raise_parse_errors_opt, ID2SYM(rb_intern("malformed_at_rules")));
+            VALUE unclosed_blocks_opt = rb_hash_aref(raise_parse_errors_opt, ID2SYM(rb_intern("unclosed_blocks")));
+            check_empty_values = RTEST(empty_values_opt) ? 1 : 0;
+            check_malformed_declarations = RTEST(malformed_declarations_opt) ? 1 : 0;
+            check_invalid_selectors = RTEST(invalid_selectors_opt) ? 1 : 0;
+            check_invalid_selector_syntax = RTEST(invalid_selector_syntax_opt) ? 1 : 0;
+            check_malformed_at_rules = RTEST(malformed_at_rules_opt) ? 1 : 0;
+            check_unclosed_blocks = RTEST(unclosed_blocks_opt) ? 1 : 0;
+        } else {
+            // true - enable all checks
+            check_empty_values = 1;
+            check_malformed_declarations = 1;
+            check_invalid_selectors = 1;
+            check_invalid_selector_syntax = 1;
+            check_malformed_at_rules = 1;
+            check_unclosed_blocks = 1;
+        }
+    }
 
     const char *css = RSTRING_PTR(css_string);
     const char *pe = css + RSTRING_LEN(css_string);
@@ -1624,23 +2427,41 @@ VALUE parse_css_new_impl(VALUE css_string, VALUE parser_options, int rule_id_off
     ctx.media_index = rb_hash_new();
     ctx.selector_lists = rb_hash_new();
     ctx.imports_array = rb_ary_new();
+    ctx.media_queries = rb_ary_new();
+    ctx.media_query_lists = rb_hash_new();
     ctx.rule_id_counter = rule_id_offset;  // Start from offset
     ctx.next_selector_list_id = 0;  // Start from 0
+    ctx.media_query_id_counter = 0;  // Start from 0
+    ctx.next_media_query_list_id = 0;  // Start from 0
     ctx.media_query_count = 0;
     ctx.media_cache = NULL;  // Removed - no perf benefit
     ctx.has_nesting = 0;  // Will be set to 1 if any nested rules are created
     ctx.selector_lists_enabled = selector_lists_enabled;
     ctx.depth = 0;  // Start at depth 0
+    // URL conversion options
+    ctx.base_uri = base_uri;
+    ctx.uri_resolver = uri_resolver;
+    ctx.absolute_paths = absolute_paths;
+    // Parse error options
+    ctx.css_string = css_string;
+    ctx.check_empty_values = check_empty_values;
+    ctx.check_malformed_declarations = check_malformed_declarations;
+    ctx.check_invalid_selectors = check_invalid_selectors;
+    ctx.check_invalid_selector_syntax = check_invalid_selector_syntax;
+    ctx.check_malformed_at_rules = check_malformed_at_rules;
+    ctx.check_unclosed_blocks = check_unclosed_blocks;
 
     // Parse CSS (top-level, no parent context)
     DEBUG_PRINTF("[PARSE] Starting parse_css_recursive from: %.80s\n", p);
-    parse_css_recursive(&ctx, p, pe, NO_PARENT_MEDIA, NO_PARENT_SELECTOR, NO_PARENT_RULE_ID);
+    parse_css_recursive(&ctx, p, pe, NO_PARENT_MEDIA, NO_PARENT_SELECTOR, NO_PARENT_RULE_ID, NO_MEDIA_QUERY_ID);
 
     // Build result hash
     VALUE result = rb_hash_new();
     rb_hash_aset(result, ID2SYM(rb_intern("rules")), ctx.rules_array);
     rb_hash_aset(result, ID2SYM(rb_intern("_media_index")), ctx.media_index);
+    rb_hash_aset(result, ID2SYM(rb_intern("media_queries")), ctx.media_queries);
     rb_hash_aset(result, ID2SYM(rb_intern("_selector_lists")), ctx.selector_lists);
+    rb_hash_aset(result, ID2SYM(rb_intern("_media_query_lists")), ctx.media_query_lists);
     rb_hash_aset(result, ID2SYM(rb_intern("imports")), ctx.imports_array);
     rb_hash_aset(result, ID2SYM(rb_intern("charset")), charset);
     rb_hash_aset(result, ID2SYM(rb_intern("last_rule_id")), INT2FIX(ctx.rule_id_counter));
@@ -1649,8 +2470,12 @@ VALUE parse_css_new_impl(VALUE css_string, VALUE parser_options, int rule_id_off
     RB_GC_GUARD(charset);
     RB_GC_GUARD(ctx.rules_array);
     RB_GC_GUARD(ctx.media_index);
+    RB_GC_GUARD(ctx.media_queries);
     RB_GC_GUARD(ctx.selector_lists);
+    RB_GC_GUARD(ctx.media_query_lists);
     RB_GC_GUARD(ctx.imports_array);
+    RB_GC_GUARD(ctx.base_uri);
+    RB_GC_GUARD(ctx.uri_resolver);
     RB_GC_GUARD(result);
 
     return result;