CSS格式化工具

// CSS压缩
function minifyCSS(css) {
    return css
        .replace(/\/\*[\s\S]*?\*\//g, '') // 移除注释
        .replace(/\s+/g, ' ') // 合并空白
        .replace(/\s*([{}:;,])\s*/g, '$1') // 移除符号周围的空白
        .replace(/;\}/g, '}') // 移除最后一个分号
        .trim();
}

// CSS美化
function beautifyCSS(css, indent = '    ') {
    let formatted = '';
    let indentLevel = 0;
    
    // 移除多余空白
    css = css.replace(/\s+/g, ' ');
    
    // 处理每个字符
    for (let i = 0; i < css.length; i++) {
        const char = css[i];
        
        if (char === '{') {
            formatted += ' {\n' + indent.repeat(indentLevel + 1);
            indentLevel++;
        } else if (char === '}') {
            indentLevel--;
            formatted += '\n' + indent.repeat(indentLevel) + '}';
        } else if (char === ';') {
            formatted += ';\n' + indent.repeat(indentLevel);
        } else if (char === ',') {
            formatted += ', ';
        } else {
            formatted += char;
        }
    }
    
    return formatted.trim();
}

// 提取CSS选择器
function extractSelectors(css) {
    const selectorRegex = /([^{]+){/g;
    const selectors = [];
    let match;
    
    while ((match = selectorRegex.exec(css)) !== null) {
        const selector = match[1].trim();
        if (selector) {
            selectors.push(selector);
        }
    }
    
    return selectors;
}

// 提取CSS属性
function extractProperties(css) {
    const propertyRegex = /([^{}:]+):\s*([^{};]+);/g;
    const properties = [];
    let match;
    
    while ((match = propertyRegex.exec(css)) !== null) {
        properties.push({
            property: match[1].trim(),
            value: match[2].trim()
        });
    }
    
    return properties;
}

// 按字母排序属性
function sortCSSProperties(css) {
    const blocks = css.split('}');
    const sortedBlocks = blocks.map(block => {
        const parts = block.split('{');
        if (parts.length !== 2) return block;
        
        const selector = parts[0].trim();
        const properties = parts[1].split(';').filter(p => p.trim());
        
        // 按字母排序属性
        properties.sort((a, b) => {
            const propA = a.split(':')[0].trim();
            const propB = b.split(':')[0].trim();
            return propA.localeCompare(propB);
        });
        
        return `${selector} {\n${properties.map(p => `    ${p.trim()}`).join(';\n')};\n}`;
    });
    
    return sortedBlocks.join('\n');
}

// 颜色格式转换 HEX → RGB
function hexToRGB(hex) {
    const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
    return result ? {
        r: parseInt(result[1], 16),
        g: parseInt(result[2], 16),
        b: parseInt(result[3], 16)
    } : null;
}

function convertHexToRGBString(hex) {
    const rgb = hexToRGB(hex);
    return rgb ? `rgb(${rgb.r}, ${rgb.g}, ${rgb.b})` : hex;
}

import re

# CSS压缩
def minify_css(css):
    # 移除注释
    css = re.sub(r'/\*[\s\S]*?\*/', '', css)
    # 合并空白
    css = re.sub(r'\s+', ' ', css)
    # 移除符号周围的空白
    css = re.sub(r'\s*([{}:;,])\s*', r'\1', css)
    # 移除最后一个分号
    css = css.replace(';}', '}')
    return css.strip()

# CSS美化
def beautify_css(css, indent='    '):
    formatted = ''
    indent_level = 0
    
    # 移除多余空白
    css = re.sub(r'\s+', ' ', css)
    
    i = 0
    while i < len(css):
        char = css[i]
        
        if char == '{':
            formatted += ' {\n' + indent * (indent_level + 1)
            indent_level += 1
        elif char == '}':
            indent_level -= 1
            formatted += '\n' + indent * indent_level + '}'
        elif char == ';':
            formatted += ';\n' + indent * indent_level
        elif char == ',':
            formatted += ', '
        else:
            formatted += char
        
        i += 1
    
    return formatted.strip()

# 提取CSS选择器
def extract_selectors(css):
    pattern = r'([^{]+){'
    selectors = re.findall(pattern, css)
    return [s.strip() for s in selectors if s.strip()]

# 提取CSS属性
def extract_properties(css):
    pattern = r'([^{}:]+):\s*([^{};]+);'
    matches = re.findall(pattern, css)
    return [{'property': m[0].strip(), 'value': m[1].strip()} for m in matches]

# 按字母排序属性
def sort_css_properties(css):
    blocks = css.split('}')
    sorted_blocks = []
    
    for block in blocks:
        parts = block.split('{')
        if len(parts) != 2:
            sorted_blocks.append(block)
            continue
        
        selector = parts[0].strip()
        properties = parts[1].split(';')
        properties = [p.strip() for p in properties if p.strip()]
        
        # 按字母排序
        properties.sort(key=lambda x: x.split(':')[0].strip())
        
        formatted_props = '\n    '.join([f'{p};' for p in properties])
        sorted_blocks.append(f'{selector} {{\n    {formatted_props}\n}}')
    
    return '\n'.join(sorted_blocks)

# HEX 转 RGB
def hex_to_rgb(hex_color):
    hex_color = hex_color.lstrip('#')
    return tuple(int(hex_color[i:i+2], 16) for i in (0, 2, 4))

def hex_to_rgb_string(hex_color):
    r, g, b = hex_to_rgb(hex_color)
    return f'rgb({r}, {g}, {b})'