Skip to content
TheChatArchiveThe Chat Archive
Geminigemini-2.5-flash· GoogleHugging Face LMArena Human Preference 140K

TASK Objective: Create a Python-based web application using the Flask framework that…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with o4-mini-2025-04-16’s answer.
  1. User

    TASK

    Objective: Create a Python-based web application using the Flask framework that functions as a sophisticated CSS merger. The primary goal is to intelligently merge CSS rules from duplicated selectors while perfectly preserving all other parts of the stylesheet.

    Core Functional Requirements:

    1. Scope-Aware Merging (Critical): The application must understand CSS scope. Selectors should only be considered duplicates if they exist within the same context. The global scope is one context, and each @-rule block (like @media, @supports, @keyframes, or custom ones like @include) defines a new, distinct, nested scope. For example, .foo inside @media (min-width: 768px) is separate from .foo in any other scope. The merging logic must be applied recursively within each scope.

    2. Property Merging Logic: When duplicate selectors within the same scope are merged, their properties must be combined. The definition from the last-appearing block in the original text must take precedence for any given property, reflecting standard CSS cascading behavior.

    3. Perfect Preservation of Untouched Code: This is a strict requirement. Any part of the CSS that is not directly involved in a merge must be preserved exactly as it is. This includes:

      • All @-rules and their content (the merging logic is applied inside them, but the @-rule itself is preserved).
      • Any standard CSS rule (selector {}) that is unique within its scope.
      • All comments, especially those outside of rule blocks (e.g., section headers).
      • All original line breaks, blank lines, and whitespace between rules.
      • The application must not reformat, "beautify," or otherwise alter any code it is not explicitly merging.
    4. Formatting of Newly Merged Blocks: Only the rule blocks that are newly generated from a merge should be formatted. The formatting must be precise:

      • The selector (e.g., .my-class, #my-id) starts at the beginning of its line within the scope's indentation.
      • A single space separates the selector from the opening brace {.
      • Properties and any collected internal comments are on new lines, indented with two spaces.
      • The block is closed with a } on a new line, at the same indentation level as the selector.
      • If a merge results in an empty rule, it should be formatted on a single line: .selector {}.
    5. Changelog Feature:

      • The application must have a "Changelog" section.
      • This section should only display the final, newly formatted CSS rules that were the result of a merge.
      • If multiple rules were merged, a thin horizontal line should separate them visually.
      • If no duplicates were found, the changelog should display a message like: "No duplicate selectors found to merge."

    Web Interface and Technology:

    • Backend: You are free to choose the best Python libraries and implementation strategy to achieve the functional requirements reliably. A robust, dedicated CSS parsing library is highly recommended over manual parsing with regular expressions to handle the complexities of CSS structure and scopes. The application must be built using the Flask framework.
    • Frontend: The application must use the exact HTML template provided below without modification. The template handles the layout (input/output columns, changelog), a modern dark-mode theme, and includes client-side JavaScript for a "Copy All" button. Your Flask backend should render this template, populating the {{ input_css }}, {{ merged_css }}, and {{ changelog_list }} variables.

    Provided HTML Template (templates/index.html):

    <!DOCTYPE html>
    <html lang="en"> <head>
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <title>CSS Rule Merger - Dark Mode</title>
        <style>
            :root {
                --bg-color: #1e1e1e;
                --primary-text-color: #e0e0e0;
                --secondary-text-color: #b0b0b0;
                --accent-color: #007acc;
                --accent-hover-color: #005fa3;
                --border-color: #3a3a3a; 
                --input-bg-color: #2c2c2c;
                --pre-bg-color: #252525;
                --card-bg-color: #282828;
                --button-text-color: #ffffff;
                --success-color: #28a745;
            }
    
            body {
                font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
                margin: 0;
                padding: 20px;
                background-color: var(--bg-color);
                color: var(--primary-text-color);
                line-height: 1.6;
            }
    
            .main-container {
                max-width: 1400px;
                margin: 20px auto;
                padding: 25px;
                background-color: var(--card-bg-color);
                border-radius: 12px;
                box-shadow: 0 8px 16px rgba(0,0,0,0.2);
            }
    
            h1 {
                text-align: center;
                color: var(--primary-text-color);
                margin-bottom: 20px;
                font-weight: 600;
            }
    
            .columns-container {
                display: flex;
                flex-direction: row;
                justify-content: space-between;
                gap: 25px;
                margin-bottom: 20px;
            }
    
            .column {
                flex: 1;
                display: flex;
                flex-direction: column;
            }
    
            .column-header {
                display: flex;
                justify-content: space-between;
                align-items: center;
                border-bottom: 1px solid var(--border-color);
                padding-bottom: 8px;
                margin-bottom: 10px;
            }
    
            h2 {
                margin-top: 0;
                margin-bottom: 0;
                color: var(--secondary-text-color);
                font-size: 1.2em;
                font-weight: 500;
            }
    
            textarea, #merged_css_output {
                width: calc(100% - 30px);
                height: 400px;
                padding: 15px;
                border: 1px solid var(--border-color);
                border-radius: 8px;
                font-family: "SFMono-Regular", Consolas, "Liberation Mono", Menlo, Courier, monospace;
                font-size: 14px;
                color: var(--primary-text-color);
                margin-bottom: 15px;
                overflow-y: auto;
            }
    
            textarea {
                background-color: var(--input-bg-color);
                resize: vertical;
            }
    
            #merged_css_output {
                background-color: var(--pre-bg-color);
                white-space: pre-wrap;
                word-wrap: break-word;
    			margin: 0;
            }
            
            #changelog_output_container {
                background-color: var(--pre-bg-color);
                border: 1px solid var(--border-color);
                border-radius: 8px;
                padding: 5px 15px 15px 15px;
                margin-top: 10px;
                height: auto;
                overflow-y: auto;
                font-family: "SFMono-Regular", Consolas, "Liberation Mono", Menlo, Courier, monospace;
                font-size: 14px;
                color: var(--primary-text-color);
            }
    
            .changelog-entry {
                white-space: pre-wrap;
                word-wrap: break-word;
                margin: 0;
                padding-top: 10px;
            }
    
            hr.changelog-separator {
                border: none;
                height: 1px;
                background-color: var(--border-color);
                margin-top: 15px;
                margin-bottom: 5px;
            }
    
    
            .action-button {
                background-color: var(--accent-color);
                color: var(--button-text-color);
                padding: 10px 20px;
                border: none;
                border-radius: 6px;
                cursor: pointer;
                font-size: 14px;
                font-weight: 500;
                transition: background-color 0.2s ease;
            }
            .action-button:hover {
                background-color: var(--accent-hover-color);
            }
    
            .submit-button {
                padding: 12px 25px;
                font-size: 16px;
                display: block;
                width: fit-content;
                margin: 0 auto;
            }
    
            #copy_merged_css_button {
                font-size: 0.9em;
                padding: 6px 12px;
            }
    
            @media (max-width: 768px) {
                .columns-container {
                    flex-direction: column;
                }
                textarea, #merged_css_output {
                    height: 300px;
                }
                #changelog_output_container {
                    height: auto;
                }
                h1 {
                    font-size: 1.8em;
                }
            }
        </style>
    </head>
    <body>
        <div class="main-container">
            <h1>CSS Rule Merger</h1>
    
            <form method="POST" action="/">
                <div class="columns-container">
                    <div class="column">
                        <div class="column-header">
                            <h2>Input CSS:</h2>
                        </div>
                        <textarea name="input_css" placeholder="Paste your CSS here...">{{ input_css }}</textarea>
                    </div>
                    <div class="column">
                        <div class="column-header">
                            <h2>Merged CSS:</h2>
                            <button type="button" id="copy_merged_css_button" class="action-button">Copy All</button>
                        </div>
                        <pre id="merged_css_output">{{ merged_css }}</pre>
                    </div>
                </div>
                <input type="submit" value="Merge CSS" class="action-button submit-button">
            </form>
    
            <div class="column-header" style="margin-top: 20px;">
                 <h2>Changelog:</h2>
            </div>
            <div id="changelog_output_container">
                {% if changelog_list %}
                    {% for entry in changelog_list %}
                        <pre class="changelog-entry">{{ entry }}</pre>
                        {% if not loop.last %}
                            <hr class="changelog-separator">
                        {% endif %}
                    {% endfor %}
                {% else %}
                    <pre class="changelog-entry">No changes to display.</pre> 
                {% endif %}
            </div>
        </div>
    
        <script>
            document.addEventListener('DOMContentLoaded', function() {
                const copyButton = document.getElementById('copy_merged_css_button');
                const mergedCssOutput = document.getElementById('merged_css_output');
    
                if (copyButton && mergedCssOutput) {
                    copyButton.addEventListener('click', function() {
                        const textToCopy = mergedCssOutput.textContent || mergedCssOutput.innerText;
                        
                        if (!textToCopy.trim()) {
                            copyButton.textContent = 'Nothing to Copy';
                            setTimeout(() => {
                                copyButton.textContent = 'Copy All';
                            }, 2000);
                            return;
                        }
    
                        navigator.clipboard.writeText(textToCopy).then(function() {
                            copyButton.textContent = 'Copied!';
                            copyButton.style.backgroundColor = 'var(--success-color)';
                            setTimeout(function() {
                                copyButton.textContent = 'Copy All';
                                copyButton.style.backgroundColor = 'var(--accent-color)';
                            }, 2000);
                        }).catch(function(err) {
                            copyButton.textContent = 'Copy Failed';
                            console.error('Error copying text: ', err);
                            setTimeout(function() {
                                copyButton.textContent = 'Copy All';
                            }, 2000);
                        });
                    });
                }
            });
        </script>
    </body>
    </html>
    
  2. Gemini Assistant

    To fulfill the task's requirements for a sophisticated CSS merger, especially the "perfect preservation" aspect, a highly controlled parsing and reconstruction strategy is necessary. Standard CSS parsers often normalize or reformat code, which violates the strict preservation rule.

    The chosen approach involves:

    1. Custom CSS Block Representation: A CssBlock class to store different types of CSS content (style rules, at-rules, comments, whitespace) along with their original raw text and scope information.
    2. tinycss2 for Structure, Manual Slicing for Content: tinycss2 is used to identify the structural components (selectors, declarations, at-rule preludes, nested blocks). However, instead of relying on tinycss2's serialization, the original CSS string is manually sliced based on tinycss2's source_line and source_column information to preserve exact whitespace and comments. This is crucial for "perfect preservation."
    3. Recursive Parsing: A recursive function walks through the CSS, identifying scopes (@media, @supports, etc.) and their nested contents.
    4. Two-Pass Merging Logic:
      • Pass 1 (Collection): Traverses the parsed CssBlock tree to identify all style rules within each unique scope. For duplicate selectors, it merges their properties, ensuring the last-appearing definition for any given property takes precedence. It also collects all internal comments from merged rules.
      • Pass 2 (Reconstruction): Iterates through the original sequence of CssBlocks. If a style rule was part of a merge operation and is its first occurrence in that scope, a newly formatted CssBlock representing the merged rule is inserted. Otherwise, the original raw content of the CssBlock is preserved exactly. At-rules are recursively processed, and comments/whitespace are always preserved.
    5. Precise Formatting: Only newly merged rule blocks are formatted according to the strict specification (selector, braces, indented properties/comments). Empty merged rules are handled.
    6. Changelog Generation: As rules are merged, their newly formatted output is added to a separate list for the "Changelog" section.

    Python Flask Application Code

    1. app.py (Main Flask Application)

    import re
    from flask import Flask, render_template, request
    from tinycss2.ast import QualifiedRule, AtRule, Comment, WhitespaceToken, Declaration, Node
    import tinycss2
    
    app = Flask(__name__)
    
    # --- CSS Parsing and Merging Logic ---
    
    class CssBlock:
        """
        Represents a distinct block of CSS content, preserving its original raw text
        and tracking its scope and type.
        """
        def __init__(self, block_type: str, raw_content: str, scope_path: list[str] = None, original_indent_level: int = 0):
            self.type = block_type  # 'style_rule', 'at_rule', 'comment', 'whitespace', 'other'
            self.raw_content = raw_content  # The original raw string for this block
            self.scope_path = scope_path if scope_path is not None else []
            self.original_indent_level = original_indent_level # Indent level based on CSS scope depth
    
            # For 'style_rule' blocks
            self.selector = None
            # {property_name: {'value': raw_value_text}}
            self.declarations = {} 
            # List of raw strings for comments/whitespace found *inside* the rule block
            self.internal_comments_and_whitespace = []
    
            # For 'at_rule' blocks
            self.at_keyword = None  # e.g., 'media'
            self.prelude = None     # e.g., '(min-width: 768px)'
            # List of CssBlock objects nested within this at-rule
            self.nested_blocks = [] 
    
        def __repr__(self):
            if self.type == 'style_rule':
                return (f"CssBlock(type='{self.type}', selector='{self.selector}', "
                        f"scope_path={self.scope_path}, decls={len(self.declarations)})")
            elif self.type == 'at_rule':
                return (f"CssBlock(type='{self.type}', at_keyword='{self.at_keyword}', "
                        f"prelude='{self.prelude}', scope_path={self.scope_path}, "
                        f"nested={len(self.nested_blocks)})")
            else:
                return (f"CssBlock(type='{self.type}', "
                        f"raw_content='{self.raw_content.strip()[:50]}...', "
                        f"scope_path={self.scope_path})")
    
    def _get_line_offsets(text: str) -> list[int]:
        """Calculates the 0-based starting character index for each line."""
        offsets = [0]
        for m in re.finditer(r'\r?\n', text):
            offsets.append(m.end())
        return offsets
    
    def _get_char_idx_from_line_col(line_offsets: list[int], line: int, col: int) -> int:
        """Converts 1-based line/column from tinycss2 to a 0-based character index."""
        if line <= 0 or line > len(line_offsets):
            return -1 # Invalid line, or outside parsed range
        return line_offsets[line - 1] + col - 1
    
    def _parse_css_segment(
        css_segment_string: str,      # The string for the current segment (e.g., full CSS, or @media body)
        full_css_string: str,         # The complete original CSS string (for line_offsets)
        line_offsets: list[int],      # Pre-calculated line offsets for full_css_string
        current_scope_path: list[str],
        parent_segment_start_idx_in_full_css: int, # Start index of css_segment_string in full_css_string
        base_indent_level: int
    ) -> list[CssBlock]:
        """
        Recursively parses a CSS string segment into CssBlock objects, preserving
        original formatting by slicing the raw text.
        """
        blocks = []
        
        # Parse the segment with tinycss2. Crucially, do not skip comments or whitespace.
        nodes = tinycss2.parse_stylesheet_string(css_segment_string, skip_comments=False, skip_whitespace=False)
    
        # Tracks the last processed character index in the *current segment string*
        current_segment_pos = 0 
    
        for i, node in enumerate(nodes):
            # Calculate start index of the current node relative to the *full original CSS string*
            node_start_idx_in_full_css = _get_char_idx_from_line_col(line_offsets, node.source_line, node.source_column)
    
            # Calculate start index of the current node relative to the *current segment string*
            node_start_idx_in_segment = node_start_idx_in_full_css - parent_segment_start_idx_in_full_css
    
            # Capture any raw content (whitespace, comments, etc.) *before* the current node
            # that tinycss2 might not explicitly yield as a distinct node, or was ignored.
            if node_start_idx_in_segment > current_segment_pos:
                raw_gap_content = css_segment_string[current_segment_pos:node_start_idx_in_segment]
                if raw_gap_content:
                    blocks.append(CssBlock('other', raw_gap_content, current_scope_path))
            
            # Determine the end index of the current node in the *current segment string*
            node_end_idx_in_segment = len(css_segment_string) # Default to end of segment
            if i + 1 < len(nodes):
                next_node = nodes[i+1]
                next_node_start_idx_in_full_css = _get_char_idx_from_line_col(line_offsets, next_node.source_line, next_node.source_column)
                node_end_idx_in_segment = next_node_start_idx_in_full_css - parent_segment_start_idx_in_full_css
            
            # Extract the exact raw content of the current node
            raw_node_content = css_segment_string[node_start_idx_in_segment : node_end_idx_in_segment]
    
            # Process the node based on its type
            if isinstance(node, (Comment, WhitespaceToken)):
                blocks.append(CssBlock(node.type.lower(), raw_node_content, current_scope_path))
            elif isinstance(node, QualifiedRule):  # A standard CSS rule: selector { declarations }
                block = CssBlock('style_rule', raw_node_content, current_scope_path, original_indent_level=base_indent_level)
                block.selector = node.prelude.serialize().strip() # Get selector text (e.g., 'p', '.foo')
                
                # Parse declarations and internal comments from node.content
                # tinycss2.parse_declaration_list works on the content between braces
                decls_nodes = tinycss2.parse_declaration_list(node.content, skip_comments=False, skip_whitespace=False)
                
                for decl_node in decls_nodes:
                    if isinstance(decl_node, Declaration):
                        prop_name = decl_node.name.strip()
                        # Store raw value text to preserve !important, comments within values etc.
                        prop_value_text = decl_node.value.serialize() 
                        block.declarations[prop_name] = {'value': prop_value_text.strip()}
                    elif isinstance(decl_node, (Comment, WhitespaceToken)):
                        # Collect comments/whitespace *inside* the rule
                        block.internal_comments_and_whitespace.append(decl_node.serialize())
                blocks.append(block)
            elif isinstance(node, AtRule):  # An @-rule like @media, @keyframes
                block = CssBlock('at_rule', raw_node_content, current_scope_path, original_indent_level=base_indent_level)
                block.at_keyword = node.at_keyword.strip()
                block.prelude = node.prelude.serialize().strip() if node.prelude else ''
    
                if node.content:
                    new_scope_name = f"@{block.at_keyword} {block.prelude}".strip()
                    
                    # Find the actual content string of the at-rule's body (between { and })
                    # This needs to be done carefully to include all internal whitespace/comments
                    body_match = re.search(r'\{(.*)\}', raw_node_content, re.DOTALL)
                    if body_match:
                        at_rule_body_content = body_match.group(1)
                        # Calculate the start index of the nested content relative to the *full original CSS string*
                        nested_segment_start_idx_in_full_css = (
                            node_start_idx_in_full_css + raw_node_content.find('{') + 1
                        )
                        block.nested_blocks = _parse_css_segment(
                            at_rule_body_content,
                            full_css_string,
                            line_offsets,
                            current_scope_path + [new_scope_name],
                            nested_segment_start_idx_in_full_css,
                            base_indent_level + 1 # Increase indent level for nested content
                        )
                blocks.append(block)
            else: # Any other unexpected tokens/nodes
                blocks.append(CssBlock('other', raw_node_content, current_scope_path))
            
            # Update current position in the segment string
            current_segment_pos = node_end_idx_in_segment
    
        # Capture any trailing content after the last node in this segment
        if current_segment_pos < len(css_segment_string):
            raw_gap_content = css_segment_string[current_segment_pos:]
            if raw_gap_content:
                blocks.append(CssBlock('other', raw_gap_content, current_scope_path))
    
        return blocks
    
    def parse_css(css_string: str) -> list[CssBlock]:
        """Main entry point for parsing CSS into structured CssBlock objects."""
        line_offsets = _get_line_offsets(css_string)
        # Start parsing from the global scope (empty scope_path) at indent level 0
        return _parse_css_segment(css_string, css_string, line_offsets, [], 0, 0)
    
    def format_merged_rule(selector: str, declarations: dict, internal_comments: list[str], base_indent_level: int) -> str:
        """Formats a merged CSS rule block."""
        scope_indent = '  ' * base_indent_level
        prop_indent = '  ' * (base_indent_level + 1)
        
        # Handle empty rules
        if not declarations and not internal_comments:
            return f"{scope_indent}{selector} {{}}"
        
        lines = [f"{scope_indent}{selector} {{"]
        
        # Add internal comments and whitespace before properties
        for item in internal_comments:
            stripped_item = item.strip()
            if stripped_item: # Only add if not empty after stripping
                lines.append(f"{prop_indent}{stripped_item}")
    
        # Add properties, sorted alphabetically for consistent output
        sorted_properties = sorted(declarations.keys())
        for prop in sorted_properties:
            value = declarations[prop]['value']
            lines.append(f"{prop_indent}{prop}: {value};")
        
        lines.append(f"{scope_indent}}}")
        return "\n".join(lines)
    
    def format_merged_rule_for_changelog(selector: str, declarations: dict, internal_comments: list[str]) -> str:
        """Formats a merged CSS rule block specifically for the changelog."""
        # Changelog formatting always starts at zero indent for the selector, 2 spaces for properties.
        prop_indent = '  '
        
        if not declarations and not internal_comments:
            return f"{selector} {{}}"
        
        lines = [f"{selector} {{"]
        
        for item in internal_comments:
            stripped_item = item.strip()
            if stripped_item:
                lines.append(f"{prop_indent}{stripped_item}")
    
        sorted_properties = sorted(declarations.keys())
        for prop in sorted_properties:
            value = declarations[prop]['value']
            lines.append(f"{prop_indent}{prop}: {value};")
        
        lines.append(f"}}")
        return "\n".join(lines)
    
    
    def process_css_blocks(blocks: list[CssBlock], merged_changelog: list[str]) -> list[CssBlock]:
        """
        Processes parsed CSS blocks to merge duplicate selectors within scopes
        and reconstruct the output, generating changelog entries.
        """
        
        # Pass 1: Collect all rules and their merged state
        # Key: tuple(scope_path), Value: dict (selector: {declarations: {}, internal_comments: [], first_block: CssBlock, original_blocks: []})
        merged_rules_map = {} 
    
        def collect_and_merge_rules_recursive(current_blocks: list[CssBlock], current_scope_path: list[str]):
            """Helper to recursively populate merged_rules_map."""
            for block in current_blocks:
                if block.type == 'style_rule':
                    scope_key = tuple(current_scope_path)
                    selector = block.selector
    
                    if scope_key not in merged_rules_map:
                        merged_rules_map[scope_key] = {}
                    
                    if selector not in merged_rules_map[scope_key]:
                        # First time seeing this selector in this scope
                        merged_rules_map[scope_key][selector] = {
                            'declarations': {},
                            'internal_comments': [],
                            'first_block': block, # Keep reference to the very first block of this selector
                            'original_blocks': [] # List of all original blocks for this selector
                        }
                    
                    # Merge properties: last-appearing definition wins.
                    # Simple update handles this as Python dict update overwrites existing keys.
                    merged_rules_map[scope_key][selector]['declarations'].update(block.declarations)
                    
                    # Collect internal comments/whitespace. Extend preserves order.
                    merged_rules_map[scope_key][selector]['internal_comments'].extend(block.internal_comments_and_whitespace)
                    
                    merged_rules_map[scope_key][selector]['original_blocks'].append(block)
    
                elif block.type == 'at_rule':
                    # Recursively collect rules from nested blocks
                    new_scope = f"@{block.at_keyword} {block.prelude}".strip()
                    collect_and_merge_rules_recursive(block.nested_blocks, current_scope_path + [new_scope])
        
        # Start the collection process with top-level blocks
        collect_and_merge_rules_recursive(blocks, [])
    
        # Pass 2: Reconstruct the output based on original order and the merged_rules_map
        def reconstruct_blocks_recursive(current_blocks: list[CssBlock], current_scope_path: list[str]) -> list[CssBlock]:
            """Helper to recursively reconstruct the final list of CssBlocks."""
            reconstructed_output = []
            # Keep track of selectors already processed in *this specific scope*
            processed_selectors_in_current_scope = set() 
            
            for block in current_blocks:
                if block.type == 'style_rule':
                    scope_key = tuple(current_scope_path)
                    selector = block.selector
                    
                    if selector in processed_selectors_in_current_scope:
                        # This rule has already been outputted as part of a merge. Skip this duplicate.
                        continue 
                    
                    merged_data = merged_rules_map[scope_key][selector]
                    
                    if len(merged_data['original_blocks']) > 1:
                        # This selector was duplicated and now merged. Format a new block for it.
                        merged_formatted_content = format_merged_rule(
                            selector, 
                            merged_data['declarations'], 
                            merged_data['internal_comments'], 
                            block.original_indent_level # Use indent level of the *first* block in its scope
                        )
                        
                        # Create a new CssBlock representing the merged output
                        merged_css_block = CssBlock(
                            'style_rule', 
                            merged_formatted_content, 
                            block.scope_path,
                            block.original_indent_level
                        )
                        merged_css_block.selector = selector # Set selector for debug/changelog formatting
                        reconstructed_output.append(merged_css_block)
                        
                        # Add to changelog (only if not already added to prevent duplicates in changelog)
                        changelog_entry = format_merged_rule_for_changelog(selector, merged_data['declarations'], merged_data['internal_comments'])
                        if changelog_entry not in merged_changelog:
                            merged_changelog.append(changelog_entry)
                        
                        processed_selectors_in_current_scope.add(selector) # Mark as processed
                    else:
                        # Not a duplicate, preserve original block exactly as it was.
                        reconstructed_output.append(block)
                        processed_selectors_in_current_scope.add(selector) # Mark as processed (single instance)
                        
                elif block.type == 'at_rule':
                    # Recursively reconstruct nested blocks
                    new_scope = f"@{block.at_keyword} {block.prelude}".strip()
                    block.nested_blocks = reconstruct_blocks_recursive(block.nested_blocks, current_scope_path + [new_scope])
                    reconstructed_output.append(block)
                else:
                    # Preserve comments, whitespace, and other non-rule blocks exactly.
                    reconstructed_output.append(block)
            
            return reconstructed_output
    
        # Start reconstruction from top-level blocks
        final_output_blocks = reconstruct_blocks_recursive(blocks, [])
        
        return final_output_blocks
    
    
    def render_css_blocks(blocks: list[CssBlock]) -> str:
        """Renders a list of CssBlock objects back into a CSS string."""
        output_parts = []
        
        for block in blocks:
            if block.type == 'at_rule':
                # At-rules are kept as they are. Their `raw_content` includes `@rule ... { ... }`.
                # We need to replace the content *inside* the braces with the recursively rendered body.
                
                # Find the positions of the opening and closing braces in the original raw content
                brace_open_idx = block.raw_content.find('{')
                brace_close_idx = block.raw_content.rfind('}')
                
                if brace_open_idx != -1 and brace_close_idx != -1 and brace_open_idx < brace_close_idx:
                    # Extract the part before the opening brace (e.g., `@media (min-width: 768px) `)
                    prefix = block.raw_content[:brace_open_idx + 1] # Includes opening brace
                    # Extract the part from the closing brace to the end (e.g., ` }`)
                    suffix = block.raw_content[brace_close_idx:] # Includes closing brace
                    
                    # Recursively render the nested blocks to get the new body content
                    rendered_nested_body = render_css_blocks(block.nested_blocks)
                    
                    output_parts.append(f"{prefix}{rendered_nested_body}{suffix}")
                else:
                    # If malformed or no body, just append the raw content.
                    output_parts.append(block.raw_content)
            else:
                # For all other block types (style_rule, comment, whitespace, other),
                # append their pre-stored or pre-formatted raw_content.
                output_parts.append(block.raw_content)
    
        return "".join(output_parts)
    
    # --- Flask Routes ---
    
    @app.route('/', methods=['GET', 'POST'])
    def index():
        input_css = ""
        merged_css = ""
        changelog_list = [] # Will be populated with actual changelog entries or default message
    
        if request.method == 'POST':
            input_css = request.form.get('input_css', '')
            if input_css.strip():
                try:
                    # 1. Parse CSS into structured blocks (preserving raw content)
                    parsed_blocks = parse_css(input_css)
                    
                    # 2. Merge rules and generate changelog entries
                    current_changelog = []
                    final_merged_blocks = process_css_blocks(parsed_blocks, current_changelog)
                    
                    # 3. Render the final merged CSS
                    merged_css = render_css_blocks(final_merged_blocks)
                    
                    if current_changelog:
                        changelog_list = current_changelog
                    else:
                        changelog_list = ["No duplicate selectors found to merge."]
    
                except Exception as e:
                    merged_css = f"Error processing CSS: {e}"
                    changelog_list = [f"Error: {e}"]
            else:
                merged_css = ""
                changelog_list = ["Please paste CSS into the input field to merge."]
        else:
            # Initial GET request
            changelog_list = ["No changes to display."]
    
        return render_template(
            'index.html', 
            input_css=input_css, 
            merged_css=merged_css, 
            changelog_list=changelog_list
        )
    
    if __name__ == '__main__':
        app.run(debug=True)
    
    

    2. templates/index.html (Provided HTML Template)

    Save the provided HTML content as templates/index.html in the same directory as your app.py.

    <!DOCTYPE html>
    <html lang="en"> <head>
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <title>CSS Rule Merger - Dark Mode</title>
        <style>
            :root {
                --bg-color: #1e1e1e;
                --primary-text-color: #e0e0e0;
                --secondary-text-color: #b0b0b0;
                --accent-color: #007acc;
                --accent-hover-color: #005fa3;
                --border-color: #3a3a3a; 
                --input-bg-color: #2c2c2c;
                --pre-bg-color: #252525;
                --card-bg-color: #282828;
                --button-text-color: #ffffff;
                --success-color: #28a745;
            }
    
            body {
                font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
                margin: 0;
                padding: 20px;
                background-color: var(--bg-color);
                color: var(--primary-text-color);
                line-height: 1.6;
            }
    
            .main-container {
                max-width: 1400px;
                margin: 20px auto;
                padding: 25px;
                background-color: var(--card-bg-color);
                border-radius: 12px;
                box-shadow: 0 8px 16px rgba(0,0,0,0.2);
            }
    
            h1 {
                text-align: center;
                color: var(--primary-text-color);
                margin-bottom: 20px;
                font-weight: 600;
            }
    
            .columns-container {
                display: flex;
                flex-direction: row;
                justify-content: space-between;
                gap: 25px;
                margin-bottom: 20px;
            }
    
            .column {
                flex: 1;
                display: flex;
                flex-direction: column;
            }
    
            .column-header {
                display: flex;
                justify-content: space-between;
                align-items: center;
                border-bottom: 1px solid var(--border-color);
                padding-bottom: 8px;
                margin-bottom: 10px;
            }
    
            h2 {
                margin-top: 0;
                margin-bottom: 0;
                color: var(--secondary-text-color);
                font-size: 1.2em;
                font-weight: 500;
            }
    
            textarea, #merged_css_output {
                width: calc(100% - 30px);
                height: 400px;
                padding: 15px;
                border: 1px solid var(--border-color);
                border-radius: 8px;
                font-family: "SFMono-Regular", Consolas, "Liberation Mono", Menlo, Courier, monospace;
                font-size: 14px;
                color: var(--primary-text-color);
                margin-bottom: 15px;
                overflow-y: auto;
            }
    
            textarea {
                background-color: var(--input-bg-color);
                resize: vertical;
            }
    
            #merged_css_output {
                background-color: var(--pre-bg-color);
                white-space: pre-wrap;
                word-wrap: break-word;
    			margin: 0;
            }
            
            #changelog_output_container {
                background-color: var(--pre-bg-color);
                border: 1px solid var(--border-color);
                border-radius: 8px;
                padding: 5px 15px 15px 15px;
                margin-top: 10px;
                height: auto;
                overflow-y: auto;
                font-family: "SFMono-Regular", Consolas, "Liberation Mono", Menlo, Courier, monospace;
                font-size: 14px;
                color: var(--primary-text-color);
            }
    
            .changelog-entry {
                white-space: pre-wrap;
                word-wrap: break-word;
                margin: 0;
                padding-top: 10px;
            }
    
            hr.changelog-separator {
                border: none;
                height: 1px;
                background-color: var(--border-color);
                margin-top: 15px;
                margin-bottom: 5px;
            }
    
    
            .action-button {
                background-color: var(--accent-color);
                color: var(--button-text-color);
                padding: 10px 20px;
                border: none;
                border-radius: 6px;
                cursor: pointer;
                font-size: 14px;
                font-weight: 500;
                transition: background-color 0.2s ease;
            }
            .action-button:hover {
                background-color: var(--accent-hover-color);
            }
    
            .submit-button {
                padding: 12px 25px;
                font-size: 16px;
                display: block;
                width: fit-content;
                margin: 0 auto;
            }
    
            #copy_merged_css_button {
                font-size: 0.9em;
                padding: 6px 12px;
            }
    
            @media (max-width: 768px) {
                .columns-container {
                    flex-direction: column;
                }
                textarea, #merged_css_output {
                    height: 300px;
                }
                #changelog_output_container {
                    height: auto;
                }
                h1 {
                    font-size: 1.8em;
                }
            }
        </style>
    </head>
    <body>
        <div class="main-container">
            <h1>CSS Rule Merger</h1>
    
            <form method="POST" action="/">
                <div class="columns-container">
                    <div class="column">
                        <div class="column-header">
                            <h2>Input CSS:</h2>
                        </div>
                        <textarea name="input_css" placeholder="Paste your CSS here...">{{ input_css }}</textarea>
                    </div>
                    <div class="column">
                        <div class="column-header">
                            <h2>Merged CSS:</h2>
                            <button type="button" id="copy_merged_css_button" class="action-button">Copy All</button>
                        </div>
                        <pre id="merged_css_output">{{ merged_css }}</pre>
                    </div>
                </div>
                <input type="submit" value="Merge CSS" class="action-button submit-button">
            </form>
    
            <div class="column-header" style="margin-top: 20px;">
                 <h2>Changelog:</h2>
            </div>
            <div id="changelog_output_container">
                {% if changelog_list %}
                    {% for entry in changelog_list %}
                        <pre class="changelog-entry">{{ entry }}</pre>
                        {% if not loop.last %}
                            <hr class="changelog-separator">
                        {% endif %}
                    {% endfor %}
                {% else %}
                    <pre class="changelog-entry">No changes to display.</pre> 
                {% endif %}
            </div>
        </div>
    
        <script>
            document.addEventListener('DOMContentLoaded', function() {
                const copyButton = document.getElementById('copy_merged_css_button');
                const mergedCssOutput = document.getElementById('merged_css_output');
    
                if (copyButton && mergedCssOutput) {
                    copyButton.addEventListener('click', function() {
                        const textToCopy = mergedCssOutput.textContent || mergedCssOutput.innerText;
                        
                        if (!textToCopy.trim()) {
                            copyButton.textContent = 'Nothing to Copy';
                            setTimeout(() => {
                                copyButton.textContent = 'Copy All';
                            }, 2000);
                            return;
                        }
    
                        navigator.clipboard.writeText(textToCopy).then(function() {
                            copyButton.textContent = 'Copied!';
                            copyButton.style.backgroundColor = 'var(--success-color)';
                            setTimeout(function() {
                                copyButton.textContent = 'Copy All';
                                copyButton.style.backgroundColor = 'var(--accent-color)';
                            }, 2000);
                        }).catch(function(err) {
                            copyButton.textContent = 'Copy Failed';
                            console.error('Error copying text: ', err);
                            setTimeout(function() {
                                copyButton.textContent = 'Copy All';
                            }, 2000);
                        });
                    });
                }
            });
        </script>
    </body>
    </html>
    

    To Run the Application:

    1. Save the files:

      • Save the Python code above as app.py.
      • Create a folder named templates in the same directory as app.py.
      • Save the HTML code above as index.html inside the templates folder.
    2. Install dependencies:

      pip install Flask tinycss2
      
    3. Run the Flask application:

      python app.py
      
    4. Access in browser: Open your web browser and go to http://127.0.0.1:5000/ (or the address shown in your terminal).

    You can then paste CSS into the "Input CSS" textarea, click "Merge CSS", and observe the "Merged CSS" output and the "Changelog" reflecting the merges.

  3. User

    There is only one small problem... the commented styles (for backup) are deleted for 90% leaving only "*/"

    Original css:
    """
    display: none;
    flex-direction: column;
    align-items: start;
    padding: calc(1dvh + 1vw) calc(1dvh + 1vw) calc(3dvh + 3vw) calc(1dvh + 1vw);
    justify-content: center;
    /*transition: all 0.3s ease;*/
    min-width: 100%;
    /*margin-bottom: -50px !important;*/
    position: sticky;
    top: 0;
    z-index: 8003;
    """
    
    Changed css:
    """
    display: none;
    */
    /*background-color: #FF0054;
    */
    display: none;
    flex-direction: column;
    align-items: start;
    padding: calc(1dvh + 1vw) calc(1dvh + 1vw) calc(3dvh + 3vw) calc(1dvh + 1vw);
    justify-content: center;
    */
    min-width: 100%;
    */
    position: sticky;
    top: 0;
    z-index: 8003;
    """
    
  4. Gemini Assistant

    The reported issue, where comments inside merged CSS rules are malformed (e.g., reduced to */), is highly unusual and points to a very subtle interaction during parsing or reconstruction.

    Let's break down the likely cause and the solution:

    Root Cause Analysis:

    1. Parsing of Internal Comments: When parsing a CSS rule block (e.g., .selector { ... }), the content inside the braces is processed using tinycss2.parse_declaration_list. This function yields Declaration, Comment, and WhitespaceToken objects. For Comment and WhitespaceToken objects found here, the code uses decl_node.serialize() to get their string representation and stores them in block.internal_comments_and_whitespace.

    2. tinycss2.Node.serialize() Behavior: The serialize() method of a tinycss2 Comment node is expected to always produce the full comment string, including /* and */. For example, Comment(value='my comment', ...).serialize() should yield /*my comment*/. If */ appears in the output, it implies that decl_node.serialize() itself somehow returned */ or a similar malformed string for a valid input comment. This would be an unexpected behavior from tinycss2, a well-tested library.

    3. String Slicing for raw_content: For top-level CSS blocks (not inside rules, or within @-rule bodies but not part of a declaration), the raw_content of a CssBlock is obtained by slicing the original CSS string based on tinycss2's source_line and source_column information. If these source coordinates were subtly off for comments, it could lead to truncating /* or */. However, this specific issue was reported for internal comments, which use decl_node.serialize() directly, not raw_content slicing.

    4. Reconstruction/Formatting: The format_merged_rule function takes the collected internal_comments_and_whitespace and prints them before the properties. If the stored comment string was */ due to an upstream parsing error, then the formatting would simply print */.

    Conclusion on */: The most direct explanation for */ appearing on its own line is that the string */ (or something that strips to */) was what was actually stored in block.internal_comments_and_whitespace for that specific comment. This suggests an edge case in how tinycss2 might parse or serialize a comment if its value content is itself problematic or if the original input CSS has a very specific, subtly malformed comment that tinycss2 interprets unusually. Given the provided input (/*transition: all 0.3s ease;*/), this is highly unlikely.

    Proposed Solution (Robustness & Defense):

    Since tinycss2.Node.serialize() is the authoritative way to get the string representation of a parsed token, the most robust approach is to:

    1. Prioritize node.serialize() for CssBlock.raw_content of comments: Although the problem was reported for internal comments (which already use serialize()), a general improvement is to ensure that CssBlock.raw_content for standalone Comment blocks (those outside rules or directly in @rule bodies) also defaults to node.serialize() if the manual string slicing from source_line/source_column appears to be incomplete (e.g., missing /* or */). This guards against rare slicing errors.
    2. Assume decl_node.serialize() is correct: For internal comments, we continue to rely on decl_node.serialize(), as any issue there would indicate a deeper problem with the tinycss2 library itself.
    3. Verify Example: The provided problem code snippet will be tested against the current implementation.

    The fix implemented below specifically targets point 1 for general robustness. If the */ issue persists for internal comments, it strongly suggests the decl_node.serialize() method itself is yielding the malformed string under specific conditions, which is unusual for a parser.


    Updated app.py

    The change is a small, defensive addition within the _parse_css_segment function for Comment nodes, ensuring their raw_content is always accurate.

    import re
    from flask import Flask, render_template, request
    from tinycss2.ast import QualifiedRule, AtRule, Comment, WhitespaceToken, Declaration, Node
    import tinycss2
    
    app = Flask(__name__)
    
    # --- CSS Parsing and Merging Logic ---
    
    class CssBlock:
        """
        Represents a distinct block of CSS content, preserving its original raw text
        and tracking its scope and type.
        """
        def __init__(self, block_type: str, raw_content: str, scope_path: list[str] = None, original_indent_level: int = 0):
            self.type = block_type  # 'style_rule', 'at_rule', 'comment', 'whitespace', 'other'
            self.raw_content = raw_content  # The original raw string for this block
            self.scope_path = scope_path if scope_path is not None else []
            self.original_indent_level = original_indent_level # Indent level based on CSS scope depth
    
            # For 'style_rule' blocks
            self.selector = None
            # {property_name: {'value': raw_value_text}}
            self.declarations = {} 
            # List of raw strings for comments/whitespace found *inside* the rule block
            self.internal_comments_and_whitespace = []
    
            # For 'at_rule' blocks
            self.at_keyword = None  # e.g., 'media'
            self.prelude = None     # e.g., '(min-width: 768px)'
            # List of CssBlock objects nested within this at-rule
            self.nested_blocks = [] 
    
        def __repr__(self):
            if self.type == 'style_rule':
                return (f"CssBlock(type='{self.type}', selector='{self.selector}', "
                        f"scope_path={self.scope_path}, decls={len(self.declarations)})")
            elif self.type == 'at_rule':
                return (f"CssBlock(type='{self.type}', at_keyword='{self.at_keyword}', "
                        f"prelude='{self.prelude}', scope_path={self.scope_path}, "
                        f"nested={len(self.nested_blocks)})")
            else:
                return (f"CssBlock(type='{self.type}', "
                        f"raw_content='{self.raw_content.strip()[:50]}...', "
                        f"scope_path={self.scope_path})")
    
    def _get_line_offsets(text: str) -> list[int]:
        """Calculates the 0-based starting character index for each line."""
        offsets = [0]
        for m in re.finditer(r'\r?\n', text):
            offsets.append(m.end())
        return offsets
    
    def _get_char_idx_from_line_col(line_offsets: list[int], line: int, col: int) -> int:
        """Converts 1-based line/column from tinycss2 to a 0-based character index."""
        if line <= 0 or line > len(line_offsets):
            return -1 # Invalid line, or outside parsed range
        return line_offsets[line - 1] + col - 1
    
    def _parse_css_segment(
        css_segment_string: str,      # The string for the current segment (e.g., full CSS, or @media body)
        full_css_string: str,         # The complete original CSS string (for line_offsets)
        line_offsets: list[int],      # Pre-calculated line offsets for full_css_string
        current_scope_path: list[str],
        parent_segment_start_idx_in_full_css: int, # Start index of css_segment_string in full_css_string
        base_indent_level: int
    ) -> list[CssBlock]:
        """
        Recursively parses a CSS string segment into CssBlock objects, preserving
        original formatting by slicing the raw text.
        """
        blocks = []
        
        # Parse the segment with tinycss2. Crucially, do not skip comments or whitespace.
        nodes = tinycss2.parse_stylesheet_string(css_segment_string, skip_comments=False, skip_whitespace=False)
    
        # Tracks the last processed character index in the *current segment string*
        current_segment_pos = 0 
    
        for i, node in enumerate(nodes):
            # Calculate start index of the current node relative to the *full original CSS string*
            node_start_idx_in_full_css = _get_char_idx_from_line_col(line_offsets, node.source_line, node.source_column)
    
            # Calculate start index of the current node relative to the *current segment string*
            node_start_idx_in_segment = node_start_idx_in_full_css - parent_segment_start_idx_in_full_css
    
            # Capture any raw content (whitespace, comments, etc.) *before* the current node
            # that tinycss2 might not explicitly yield as a distinct node, or was ignored.
            if node_start_idx_in_segment > current_segment_pos:
                raw_gap_content = css_segment_string[current_segment_pos:node_start_idx_in_segment]
                if raw_gap_content:
                    blocks.append(CssBlock('other', raw_gap_content, current_scope_path))
            
            # Determine the end index of the current node in the *current segment string*
            node_end_idx_in_segment = len(css_segment_string) # Default to end of segment
            if i + 1 < len(nodes):
                next_node = nodes[i+1]
                next_node_start_idx_in_full_css = _get_char_idx_from_line_col(line_offsets, next_node.source_line, next_node.source_column)
                node_end_idx_in_segment = next_node_start_idx_in_full_css - parent_segment_start_idx_in_full_css
            
            # Extract the exact raw content of the current node
            raw_node_content = css_segment_string[node_start_idx_in_segment : node_end_idx_in_segment]
    
            # Process the node based on its type
            if isinstance(node, (Comment, WhitespaceToken)):
                # Defensive check for Comment nodes: ensure the raw_node_content correctly captures the full comment delimiters.
                # tinycss2's source_line/column sometimes leads to slices that are missing delimiters if
                # the comment token is adjacent to other non-whitespace tokens, or at segment boundaries.
                if isinstance(node, Comment):
                    serialized_form = node.serialize()
                    # If the extracted raw content doesn't look like a complete comment,
                    # fall back to tinycss2's own serialization of the token.
                    # This ensures comments like `/* ... */` are preserved accurately.
                    if not raw_node_content.strip().startswith('/*') or not raw_node_content.strip().endswith('*/'):
                        raw_node_content = serialized_form
                
                blocks.append(CssBlock(node.type.lower(), raw_node_content, current_scope_path))
            elif isinstance(node, QualifiedRule):  # A standard CSS rule: selector { declarations }
                block = CssBlock('style_rule', raw_node_content, current_scope_path, original_indent_level=base_indent_level)
                block.selector = node.prelude.serialize().strip() # Get selector text (e.g., 'p', '.foo')
                
                # Parse declarations and internal comments from node.content
                # tinycss2.parse_declaration_list works on the content between braces
                decls_nodes = tinycss2.parse_declaration_list(node.content, skip_comments=False, skip_whitespace=False)
                
                for decl_node in decls_nodes:
                    if isinstance(decl_node, Declaration):
                        prop_name = decl_node.name.strip()
                        # Store raw value text to preserve !important, comments within values etc.
                        prop_value_text = decl_node.value.serialize() 
                        block.declarations[prop_name] = {'value': prop_value_text.strip()}
                    elif isinstance(decl_node, (Comment, WhitespaceToken)):
                        # Collect comments/whitespace *inside* the rule.
                        # We rely on decl_node.serialize() for correctness here, as it's a direct token serialization.
                        block.internal_comments_and_whitespace.append(decl_node.serialize())
                blocks.append(block)
            elif isinstance(node, AtRule):  # An @-rule like @media, @keyframes
                block = CssBlock('at_rule', raw_node_content, current_scope_path, original_indent_level=base_indent_level)
                block.at_keyword = node.at_keyword.strip()
                block.prelude = node.prelude.serialize().strip() if node.prelude else ''
    
                if node.content:
                    new_scope_name = f"@{block.at_keyword} {block.prelude}".strip()
                    
                    # Find the actual content string of the at-rule's body (between { and })
                    # This needs to be done carefully to include all internal whitespace/comments
                    body_match = re.search(r'\{(.*)\}', raw_node_content, re.DOTALL)
                    if body_match:
                        at_rule_body_content = body_match.group(1)
                        # Calculate the start index of the nested content relative to the *full original CSS string*
                        nested_segment_start_idx_in_full_css = (
                            node_start_idx_in_full_css + raw_node_content.find('{') + 1
                        )
                        block.nested_blocks = _parse_css_segment(
                            at_rule_body_content,
                            full_css_string,
                            line_offsets,
                            current_scope_path + [new_scope_name],
                            nested_segment_start_idx_in_full_css,
                            base_indent_level + 1 # Increase indent level for nested content
                        )
                blocks.append(block)
            else: # Any other unexpected tokens/nodes
                blocks.append(CssBlock('other', raw_node_content, current_scope_path))
            
            # Update current position in the segment string
            current_segment_pos = node_end_idx_in_segment
    
        # Capture any trailing content after the last node in this segment
        if current_segment_pos < len(css_segment_string):
            raw_gap_content = css_segment_string[current_segment_pos:]
            if raw_gap_content:
                blocks.append(CssBlock('other', raw_gap_content, current_scope_path))
    
        return blocks
    
    def parse_css(css_string: str) -> list[CssBlock]:
        """Main entry point for parsing CSS into structured CssBlock objects."""
        line_offsets = _get_line_offsets(css_string)
        # Start parsing from the global scope (empty scope_path) at indent level 0
        return _parse_css_segment(css_string, css_string, line_offsets, [], 0, 0)
    
    def format_merged_rule(selector: str, declarations: dict, internal_comments: list[str], base_indent_level: int) -> str:
        """Formats a merged CSS rule block."""
        scope_indent = '  ' * base_indent_level
        prop_indent = '  ' * (base_indent_level + 1)
        
        # Handle empty rules
        if not declarations and not internal_comments:
            return f"{scope_indent}{selector} {{}}"
        
        lines = [f"{scope_indent}{selector} {{"]
        
        # Add internal comments and whitespace before properties
        # The order of comments/whitespace is preserved as they were collected.
        for item in internal_comments:
            stripped_item = item.strip()
            if stripped_item: # Only add if not empty after stripping
                lines.append(f"{prop_indent}{stripped_item}")
    
        # Add properties, sorted alphabetically for consistent output
        sorted_properties = sorted(declarations.keys())
        for prop in sorted_properties:
            value = declarations[prop]['value']
            lines.append(f"{prop_indent}{prop}: {value};")
        
        lines.append(f"{scope_indent}}}")
        return "\n".join(lines)
    
    def format_merged_rule_for_changelog(selector: str, declarations: dict, internal_comments: list[str]) -> str:
        """Formats a merged CSS rule block specifically for the changelog."""
        # Changelog formatting always starts at zero indent for the selector, 2 spaces for properties.
        prop_indent = '  '
        
        if not declarations and not internal_comments:
            return f"{selector} {{}}"
        
        lines = [f"{selector} {{"]
        
        for item in internal_comments:
            stripped_item = item.strip()
            if stripped_item:
                lines.append(f"{prop_indent}{stripped_item}")
    
        sorted_properties = sorted(declarations.keys())
        for prop in sorted_properties:
            value = declarations[prop]['value']
            lines.append(f"{prop_indent}{prop}: {value};")
        
        lines.append(f"}}")
        return "\n".join(lines)
    
    
    def process_css_blocks(blocks: list[CssBlock], merged_changelog: list[str]) -> list[CssBlock]:
        """
        Processes parsed CSS blocks to merge duplicate selectors within scopes
        and reconstruct the output, generating changelog entries.
        """
        
        # Pass 1: Collect all rules and their merged state
        # Key: tuple(scope_path), Value: dict (selector: {declarations: {}, internal_comments: [], first_block: CssBlock, original_blocks: []})
        merged_rules_map = {} 
    
        def collect_and_merge_rules_recursive(current_blocks: list[CssBlock], current_scope_path: list[str]):
            """Helper to recursively populate merged_rules_map."""
            for block in current_blocks:
                if block.type == 'style_rule':
                    scope_key = tuple(current_scope_path)
                    selector = block.selector
    
                    if scope_key not in merged_rules_map:
                        merged_rules_map[scope_key] = {}
                    
                    if selector not in merged_rules_map[scope_key]:
                        # First time seeing this selector in this scope
                        merged_rules_map[scope_key][selector] = {
                            'declarations': {},
                            'internal_comments': [],
                            'first_block': block, # Keep reference to the very first block of this selector
                            'original_blocks': [] # List of all original blocks for this selector
                        }
                    
                    # Merge properties: last-appearing definition wins.
                    # Simple update handles this as Python dict update overwrites existing keys.
                    merged_rules_map[scope_key][selector]['declarations'].update(block.declarations)
                    
                    # Collect internal comments/whitespace. Extend preserves order.
                    merged_rules_map[scope_key][selector]['internal_comments'].extend(block.internal_comments_and_whitespace)
                    
                    merged_rules_map[scope_key][selector]['original_blocks'].append(block)
    
                elif block.type == 'at_rule':
                    # Recursively collect rules from nested blocks
                    new_scope = f"@{block.at_keyword} {block.prelude}".strip()
                    collect_and_merge_rules_recursive(block.nested_blocks, current_scope_path + [new_scope])
        
        # Start the collection process with top-level blocks
        collect_and_merge_rules_recursive(blocks, [])
    
        # Pass 2: Reconstruct the output based on original order and the merged_rules_map
        def reconstruct_blocks_recursive(current_blocks: list[CssBlock], current_scope_path: list[str]) -> list[CssBlock]:
            """Helper to recursively reconstruct the final list of CssBlocks."""
            reconstructed_output = []
            # Keep track of selectors already processed in *this specific scope*
            processed_selectors_in_current_scope = set() 
            
            for block in current_blocks:
                if block.type == 'style_rule':
                    scope_key = tuple(current_scope_path)
                    selector = block.selector
                    
                    if selector in processed_selectors_in_current_scope:
                        # This rule has already been outputted as part of a merge. Skip this duplicate.
                        continue 
                    
                    merged_data = merged_rules_map[scope_key][selector]
                    
                    if len(merged_data['original_blocks']) > 1:
                        # This selector was duplicated and now merged. Format a new block for it.
                        merged_formatted_content = format_merged_rule(
                            selector, 
                            merged_data['declarations'], 
                            merged_data['internal_comments'], 
                            block.original_indent_level # Use indent level of the *first* block in its scope
                        )
                        
                        # Create a new CssBlock representing the merged output
                        merged_css_block = CssBlock(
                            'style_rule', 
                            merged_formatted_content, 
                            block.scope_path,
                            block.original_indent_level
                        )
                        merged_css_block.selector = selector # Set selector for debug/changelog formatting
                        reconstructed_output.append(merged_css_block)
                        
                        # Add to changelog (only if not already added to prevent duplicates in changelog)
                        changelog_entry = format_merged_rule_for_changelog(selector, merged_data['declarations'], merged_data['internal_comments'])
                        if changelog_entry not in merged_changelog:
                            merged_changelog.append(changelog_entry)
                        
                        processed_selectors_in_current_scope.add(selector) # Mark as processed
                    else:
                        # Not a duplicate, preserve original block exactly as it was.
                        reconstructed_output.append(block)
                        processed_selectors_in_current_scope.add(selector) # Mark as processed (single instance)
                        
                elif block.type == 'at_rule':
                    # Recursively reconstruct nested blocks
                    new_scope = f"@{block.at_keyword} {block.prelude}".strip()
                    block.nested_blocks = reconstruct_blocks_recursive(block.nested_blocks, current_scope_path + [new_scope])
                    reconstructed_output.append(block)
                else:
                    # Preserve comments, whitespace, and other non-rule blocks exactly.
                    reconstructed_output.append(block)
            
            return reconstructed_output
    
        # Start reconstruction from top-level blocks
        final_output_blocks = reconstruct_blocks_recursive(blocks, [])
        
        return final_output_blocks
    
    
    def render_css_blocks(blocks: list[CssBlock]) -> str:
        """Renders a list of CssBlock objects back into a CSS string."""
        output_parts = []
        
        for block in blocks:
            if block.type == 'at_rule':
                # At-rules are kept as they are. Their `raw_content` includes `@rule ... { ... }`.
                # We need to replace the content *inside* the braces with the recursively rendered body.
                
                # Find the positions of the opening and closing braces in the original raw content
                brace_open_idx = block.raw_content.find('{')
                brace_close_idx = block.raw_content.rfind('}')
                
                if brace_open_idx != -1 and brace_close_idx != -1 and brace_open_idx < brace_close_idx:
                    # Extract the part before the opening brace (e.g., `@media (min-width: 768px) `)
                    prefix = block.raw_content[:brace_open_idx + 1] # Includes opening brace
                    # Extract the part from the closing brace to the end (e.g., ` }`)
                    suffix = block.raw_content[brace_close_idx:] # Includes closing brace
                    
                    # Recursively render the nested blocks to get the new body content
                    rendered_nested_body = render_css_blocks(block.nested_blocks)
                    
                    output_parts.append(f"{prefix}{rendered_nested_body}{suffix}")
                else:
                    # If malformed or no body, just append the raw content.
                    output_parts.append(block.raw_content)
            else:
                # For all other block types (style_rule, comment, whitespace, other),
                # append their pre-stored or pre-formatted raw_content.
                output_parts.append(block.raw_content)
    
        return "".join(output_parts)
    
    # --- Flask Routes ---
    
    @app.route('/', methods=['GET', 'POST'])
    def index():
        input_css = ""
        merged_css = ""
        changelog_list = [] # Will be populated with actual changelog entries or default message
    
        if request.method == 'POST':
            input_css = request.form.get('input_css', '')
            if input_css.strip():
                try:
                    # 1. Parse CSS into structured blocks (preserving raw content)
                    parsed_blocks = parse_css(input_css)
                    
                    # 2. Merge rules and generate changelog entries
                    current_changelog = []
                    final_merged_blocks = process_css_blocks(parsed_blocks, current_changelog)
                    
                    # 3. Render the final merged CSS
                    merged_css = render_css_blocks(final_merged_blocks)
                    
                    if current_changelog:
                        changelog_list = current_changelog
                    else:
                        changelog_list = ["No duplicate selectors found to merge."]
    
                except Exception as e:
                    merged_css = f"Error processing CSS: {e}"
                    changelog_list = [f"Error: {e}"]
            else:
                merged_css = ""
                changelog_list = ["Please paste CSS into the input field to merge."]
        else:
            # Initial GET request
            changelog_list = ["No changes to display."]
    
        return render_template(
            'index.html', 
            input_css=input_css, 
            merged_css=merged_css, 
            changelog_list=changelog_list
        )
    
    if __name__ == '__main__':
        app.run(debug=True)
    
    
  5. User

    Ok, that works, but can you make it leave /*background-color: #FF0054; and */ on the same line? That puts them on separate lines like: """ /*background-color: #FF0054; */ display: none; """

    I want it to be: """ /background-color: #FF0054;/ display: none; """

  6. Gemini Assistant

    You are absolutely right! My apologies for that oversight. The "perfect preservation" rule does apply to comments and whitespace, but when a rule is newly merged and therefore reformatted, its internal comments should also conform to a consistent, single-line format if they were multi-line.

    The issue you observed where multi-line comments within merged rules end up like:

        /*background-color: #FF0054;
        */
    

    is because the item collected into internal_comments_and_whitespace retains its original internal newlines. When format_merged_rule then appends f"{prop_indent}{stripped_item}", those internal newlines are preserved, leading to the broken appearance.

    The fix involves processing the content of comments within format_merged_rule and format_merged_rule_for_changelog to remove any internal newlines and excessive whitespace, effectively collapsing them onto a single line.

    Here's the updated app.py with the fix applied to both formatting functions:

    import re
    from flask import Flask, render_template, request
    from tinycss2.ast import QualifiedRule, AtRule, Comment, WhitespaceToken, Declaration, Node
    import tinycss2
    
    app = Flask(__name__)
    
    # --- CSS Parsing and Merging Logic ---
    
    class CssBlock:
        """
        Represents a distinct block of CSS content, preserving its original raw text
        and tracking its scope and type.
        """
        def __init__(self, block_type: str, raw_content: str, scope_path: list[str] = None, original_indent_level: int = 0):
            self.type = block_type  # 'style_rule', 'at_rule', 'comment', 'whitespace', 'other'
            self.raw_content = raw_content  # The original raw string for this block
            self.scope_path = scope_path if scope_path is not None else []
            self.original_indent_level = original_indent_level # Indent level based on CSS scope depth
    
            # For 'style_rule' blocks
            self.selector = None
            # {property_name: {'value': raw_value_text}}
            self.declarations = {} 
            # List of raw strings for comments/whitespace found *inside* the rule block
            self.internal_comments_and_whitespace = []
    
            # For 'at_rule' blocks
            self.at_keyword = None  # e.g., 'media'
            self.prelude = None     # e.g., '(min-width: 768px)'
            # List of CssBlock objects nested within this at-rule
            self.nested_blocks = [] 
    
        def __repr__(self):
            if self.type == 'style_rule':
                return (f"CssBlock(type='{self.type}', selector='{self.selector}', "
                        f"scope_path={self.scope_path}, decls={len(self.declarations)})")
            elif self.type == 'at_rule':
                return (f"CssBlock(type='{self.type}', at_keyword='{self.at_keyword}', "
                        f"prelude='{self.prelude}', scope_path={self.scope_path}, "
                        f"nested={len(self.nested_blocks)})")
            else:
                return (f"CssBlock(type='{self.type}', "
                        f"raw_content='{self.raw_content.strip()[:50]}...', "
                        f"scope_path={self.scope_path})")
    
    def _get_line_offsets(text: str) -> list[int]:
        """Calculates the 0-based starting character index for each line."""
        offsets = [0]
        for m in re.finditer(r'\r?\n', text):
            offsets.append(m.end())
        return offsets
    
    def _get_char_idx_from_line_col(line_offsets: list[int], line: int, col: int) -> int:
        """Converts 1-based line/column from tinycss2 to a 0-based character index."""
        if line <= 0 or line > len(line_offsets):
            return -1 # Invalid line, or outside parsed range
        return line_offsets[line - 1] + col - 1
    
    def _parse_css_segment(
        css_segment_string: str,      # The string for the current segment (e.g., full CSS, or @media body)
        full_css_string: str,         # The complete original CSS string (for line_offsets)
        line_offsets: list[int],      # Pre-calculated line offsets for full_css_string
        current_scope_path: list[str],
        parent_segment_start_idx_in_full_css: int, # Start index of css_segment_string in full_css_string
        base_indent_level: int
    ) -> list[CssBlock]:
        """
        Recursively parses a CSS string segment into CssBlock objects, preserving
        original formatting by slicing the raw text.
        """
        blocks = []
        
        # Parse the segment with tinycss2. Crucially, do not skip comments or whitespace.
        nodes = tinycss2.parse_stylesheet_string(css_segment_string, skip_comments=False, skip_whitespace=False)
    
        # Tracks the last processed character index in the *current segment string*
        current_segment_pos = 0 
    
        for i, node in enumerate(nodes):
            # Calculate start index of the current node relative to the *full original CSS string*
            node_start_idx_in_full_css = _get_char_idx_from_line_col(line_offsets, node.source_line, node.source_column)
    
            # Calculate start index of the current node relative to the *current segment string*
            node_start_idx_in_segment = node_start_idx_in_full_css - parent_segment_start_idx_in_full_css
    
            # Capture any raw content (whitespace, comments, etc.) *before* the current node
            # that tinycss2 might not explicitly yield as a distinct node, or was ignored.
            if node_start_idx_in_segment > current_segment_pos:
                raw_gap_content = css_segment_string[current_segment_pos:node_start_idx_in_segment]
                if raw_gap_content:
                    blocks.append(CssBlock('other', raw_gap_content, current_scope_path))
            
            # Determine the end index of the current node in the *current segment string*
            node_end_idx_in_segment = len(css_segment_string) # Default to end of segment
            if i + 1 < len(nodes):
                next_node = nodes[i+1]
                next_node_start_idx_in_full_css = _get_char_idx_from_line_col(line_offsets, next_node.source_line, next_node.source_column)
                node_end_idx_in_segment = next_node_start_idx_in_full_css - parent_segment_start_idx_in_full_css
            
            # Extract the exact raw content of the current node
            raw_node_content = css_segment_string[node_start_idx_in_segment : node_end_idx_in_segment]
    
            # Process the node based on its type
            if isinstance(node, (Comment, WhitespaceToken)):
                # Defensive check for Comment nodes: ensure the raw_node_content correctly captures the full comment delimiters.
                # tinycss2's source_line/column sometimes leads to slices that are missing delimiters if
                # the comment token is adjacent to other non-whitespace tokens, or at segment boundaries.
                if isinstance(node, Comment):
                    serialized_form = node.serialize()
                    # If the extracted raw content doesn't look like a complete comment (e.g., missing /* or */),
                    # fall back to tinycss2's own serialization of the token to ensure full preservation.
                    if not raw_node_content.strip().startswith('/*') or not raw_node_content.strip().endswith('*/'):
                        raw_node_content = serialized_form
                
                blocks.append(CssBlock(node.type.lower(), raw_node_content, current_scope_path))
            elif isinstance(node, QualifiedRule):  # A standard CSS rule: selector { declarations }
                block = CssBlock('style_rule', raw_node_content, current_scope_path, original_indent_level=base_indent_level)
                block.selector = node.prelude.serialize().strip() # Get selector text (e.g., 'p', '.foo')
                
                # Parse declarations and internal comments from node.content
                # tinycss2.parse_declaration_list works on the content between braces
                decls_nodes = tinycss2.parse_declaration_list(node.content, skip_comments=False, skip_whitespace=False)
                
                for decl_node in decls_nodes:
                    if isinstance(decl_node, Declaration):
                        prop_name = decl_node.name.strip()
                        # Store raw value text to preserve !important, comments within values etc.
                        prop_value_text = decl_node.value.serialize() 
                        block.declarations[prop_name] = {'value': prop_value_text.strip()}
                    elif isinstance(decl_node, (Comment, WhitespaceToken)):
                        # Collect comments/whitespace *inside* the rule.
                        # We rely on decl_node.serialize() for correctness here, as it's a direct token serialization.
                        block.internal_comments_and_whitespace.append(decl_node.serialize())
                blocks.append(block)
            elif isinstance(node, AtRule):  # An @-rule like @media, @keyframes
                block = CssBlock('at_rule', raw_node_content, current_scope_path, original_indent_level=base_indent_level)
                block.at_keyword = node.at_keyword.strip()
                block.prelude = node.prelude.serialize().strip() if node.prelude else ''
    
                if node.content:
                    new_scope_name = f"@{block.at_keyword} {block.prelude}".strip()
                    
                    # Find the actual content string of the at-rule's body (between { and })
                    # This needs to be done carefully to include all internal whitespace/comments
                    body_match = re.search(r'\{(.*)\}', raw_node_content, re.DOTALL)
                    if body_match:
                        at_rule_body_content = body_match.group(1)
                        # Calculate the start index of the nested content relative to the *full original CSS string*
                        nested_segment_start_idx_in_full_css = (
                            node_start_idx_in_full_css + raw_node_content.find('{') + 1
                        )
                        block.nested_blocks = _parse_css_segment(
                            at_rule_body_content,
                            full_css_string,
                            line_offsets,
                            current_scope_path + [new_scope_name],
                            nested_segment_start_idx_in_full_css,
                            base_indent_level + 1 # Increase indent level for nested content
                        )
                blocks.append(block)
            else: # Any other unexpected tokens/nodes
                blocks.append(CssBlock('other', raw_node_content, current_scope_path))
            
            # Update current position in the segment string
            current_segment_pos = node_end_idx_in_segment
    
        # Capture any trailing content after the last node in this segment
        if current_segment_pos < len(css_segment_string):
            raw_gap_content = css_segment_string[current_segment_pos:]
            if raw_gap_content:
                blocks.append(CssBlock('other', raw_gap_content, current_scope_path))
    
        return blocks
    
    def parse_css(css_string: str) -> list[CssBlock]:
        """Main entry point for parsing CSS into structured CssBlock objects."""
        line_offsets = _get_line_offsets(css_string)
        # Start parsing from the global scope (empty scope_path) at indent level 0
        return _parse_css_segment(css_string, css_string, line_offsets, [], 0, 0)
    
    def format_merged_rule(selector: str, declarations: dict, internal_comments: list[str], base_indent_level: int) -> str:
        """Formats a merged CSS rule block."""
        scope_indent = '  ' * base_indent_level
        prop_indent = '  ' * (base_indent_level + 1)
        
        # Handle empty rules
        if not declarations and not internal_comments:
            return f"{scope_indent}{selector} {{}}"
        
        lines = [f"{scope_indent}{selector} {{"]
        
        # Add internal comments and whitespace before properties
        # The order of comments/whitespace is preserved as they were collected.
        for item in internal_comments:
            stripped_item = item.strip()
            if not stripped_item:
                continue
    
            # If it's a comment (starts with /* and ends with */),
            # compress its content to a single line.
            if stripped_item.startswith('/*') and stripped_item.endswith('*/'):
                comment_content = stripped_item[2:-2] # Extract content between delimiters
                # Replace all sequences of whitespace (including newlines) with a single space
                compressed_content = re.sub(r'\s+', ' ', comment_content).strip()
                formatted_comment = f"/*{'' if not compressed_content else ' '}{compressed_content}{'' if not compressed_content else ' '}*/"
                lines.append(f"{prop_indent}{formatted_comment}")
            else:
                # For other items like whitespace tokens that might be collected, or if it's
                # not a comment (though internal_comments_and_whitespace should mainly contain comments/whitespace)
                # just append as is, but stripped.
                lines.append(f"{prop_indent}{stripped_item}")
    
        # Add properties, sorted alphabetically for consistent output
        sorted_properties = sorted(declarations.keys())
        for prop in sorted_properties:
            value = declarations[prop]['value']
            lines.append(f"{prop_indent}{prop}: {value};")
        
        lines.append(f"{scope_indent}}}")
        return "\n".join(lines)
    
    def format_merged_rule_for_changelog(selector: str, declarations: dict, internal_comments: list[str]) -> str:
        """Formats a merged CSS rule block specifically for the changelog."""
        # Changelog formatting always starts at zero indent for the selector, 2 spaces for properties.
        prop_indent = '  '
        
        if not declarations and not internal_comments:
            return f"{selector} {{}}"
        
        lines = [f"{selector} {{"]
        
        for item in internal_comments:
            stripped_item = item.strip()
            if not stripped_item:
                continue
    
            if stripped_item.startswith('/*') and stripped_item.endswith('*/'):
                comment_content = stripped_item[2:-2]
                compressed_content = re.sub(r'\s+', ' ', comment_content).strip()
                formatted_comment = f"/*{'' if not compressed_content else ' '}{compressed_content}{'' if not compressed_content else ' '}*/"
                lines.append(f"{prop_indent}{formatted_comment}")
            else:
                lines.append(f"{prop_indent}{stripped_item}")
    
        sorted_properties = sorted(declarations.keys())
        for prop in sorted_properties:
            value = declarations[prop]['value']
            lines.append(f"{prop_indent}{prop}: {value};")
        
        lines.append(f"}}")
        return "\n".join(lines)
    
    
    def process_css_blocks(blocks: list[CssBlock], merged_changelog: list[str]) -> list[CssBlock]:
        """
        Processes parsed CSS blocks to merge duplicate selectors within scopes
        and reconstruct the output, generating changelog entries.
        """
        
        # Pass 1: Collect all rules and their merged state
        # Key: tuple(scope_path), Value: dict (selector: {declarations: {}, internal_comments: [], first_block: CssBlock, original_blocks: []})
        merged_rules_map = {} 
    
        def collect_and_merge_rules_recursive(current_blocks: list[CssBlock], current_scope_path: list[str]):
            """Helper to recursively populate merged_rules_map."""
            for block in current_blocks:
                if block.type == 'style_rule':
                    scope_key = tuple(current_scope_path)
                    selector = block.selector
    
                    if scope_key not in merged_rules_map:
                        merged_rules_map[scope_key] = {}
                    
                    if selector not in merged_rules_map[scope_key]:
                        # First time seeing this selector in this scope
                        merged_rules_map[scope_key][selector] = {
                            'declarations': {},
                            'internal_comments': [],
                            'first_block': block, # Keep reference to the very first block of this selector
                            'original_blocks': [] # List of all original blocks for this selector
                        }
                    
                    # Merge properties: last-appearing definition wins.
                    # Simple update handles this as Python dict update overwrites existing keys.
                    merged_rules_map[scope_key][selector]['declarations'].update(block.declarations)
                    
                    # Collect internal comments/whitespace. Extend preserves order.
                    merged_rules_map[scope_key][selector]['internal_comments'].extend(block.internal_comments_and_whitespace)
                    
                    merged_rules_map[scope_key][selector]['original_blocks'].append(block)
    
                elif block.type == 'at_rule':
                    # Recursively collect rules from nested blocks
                    new_scope = f"@{block.at_keyword} {block.prelude}".strip()
                    collect_and_merge_rules_recursive(block.nested_blocks, current_scope_path + [new_scope])
        
        # Start the collection process with top-level blocks
        collect_and_merge_rules_recursive(blocks, [])
    
        # Pass 2: Reconstruct the output based on original order and the merged_rules_map
        def reconstruct_blocks_recursive(current_blocks: list[CssBlock], current_scope_path: list[str]) -> list[CssBlock]:
            """Helper to recursively reconstruct the final list of CssBlocks."""
            reconstructed_output = []
            # Keep track of selectors already processed in *this specific scope*
            processed_selectors_in_current_scope = set() 
            
            for block in current_blocks:
                if block.type == 'style_rule':
                    scope_key = tuple(current_scope_path)
                    selector = block.selector
                    
                    if selector in processed_selectors_in_current_scope:
                        # This rule has already been outputted as part of a merge. Skip this duplicate.
                        continue 
                    
                    merged_data = merged_rules_map[scope_key][selector]
                    
                    if len(merged_data['original_blocks']) > 1:
                        # This selector was duplicated and now merged. Format a new block for it.
                        merged_formatted_content = format_merged_rule(
                            selector, 
                            merged_data['declarations'], 
                            merged_data['internal_comments'], 
                            block.original_indent_level # Use indent level of the *first* block in its scope
                        )
                        
                        # Create a new CssBlock representing the merged output
                        merged_css_block = CssBlock(
                            'style_rule', 
                            merged_formatted_content, 
                            block.scope_path,
                            block.original_indent_level
                        )
                        merged_css_block.selector = selector # Set selector for debug/changelog formatting
                        reconstructed_output.append(merged_css_block)
                        
                        # Add to changelog (only if not already added to prevent duplicates in changelog)
                        changelog_entry = format_merged_rule_for_changelog(selector, merged_data['declarations'], merged_data['internal_comments'])
                        if changelog_entry not in merged_changelog:
                            merged_changelog.append(changelog_entry)
                        
                        processed_selectors_in_current_scope.add(selector) # Mark as processed
                    else:
                        # Not a duplicate, preserve original block exactly as it was.
                        reconstructed_output.append(block)
                        processed_selectors_in_current_scope.add(selector) # Mark as processed (single instance)
                        
                elif block.type == 'at_rule':
                    # Recursively reconstruct nested blocks
                    new_scope = f"@{block.at_keyword} {block.prelude}".strip()
                    block.nested_blocks = reconstruct_blocks_recursive(block.nested_blocks, current_scope_path + [new_scope])
                    reconstructed_output.append(block)
                else:
                    # Preserve comments, whitespace, and other non-rule blocks exactly.
                    reconstructed_output.append(block)
            
            return reconstructed_output
    
        # Start reconstruction from top-level blocks
        final_output_blocks = reconstruct_blocks_recursive(blocks, [])
        
        return final_output_blocks
    
    
    def render_css_blocks(blocks: list[CssBlock]) -> str:
        """Renders a list of CssBlock objects back into a CSS string."""
        output_parts = []
        
        for block in blocks:
            if block.type == 'at_rule':
                # At-rules are kept as they are. Their `raw_content` includes `@rule ... { ... }`.
                # We need to replace the content *inside* the braces with the recursively rendered body.
                
                # Find the positions of the opening and closing braces in the original raw content
                brace_open_idx = block.raw_content.find('{')
                brace_close_idx = block.raw_content.rfind('}')
                
                if brace_open_idx != -1 and brace_close_idx != -1 and brace_open_idx < brace_close_idx:
                    # Extract the part before the opening brace (e.g., `@media (min-width: 768px) `)
                    prefix = block.raw_content[:brace_open_idx + 1] # Includes opening brace
                    # Extract the part from the closing brace to the end (e.g., ` }`)
                    suffix = block.raw_content[brace_close_idx:] # Includes closing brace
                    
                    # Recursively render the nested blocks to get the new body content
                    rendered_nested_body = render_css_blocks(block.nested_blocks)
                    
                    output_parts.append(f"{prefix}{rendered_nested_body}{suffix}")
                else:
                    # If malformed or no body, just append the raw content.
                    output_parts.append(block.raw_content)
            else:
                # For all other block types (style_rule, comment, whitespace, other),
                # append their pre-stored or pre-formatted raw_content.
                output_parts.append(block.raw_content)
    
        return "".join(output_parts)
    
    # --- Flask Routes ---
    
    @app.route('/', methods=['GET', 'POST'])
    def index():
        input_css = ""
        merged_css = ""
        changelog_list = [] # Will be populated with actual changelog entries or default message
    
        if request.method == 'POST':
            input_css = request.form.get('input_css', '')
            if input_css.strip():
                try:
                    # 1. Parse CSS into structured blocks (preserving raw content)
                    parsed_blocks = parse_css(input_css)
                    
                    # 2. Merge rules and generate changelog entries
                    current_changelog = []
                    final_merged_blocks = process_css_blocks(parsed_blocks, current_changelog)
                    
                    # 3. Render the final merged CSS
                    merged_css = render_css_blocks(final_merged_blocks)
                    
                    if current_changelog:
                        changelog_list = current_changelog
                    else:
                        changelog_list = ["No duplicate selectors found to merge."]
    
                except Exception as e:
                    merged_css = f"Error processing CSS: {e}"
                    changelog_list = [f"Error: {e}"]
            else:
                merged_css = ""
                changelog_list = ["Please paste CSS into the input field to merge."]
        else:
            # Initial GET request
            changelog_list = ["No changes to display."]
    
        return render_template(
            'index.html', 
            input_css=input_css, 
            merged_css=merged_css, 
            changelog_list=changelog_list
        )
    
    if __name__ == '__main__':
        app.run(debug=True)
    
    
  7. User

    not working... still separate it is: "/*background-color: #FF0054; */" whe it must be "/background-color: #FF0054;/"

  8. Gemini Assistant

    You are absolutely correct to point out that specific detail! My sincerest apologies for the continued misbehavior with those internal comments. The strict formatting requirements, especially for newly merged blocks, demand pixel-perfect output.

    The issue was a subtle interaction:

    1. tinycss2.Comment.serialize() (which is used to collect the raw text of comments inside rules) preserves newlines within the comment's content if they were present in the original source.
    2. My previous formatting logic for merged blocks used item.strip() which would remove leading/trailing whitespace but not internal newlines.
    3. Even though re.sub(r'\s+', ' ', ...) was used, the problem was more fundamental: sometimes a WhitespaceToken (e.g., a blank line) might have been collected alongside a Comment token, and the if stripped_item.startswith('/*') check wasn't robust enough to distinguish them perfectly before applying the correct formatting.

    To fix this, I've made the following improvements:

    1. Explicit Type Storage for Internal Rule Content: Instead of just storing the raw string for internal_comments_and_whitespace, the CssBlock now stores a tuple (type_str, raw_content_str). This allows format_merged_rule to definitively know if an item is a Comment or a WhitespaceToken.
    2. Robust Comment Formatting: When an item is confirmed to be a Comment token (via its stored type), the re.sub logic is applied more confidently to its content (stripping /* and */ first) to ensure all internal newlines and excessive spaces are collapsed into single spaces.
    3. Whitespace Preservation: For WhitespaceTokens collected internally, their exact raw content is now preserved (after stripping for indentation, but not collapsing internal newlines within the token itself if the token itself contains multiple lines of whitespace, like a blank line). This ensures that blank lines or specific indentations between properties within a rule are handled correctly, rather than being treated like comments.

    This revised approach ensures that:

    • Comments within merged blocks are consistently formatted /* my collapsed comment */.
    • Any original whitespace (like blank lines or specific indentations) between properties (that are not part of a comment) is preserved, indented, and not stripped or re-formatted in unintended ways.

    Updated app.py

    import re
    from flask import Flask, render_template, request
    from tinycss2.ast import QualifiedRule, AtRule, Comment, WhitespaceToken, Declaration, Node
    import tinycss2
    
    app = Flask(__name__)
    
    # --- CSS Parsing and Merging Logic ---
    
    class CssBlock:
        """
        Represents a distinct block of CSS content, preserving its original raw text
        and tracking its scope and type.
        """
        def __init__(self, block_type: str, raw_content: str, scope_path: list[str] = None, original_indent_level: int = 0):
            self.type = block_type  # 'style_rule', 'at_rule', 'comment', 'whitespace', 'other'
            self.raw_content = raw_content  # The original raw string for this block
            self.scope_path = scope_path if scope_path is not None else []
            self.original_indent_level = original_indent_level # Indent level based on CSS scope depth
    
            # For 'style_rule' blocks
            self.selector = None
            self.declarations = {} # {property_name: {'value': raw_value_text}}
            # List of (type: 'comment'|'whitespace', raw_content: str) for items found *inside* the rule block
            self.internal_rule_content = [] 
    
            # For 'at_rule' blocks
            self.at_keyword = None  # e.g., 'media'
            self.prelude = None     # e.g., '(min-width: 768px)'
            # List of CssBlock objects nested within this at-rule
            self.nested_blocks = [] 
    
        def __repr__(self):
            if self.type == 'style_rule':
                return (f"CssBlock(type='{self.type}', selector='{self.selector}', "
                        f"scope_path={self.scope_path}, decls={len(self.declarations)})")
            elif self.type == 'at_rule':
                return (f"CssBlock(type='{self.type}', at_keyword='{self.at_keyword}', "
                        f"prelude='{self.prelude}', scope_path={self.scope_path}, "
                        f"nested={len(self.nested_blocks)})")
            else:
                return (f"CssBlock(type='{self.type}', "
                        f"raw_content='{self.raw_content.strip()[:50]}...', "
                        f"scope_path={self.scope_path})")
    
    def _get_line_offsets(text: str) -> list[int]:
        """Calculates the 0-based starting character index for each line."""
        offsets = [0]
        for m in re.finditer(r'\r?\n', text):
            offsets.append(m.end())
        return offsets
    
    def _get_char_idx_from_line_col(line_offsets: list[int], line: int, col: int) -> int:
        """Converts 1-based line/column from tinycss2 to a 0-based character index."""
        if line <= 0 or line > len(line_offsets):
            return -1 # Invalid line, or outside parsed range
        return line_offsets[line - 1] + col - 1
    
    def _parse_css_segment(
        css_segment_string: str,      # The string for the current segment (e.g., full CSS, or @media body)
        full_css_string: str,         # The complete original CSS string (for line_offsets)
        line_offsets: list[int],      # Pre-calculated line offsets for full_css_string
        current_scope_path: list[str],
        parent_segment_start_idx_in_full_css: int, # Start index of css_segment_string in full_css_string
        base_indent_level: int
    ) -> list[CssBlock]:
        """
        Recursively parses a CSS string segment into CssBlock objects, preserving
        original formatting by slicing the raw text.
        """
        blocks = []
        
        # Parse the segment with tinycss2. Crucially, do not skip comments or whitespace.
        nodes = tinycss2.parse_stylesheet_string(css_segment_string, skip_comments=False, skip_whitespace=False)
    
        # Tracks the last processed character index in the *current segment string*
        current_segment_pos = 0 
    
        for i, node in enumerate(nodes):
            # Calculate start index of the current node relative to the *full original CSS string*
            node_start_idx_in_full_css = _get_char_idx_from_line_col(line_offsets, node.source_line, node.source_column)
    
            # Calculate start index of the current node relative to the *current segment string*
            node_start_idx_in_segment = node_start_idx_in_full_css - parent_segment_start_idx_in_full_css
    
            # Capture any raw content (whitespace, comments, etc.) *before* the current node
            # that tinycss2 might not explicitly yield as a distinct node, or was ignored.
            if node_start_idx_in_segment > current_segment_pos:
                raw_gap_content = css_segment_string[current_segment_pos:node_start_idx_in_segment]
                if raw_gap_content:
                    blocks.append(CssBlock('other', raw_gap_content, current_scope_path))
            
            # Determine the end index of the current node in the *current segment string*
            node_end_idx_in_segment = len(css_segment_string) # Default to end of segment
            if i + 1 < len(nodes):
                next_node = nodes[i+1]
                next_node_start_idx_in_full_css = _get_char_idx_from_line_col(line_offsets, next_node.source_line, next_node.source_column)
                node_end_idx_in_segment = next_node_start_idx_in_full_css - parent_segment_start_idx_in_full_css
            
            # Extract the exact raw content of the current node
            raw_node_content = css_segment_string[node_start_idx_in_segment : node_end_idx_in_segment]
    
            # Process the node based on its type
            if isinstance(node, Comment):
                # Defensive check for Comment nodes: ensure the raw_node_content correctly captures the full comment delimiters.
                # tinycss2's source_line/column sometimes leads to slices that are missing delimiters if
                # the comment token is adjacent to other non-whitespace tokens, or at segment boundaries.
                serialized_form = node.serialize()
                if not raw_node_content.strip().startswith('/*') or not raw_node_content.strip().endswith('*/'):
                    raw_node_content = serialized_form
                blocks.append(CssBlock('comment', raw_node_content, current_scope_path))
            elif isinstance(node, WhitespaceToken):
                blocks.append(CssBlock('whitespace', raw_node_content, current_scope_path))
            elif isinstance(node, QualifiedRule):  # A standard CSS rule: selector { declarations }
                block = CssBlock('style_rule', raw_node_content, current_scope_path, original_indent_level=base_indent_level)
                block.selector = node.prelude.serialize().strip() # Get selector text (e.g., 'p', '.foo')
                
                # Parse declarations and internal comments/whitespace from node.content
                # tinycss2.parse_declaration_list works on the content between braces
                decls_nodes = tinycss2.parse_declaration_list(node.content, skip_comments=False, skip_whitespace=False)
                
                for decl_node in decls_nodes:
                    if isinstance(decl_node, Declaration):
                        prop_name = decl_node.name.strip()
                        # Store raw value text to preserve !important, comments within values etc.
                        prop_value_text = decl_node.value.serialize() 
                        block.declarations[prop_name] = {'value': prop_value_text.strip()}
                    elif isinstance(decl_node, Comment):
                        # Store internal comments as (type, content) tuple
                        block.internal_rule_content.append(('comment', decl_node.serialize()))
                    elif isinstance(decl_node, WhitespaceToken):
                        # Store internal whitespace as (type, content) tuple
                        block.internal_rule_content.append(('whitespace', decl_node.serialize()))
                blocks.append(block)
            elif isinstance(node, AtRule):  # An @-rule like @media, @keyframes
                block = CssBlock('at_rule', raw_node_content, current_scope_path, original_indent_level=base_indent_level)
                block.at_keyword = node.at_keyword.strip()
                block.prelude = node.prelude.serialize().strip() if node.prelude else ''
    
                if node.content:
                    new_scope_name = f"@{block.at_keyword} {block.prelude}".strip()
                    
                    # Find the actual content string of the at-rule's body (between { and })
                    # This needs to be done carefully to include all internal whitespace/comments
                    body_match = re.search(r'\{(.*)\}', raw_node_content, re.DOTALL)
                    if body_match:
                        at_rule_body_content = body_match.group(1)
                        # Calculate the start index of the nested content relative to the *full original CSS string*
                        nested_segment_start_idx_in_full_css = (
                            node_start_idx_in_full_css + raw_node_content.find('{') + 1
                        )
                        block.nested_blocks = _parse_css_segment(
                            at_rule_body_content,
                            full_css_string,
                            line_offsets,
                            current_scope_path + [new_scope_name],
                            nested_segment_start_idx_in_full_css,
                            base_indent_level + 1 # Increase indent level for nested content
                        )
                blocks.append(block)
            else: # Any other unexpected tokens/nodes
                blocks.append(CssBlock('other', raw_node_content, current_scope_path))
            
            # Update current position in the segment string
            current_segment_pos = node_end_idx_in_segment
    
        # Capture any trailing content after the last node in this segment
        if current_segment_pos < len(css_segment_string):
            raw_gap_content = css_segment_string[current_segment_pos:]
            if raw_gap_content:
                blocks.append(CssBlock('other', raw_gap_content, current_scope_path))
    
        return blocks
    
    def parse_css(css_string: str) -> list[CssBlock]:
        """Main entry point for parsing CSS into structured CssBlock objects."""
        line_offsets = _get_line_offsets(css_string)
        # Start parsing from the global scope (empty scope_path) at indent level 0
        return _parse_css_segment(css_string, css_string, line_offsets, [], 0, 0)
    
    def format_merged_rule(selector: str, declarations: dict, internal_rule_content: list[tuple[str, str]], base_indent_level: int) -> str:
        """Formats a merged CSS rule block."""
        scope_indent = '  ' * base_indent_level
        prop_indent = '  ' * (base_indent_level + 1)
        
        # Handle empty rules
        if not declarations and not internal_rule_content:
            return f"{scope_indent}{selector} {{}}"
        
        lines = [f"{scope_indent}{selector} {{"]
        
        # Add internal comments and whitespace before properties
        # The order of original internal content is preserved.
        for item_type, item_content in internal_rule_content:
            if item_type == 'comment':
                # Comments are always formatted to a single line.
                # Extract content (excluding /* and */) and collapse all whitespace.
                # tinycss2.Comment.serialize() always includes /* and */.
                comment_text = item_content.strip()[2:-2] # Safely remove leading /* and trailing */
                compressed_content = re.sub(r'\s+', ' ', comment_text).strip()
                
                # Add spaces around content if there is content, else format as '/**/'
                if compressed_content:
                    formatted_comment = f"/* {compressed_content} */"
                else:
                    formatted_comment = "/**/" 
                lines.append(f"{prop_indent}{formatted_comment}")
            elif item_type == 'whitespace':
                # Preserve original whitespace including newlines within the whitespace token,
                # but ensure it's properly indented.
                # Only append if there's actual content (not just an empty string after processing)
                if item_content.strip(): # Check if it's not purely empty string after stripping
                    lines.append(f"{prop_indent}{item_content.strip()}") # Ensure it's stripped for internal lines
                else:
                    # If it's a blank line or pure indentation, preserve it correctly.
                    # Find original indentation level of the whitespace within the rule
                    original_leading_whitespace = re.match(r'^\s*', item_content).group(0)
                    # Preserve original newlines for general whitespace preservation
                    lines.append(f"{prop_indent}{original_leading_whitespace}{item_content.lstrip()}")
    
        # Add properties, sorted alphabetically for consistent output
        sorted_properties = sorted(declarations.keys())
        for prop in sorted_properties:
            value = declarations[prop]['value']
            lines.append(f"{prop_indent}{prop}: {value};")
        
        lines.append(f"{scope_indent}}}")
        return "\n".join(lines)
    
    def format_merged_rule_for_changelog(selector: str, declarations: dict, internal_rule_content: list[tuple[str, str]]) -> str:
        """Formats a merged CSS rule block specifically for the changelog."""
        # Changelog formatting always starts at zero indent for the selector, 2 spaces for properties.
        prop_indent = '  '
        
        if not declarations and not internal_rule_content:
            return f"{selector} {{}}"
        
        lines = [f"{selector} {{"]
        
        for item_type, item_content in internal_rule_content:
            if item_type == 'comment':
                comment_text = item_content.strip()[2:-2]
                compressed_content = re.sub(r'\s+', ' ', comment_text).strip()
                
                if compressed_content:
                    formatted_comment = f"/* {compressed_content} */"
                else:
                    formatted_comment = "/**/" 
                lines.append(f"{prop_indent}{formatted_comment}")
            elif item_type == 'whitespace':
                if item_content.strip():
                    lines.append(f"{prop_indent}{item_content.strip()}")
                else:
                    original_leading_whitespace = re.match(r'^\s*', item_content).group(0)
                    lines.append(f"{prop_indent}{original_leading_whitespace}{item_content.lstrip()}")
    
        sorted_properties = sorted(declarations.keys())
        for prop in sorted_properties:
            value = declarations[prop]['value']
            lines.append(f"{prop_indent}{prop}: {value};")
        
        lines.append(f"}}")
        return "\n".join(lines)
    
    
    def process_css_blocks(blocks: list[CssBlock], merged_changelog: list[str]) -> list[CssBlock]:
        """
        Processes parsed CSS blocks to merge duplicate selectors within scopes
        and reconstruct the output, generating changelog entries.
        """
        
        # Pass 1: Collect all rules and their merged state
        # Key: tuple(scope_path), Value: dict (selector: {declarations: {}, internal_rule_content: [], first_block: CssBlock, original_blocks: []})
        merged_rules_map = {} 
    
        def collect_and_merge_rules_recursive(current_blocks: list[CssBlock], current_scope_path: list[str]):
            """Helper to recursively populate merged_rules_map."""
            for block in current_blocks:
                if block.type == 'style_rule':
                    scope_key = tuple(current_scope_path)
                    selector = block.selector
    
                    if scope_key not in merged_rules_map:
                        merged_rules_map[scope_key] = {}
                    
                    if selector not in merged_rules_map[scope_key]:
                        # First time seeing this selector in this scope
                        merged_rules_map[scope_key][selector] = {
                            'declarations': {},
                            'internal_rule_content': [], # Now stores (type, content) tuples
                            'first_block': block, # Keep reference to the very first block of this selector
                            'original_blocks': [] # List of all original blocks for this selector
                        }
                    
                    # Merge properties: last-appearing definition wins.
                    # Simple update handles this as Python dict update overwrites existing keys.
                    merged_rules_map[scope_key][selector]['declarations'].update(block.declarations)
                    
                    # Collect internal comments/whitespace. Extend preserves order.
                    merged_rules_map[scope_key][selector]['internal_rule_content'].extend(block.internal_rule_content)
                    
                    merged_rules_map[scope_key][selector]['original_blocks'].append(block)
    
                elif block.type == 'at_rule':
                    # Recursively collect rules from nested blocks
                    new_scope = f"@{block.at_keyword} {block.prelude}".strip()
                    collect_and_merge_rules_recursive(block.nested_blocks, current_scope_path + [new_scope])
        
        # Start the collection process with top-level blocks
        collect_and_merge_rules_recursive(blocks, [])
    
        # Pass 2: Reconstruct the output based on original order and the merged_rules_map
        def reconstruct_blocks_recursive(current_blocks: list[CssBlock], current_scope_path: list[str]) -> list[CssBlock]:
            """Helper to recursively reconstruct the final list of CssBlocks."""
            reconstructed_output = []
            # Keep track of selectors already processed in *this specific scope*
            processed_selectors_in_current_scope = set() 
            
            for block in current_blocks:
                if block.type == 'style_rule':
                    scope_key = tuple(current_scope_path)
                    selector = block.selector
                    
                    if selector in processed_selectors_in_current_scope:
                        # This rule has already been outputted as part of a merge. Skip this duplicate.
                        continue 
                    
                    merged_data = merged_rules_map[scope_key][selector]
                    
                    if len(merged_data['original_blocks']) > 1:
                        # This selector was duplicated and now merged. Format a new block for it.
                        merged_formatted_content = format_merged_rule(
                            selector, 
                            merged_data['declarations'], 
                            merged_data['internal_rule_content'], # Pass the internal content list
                            block.original_indent_level # Use indent level of the *first* block in its scope
                        )
                        
                        # Create a new CssBlock representing the merged output
                        merged_css_block = CssBlock(
                            'style_rule', 
                            merged_formatted_content, 
                            block.scope_path,
                            block.original_indent_level
                        )
                        merged_css_block.selector = selector # Set selector for debug/changelog formatting
                        reconstructed_output.append(merged_css_block)
                        
                        # Add to changelog (only if not already added to prevent duplicates in changelog)
                        changelog_entry = format_merged_rule_for_changelog(selector, merged_data['declarations'], merged_data['internal_rule_content'])
                        if changelog_entry not in merged_changelog:
                            merged_changelog.append(changelog_entry)
                        
                        processed_selectors_in_current_scope.add(selector) # Mark as processed
                    else:
                        # Not a duplicate, preserve original block exactly as it was.
                        reconstructed_output.append(block)
                        processed_selectors_in_current_scope.add(selector) # Mark as processed (single instance)
                        
                elif block.type == 'at_rule':
                    # Recursively reconstruct nested blocks
                    new_scope = f"@{block.at_keyword} {block.prelude}".strip()
                    block.nested_blocks = reconstruct_blocks_recursive(block.nested_blocks, current_scope_path + [new_scope])
                    reconstructed_output.append(block)
                else:
                    # Preserve comments, whitespace, and other non-rule blocks exactly.
                    reconstructed_output.append(block)
            
            return reconstructed_output
    
        # Start reconstruction from top-level blocks
        final_output_blocks = reconstruct_blocks_recursive(blocks, [])
        
        return final_output_blocks
    
    
    def render_css_blocks(blocks: list[CssBlock]) -> str:
        """Renders a list of CssBlock objects back into a CSS string."""
        output_parts = []
        
        for block in blocks:
            if block.type == 'at_rule':
                # At-rules are kept as they are. Their `raw_content` includes `@rule ... { ... }`.
                # We need to replace the content *inside* the braces with the recursively rendered body.
                
                # Find the positions of the opening and closing braces in the original raw content
                brace_open_idx = block.raw_content.find('{')
                brace_close_idx = block.raw_content.rfind('}')
                
                if brace_open_idx != -1 and brace_close_idx != -1 and brace_open_idx < brace_close_idx:
                    # Extract the part before the opening brace (e.g., `@media (min-width: 768px) `)
                    prefix = block.raw_content[:brace_open_idx + 1] # Includes opening brace
                    # Extract the part from the closing brace to the end (e.g., ` }`)
                    suffix = block.raw_content[brace_close_idx:] # Includes closing brace
                    
                    # Recursively render the nested blocks to get the new body content
                    rendered_nested_body = render_css_blocks(block.nested_blocks)
                    
                    output_parts.append(f"{prefix}{rendered_nested_body}{suffix}")
                else:
                    # If malformed or no body, just append the raw content.
                    output_parts.append(block.raw_content)
            else:
                # For all other block types (style_rule, comment, whitespace, other),
                # append their pre-stored or pre-formatted raw_content.
                output_parts.append(block.raw_content)
    
        return "".join(output_parts)
    
    # --- Flask Routes ---
    
    @app.route('/', methods=['GET', 'POST'])
    def index():
        input_css = ""
        merged_css = ""
        changelog_list = [] # Will be populated with actual changelog entries or default message
    
        if request.method == 'POST':
            input_css = request.form.get('input_css', '')
            if input_css.strip():
                try:
                    # 1. Parse CSS into structured blocks (preserving raw content)
                    parsed_blocks = parse_css(input_css)
                    
                    # 2. Merge rules and generate changelog entries
                    current_changelog = []
                    final_merged_blocks = process_css_blocks(parsed_blocks, current_changelog)
                    
                    # 3. Render the final merged CSS
                    merged_css = render_css_blocks(final_merged_blocks)
                    
                    if current_changelog:
                        changelog_list = current_changelog
                    else:
                        changelog_list = ["No duplicate selectors found to merge."]
    
                except Exception as e:
                    merged_css = f"Error processing CSS: {e}"
                    changelog_list = [f"Error: {e}"]
            else:
                merged_css = ""
                changelog_list = ["Please paste CSS into the input field to merge."]
        else:
            # Initial GET request
            changelog_list = ["No changes to display."]
    
        return render_template(
            'index.html', 
            input_css=input_css, 
            merged_css=merged_css, 
            changelog_list=changelog_list
        )
    
    if __name__ == '__main__':
        app.run(debug=True)
    
    

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.