cataract 0.3.0 → 0.5.0

data/ext/cataract/cataract.c

@@ -9,6 +9,7 @@ VALUE cAtRule;
 VALUE cStylesheet;
 VALUE cImportStatement;
 VALUE cMediaQuery;
+VALUE cConditionalGroup;
 
 // Error class definitions (shared with main extension)
 VALUE eCataractError;
@@ -168,6 +169,13 @@ static void serialize_at_rule(VALUE result, VALUE at_rule) {
     VALUE selector = rb_struct_aref(at_rule, INT2FIX(AT_RULE_SELECTOR));
     VALUE content = rb_struct_aref(at_rule, INT2FIX(AT_RULE_CONTENT));
 
+    if (NIL_P(content)) {
+        // Statement form (e.g. `@layer a, b;`) - no block to wrap.
+        rb_str_append(result, selector);
+        rb_str_cat2(result, ";\n");
+        return;
+    }
+
     rb_str_append(result, selector);
     rb_str_cat2(result, " {\n");
 
@@ -277,6 +285,14 @@ static void serialize_at_rule_formatted(VALUE result, VALUE at_rule, const char
     VALUE selector = rb_struct_aref(at_rule, INT2FIX(AT_RULE_SELECTOR));
     VALUE content = rb_struct_aref(at_rule, INT2FIX(AT_RULE_CONTENT));
 
+    if (NIL_P(content)) {
+        // Statement form (e.g. `@layer a, b;`) - no block to wrap.
+        rb_str_cat2(result, indent);
+        rb_str_append(result, selector);
+        rb_str_cat2(result, ";\n");
+        return;
+    }
+
     rb_str_cat2(result, indent);
     rb_str_append(result, selector);
     rb_str_cat2(result, " {\n");
@@ -377,6 +393,108 @@ static int build_mq_reverse_map_callback(VALUE list_id, VALUE mq_ids, VALUE arg)
     return ST_CONTINUE;
 }
 
+// Build the media_query_id => list_id reverse map used by both stylesheet
+// serializers (grouping and nesting) to detect when a rule's media query is
+// part of a comma-separated list (e.g. "@media screen, print").
+static VALUE build_mq_id_to_list_id(VALUE media_query_lists) {
+    VALUE mq_id_to_list_id = rb_hash_new();
+    if (!NIL_P(media_query_lists) && TYPE(media_query_lists) == T_HASH) {
+        struct build_mq_reverse_map_ctx ctx = { mq_id_to_list_id };
+        rb_hash_foreach(media_query_lists, build_mq_reverse_map_callback, (VALUE)&ctx);
+    }
+    return mq_id_to_list_id;
+}
+
+// Build a rule_id => rule lookup. rules_array is NOT guaranteed to satisfy
+// rules[i].id == i here - that invariant only holds for the full,
+// freshly-parsed rules array; Stylesheet#to_s(media: ...) passes a filtered
+// subset whenever the media filter isn't :all, so a plain array index would
+// silently fetch the wrong rule (or even an AtRule, which doesn't share
+// Rule's struct layout) once any rule has been filtered out. Both Rule and
+// AtRule keep id at field index 0, so a single RULE_ID read is safe for
+// either struct type.
+static VALUE build_rules_by_id(VALUE rules_array) {
+    VALUE rules_by_id = rb_hash_new();
+    long len = RARRAY_LEN(rules_array);
+    for (long i = 0; i < len; i++) {
+        VALUE rule = rb_ary_entry(rules_array, i);
+        VALUE rule_id = rb_struct_aref(rule, INT2FIX(RULE_ID));
+        rb_hash_aset(rules_by_id, rule_id, rule);
+    }
+    return rules_by_id;
+}
+
+// A rule's conditional-group wrapping chain, outermost first, found by
+// walking parent_id from its own conditional_group_id up to the root. Only
+// @supports currently populates conditional_group_id (see the parser), but
+// this walks whatever's there generically.
+static VALUE conditional_group_chain(VALUE conditional_groups, VALUE conditional_group_id) {
+    VALUE chain = rb_ary_new();
+    VALUE id = conditional_group_id;
+    while (!NIL_P(id)) {
+        VALUE group = rb_ary_entry(conditional_groups, FIX2INT(id));
+        if (NIL_P(group)) break;
+
+        rb_ary_unshift(chain, group);
+        id = rb_struct_aref(group, INT2FIX(CONDITIONAL_GROUP_PARENT_ID));
+    }
+    return chain;
+}
+
+// Reconcile the currently-open conditional-group blocks with the ones a
+// rule needs, like diffing two paths down a tree: close whatever's open
+// past where the chains diverge (innermost first), then open whatever the
+// target chain adds from that point on. Nested entirely inside whatever
+// media block is currently open (conditional groups don't affect media
+// context). Returns target_chain, for the caller to track as current.
+static VALUE sync_conditional_group_chain(VALUE result, VALUE current_chain, VALUE target_chain, const char *indent) {
+    long current_len = RARRAY_LEN(current_chain);
+    long target_len = RARRAY_LEN(target_chain);
+    long common = 0;
+    while (common < current_len && common < target_len) {
+        VALUE cur_id = rb_struct_aref(rb_ary_entry(current_chain, common), INT2FIX(CONDITIONAL_GROUP_ID));
+        VALUE tgt_id = rb_struct_aref(rb_ary_entry(target_chain, common), INT2FIX(CONDITIONAL_GROUP_ID));
+        if (!rb_equal(cur_id, tgt_id)) break;
+
+        common++;
+    }
+
+    for (long i = current_len - 1; i >= common; i--) {
+        rb_str_cat2(result, indent);
+        rb_str_cat2(result, "}\n");
+    }
+
+    for (long i = common; i < target_len; i++) {
+        VALUE group = rb_ary_entry(target_chain, i);
+        VALUE name = rb_struct_aref(group, INT2FIX(CONDITIONAL_GROUP_NAME));
+        VALUE condition = rb_struct_aref(group, INT2FIX(CONDITIONAL_GROUP_CONDITION));
+
+        rb_str_cat2(result, indent);
+        rb_str_cat2(result, "@");
+        rb_str_append(result, rb_sym2str(rb_struct_aref(group, INT2FIX(CONDITIONAL_GROUP_TYPE))));
+        if (!NIL_P(name) || !NIL_P(condition)) {
+            rb_str_cat2(result, " ");
+            if (!NIL_P(name)) {
+                rb_str_append(result, name);
+                if (!NIL_P(condition)) rb_str_cat2(result, " ");
+            }
+            if (!NIL_P(condition)) {
+                rb_str_append(result, condition);
+            }
+        }
+        rb_str_cat2(result, " {\n");
+    }
+
+    return target_chain;
+}
+
+static void close_conditional_groups(VALUE result, long count, const char *indent) {
+    for (long i = 0; i < count; i++) {
+        rb_str_cat2(result, indent);
+        rb_str_cat2(result, "}\n");
+    }
+}
+
 // Rule and AtRule don't share a member layout past their first few fields
 // (see the AT_RULE_* comment in cataract.h), so reading parent_rule_id or
 // media_query_id off a rule of unknown type needs to dispatch on which
@@ -394,6 +512,12 @@ static inline VALUE rule_media_query_id_of(VALUE rule) {
         : rb_struct_aref(rule, INT2FIX(RULE_MEDIA_QUERY_ID));
 }
 
+static inline VALUE rule_conditional_group_id_of(VALUE rule) {
+    return rb_obj_is_kind_of(rule, cAtRule)
+        ? rb_struct_aref(rule, INT2FIX(AT_RULE_CONDITIONAL_GROUP_ID))
+        : rb_struct_aref(rule, INT2FIX(RULE_CONDITIONAL_GROUP_ID));
+}
+
 // Formatting options for stylesheet serialization
 // Avoids mode flags and if/else branches - all behavior controlled by struct values
 struct format_opts {
@@ -421,7 +545,7 @@ static inline void emit_rule(VALUE result, VALUE rule, const char *decl_indent,
 // each match as processed. Returns an array of their selectors (does not
 // include the current rule's own selector or mark it processed - the
 // caller's rule_id is handled by serialize_rule_in_group).
-static VALUE collect_matching_selectors(VALUE rule_ids_in_list, VALUE rule_media_query_id, VALUE rule_declarations, VALUE rules_array, VALUE processed_rule_ids) {
+static VALUE collect_matching_selectors(VALUE rule_ids_in_list, VALUE rule_media_query_id, VALUE rule_declarations, VALUE rules_by_id, VALUE processed_rule_ids) {
     VALUE matching_selectors = rb_ary_new();
     long list_len = RARRAY_LEN(rule_ids_in_list);
 
@@ -434,7 +558,7 @@ static VALUE collect_matching_selectors(VALUE rule_ids_in_list, VALUE rule_media
         }
 
         // Find the rule by ID
-        VALUE other_rule = rb_ary_entry(rules_array, FIX2INT(other_rule_id));
+        VALUE other_rule = rb_hash_aref(rules_by_id, other_rule_id);
         if (NIL_P(other_rule)) continue;
 
         // Check same media context (compare media_query_id directly)
@@ -481,7 +605,7 @@ static void emit_grouped_rule(VALUE result, VALUE rule, VALUE matching_selectors
 struct rule_group_ctx {
     VALUE selector_lists;
     int grouping_enabled;
-    VALUE rules_array;
+    VALUE rules_by_id;
     VALUE processed_rule_ids;
     const struct format_opts *opts;
 };
@@ -512,7 +636,7 @@ static void serialize_rule_in_group(
 
             if (!NIL_P(rule_ids_in_list) && RARRAY_LEN(rule_ids_in_list) > 1) {
                 VALUE rule_declarations = rb_struct_aref(rule, INT2FIX(RULE_DECLARATIONS));
-                VALUE matching_selectors = collect_matching_selectors(rule_ids_in_list, rule_media_query_id, rule_declarations, ctx->rules_array, ctx->processed_rule_ids);
+                VALUE matching_selectors = collect_matching_selectors(rule_ids_in_list, rule_media_query_id, rule_declarations, ctx->rules_by_id, ctx->processed_rule_ids);
                 emit_grouped_rule(result, rule, matching_selectors, rule_declarations, ctx->opts, decl_indent, rule_prefix);
                 return;
             }
@@ -533,6 +657,7 @@ static VALUE serialize_stylesheet_with_grouping(
     VALUE media_query_lists,
     VALUE result,
     VALUE selector_lists,
+    VALUE conditional_groups,
     const struct format_opts *opts
 ) {
     long total_rules = RARRAY_LEN(rules_array);
@@ -542,20 +667,23 @@ static VALUE serialize_stylesheet_with_grouping(
 
     // Build reverse map: media_query_id => list_id
     // This allows us to detect when multiple rules share a comma-separated media query list
-    VALUE mq_id_to_list_id = rb_hash_new();
-    if (!NIL_P(media_query_lists) && TYPE(media_query_lists) == T_HASH) {
-        struct build_mq_reverse_map_ctx ctx = { mq_id_to_list_id };
-        rb_hash_foreach(media_query_lists, build_mq_reverse_map_callback, (VALUE)&ctx);
-    }
+    VALUE mq_id_to_list_id = build_mq_id_to_list_id(media_query_lists);
+
+    // Only needed by the grouping path - rules_array here may already be
+    // filtered (Stylesheet#to_s(media: ...) for anything but :all), so
+    // looking up "other rules in this selector list" needs a real id => rule
+    // map rather than indexing directly into rules_array.
+    VALUE rules_by_id = grouping_enabled ? build_rules_by_id(rules_array) : Qnil;
 
     // Track processed rules to avoid duplicates when grouping
     VALUE processed_rule_ids = rb_hash_new();
 
-    struct rule_group_ctx group_ctx = { selector_lists, grouping_enabled, rules_array, processed_rule_ids, opts };
+    struct rule_group_ctx group_ctx = { selector_lists, grouping_enabled, rules_by_id, processed_rule_ids, opts };
 
     // Iterate through rules in insertion order, grouping consecutive media queries
     VALUE current_media = Qnil;
     int in_media_block = 0;
+    VALUE current_cg_chain = rb_ary_new();
 
     for (long i = 0; i < total_rules; i++) {
         VALUE rule = rb_ary_entry(rules_array, i);
@@ -573,10 +701,12 @@ static VALUE serialize_stylesheet_with_grouping(
             rule_media = rb_ary_entry(media_queries, FIX2INT(rule_media_query_id));
         }
         int is_first_rule = (i == 0);
+        VALUE rule_cg_chain = conditional_group_chain(conditional_groups, rule_conditional_group_id_of(rule));
 
         if (NIL_P(rule_media)) {
             // Not in any media query - close any open media block first
             if (in_media_block) {
+                current_cg_chain = sync_conditional_group_chain(result, current_cg_chain, rb_ary_new(), opts->media_indent);
                 rb_str_cat2(result, "}\n");
                 in_media_block = 0;
                 current_media = Qnil;
@@ -587,11 +717,15 @@ static VALUE serialize_stylesheet_with_grouping(
                 rb_str_cat2(result, "\n");
             }
 
-            serialize_rule_in_group(result, rule, rule_id, rule_media_query_id, &group_ctx, 0);
+            current_cg_chain = sync_conditional_group_chain(result, current_cg_chain, rule_cg_chain, "");
+
+            serialize_rule_in_group(result, rule, rule_id, rule_media_query_id, &group_ctx, RARRAY_LEN(current_cg_chain) > 0);
         } else {
             // This rule is in a media query
             // Check if media query changed from previous rule (compare MediaQuery objects by value)
             if (NIL_P(current_media) || !rb_equal(current_media, rule_media)) {
+                current_cg_chain = sync_conditional_group_chain(result, current_cg_chain, rb_ary_new(), opts->media_indent);
+
                 // Close previous media block if open
                 if (in_media_block) {
                     rb_str_cat2(result, "}\n");
@@ -615,18 +749,23 @@ static VALUE serialize_stylesheet_with_grouping(
                 in_media_block = 1;
             }
 
+            current_cg_chain = sync_conditional_group_chain(result, current_cg_chain, rule_cg_chain, opts->media_indent);
+
             serialize_rule_in_group(result, rule, rule_id, rule_media_query_id, &group_ctx, 1);
         }
     }
 
-    // Close final media block if still open
+    // Close final conditional-group and media blocks if still open
+    close_conditional_groups(result, RARRAY_LEN(current_cg_chain), in_media_block ? opts->media_indent : "");
     if (in_media_block) {
         rb_str_cat2(result, "}\n");
     }
 
-    // Guard hash objects we created and used throughout
+    // Guard hash/array objects we created and used throughout
     RB_GC_GUARD(mq_id_to_list_id);
+    RB_GC_GUARD(rules_by_id);
     RB_GC_GUARD(processed_rule_ids);
+    RB_GC_GUARD(current_cg_chain);
     return result;
 }
 
@@ -846,12 +985,18 @@ static void serialize_rule_with_children(VALUE result, VALUE rules_array, long r
 static VALUE serialize_stylesheet_with_nesting(
     VALUE rules_array,
     VALUE media_queries,
+    VALUE media_query_lists,
     VALUE result,
     const struct format_opts *opts
 ) {
     int formatted = (opts->decl_indent_base != NULL);
     long total_rules = RARRAY_LEN(rules_array);
 
+    // Reverse map: media_query_id => list_id, so a rule whose media query is
+    // part of a comma-separated list (e.g. "@media screen, print") renders
+    // the full list, not just its own single media query.
+    VALUE mq_id_to_list_id = build_mq_id_to_list_id(media_query_lists);
+
     // Build parent_to_children map (parent_rule_id -> array of child indices)
     // This allows O(1) lookup of children when serializing each parent
     VALUE parent_to_children = rb_hash_new();
@@ -930,7 +1075,7 @@ static VALUE serialize_stylesheet_with_nesting(
                 // Open new media block - store the MediaQuery object for comparison
                 current_media = rule_media;
                 rb_str_cat2(result, "@media ");
-                append_media_query_text(result, rule_media);
+                append_media_query_string(result, rule_media_query_id, mq_id_to_list_id, media_query_lists, media_queries);
                 rb_str_cat2(result, " {\n");
                 in_media_block = 1;
             }
@@ -970,11 +1115,12 @@ static VALUE serialize_stylesheet_with_nesting(
 // this, differing only in which format_opts they select. Dispatches on has_nesting
 // to pick the selector-list-grouping serializer (no nesting - zero overhead) or the
 // parent/child lookahead serializer (has nesting).
-static VALUE stylesheet_serialize_impl(VALUE rules_array, VALUE charset, VALUE has_nesting, VALUE selector_lists, VALUE media_queries, VALUE media_query_lists, int formatted) {
+static VALUE stylesheet_serialize_impl(VALUE rules_array, VALUE charset, VALUE has_nesting, VALUE selector_lists, VALUE media_queries, VALUE media_query_lists, VALUE conditional_groups, int formatted) {
     Check_Type(rules_array, T_ARRAY);
     Check_Type(media_queries, T_ARRAY);
     if (!NIL_P(media_query_lists)) Check_Type(media_query_lists, T_HASH);
     if (!NIL_P(selector_lists)) Check_Type(selector_lists, T_HASH);
+    if (!NIL_P(conditional_groups)) Check_Type(conditional_groups, T_ARRAY);
 
     VALUE result = rb_str_new_cstr("");
 
@@ -1008,22 +1154,23 @@ static VALUE stylesheet_serialize_impl(VALUE rules_array, VALUE charset, VALUE h
 
     // Fast path: if no nesting, use the selector-list-grouping serializer (zero overhead)
     if (!RTEST(has_nesting)) {
-        return serialize_stylesheet_with_grouping(rules_array, media_queries, media_query_lists, result, selector_lists, &opts);
+        return serialize_stylesheet_with_grouping(rules_array, media_queries, media_query_lists, result, selector_lists, conditional_groups, &opts);
     }
 
     // Has nesting - use the parent/child lookahead serializer
     // TODO: Phase 2 - use selector_lists for grouping on the nesting path too
-    return serialize_stylesheet_with_nesting(rules_array, media_queries, result, &opts);
+    // TODO: conditional_groups (@supports etc.) aren't reconstructed on this path yet
+    return serialize_stylesheet_with_nesting(rules_array, media_queries, media_query_lists, result, &opts);
 }
 
 // New stylesheet serialization entry point - checks for nesting and delegates
-static VALUE stylesheet_to_s(VALUE self, VALUE rules_array, VALUE charset, VALUE has_nesting, VALUE selector_lists, VALUE media_queries, VALUE media_query_lists) {
-    return stylesheet_serialize_impl(rules_array, charset, has_nesting, selector_lists, media_queries, media_query_lists, 0);
+static VALUE stylesheet_to_s(VALUE self, VALUE rules_array, VALUE charset, VALUE has_nesting, VALUE selector_lists, VALUE media_queries, VALUE media_query_lists, VALUE conditional_groups) {
+    return stylesheet_serialize_impl(rules_array, charset, has_nesting, selector_lists, media_queries, media_query_lists, conditional_groups, 0);
 }
 
 // Formatted version with indentation and newlines (with nesting support)
-static VALUE stylesheet_to_formatted_s(VALUE self, VALUE rules_array, VALUE charset, VALUE has_nesting, VALUE selector_lists, VALUE media_queries, VALUE media_query_lists) {
-    return stylesheet_serialize_impl(rules_array, charset, has_nesting, selector_lists, media_queries, media_query_lists, 1);
+static VALUE stylesheet_to_formatted_s(VALUE self, VALUE rules_array, VALUE charset, VALUE has_nesting, VALUE selector_lists, VALUE media_queries, VALUE media_query_lists, VALUE conditional_groups) {
+    return stylesheet_serialize_impl(rules_array, charset, has_nesting, selector_lists, media_queries, media_query_lists, conditional_groups, 1);
 }
 
 /*
@@ -1077,78 +1224,6 @@ static VALUE new_parse_declarations_string(const char *start, const char *end) {
     return declarations;
 }
 
-/*
- * Convert array of Declaration structs to CSS string
- * Format: "prop: value; prop2: value2 !important; "
- *
- * This is a copy of declarations_array_to_s from cataract.c,
- * but works with Declaration structs instead of Declaration structs
- */
-static VALUE new_declarations_array_to_s(VALUE declarations_array) {
-    Check_Type(declarations_array, T_ARRAY);
-
-    long len = RARRAY_LEN(declarations_array);
-    if (len == 0) {
-        return rb_str_new_cstr("");
-    }
-
-    // Use rb_str_buf_new for efficient string building
-    VALUE result = rb_str_buf_new(len * 32); // Estimate 32 chars per declaration
-
-    for (long i = 0; i < len; i++) {
-        VALUE decl = rb_ary_entry(declarations_array, i);
-
-        // Validate this is a Declaration struct
-        if (!RB_TYPE_P(decl, T_STRUCT) || rb_obj_class(decl) != cDeclaration) {
-            rb_raise(rb_eTypeError,
-                     "Expected array of Declaration structs, got %s at index %ld",
-                     rb_obj_classname(decl), i);
-        }
-
-        // Extract struct fields
-        VALUE property = rb_struct_aref(decl, INT2FIX(DECL_PROPERTY));
-        VALUE value = rb_struct_aref(decl, INT2FIX(DECL_VALUE));
-        VALUE important = rb_struct_aref(decl, INT2FIX(DECL_IMPORTANT));
-
-        // Append: "property: value"
-        rb_str_buf_append(result, property);
-        rb_str_buf_cat2(result, ": ");
-        rb_str_buf_append(result, value);
-
-        // Append " !important" if needed
-        if (RTEST(important)) {
-            rb_str_buf_cat2(result, " !important");
-        }
-
-        rb_str_buf_cat2(result, "; ");
-
-        RB_GC_GUARD(decl);
-        RB_GC_GUARD(property);
-        RB_GC_GUARD(value);
-        RB_GC_GUARD(important);
-    }
-
-    // Strip trailing space
-    rb_str_set_len(result, RSTRING_LEN(result) - 1);
-
-    RB_GC_GUARD(result);
-    return result;
-}
-
-/*
- * Instance method: Declarations#to_s
- * Converts declarations to CSS string
- *
- * @return [String] CSS declarations like "color: red; margin: 10px !important;"
- */
-static VALUE new_declarations_to_s_method(VALUE self) {
-    // Get @values instance variable (array of Declaration structs)
-    VALUE values = rb_ivar_get(self, rb_intern("@values"));
-
-    // Call core serialization function
-    return new_declarations_array_to_s(values);
-}
-
 /*
  * Ruby-facing wrapper for new_parse_declarations
  *
@@ -1239,23 +1314,30 @@ void Init_native_extension(void) {
         rb_raise(rb_eLoadError, "Cataract::MediaQuery not defined. Do not require 'cataract/native_extension' directly, use require 'cataract'");
     }
 
-    // Define Declarations class and add to_s method
-    VALUE cDeclarations = rb_define_class_under(mCataract, "Declarations", rb_cObject);
-    rb_define_method(cDeclarations, "to_s", new_declarations_to_s_method, 0);
+    if (rb_const_defined(mCataract, rb_intern("ConditionalGroup"))) {
+        cConditionalGroup = rb_const_get(mCataract, rb_intern("ConditionalGroup"));
+    } else {
+        rb_raise(rb_eLoadError, "Cataract::ConditionalGroup not defined. Do not require 'cataract/native_extension' directly, use require 'cataract'");
+    }
 
-    // Define Stylesheet class (Ruby will add instance methods like each_selector)
+    // Define Stylesheet class (Ruby will add instance methods like each_selector).
+    // Declarations is left alone here - it's a plain Ruby class (declarations.rb)
+    // with its own #to_s, not something this backend attaches methods to.
     cStylesheet = rb_define_class_under(mCataract, "Stylesheet", rb_cObject);
 
-    // Define module functions
-    rb_define_module_function(mCataract, "_parse_css", parse_css_new, -1);
-    rb_define_module_function(mCataract, "stylesheet_to_s", stylesheet_to_s, 6);
-    rb_define_module_function(mCataract, "stylesheet_to_formatted_s", stylesheet_to_formatted_s, 6);
-    rb_define_module_function(mCataract, "parse_media_types", parse_media_types, 1);
-    rb_define_module_function(mCataract, "parse_declarations", new_parse_declarations, 1);
-    rb_define_module_function(mCataract, "flatten", cataract_flatten, 1);
-    rb_define_module_function(mCataract, "merge", cataract_flatten, 1); // Deprecated alias for backwards compatibility
-    rb_define_module_function(mCataract, "calculate_specificity", calculate_specificity, 1);
-    rb_define_module_function(mCataract, "expand_shorthand", cataract_expand_shorthand, 1);
+    // Every native-specific entry point lives under Cataract::Backends::Native,
+    // never directly on Cataract itself, so the pure Ruby backend can be loaded
+    // in the same process without either backend clobbering the other's methods.
+    VALUE mBackends = rb_define_module_under(mCataract, "Backends");
+    VALUE mNative = rb_define_module_under(mBackends, "Native");
+
+    rb_define_module_function(mNative, "parse", parse_css_new, -1);
+    rb_define_module_function(mNative, "stylesheet_to_s", stylesheet_to_s, 7);
+    rb_define_module_function(mNative, "stylesheet_to_formatted_s", stylesheet_to_formatted_s, 7);
+    rb_define_module_function(mNative, "parse_declarations", new_parse_declarations, 1);
+    rb_define_module_function(mNative, "flatten", cataract_flatten, 1);
+    rb_define_module_function(mNative, "calculate_specificity", calculate_specificity, 1);
+    rb_define_module_function(mNative, "expand_shorthand", cataract_expand_shorthand, 1);
 
     // Initialize flatten constants (cached property strings)
     init_flatten_constants();
@@ -1275,11 +1357,11 @@ void Init_native_extension(void) {
         rb_hash_aset(compile_flags, ID2SYM(rb_intern("str_buf_optimization")), Qtrue);
     #endif
 
-    rb_define_const(mCataract, "COMPILE_FLAGS", compile_flags);
+    rb_define_const(mNative, "COMPILE_FLAGS", compile_flags);
 
-    // Flag to indicate native extension is loaded (for pure Ruby fallback detection)
-    rb_define_const(mCataract, "NATIVE_EXTENSION_LOADED", Qtrue);
+    // Flag to indicate the native backend is loaded (for pure Ruby fallback detection)
+    rb_define_const(mNative, "NATIVE_EXTENSION_LOADED", Qtrue);
 
     // Implementation type constant
-    rb_define_const(mCataract, "IMPLEMENTATION", ID2SYM(rb_intern("native")));
+    rb_define_const(mNative, "IMPLEMENTATION", ID2SYM(rb_intern("native")));
 }

data/ext/cataract/cataract.h

@@ -14,6 +14,7 @@ extern VALUE cAtRule;
 extern VALUE cStylesheet;
 extern VALUE cImportStatement;
 extern VALUE cMediaQuery;
+extern VALUE cConditionalGroup;
 
 // Error class references
 extern VALUE eCataractError;
@@ -25,7 +26,7 @@ extern VALUE eParseError;
 // Struct field indices
 // ============================================================================
 
-// Rule struct field indices (id, selector, declarations, specificity, parent_rule_id, nesting_style, selector_list_id, media_query_id)
+// Rule struct field indices (id, selector, declarations, specificity, parent_rule_id, nesting_style, selector_list_id, media_query_id, conditional_group_id)
 #define RULE_ID 0
 #define RULE_SELECTOR 1
 #define RULE_DECLARATIONS 2
@@ -34,6 +35,7 @@ extern VALUE eParseError;
 #define RULE_NESTING_STYLE 5
 #define RULE_SELECTOR_LIST_ID 6
 #define RULE_MEDIA_QUERY_ID 7
+#define RULE_CONDITIONAL_GROUP_ID 8
 
 // Nesting style constants
 #define NESTING_STYLE_IMPLICIT 0  // .parent { .child { } } - no &
@@ -45,13 +47,14 @@ extern VALUE eParseError;
 #define NO_PARENT_SELECTOR Qnil
 #define NO_PARENT_RULE_ID Qnil
 #define NO_MEDIA_QUERY_ID (-1)
+#define NO_CONDITIONAL_GROUP_ID (-1)
 
 // Declaration struct field indices (property, value, important)
 #define DECL_PROPERTY 0
 #define DECL_VALUE 1
 #define DECL_IMPORTANT 2
 
-// AtRule struct field indices (id, selector, content, specificity, media_query_id)
+// AtRule struct field indices (id, selector, content, specificity, media_query_id, conditional_group_id)
 // Matches Rule interface for duck-typing, but AtRule has fewer members - its
 // indices do NOT line up with Rule's past AT_RULE_SPECIFICITY (e.g. index 4
 // is media_query_id here but parent_rule_id on Rule), so never read a field
@@ -61,6 +64,14 @@ extern VALUE eParseError;
 #define AT_RULE_CONTENT 2
 #define AT_RULE_SPECIFICITY 3
 #define AT_RULE_MEDIA_QUERY_ID 4
+#define AT_RULE_CONDITIONAL_GROUP_ID 5
+
+// ConditionalGroup struct field indices (id, type, name, condition, parent_id)
+#define CONDITIONAL_GROUP_ID 0
+#define CONDITIONAL_GROUP_TYPE 1
+#define CONDITIONAL_GROUP_NAME 2
+#define CONDITIONAL_GROUP_CONDITION 3
+#define CONDITIONAL_GROUP_PARENT_ID 4
 
 // ============================================================================
 // Macros
@@ -262,7 +273,6 @@ static inline VALUE strip_string(const char *str, long len) {
 // CSS parser (css_parser_new.c)
 VALUE parse_css_new(int argc, VALUE *argv, VALUE self);
 VALUE parse_css_new_impl(VALUE css_string, VALUE parser_options, int rule_id_offset);
-VALUE parse_media_types(VALUE self, VALUE media_query_sym);
 
 // Flatten (flatten.c)
 VALUE cataract_flatten(VALUE self, VALUE rules_array);