cataract 0.2.3 → 0.2.4

data/ext/cataract/css_parser.c

@@ -19,13 +19,21 @@ 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)
+    // 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)
+    int absolute_paths;       // Whether to convert relative URLs to absolute
 } ParserContext;
 
 // Macro to skip CSS comments /* ... */
@@ -384,12 +392,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 +587,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;
@@ -513,6 +697,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 +720,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 +819,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,11 +850,47 @@ 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 {
 
@@ -676,8 +901,58 @@ static VALUE parse_mixed_block(ParserContext *ctx, const char *start, const char
 
             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(eParserError,
+                        "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 +965,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 +977,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 +988,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;
         }
@@ -770,13 +1053,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 +1072,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 +1081,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);
                     }
 
@@ -874,6 +1164,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 +1251,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 +1266,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 +1344,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 +1370,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,
@@ -1074,10 +1436,110 @@ static void parse_css_recursive(ParserContext *ctx, const char *css, const char
                 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 {
@@ -1087,9 +1549,9 @@ static void parse_css_recursive(ParserContext *ctx, const char *css, const char
             const char *block_end = find_matching_brace(p, pe);
             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++;
@@ -1135,7 +1597,7 @@ static void parse_css_recursive(ParserContext *ctx, const char *css, const char
 
                 // 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++;
@@ -1186,7 +1648,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 +1658,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);
@@ -1242,7 +1706,7 @@ static void parse_css_recursive(ParserContext *ctx, const char *css, const char
                 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 +1716,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);
@@ -1299,7 +1765,7 @@ static void parse_css_recursive(ParserContext *ctx, const char *css, const char
 
                 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
@@ -1390,6 +1856,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 +1864,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
@@ -1499,7 +1967,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 +1975,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 +1983,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
@@ -1588,6 +2058,12 @@ VALUE parse_css_new_impl(VALUE css_string, VALUE parser_options, int rule_id_off
     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;
 
+    // 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")));
+    int absolute_paths = RTEST(absolute_paths_opt) ? 1 : 0;
+
     const char *css = RSTRING_PTR(css_string);
     const char *pe = css + RSTRING_LEN(css_string);
     const char *p = css;
@@ -1624,23 +2100,33 @@ 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 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 +2135,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;