ether-code 0.1.6 → 0.1.8

package/parsers/css-parser.js

@@ -1,1981 +0,0 @@
-const fs = require('fs')
-const path = require('path')
-const AST = require('./ast-css')
-
-class CSSLexer {
-    constructor(source, i18n) {
-        this.source = source
-        this.i18n = i18n
-        this.pos = 0
-        this.line = 1
-        this.column = 1
-        this.tokens = []
-        this.indentStack = [0]
-    }
-
-    peek(offset = 0) {
-        return this.source[this.pos + offset] || ''
-    }
-
-    advance() {
-        const char = this.source[this.pos]
-        this.pos++
-        if (char === '\n') {
-            this.line++
-            this.column = 1
-        } else {
-            this.column++
-        }
-        return char
-    }
-
-    skipWhitespace() {
-        while (this.pos < this.source.length) {
-            const char = this.peek()
-            if (char === ' ' || char === '\t' || char === '\r') {
-                this.advance()
-            } else if (char === '-' && this.peek(1) === '-' && this.peek(2) !== '-') {
-                this.skipLineComment()
-            } else if (char === '{' && this.peek(1) === '-') {
-                this.skipBlockComment()
-            } else {
-                break
-            }
-        }
-    }
-
-    skipLineComment() {
-        while (this.pos < this.source.length && this.peek() !== '\n') {
-            this.advance()
-        }
-    }
-
-    skipBlockComment() {
-        this.advance()
-        this.advance()
-        while (this.pos < this.source.length) {
-            if (this.peek() === '-' && this.peek(1) === '}') {
-                this.advance()
-                this.advance()
-                break
-            }
-            this.advance()
-        }
-    }
-
-    readIndent() {
-        let indent = 0
-        while (this.peek() === ' ') {
-            indent++
-            this.advance()
-        }
-        while (this.peek() === '\t') {
-            indent += 4
-            this.advance()
-        }
-        return indent
-    }
-
-    readString(quote) {
-        let value = ''
-        this.advance()
-        while (this.pos < this.source.length) {
-            const char = this.peek()
-            if (char === quote) {
-                this.advance()
-                break
-            }
-            if (char === '\\') {
-                this.advance()
-                value += this.advance()
-            } else {
-                value += this.advance()
-            }
-        }
-        return value
-    }
-
-    readNumber() {
-        let value = ''
-        if (this.peek() === '-' || this.peek() === '+') {
-            value += this.advance()
-        }
-        while (/[0-9]/.test(this.peek())) {
-            value += this.advance()
-        }
-        if (this.peek() === '.') {
-            value += this.advance()
-            while (/[0-9]/.test(this.peek())) {
-                value += this.advance()
-            }
-        }
-        if (this.peek() === 'e' || this.peek() === 'E') {
-            value += this.advance()
-            if (this.peek() === '-' || this.peek() === '+') {
-                value += this.advance()
-            }
-            while (/[0-9]/.test(this.peek())) {
-                value += this.advance()
-            }
-        }
-        return parseFloat(value)
-    }
-
-    readIdentifier() {
-        let value = ''
-        while (this.pos < this.source.length) {
-            const char = this.peek()
-            if (/[a-zA-ZÀ-ÿА-яぁ-ゟァ-ヿ一-龯0-9_-]/.test(char)) {
-                value += this.advance()
-            } else {
-                break
-            }
-        }
-        return value
-    }
-
-    readWord() {
-        let words = []
-        let currentWord = ''
-        const startPos = this.pos
-        
-        while (this.pos < this.source.length) {
-            const char = this.peek()
-            if (/[a-zA-ZÀ-ÿА-яぁ-ゟァ-ヿ一-龯0-9_-]/.test(char)) {
-                currentWord += this.advance()
-            } else if (char === ' ' && currentWord) {
-                const nextChar = this.source[this.pos + 1]
-                if (nextChar && /[a-zA-ZÀ-ÿА-яぁ-ゟァ-ヿ一-龯]/.test(nextChar)) {
-                    const testWord = currentWord + ' ' + this.peekWord(this.pos + 1)
-                    if (this.isMultiWordKeyword(testWord)) {
-                        words.push(currentWord)
-                        currentWord = ''
-                        this.advance()
-                    } else {
-                        break
-                    }
-                } else {
-                    break
-                }
-            } else {
-                break
-            }
-        }
-        
-        if (currentWord) {
-            words.push(currentWord)
-        }
-        
-        return words.join(' ')
-    }
-
-    peekWord(startPos) {
-        let word = ''
-        let pos = startPos
-        while (pos < this.source.length) {
-            const char = this.source[pos]
-            if (/[a-zA-ZÀ-ÿА-яぁ-ゟァ-ヿ一-龯0-9_-]/.test(char)) {
-                word += char
-                pos++
-            } else {
-                break
-            }
-        }
-        return word
-    }
-
-    isMultiWordKeyword(text) {
-        const multiWordPatterns = [
-            'marge autour', 'marge dedans', 'margin top', 'margin bottom',
-            'margen alrededor', 'margen adentro', 'внешний отступ', 'внутренний отступ',
-            '外边距', '内边距', '外側余白', '内側余白',
-            'tres clair', 'très clair', 'tres fonce', 'très foncé', 'tres grand', 'très grand', 'tres petit', 'très petit',
-            'very light', 'very dark', 'very large', 'very small',
-            'muy claro', 'muy oscuro', 'muy grande', 'muy pequeño',
-            'очень светлый', 'очень темный', 'очень большой', 'очень маленький',
-            '非常浅', '非常深', '非常大', '非常小',
-            'とても明るい', 'とても暗い', 'とても大きい', 'とても小さい',
-            'bleu clair', 'vert fonce', 'vert foncé', 'rouge vif',
-            'light blue', 'dark green', 'bright red',
-            'azul claro', 'verde oscuro', 'rojo vivo',
-            'голубой', 'темно-зеленый', 'ярко-красный',
-            '浅蓝', '深绿', '亮红',
-            '水色', '深緑', '鮮やかな赤',
-            'police generique', 'police générique', 'border radius', 'box shadow',
-            'generic font', 'fuente generica', 'fuente genérica',
-            'общий шрифт', '通用字体', '汎用フォント',
-            'text align', 'font size', 'font weight', 'line height',
-            'letter spacing', 'word spacing', 'text decoration',
-            'text transform', 'white space', 'overflow wrap',
-            'au survol', 'au clic', 'au focus', 'en survol',
-            'on hover', 'on click', 'on focus',
-            'al pasar', 'al clicar', 'al enfocar',
-            'при наведении', 'при клике', 'при фокусе',
-            '悬停时', '点击时', '聚焦时',
-            'ホバー時', 'クリック時', 'フォーカス時',
-            'quand survole', 'quand survolé', 'quand clique', 'quand cliqué', 'quand focalise', 'quand focalisé',
-            'when hovered', 'when clicked', 'when focused',
-            'cuando pasado', 'cuando clicado', 'cuando enfocado',
-            'когда наведен', 'когда кликнут', 'когда сфокусирован',
-            '当悬停', '当点击', '当聚焦',
-            'ホバーされた時', 'クリックされた時', 'フォーカスされた時',
-            'plus grand que', 'plus petit que', 'egal a', 'égal à',
-            'greater than', 'less than', 'equal to',
-            'mayor que', 'menor que', 'igual a',
-            'больше чем', 'меньше чем', 'равно',
-            '大于', '小于', '等于',
-            'より大きい', 'より小さい', '等しい',
-            'au moins', 'au plus', 'tous les', 'safe area',
-            'at least', 'at most', 'all the',
-            'al menos', 'como maximo', 'como máximo', 'todos los',
-            'как минимум', 'как максимум', 'все',
-            '至少', '最多', '所有',
-            '少なくとも', '多くとも', 'すべての',
-            'largeur min', 'largeur max', 'hauteur min', 'hauteur max',
-            'min width', 'max width', 'min height', 'max height',
-            'ancho minimo', 'ancho mínimo', 'ancho maximo', 'ancho máximo',
-            'alto minimo', 'alto mínimo', 'alto maximo', 'alto máximo',
-            'мин ширина', 'макс ширина', 'мин высота', 'макс высота',
-            '最小宽度', '最大宽度', '最小高度', '最大高度',
-            '最小幅', '最大幅', '最小高さ', '最大高さ',
-            'ratio aspect', 'aspect ratio', 'relacion aspecto', 'relación aspecto',
-            'соотношение сторон', '宽高比', 'アスペクト比',
-            'degrade lineaire', 'dégradé linéaire', 'degrade radial', 'dégradé radial', 'degrade conique', 'dégradé conique',
-            'linear gradient', 'radial gradient', 'conic gradient',
-            'degradado lineal', 'degradado radial', 'degradado conico', 'degradado cónico',
-            'линейный градиент', 'радиальный градиент', 'конический градиент',
-            '线性渐变', '径向渐变', '锥形渐变',
-            '線形グラデーション', '放射グラデーション', '円錐グラデーション',
-            'melange couleur', 'mélange couleur', 'color mix',
-            'mezcla color', 'смешение цветов', '颜色混合', '色の混合',
-            'clair sombre', 'light dark', 'claro oscuro', 'светлый темный', '明暗', '明暗',
-            'ombre portee', 'ombre portée', 'drop shadow', 'sombra proyectada', 'тень', '投影', 'ドロップシャドウ',
-            'niveaux gris', 'grayscale', 'escala grises', 'оттенки серого', '灰度', 'グレースケール',
-            'teinte rotation', 'hue rotate', 'rotacion tono', 'rotación tono', 'вращение оттенка', '色相旋转', '色相回転',
-            'courbe bezier', 'courbe bézier', 'cubic bezier', 'curva bezier', 'curva bézier', 'кривая безье', '贝塞尔曲线', 'ベジェ曲線',
-            'fondu croise', 'fondu croisé', 'cross fade', 'fundido cruzado', 'перекрестное затухание', '交叉淡入淡出', 'クロスフェード',
-            'ensemble images', 'image set', 'conjunto imagenes', 'conjunto imágenes', 'набор изображений', '图像集', '画像セット',
-            'ajuster contenu', 'fit content', 'ajustar contenido', 'подогнать содержимое', '适应内容', 'コンテンツに合わせる'
-        ]
-        const lowerText = text.toLowerCase()
-        return multiWordPatterns.some(p => lowerText.startsWith(p.toLowerCase()))
-    }
-
-    tokenize() {
-        while (this.pos < this.source.length) {
-            const loc = { line: this.line, column: this.column }
-            
-            if (this.peek() === '\n') {
-                this.advance()
-                if (this.pos < this.source.length && this.peek() !== '\n') {
-                    const indent = this.readIndent()
-                    this.tokens.push({ type: 'NEWLINE', loc })
-                    this.tokens.push({ type: 'INDENT', value: indent, loc: { line: this.line, column: 1 } })
-                }
-                continue
-            }
-
-            this.skipWhitespace()
-            if (this.pos >= this.source.length) break
-
-            const char = this.peek()
-            const newLoc = { line: this.line, column: this.column }
-
-            if (char === '"' || char === "'") {
-                const value = this.readString(char)
-                this.tokens.push({ type: 'STRING', value, quote: char, loc: newLoc })
-            } else if (/[0-9]/.test(char) || (char === '-' && /[0-9]/.test(this.peek(1))) || (char === '.' && /[0-9]/.test(this.peek(1)))) {
-                const value = this.readNumber()
-                const unit = this.readUnit()
-                this.tokens.push({ type: 'NUMBER', value, unit, loc: newLoc })
-            } else if (char === '#') {
-                this.advance()
-                const hex = this.readIdentifier()
-                this.tokens.push({ type: 'HEX_COLOR', value: hex, loc: newLoc })
-            } else if (char === '.') {
-                this.advance()
-                const className = this.readIdentifier()
-                this.tokens.push({ type: 'CLASS_SELECTOR', value: className, loc: newLoc })
-            } else if (char === '@') {
-                this.advance()
-                const atKeyword = this.readWord()
-                this.tokens.push({ type: 'AT_KEYWORD', value: atKeyword, loc: newLoc })
-            } else if (char === ':') {
-                this.advance()
-                if (this.peek() === ':') {
-                    this.advance()
-                    const pseudoElement = this.readIdentifier()
-                    this.tokens.push({ type: 'PSEUDO_ELEMENT', value: pseudoElement, loc: newLoc })
-                } else if (/[a-zA-Z]/.test(this.peek())) {
-                    const pseudoClass = this.readIdentifier()
-                    this.tokens.push({ type: 'PSEUDO_CLASS', value: pseudoClass, loc: newLoc })
-                } else {
-                    this.tokens.push({ type: 'COLON', loc: newLoc })
-                }
-            } else if (char === '=') {
-                this.advance()
-                this.tokens.push({ type: 'EQUALS', loc: newLoc })
-            } else if (char === ',') {
-                this.advance()
-                this.tokens.push({ type: 'COMMA', loc: newLoc })
-            } else if (char === '(') {
-                this.advance()
-                this.tokens.push({ type: 'LPAREN', loc: newLoc })
-            } else if (char === ')') {
-                this.advance()
-                this.tokens.push({ type: 'RPAREN', loc: newLoc })
-            } else if (char === '[') {
-                this.advance()
-                this.tokens.push({ type: 'LBRACKET', loc: newLoc })
-            } else if (char === ']') {
-                this.advance()
-                this.tokens.push({ type: 'RBRACKET', loc: newLoc })
-            } else if (char === '{') {
-                this.advance()
-                this.tokens.push({ type: 'LBRACE', loc: newLoc })
-            } else if (char === '}') {
-                this.advance()
-                this.tokens.push({ type: 'RBRACE', loc: newLoc })
-            } else if (char === '>') {
-                this.advance()
-                if (this.peek() === '=') {
-                    this.advance()
-                    this.tokens.push({ type: 'GTE', loc: newLoc })
-                } else {
-                    this.tokens.push({ type: 'CHILD_COMBINATOR', loc: newLoc })
-                }
-            } else if (char === '<') {
-                this.advance()
-                if (this.peek() === '=') {
-                    this.advance()
-                    this.tokens.push({ type: 'LTE', loc: newLoc })
-                } else {
-                    this.tokens.push({ type: 'LT', loc: newLoc })
-                }
-            } else if (char === '+') {
-                this.advance()
-                this.tokens.push({ type: 'ADJACENT_COMBINATOR', loc: newLoc })
-            } else if (char === '~') {
-                this.advance()
-                this.tokens.push({ type: 'SIBLING_COMBINATOR', loc: newLoc })
-            } else if (char === '*') {
-                this.advance()
-                this.tokens.push({ type: 'UNIVERSAL_SELECTOR', loc: newLoc })
-            } else if (char === '|') {
-                this.advance()
-                if (this.peek() === '|') {
-                    this.advance()
-                    this.tokens.push({ type: 'COLUMN_COMBINATOR', loc: newLoc })
-                } else {
-                    this.tokens.push({ type: 'NAMESPACE', loc: newLoc })
-                }
-            } else if (char === '!') {
-                this.advance()
-                const word = this.readIdentifier()
-                if (word.toLowerCase() === 'important') {
-                    this.tokens.push({ type: 'IMPORTANT', loc: newLoc })
-                }
-            } else if (char === '/') {
-                this.advance()
-                this.tokens.push({ type: 'SLASH', loc: newLoc })
-            } else if (char === '%') {
-                this.advance()
-                this.tokens.push({ type: 'PERCENT', loc: newLoc })
-            } else if (/[a-zA-ZÀ-ÿА-яぁ-ゟァ-ヿ一-龯_]/.test(char)) {
-                const word = this.readWord()
-                const tokenType = this.classifyWord(word)
-                this.tokens.push({ type: tokenType, value: word, loc: newLoc })
-            } else {
-                this.advance()
-            }
-        }
-
-        this.tokens.push({ type: 'EOF', loc: { line: this.line, column: this.column } })
-        return this.tokens
-    }
-
-    readUnit() {
-        const units = [
-            'px', 'em', 'rem', '%', 'vh', 'vw', 'vmin', 'vmax',
-            'cm', 'mm', 'in', 'pt', 'pc', 'ch', 'ex',
-            'deg', 'rad', 'grad', 'turn',
-            's', 'ms', 'fr', 'dpi', 'dpcm', 'dppx',
-            'cqw', 'cqh', 'cqi', 'cqb', 'cqmin', 'cqmax',
-            'svw', 'svh', 'lvw', 'lvh', 'dvw', 'dvh'
-        ]
-        
-        for (const unit of units) {
-            if (this.source.substring(this.pos, this.pos + unit.length).toLowerCase() === unit) {
-                for (let i = 0; i < unit.length; i++) {
-                    this.advance()
-                }
-                return unit
-            }
-        }
-        return null
-    }
-
-    classifyWord(word) {
-        const lowerWord = word.toLowerCase()
-        
-        if (this.isEtherKeyword(lowerWord)) return 'ETHER_KEYWORD'
-        if (this.isProperty(lowerWord)) return 'PROPERTY'
-        if (this.isColorName(lowerWord)) return 'COLOR_NAME'
-        if (this.isFunction(lowerWord)) return 'FUNCTION'
-        if (this.isValue(lowerWord)) return 'VALUE_KEYWORD'
-        
-        return 'IDENTIFIER'
-    }
-
-    isEtherKeyword(word) {
-        const keywords = [
-            'si', 'if', 'sinon', 'else', 'au survol', 'hover',
-            'au clic', 'active', 'au focus', 'focus',
-            'quand survole', 'quand survolé', 'quand clique', 'quand cliqué', 'quand focalise', 'quand focalisé',
-            'tous les', 'all', 'chaque', 'each', 'premier', 'first',
-            'dernier', 'last', 'impairs', 'odd', 'pairs', 'even',
-            'et', 'and', 'ou', 'or', 'pas', 'not',
-            'centre', 'centré', 'centered', 'invisible', 'cache', 'caché', 'hidden',
-            'cliquable', 'clickable', 'selectionnable', 'sélectionnable', 'selectable',
-            'cuando', 'si', 'sino', 'al pasar', 'al clicar', 'al enfocar',
-            'cuando pasado', 'cuando clicado', 'cuando enfocado',
-            'todos', 'cada', 'primero', 'ultimo', 'último', 'impares', 'pares',
-            'y', 'o', 'no', 'centrado', 'oculto', 'seleccionable',
-            'если', 'иначе', 'при наведении', 'при клике', 'при фокусе',
-            'когда наведен', 'когда кликнут', 'когда сфокусирован',
-            'все', 'каждый', 'первый', 'последний', 'нечетные', 'четные',
-            'и', 'или', 'не', 'центрированный', 'скрытый', 'выбираемый',
-            '如果', '否则', '悬停时', '点击时', '聚焦时',
-            '当悬停', '当点击', '当聚焦',
-            '所有', '每个', '第一个', '最后一个', '奇数', '偶数',
-            '和', '或', '非', '居中', '隐藏', '可选择',
-            'もし', 'そうでなければ', 'ホバー時', 'クリック時', 'フォーカス時',
-            'ホバーされた時', 'クリックされた時', 'フォーカスされた時',
-            'すべて', '各', '最初', '最後', '奇数', '偶数',
-            'かつ', 'または', 'ではない', '中央', '非表示', '選択可能'
-        ]
-        return keywords.includes(word.toLowerCase())
-    }
-
-    isProperty(word) {
-        for (const category of Object.values(this.i18n)) {
-            if (typeof category === 'object' && category !== null) {
-                for (const item of Object.values(category)) {
-                    if (typeof item === 'object' && item !== null) {
-                        for (const translation of Object.values(item)) {
-                            if (typeof translation === 'string' && translation.toLowerCase() === word.toLowerCase()) {
-                                return true
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        return false
-    }
-
-    isColorName(word) {
-        const colors = this.i18n.colors || {}
-        for (const color of Object.values(colors)) {
-            if (typeof color === 'object') {
-                for (const translation of Object.values(color)) {
-                    if (typeof translation === 'string' && translation.toLowerCase() === word.toLowerCase()) {
-                        return true
-                    }
-                }
-            }
-        }
-        return false
-    }
-
-    isFunction(word) {
-        const functions = [
-            'rgb', 'rgba', 'hsl', 'hsla', 'hwb', 'lab', 'lch', 'oklab', 'oklch',
-            'url', 'calc', 'min', 'max', 'clamp', 'var',
-            'linear-gradient', 'radial-gradient', 'conic-gradient',
-            'repeat', 'minmax', 'fit-content',
-            'translate', 'translateX', 'translateY', 'translateZ',
-            'rotate', 'rotateX', 'rotateY', 'rotateZ', 'rotate3d',
-            'scale', 'scaleX', 'scaleY', 'scaleZ', 'scale3d',
-            'skew', 'skewX', 'skewY', 'matrix', 'matrix3d', 'perspective',
-            'blur', 'brightness', 'contrast', 'drop-shadow', 'grayscale',
-            'hue-rotate', 'invert', 'opacity', 'saturate', 'sepia',
-            'circle', 'ellipse', 'polygon', 'path', 'inset',
-            'cubic-bezier', 'steps', 'linear', 'ease', 'ease-in', 'ease-out', 'ease-in-out',
-            'attr', 'counter', 'counters', 'env', 'image-set', 'cross-fade',
-            'color-mix', 'light-dark'
-        ]
-        return functions.includes(word.toLowerCase())
-    }
-
-    isValue(word) {
-        const values = [
-            'auto', 'none', 'inherit', 'initial', 'unset', 'revert', 'revert-layer',
-            'block', 'inline', 'flex', 'grid', 'contents', 'flow-root',
-            'absolute', 'relative', 'fixed', 'sticky', 'static',
-            'visible', 'hidden', 'scroll', 'clip',
-            'solid', 'dashed', 'dotted', 'double', 'groove', 'ridge', 'inset', 'outset',
-            'normal', 'bold', 'bolder', 'lighter',
-            'italic', 'oblique',
-            'left', 'right', 'center', 'justify', 'start', 'end',
-            'top', 'bottom', 'middle', 'baseline',
-            'wrap', 'nowrap', 'pre', 'pre-wrap', 'pre-line', 'break-spaces',
-            'pointer', 'default', 'text', 'wait', 'help', 'not-allowed', 'grab', 'grabbing',
-            'cover', 'contain', 'fill', 'fit', 'scale-down',
-            'repeat', 'no-repeat', 'repeat-x', 'repeat-y', 'space', 'round',
-            'row', 'column', 'row-reverse', 'column-reverse',
-            'stretch', 'flex-start', 'flex-end', 'space-between', 'space-around', 'space-evenly',
-            'uppercase', 'lowercase', 'capitalize',
-            'underline', 'overline', 'line-through', 'wavy',
-            'forwards', 'backwards', 'both', 'alternate', 'alternate-reverse',
-            'running', 'paused', 'infinite'
-        ]
-        return values.includes(word.toLowerCase())
-    }
-}
-
-class CSSParser {
-    constructor(i18nPath = null) {
-        this.i18n = {}
-        this.tokens = []
-        this.pos = 0
-        this.currentIndent = 0
-        
-        if (i18nPath) {
-            this.loadI18n(i18nPath)
-        }
-    }
-
-    loadI18n(filePath) {
-        try {
-            const content = fs.readFileSync(filePath, 'utf-8')
-            this.i18n = JSON.parse(content)
-        } catch (e) {
-            console.error(`Erreur chargement i18n: ${e.message}`)
-            this.i18n = {}
-        }
-    }
-
-    setI18n(i18nData) {
-        this.i18n = i18nData
-    }
-
-    parse(source) {
-        const lexer = new CSSLexer(source, this.i18n)
-        this.tokens = lexer.tokenize()
-        this.pos = 0
-        return this.parseStyleSheet()
-    }
-
-    peek(offset = 0) {
-        const idx = this.pos + offset
-        return idx < this.tokens.length ? this.tokens[idx] : { type: 'EOF' }
-    }
-
-    advance() {
-        const token = this.tokens[this.pos]
-        this.pos++
-        return token
-    }
-
-    expect(type) {
-        const token = this.peek()
-        if (token.type !== type) {
-            throw new Error(`Attendu ${type}, reçu ${token.type} à ligne ${token.loc?.line}`)
-        }
-        return this.advance()
-    }
-
-    match(...types) {
-        return types.includes(this.peek().type)
-    }
-
-    skipNewlines() {
-        while (this.match('NEWLINE', 'INDENT')) {
-            if (this.match('INDENT')) {
-                this.currentIndent = this.peek().value
-            }
-            this.advance()
-        }
-    }
-
-    parseStyleSheet() {
-        const rules = []
-        
-        this.skipNewlines()
-        
-        while (!this.match('EOF')) {
-            const rule = this.parseRule()
-            if (rule) {
-                rules.push(rule)
-            }
-            this.skipNewlines()
-        }
-        
-        return new AST.StyleSheet(rules)
-    }
-
-    parseRule() {
-        const token = this.peek()
-        
-        if (token.type === 'AT_KEYWORD') {
-            return this.parseAtRule()
-        }
-        
-        if (token.type === 'ETHER_KEYWORD') {
-            return this.parseEtherConstruct()
-        }
-        
-        return this.parseStyleRule()
-    }
-
-    parseAtRule() {
-        const atToken = this.advance()
-        const name = atToken.value.toLowerCase()
-        
-        switch (name) {
-            case 'si':
-            case 'if':
-            case 'media':
-                return this.parseMediaQuery(atToken.loc)
-            case 'keyframes':
-            case 'animation':
-                return this.parseKeyframes(atToken.loc)
-            case 'font-face':
-            case 'police':
-                return this.parseFontFace(atToken.loc)
-            case 'import':
-            case 'importer':
-                return this.parseImport(atToken.loc)
-            case 'supports':
-            case 'supporte':
-                return this.parseSupports(atToken.loc)
-            case 'layer':
-            case 'couche':
-                return this.parseLayer(atToken.loc)
-            case 'container':
-            case 'conteneur':
-                return this.parseContainer(atToken.loc)
-            case 'scope':
-            case 'portée':
-                return this.parseScope(atToken.loc)
-            case 'page':
-                return this.parsePage(atToken.loc)
-            case 'property':
-            case 'propriété':
-                return this.parsePropertyRule(atToken.loc)
-            case 'counter-style':
-            case 'style compteur':
-                return this.parseCounterStyle(atToken.loc)
-            case 'starting-style':
-            case 'style initial':
-                return this.parseStartingStyle(atToken.loc)
-            default:
-                return this.parseGenericAtRule(name, atToken.loc)
-        }
-    }
-
-    parseMediaQuery(loc) {
-        const conditions = []
-        let mediaType = null
-        
-        this.skipNewlines()
-        
-        while (!this.match('NEWLINE', 'EOF', 'LBRACE')) {
-            const token = this.peek()
-            
-            if (token.type === 'IDENTIFIER' || token.type === 'ETHER_KEYWORD') {
-                const word = this.advance().value.toLowerCase()
-                if (['screen', 'print', 'all', 'écran', 'impression', 'tout'].includes(word)) {
-                    mediaType = this.translateMediaType(word)
-                } else if (['and', 'et', 'or', 'ou', 'not', 'pas', 'only', 'seulement'].includes(word)) {
-                    conditions.push({ type: 'operator', value: word })
-                } else {
-                    conditions.push(this.parseMediaFeature(word))
-                }
-            } else if (token.type === 'LPAREN') {
-                this.advance()
-                const feature = this.parseMediaFeature()
-                this.expect('RPAREN')
-                conditions.push(feature)
-            } else if (token.type === 'NUMBER') {
-                const num = this.advance()
-                conditions.push({ type: 'value', value: num.value, unit: num.unit })
-            } else if (token.type === 'GT' || token.type === 'LT' || token.type === 'GTE' || token.type === 'LTE') {
-                conditions.push({ type: 'operator', value: this.advance().type })
-            } else {
-                this.advance()
-            }
-        }
-        
-        const rules = this.parseBlock()
-        
-        return new AST.MediaQuery(mediaType, conditions, rules, loc)
-    }
-
-    parseMediaFeature(name = null) {
-        if (!name && this.match('IDENTIFIER', 'PROPERTY')) {
-            name = this.advance().value
-        }
-        
-        let value = null
-        let operator = null
-        
-        if (this.match('COLON')) {
-            this.advance()
-            value = this.parseValue()
-        } else if (this.match('GTE', 'LTE', 'GT', 'LT')) {
-            operator = this.advance().type
-            value = this.parseValue()
-        }
-        
-        const cssFeature = this.translateMediaFeature(name)
-        
-        return new AST.MediaCondition(cssFeature, value, operator)
-    }
-
-    translateMediaType(type) {
-        const map = {
-            'ecran': 'screen', 'écran': 'screen', 'screen': 'screen', 'pantalla': 'screen', 'экран': 'screen', '屏幕': 'screen', '画面': 'screen',
-            'impression': 'print', 'print': 'print', 'impresion': 'print', 'impresión': 'print', 'печать': 'print', '打印': 'print', '印刷': 'print',
-            'tout': 'all', 'all': 'all', 'todo': 'all', 'все': 'all', '全部': 'all', 'すべて': 'all'
-        }
-        return map[type.toLowerCase()] || type
-    }
-
-    translateMediaFeature(feature) {
-        const map = {
-            'largeur': 'width', 'width': 'width', 'ancho': 'width', 'ширина': 'width', '宽度': 'width', '幅': 'width',
-            'hauteur': 'height', 'height': 'height', 'alto': 'height', 'altura': 'height', 'высота': 'height', '高度': 'height', '高さ': 'height',
-            'largeur min': 'min-width', 'min-width': 'min-width', 'ancho minimo': 'min-width', 'ancho mínimo': 'min-width', 'мин ширина': 'min-width', '最小宽度': 'min-width', '最小幅': 'min-width',
-            'largeur max': 'max-width', 'max-width': 'max-width', 'ancho maximo': 'max-width', 'ancho máximo': 'max-width', 'макс ширина': 'max-width', '最大宽度': 'max-width', '最大幅': 'max-width',
-            'hauteur min': 'min-height', 'min-height': 'min-height', 'alto minimo': 'min-height', 'alto mínimo': 'min-height', 'мин высота': 'min-height', '最小高度': 'min-height', '最小高さ': 'min-height',
-            'hauteur max': 'max-height', 'max-height': 'max-height', 'alto maximo': 'max-height', 'alto máximo': 'max-height', 'макс высота': 'max-height', '最大高度': 'max-height', '最大高さ': 'max-height',
-            'orientation': 'orientation', 'orientacion': 'orientation', 'orientación': 'orientation', 'ориентация': 'orientation', '方向': 'orientation', '向き': 'orientation',
-            'paysage': 'landscape', 'landscape': 'landscape', 'paisaje': 'landscape', 'альбомная': 'landscape', '横向': 'landscape', '横': 'landscape',
-            'portrait': 'portrait', 'retrato': 'portrait', 'книжная': 'portrait', '纵向': 'portrait', '縦': 'portrait',
-            'resolution': 'resolution', 'résolution': 'resolution', 'resolución': 'resolution', 'resolucion': 'resolution', 'разрешение': 'resolution', '分辨率': 'resolution', '解像度': 'resolution',
-            'couleur': 'color', 'color': 'color', 'цвет': 'color', '颜色': 'color', '色': 'color',
-            'ratio aspect': 'aspect-ratio', 'aspect-ratio': 'aspect-ratio', 'relacion aspecto': 'aspect-ratio', 'relación aspecto': 'aspect-ratio', 'соотношение сторон': 'aspect-ratio', '宽高比': 'aspect-ratio', 'アスペクト比': 'aspect-ratio',
-            'preference couleur': 'prefers-color-scheme', 'préférence couleur': 'prefers-color-scheme', 'prefers-color-scheme': 'prefers-color-scheme', 'preferencia color': 'prefers-color-scheme', 'предпочтение цвета': 'prefers-color-scheme', '颜色偏好': 'prefers-color-scheme', '色設定': 'prefers-color-scheme',
-            'mouvement reduit': 'prefers-reduced-motion', 'mouvement réduit': 'prefers-reduced-motion', 'prefers-reduced-motion': 'prefers-reduced-motion', 'movimiento reducido': 'prefers-reduced-motion', 'уменьшенное движение': 'prefers-reduced-motion', '减少动画': 'prefers-reduced-motion', '動作軽減': 'prefers-reduced-motion',
-            'contraste eleve': 'prefers-contrast', 'contraste élevé': 'prefers-contrast', 'prefers-contrast': 'prefers-contrast', 'contraste alto': 'prefers-contrast', 'высокий контраст': 'prefers-contrast', '高对比度': 'prefers-contrast', 'ハイコントラスト': 'prefers-contrast'
-        }
-        return map[feature?.toLowerCase()] || feature
-    }
-
-    parseKeyframes(loc) {
-        this.skipNewlines()
-        let name = ''
-        if (this.match('IDENTIFIER', 'STRING')) {
-            name = this.advance().value
-        }
-        
-        const keyframes = []
-        this.skipNewlines()
-        
-        if (this.match('LBRACE')) {
-            this.advance()
-            this.skipNewlines()
-            
-            while (!this.match('RBRACE', 'EOF')) {
-                const keyframe = this.parseKeyframe()
-                if (keyframe) keyframes.push(keyframe)
-                this.skipNewlines()
-            }
-            
-            if (this.match('RBRACE')) this.advance()
-        } else {
-            const baseIndent = this.currentIndent
-            while (!this.match('EOF')) {
-                this.skipNewlines()
-                if (this.currentIndent <= baseIndent && !this.match('NUMBER', 'IDENTIFIER')) {
-                    break
-                }
-                const keyframe = this.parseKeyframe()
-                if (keyframe) keyframes.push(keyframe)
-            }
-        }
-        
-        return new AST.KeyframesRule(name, keyframes, loc)
-    }
-
-    parseKeyframe() {
-        let selector = null
-        
-        if (this.match('NUMBER')) {
-            const num = this.advance()
-            selector = num.value + (num.unit || '%')
-        } else if (this.match('IDENTIFIER')) {
-            const word = this.advance().value.toLowerCase()
-            if (['from', 'début', 'inicio', 'начало', '开始', '開始'].includes(word)) {
-                selector = 'from'
-            } else if (['to', 'fin', 'final', 'конец', '结束', '終了'].includes(word)) {
-                selector = 'to'
-            } else {
-                selector = word
-            }
-        }
-        
-        const declarations = this.parseDeclarations()
-        
-        return new AST.Keyframe(selector, declarations)
-    }
-
-    parseFontFace(loc) {
-        const declarations = this.parseDeclarations()
-        return new AST.FontFaceRule(declarations, loc)
-    }
-
-    parseImport(loc) {
-        this.skipNewlines()
-        let url = ''
-        
-        if (this.match('STRING')) {
-            url = this.advance().value
-        } else if (this.match('FUNCTION') && this.peek().value.toLowerCase() === 'url') {
-            this.advance()
-            if (this.match('LPAREN')) {
-                this.advance()
-                if (this.match('STRING')) {
-                    url = this.advance().value
-                }
-                this.expect('RPAREN')
-            }
-        }
-        
-        let mediaQueries = null
-        let layer = null
-        let supports = null
-        
-        while (!this.match('NEWLINE', 'EOF')) {
-            const token = this.peek()
-            if (token.type === 'IDENTIFIER') {
-                const word = token.value.toLowerCase()
-                if (['layer', 'couche'].includes(word)) {
-                    this.advance()
-                    if (this.match('LPAREN')) {
-                        this.advance()
-                        layer = this.match('IDENTIFIER') ? this.advance().value : null
-                        this.expect('RPAREN')
-                    } else {
-                        layer = true
-                    }
-                } else if (['supports', 'supporte'].includes(word)) {
-                    this.advance()
-                    if (this.match('LPAREN')) {
-                        this.advance()
-                        supports = this.parseSupportsCondition()
-                        this.expect('RPAREN')
-                    }
-                } else {
-                    break
-                }
-            } else {
-                break
-            }
-        }
-        
-        return new AST.ImportRule(url, mediaQueries, layer, supports, loc)
-    }
-
-    parseSupports(loc) {
-        const condition = this.parseSupportsCondition()
-        const rules = this.parseBlock()
-        return new AST.SupportsRule(condition, rules, loc)
-    }
-
-    parseSupportsCondition() {
-        const conditions = []
-        
-        while (!this.match('NEWLINE', 'EOF', 'LBRACE', 'RPAREN')) {
-            if (this.match('LPAREN')) {
-                this.advance()
-                const property = this.match('PROPERTY', 'IDENTIFIER') ? this.advance().value : null
-                let value = null
-                if (this.match('COLON')) {
-                    this.advance()
-                    value = this.parseValue()
-                }
-                this.expect('RPAREN')
-                conditions.push({ property, value })
-            } else if (this.match('IDENTIFIER', 'ETHER_KEYWORD')) {
-                const word = this.advance().value.toLowerCase()
-                if (['and', 'et', 'or', 'ou', 'not', 'pas'].includes(word)) {
-                    conditions.push({ operator: word })
-                }
-            } else {
-                this.advance()
-            }
-        }
-        
-        return conditions
-    }
-
-    parseLayer(loc) {
-        this.skipNewlines()
-        let name = null
-        
-        if (this.match('IDENTIFIER')) {
-            name = this.advance().value
-        }
-        
-        if (this.match('LBRACE') || (this.match('NEWLINE') && this.tokens[this.pos + 1]?.type === 'INDENT')) {
-            const rules = this.parseBlock()
-            return new AST.LayerRule(name, rules, loc)
-        }
-        
-        return new AST.LayerRule(name, null, loc)
-    }
-
-    parseContainer(loc) {
-        this.skipNewlines()
-        let name = null
-        const conditions = []
-        
-        if (this.match('IDENTIFIER')) {
-            const word = this.peek().value.toLowerCase()
-            if (!['size', 'inline-size', 'block-size', 'taille'].includes(word)) {
-                name = this.advance().value
-            }
-        }
-        
-        while (!this.match('NEWLINE', 'EOF', 'LBRACE')) {
-            if (this.match('LPAREN')) {
-                this.advance()
-                const feature = this.parseMediaFeature()
-                this.expect('RPAREN')
-                conditions.push(feature)
-            } else {
-                this.advance()
-            }
-        }
-        
-        const rules = this.parseBlock()
-        
-        return new AST.ContainerQuery(name, conditions, rules, loc)
-    }
-
-    parseScope(loc) {
-        let start = null
-        let end = null
-        
-        if (this.match('LPAREN')) {
-            this.advance()
-            start = this.parseSelector()
-            this.expect('RPAREN')
-        }
-        
-        if (this.match('IDENTIFIER') && this.peek().value.toLowerCase() === 'to') {
-            this.advance()
-            if (this.match('LPAREN')) {
-                this.advance()
-                end = this.parseSelector()
-                this.expect('RPAREN')
-            }
-        }
-        
-        const rules = this.parseBlock()
-        
-        return new AST.ScopeRule(start, end, rules, loc)
-    }
-
-    parsePage(loc) {
-        let selector = null
-        
-        if (this.match('COLON')) {
-            this.advance()
-            selector = this.match('IDENTIFIER') ? this.advance().value : null
-        }
-        
-        const declarations = this.parseDeclarations()
-        
-        return new AST.PageRule(selector, declarations, loc)
-    }
-
-    parsePropertyRule(loc) {
-        this.skipNewlines()
-        let name = ''
-        
-        if (this.match('IDENTIFIER')) {
-            name = '--' + this.advance().value
-        }
-        
-        const declarations = this.parseDeclarations()
-        
-        let syntax = '*'
-        let inherits = false
-        let initialValue = null
-        
-        for (const decl of declarations) {
-            if (decl.property.cssName === 'syntax') {
-                syntax = decl.value.value
-            } else if (decl.property.cssName === 'inherits') {
-                inherits = decl.value.value === 'true'
-            } else if (decl.property.cssName === 'initial-value') {
-                initialValue = decl.value
-            }
-        }
-        
-        return new AST.PropertyRule(name, syntax, inherits, initialValue, loc)
-    }
-
-    parseCounterStyle(loc) {
-        this.skipNewlines()
-        let name = ''
-        
-        if (this.match('IDENTIFIER')) {
-            name = this.advance().value
-        }
-        
-        const declarations = this.parseDeclarations()
-        
-        return new AST.CounterStyleRule(name, declarations, loc)
-    }
-
-    parseStartingStyle(loc) {
-        const rules = this.parseBlock()
-        return new AST.StartingStyleRule(rules, loc)
-    }
-
-    parseGenericAtRule(name, loc) {
-        while (!this.match('NEWLINE', 'EOF', 'LBRACE')) {
-            this.advance()
-        }
-        
-        if (this.match('LBRACE')) {
-            const rules = this.parseBlock()
-            return { type: 'AtRule', name, rules, loc }
-        }
-        
-        return { type: 'AtRule', name, loc }
-    }
-
-    parseEtherConstruct() {
-        const token = this.advance()
-        const keyword = token.value.toLowerCase()
-        
-        if (['au survol', 'hover', 'quand survolé', 'en survol'].includes(keyword)) {
-            return this.parseEtherState(':hover', token.loc)
-        }
-        if (['au clic', 'active', 'quand cliqué', 'en clic'].includes(keyword)) {
-            return this.parseEtherState(':active', token.loc)
-        }
-        if (['au focus', 'focus', 'quand focalisé', 'en focus'].includes(keyword)) {
-            return this.parseEtherState(':focus', token.loc)
-        }
-        if (['si', 'if'].includes(keyword)) {
-            return this.parseEtherCondition(token.loc)
-        }
-        if (['centré', 'centered'].includes(keyword)) {
-            return this.parseEtherAlias('centré', token.loc)
-        }
-        if (['invisible'].includes(keyword)) {
-            return this.parseEtherAlias('invisible', token.loc)
-        }
-        if (['caché', 'hidden'].includes(keyword)) {
-            return this.parseEtherAlias('caché', token.loc)
-        }
-        
-        return null
-    }
-
-    parseEtherState(cssState, loc) {
-        const declarations = this.parseDeclarations()
-        return new AST.EtherState(cssState, declarations, loc)
-    }
-
-    parseEtherCondition(loc) {
-        const condition = []
-        
-        while (!this.match('NEWLINE', 'EOF')) {
-            condition.push(this.advance())
-        }
-        
-        const rules = this.parseBlock()
-        let elseRules = null
-        
-        this.skipNewlines()
-        if (this.match('ETHER_KEYWORD')) {
-            const word = this.peek().value.toLowerCase()
-            if (['sinon', 'else'].includes(word)) {
-                this.advance()
-                elseRules = this.parseBlock()
-            }
-        }
-        
-        return new AST.EtherCondition(condition, rules, elseRules, loc)
-    }
-
-    parseEtherAlias(alias, loc) {
-        const aliasMap = {
-            'centré': [
-                new AST.Declaration(
-                    new AST.Property('alignement texte', 'text-align'),
-                    new AST.Value('centre', 'center')
-                ),
-                new AST.Declaration(
-                    new AST.Property('marge', 'margin'),
-                    new AST.Value('auto', 'auto')
-                )
-            ],
-            'invisible': [
-                new AST.Declaration(
-                    new AST.Property('affichage', 'display'),
-                    new AST.Value('aucun', 'none')
-                )
-            ],
-            'caché': [
-                new AST.Declaration(
-                    new AST.Property('visibilité', 'visibility'),
-                    new AST.Value('caché', 'hidden')
-                )
-            ]
-        }
-        
-        return new AST.EtherAlias(alias, aliasMap[alias] || [], loc)
-    }
-
-    parseStyleRule() {
-        const selectors = this.parseSelectorList()
-        const declarations = this.parseDeclarations()
-        const nestedRules = []
-        
-        return new AST.Rule(selectors, declarations, this.peek().loc)
-    }
-
-    parseSelectorList() {
-        const selectors = []
-        
-        selectors.push(this.parseSelector())
-        
-        while (this.match('COMMA')) {
-            this.advance()
-            this.skipNewlines()
-            selectors.push(this.parseSelector())
-        }
-        
-        return new AST.SelectorList(selectors)
-    }
-
-    parseSelector() {
-        let left = this.parseCompoundSelector()
-        
-        while (this.match('CHILD_COMBINATOR', 'ADJACENT_COMBINATOR', 'SIBLING_COMBINATOR', 'COLUMN_COMBINATOR')) {
-            const combinator = this.advance().type
-            const right = this.parseCompoundSelector()
-            left = new AST.ComplexSelector(left, this.getCombinatorSymbol(combinator), right)
-        }
-        
-        if (this.match('IDENTIFIER', 'CLASS_SELECTOR', 'UNIVERSAL_SELECTOR', 'LBRACKET', 'PSEUDO_CLASS', 'PSEUDO_ELEMENT')) {
-            const right = this.parseCompoundSelector()
-            left = new AST.ComplexSelector(left, ' ', right)
-        }
-        
-        return left
-    }
-
-    getCombinatorSymbol(type) {
-        const map = {
-            'CHILD_COMBINATOR': '>',
-            'ADJACENT_COMBINATOR': '+',
-            'SIBLING_COMBINATOR': '~',
-            'COLUMN_COMBINATOR': '||'
-        }
-        return map[type] || ' '
-    }
-
-    parseCompoundSelector() {
-        const selectors = []
-        
-        while (true) {
-            if (this.match('UNIVERSAL_SELECTOR')) {
-                this.advance()
-                selectors.push(new AST.SimpleSelector('universal', '*'))
-            } else if (this.match('IDENTIFIER')) {
-                const tag = this.advance().value
-                selectors.push(new AST.SimpleSelector('type', tag))
-            } else if (this.match('CLASS_SELECTOR')) {
-                const className = this.advance().value
-                selectors.push(new AST.SimpleSelector('class', className))
-            } else if (this.match('HEX_COLOR') && selectors.length === 0) {
-                const id = this.advance().value
-                selectors.push(new AST.SimpleSelector('id', id))
-            } else if (this.match('LBRACKET')) {
-                selectors.push(this.parseAttributeSelector())
-            } else if (this.match('PSEUDO_CLASS')) {
-                selectors.push(this.parsePseudoClassSelector())
-            } else if (this.match('PSEUDO_ELEMENT')) {
-                selectors.push(this.parsePseudoElementSelector())
-            } else {
-                break
-            }
-        }
-        
-        if (selectors.length === 0) {
-            return null
-        }
-        
-        if (selectors.length === 1) {
-            return selectors[0]
-        }
-        
-        return new AST.CompoundSelector(selectors)
-    }
-
-    parseAttributeSelector() {
-        this.expect('LBRACKET')
-        
-        const attribute = this.match('IDENTIFIER') ? this.advance().value : ''
-        let operator = null
-        let value = null
-        let flags = null
-        
-        if (this.match('EQUALS')) {
-            this.advance()
-            operator = '='
-        } else if (this.peek().type === 'IDENTIFIER') {
-            const op = this.peek().value
-            if (['~=', '|=', '^=', '$=', '*='].includes(op)) {
-                operator = this.advance().value
-            }
-        }
-        
-        if (operator && this.match('STRING', 'IDENTIFIER')) {
-            value = this.advance().value
-        }
-        
-        if (this.match('IDENTIFIER')) {
-            const flag = this.peek().value.toLowerCase()
-            if (['i', 's'].includes(flag)) {
-                flags = this.advance().value
-            }
-        }
-        
-        this.expect('RBRACKET')
-        
-        return new AST.AttributeSelector(attribute, operator, value, flags)
-    }
-
-    parsePseudoClassSelector() {
-        const name = this.advance().value
-        let argument = null
-        
-        if (this.match('LPAREN')) {
-            this.advance()
-            const args = []
-            while (!this.match('RPAREN', 'EOF')) {
-                args.push(this.advance())
-            }
-            argument = args.map(t => t.value).join('')
-            this.expect('RPAREN')
-        }
-        
-        return new AST.PseudoClassSelector(name, argument)
-    }
-
-    parsePseudoElementSelector() {
-        const name = this.advance().value
-        return new AST.PseudoElementSelector(name)
-    }
-
-    parseDeclarations() {
-        const declarations = []
-        
-        this.skipNewlines()
-        
-        if (this.match('LBRACE')) {
-            this.advance()
-            this.skipNewlines()
-            
-            while (!this.match('RBRACE', 'EOF')) {
-                const decl = this.parseDeclaration()
-                if (decl) declarations.push(decl)
-                this.skipNewlines()
-            }
-            
-            if (this.match('RBRACE')) this.advance()
-        } else {
-            const baseIndent = this.currentIndent
-            
-            while (!this.match('EOF')) {
-                this.skipNewlines()
-                
-                if (this.currentIndent <= baseIndent && declarations.length > 0) {
-                    break
-                }
-                
-                if (this.match('PROPERTY', 'IDENTIFIER')) {
-                    const decl = this.parseDeclaration()
-                    if (decl) declarations.push(decl)
-                } else {
-                    break
-                }
-            }
-        }
-        
-        return declarations
-    }
-
-    parseBlock() {
-        const rules = []
-        
-        this.skipNewlines()
-        
-        if (this.match('LBRACE')) {
-            this.advance()
-            this.skipNewlines()
-            
-            while (!this.match('RBRACE', 'EOF')) {
-                const rule = this.parseRule()
-                if (rule) rules.push(rule)
-                this.skipNewlines()
-            }
-            
-            if (this.match('RBRACE')) this.advance()
-        } else {
-            const baseIndent = this.currentIndent
-            
-            while (!this.match('EOF')) {
-                this.skipNewlines()
-                
-                if (this.currentIndent <= baseIndent && rules.length > 0) {
-                    break
-                }
-                
-                const rule = this.parseRule()
-                if (rule) {
-                    rules.push(rule)
-                } else {
-                    break
-                }
-            }
-        }
-        
-        return rules
-    }
-
-    parseDeclaration() {
-        const propToken = this.peek()
-        
-        if (!this.match('PROPERTY', 'IDENTIFIER')) {
-            return null
-        }
-        
-        const propertyName = this.advance().value
-        const cssProperty = this.translateProperty(propertyName)
-        
-        if (!this.match('EQUALS', 'COLON')) {
-            return null
-        }
-        this.advance()
-        
-        const value = this.parseValue()
-        
-        let important = false
-        if (this.match('IMPORTANT')) {
-            this.advance()
-            important = true
-        }
-        
-        return new AST.Declaration(
-            new AST.Property(propertyName, cssProperty, propToken.loc),
-            value,
-            important,
-            propToken.loc
-        )
-    }
-
-    translateProperty(name) {
-        const lowerName = name.toLowerCase()
-        
-        for (const category of Object.values(this.i18n)) {
-            if (typeof category === 'object' && category !== null) {
-                for (const [key, item] of Object.entries(category)) {
-                    if (typeof item === 'object' && item !== null && item.css) {
-                        for (const [lang, translation] of Object.entries(item)) {
-                            if (lang !== 'css' && typeof translation === 'string' && translation.toLowerCase() === lowerName) {
-                                return item.css
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        
-        const directMap = {
-            'couleur': 'color', 'color': 'color', 'цвет': 'color', '颜色': 'color', '色': 'color',
-            'fond': 'background', 'background': 'background', 'fondo': 'background', 'фон': 'background', '背景': 'background',
-            'largeur': 'width', 'width': 'width', 'ancho': 'width', 'ширина': 'width', '宽度': 'width', '幅': 'width',
-            'hauteur': 'height', 'height': 'height', 'alto': 'height', 'altura': 'height', 'высота': 'height', '高度': 'height', '高さ': 'height',
-            'marge autour': 'margin', 'margin': 'margin', 'margen': 'margin', 'внешний отступ': 'margin', '外边距': 'margin', '外側余白': 'margin',
-            'marge dedans': 'padding', 'padding': 'padding', 'relleno': 'padding', 'внутренний отступ': 'padding', '内边距': 'padding', '内側余白': 'padding',
-            'bordure': 'border', 'border': 'border', 'borde': 'border', 'граница': 'border', '边框': 'border', 'ボーダー': 'border',
-            'arrondi': 'border-radius', 'border-radius': 'border-radius', 'radio borde': 'border-radius', 'скругление': 'border-radius', '圆角': 'border-radius', '角丸': 'border-radius',
-            'ombre': 'box-shadow', 'box-shadow': 'box-shadow', 'sombra': 'box-shadow', 'тень': 'box-shadow', '阴影': 'box-shadow', '影': 'box-shadow',
-            'police': 'font-family', 'font-family': 'font-family', 'fuente': 'font-family', 'familia fuente': 'font-family', 'шрифт': 'font-family', '字体': 'font-family', 'フォント': 'font-family',
-            'taille': 'font-size', 'font-size': 'font-size', 'tamano': 'font-size', 'tamaño': 'font-size', 'размер шрифта': 'font-size', '字号': 'font-size', '文字サイズ': 'font-size',
-            'poids': 'font-weight', 'font-weight': 'font-weight', 'peso': 'font-weight', 'насыщенность': 'font-weight', '字重': 'font-weight', 'フォントウェイト': 'font-weight',
-            'style': 'font-style', 'font-style': 'font-style', 'estilo': 'font-style', 'estilo fuente': 'font-style', 'начертание': 'font-style', '字体样式': 'font-style', 'フォントスタイル': 'font-style',
-            'alignement': 'text-align', 'text-align': 'text-align', 'alineacion': 'text-align', 'alineación': 'text-align', 'выравнивание': 'text-align', '文本对齐': 'text-align', 'テキスト配置': 'text-align',
-            'affichage': 'display', 'display': 'display', 'mostrar': 'display', 'отображение': 'display', '显示': 'display', '表示': 'display',
-            'position': 'position', 'posicion': 'position', 'posición': 'position', 'позиция': 'position', '位置': 'position',
-            'haut': 'top', 'top': 'top', 'arriba': 'top', 'верх': 'top', '顶部': 'top', '上': 'top',
-            'bas': 'bottom', 'bottom': 'bottom', 'abajo': 'bottom', 'низ': 'bottom', '底部': 'bottom', '下': 'bottom',
-            'gauche': 'left', 'left': 'left', 'izquierda': 'left', 'лево': 'left', '左': 'left',
-            'droite': 'right', 'right': 'right', 'derecha': 'right', 'право': 'right', '右': 'right',
-            'opacite': 'opacity', 'opacité': 'opacity', 'opacity': 'opacity', 'opacidad': 'opacity', 'прозрачность': 'opacity', '不透明度': 'opacity', '透明度': 'opacity',
-            'transition': 'transition', 'transicion': 'transition', 'transición': 'transition', 'переход': 'transition', '过渡': 'transition', 'トランジション': 'transition',
-            'animation': 'animation', 'animacion': 'animation', 'animación': 'animation', 'анимация': 'animation', '动画': 'animation', 'アニメーション': 'animation',
-            'transformation': 'transform', 'transform': 'transform', 'transformacion': 'transform', 'transformación': 'transform', 'трансформация': 'transform', '变换': 'transform', '変形': 'transform',
-            'filtre': 'filter', 'filter': 'filter', 'filtro': 'filter', 'фильтр': 'filter', '滤镜': 'filter', 'フィルター': 'filter',
-            'grille': 'grid', 'grid': 'grid', 'rejilla': 'grid', 'cuadricula': 'grid', 'cuadrícula': 'grid', 'сетка': 'grid', '网格': 'grid', 'グリッド': 'grid',
-            'flex': 'flex', 'флекс': 'flex', '弹性': 'flex', 'フレックス': 'flex',
-            'curseur': 'cursor', 'cursor': 'cursor', 'курсор': 'cursor', '光标': 'cursor', 'カーソル': 'cursor',
-            'debordement': 'overflow', 'débordement': 'overflow', 'overflow': 'overflow', 'desbordamiento': 'overflow', 'переполнение': 'overflow', '溢出': 'overflow', 'オーバーフロー': 'overflow',
-            'visibilite': 'visibility', 'visibilité': 'visibility', 'visibility': 'visibility', 'visibilidad': 'visibility', 'видимость': 'visibility', '可见性': 'visibility', '表示状態': 'visibility',
-            'index z': 'z-index', 'z-index': 'z-index', 'indice z': 'z-index', 'índice z': 'z-index', 'индекс z': 'z-index', 'z索引': 'z-index', 'zインデックス': 'z-index',
-            'espacement lettres': 'letter-spacing', 'letter-spacing': 'letter-spacing', 'espaciado letras': 'letter-spacing', 'межбуквенный интервал': 'letter-spacing', '字母间距': 'letter-spacing', '文字間隔': 'letter-spacing',
-            'espacement mots': 'word-spacing', 'word-spacing': 'word-spacing', 'espaciado palabras': 'word-spacing', 'межсловный интервал': 'word-spacing', '单词间距': 'word-spacing', '単語間隔': 'word-spacing',
-            'hauteur ligne': 'line-height', 'line-height': 'line-height', 'altura linea': 'line-height', 'altura línea': 'line-height', 'высота строки': 'line-height', '行高': 'line-height', '行の高さ': 'line-height',
-            'decoration texte': 'text-decoration', 'décoration texte': 'text-decoration', 'text-decoration': 'text-decoration', 'decoracion texto': 'text-decoration', 'decoración texto': 'text-decoration', 'оформление текста': 'text-decoration', '文本装饰': 'text-decoration', 'テキスト装飾': 'text-decoration',
-            'transformation texte': 'text-transform', 'text-transform': 'text-transform', 'transformacion texto': 'text-transform', 'transformación texto': 'text-transform', 'преобразование текста': 'text-transform', '文本转换': 'text-transform', 'テキスト変換': 'text-transform',
-            'espace blanc': 'white-space', 'white-space': 'white-space', 'espacio blanco': 'white-space', 'пробелы': 'white-space', '空白处理': 'white-space', '空白': 'white-space',
-            'retour ligne': 'word-wrap', 'word-wrap': 'word-wrap', 'ajuste palabra': 'word-wrap', 'перенос слов': 'word-wrap', '单词换行': 'word-wrap', '単語折り返し': 'word-wrap',
-            'contenu': 'content', 'content': 'content', 'contenido': 'content', 'содержимое': 'content', '内容': 'content', 'コンテンツ': 'content',
-            'compteur': 'counter-reset', 'counter-reset': 'counter-reset', 'contador': 'counter-reset', 'счетчик': 'counter-reset', '计数器': 'counter-reset', 'カウンター': 'counter-reset',
-            'liste style': 'list-style', 'list-style': 'list-style', 'estilo lista': 'list-style', 'стиль списка': 'list-style', '列表样式': 'list-style', 'リストスタイル': 'list-style',
-            'tableau': 'table-layout', 'table-layout': 'table-layout', 'disposicion tabla': 'table-layout', 'disposición tabla': 'table-layout', 'макет таблицы': 'table-layout', '表格布局': 'table-layout', 'テーブルレイアウト': 'table-layout',
-            'bordure collapse': 'border-collapse', 'border-collapse': 'border-collapse', 'colapsar bordes': 'border-collapse', 'схлопывание границ': 'border-collapse', '边框折叠': 'border-collapse', 'ボーダー折りたたみ': 'border-collapse',
-            'outline': 'outline', 'contorno': 'outline', 'контур': 'outline', '轮廓': 'outline', 'アウトライン': 'outline',
-            'selection utilisateur': 'user-select', 'sélection utilisateur': 'user-select', 'user-select': 'user-select', 'seleccion usuario': 'user-select', 'selección usuario': 'user-select', 'выделение пользователем': 'user-select', '用户选择': 'user-select', 'ユーザー選択': 'user-select',
-            'evenements pointeur': 'pointer-events', 'événements pointeur': 'pointer-events', 'pointer-events': 'pointer-events', 'eventos puntero': 'pointer-events', 'события указателя': 'pointer-events', '指针事件': 'pointer-events', 'ポインターイベント': 'pointer-events',
-            'redimensionner': 'resize', 'resize': 'resize', 'redimensionar': 'resize', 'изменение размера': 'resize', '调整大小': 'resize', 'リサイズ': 'resize',
-            'apparence': 'appearance', 'appearance': 'appearance', 'apariencia': 'appearance', 'внешний вид': 'appearance', '外观': 'appearance', '外観': 'appearance',
-            'ajustement objet': 'object-fit', 'object-fit': 'object-fit', 'ajuste objeto': 'object-fit', 'подгонка объекта': 'object-fit', '对象适应': 'object-fit', 'オブジェクトフィット': 'object-fit',
-            'position objet': 'object-position', 'object-position': 'object-position', 'posicion objeto': 'object-position', 'posición objeto': 'object-position', 'позиция объекта': 'object-position', '对象位置': 'object-position', 'オブジェクト位置': 'object-position',
-            'accent couleur': 'accent-color', 'accent-color': 'accent-color', 'color acento': 'accent-color', 'цвет акцента': 'accent-color', '强调色': 'accent-color', 'アクセントカラー': 'accent-color',
-            'schema couleur': 'color-scheme', 'schéma couleur': 'color-scheme', 'color-scheme': 'color-scheme', 'esquema color': 'color-scheme', 'цветовая схема': 'color-scheme', '配色方案': 'color-scheme', 'カラースキーム': 'color-scheme',
-            'ratio aspect': 'aspect-ratio', 'aspect-ratio': 'aspect-ratio', 'relacion aspecto': 'aspect-ratio', 'relación aspecto': 'aspect-ratio', 'соотношение сторон': 'aspect-ratio', '宽高比': 'aspect-ratio', 'アスペクト比': 'aspect-ratio',
-            'ecart': 'gap', 'écart': 'gap', 'gap': 'gap', 'espacio': 'gap', 'brecha': 'gap', 'промежуток': 'gap', '间距': 'gap', 'ギャップ': 'gap',
-            'place contenu': 'place-content', 'place-content': 'place-content', 'colocar contenido': 'place-content', 'размещение содержимого': 'place-content', '放置内容': 'place-content', 'コンテンツ配置': 'place-content',
-            'place elements': 'place-items', 'place éléments': 'place-items', 'place-items': 'place-items', 'colocar elementos': 'place-items', 'размещение элементов': 'place-items', '放置项目': 'place-items', 'アイテム配置': 'place-items'
-        }
-        
-        return directMap[lowerName] || name
-    }
-
-    parseValue() {
-        const values = []
-        
-        while (!this.match('NEWLINE', 'EOF', 'IMPORTANT', 'RBRACE', 'RPAREN')) {
-            if (this.match('COMMA')) {
-                break
-            }
-            
-            const val = this.parseSingleValue()
-            if (val) {
-                values.push(val)
-            } else {
-                break
-            }
-        }
-        
-        if (values.length === 0) {
-            return new AST.Value('', '')
-        }
-        
-        if (values.length === 1) {
-            return values[0]
-        }
-        
-        return new AST.ValueList(values)
-    }
-
-    parseSingleValue() {
-        const token = this.peek()
-        
-        if (this.match('NUMBER')) {
-            const num = this.advance()
-            if (num.unit === '%') {
-                return new AST.PercentageValue(num.value, token.loc)
-            }
-            return new AST.NumberValue(num.value, num.unit, token.loc)
-        }
-        
-        if (this.match('HEX_COLOR')) {
-            const hex = this.advance().value
-            return new AST.ColorValue('hex', hex, '#' + hex, token.loc)
-        }
-        
-        if (this.match('COLOR_NAME')) {
-            const colorName = this.advance().value
-            const cssColor = this.translateColor(colorName)
-            return new AST.ColorValue('named', colorName, cssColor, token.loc)
-        }
-        
-        if (this.match('STRING')) {
-            const str = this.advance()
-            return new AST.StringValue(str.value, str.quote, token.loc)
-        }
-        
-        if (this.match('FUNCTION')) {
-            return this.parseFunctionCall()
-        }
-        
-        if (this.match('IDENTIFIER', 'VALUE_KEYWORD', 'PROPERTY')) {
-            const word = this.advance()
-            
-            if (this.match('COLON')) {
-                this.advance()
-                return this.parseFunctionWithColon(word.value, token.loc)
-            }
-            
-            const cssValue = this.translateValue(word.value)
-            return new AST.Identifier(word.value, cssValue, token.loc)
-        }
-        
-        if (this.match('SLASH')) {
-            this.advance()
-            return new AST.Identifier('/', '/', token.loc)
-        }
-        
-        if (this.match('COMMA')) {
-            this.advance()
-            return null
-        }
-        
-        return null
-    }
-
-    parseFunctionCall() {
-        const funcToken = this.advance()
-        const funcName = funcToken.value
-        const cssFuncName = this.translateFunction(funcName)
-        const args = []
-        
-        if (this.match('LPAREN')) {
-            this.advance()
-            
-            while (!this.match('RPAREN', 'EOF')) {
-                const arg = this.parseSingleValue()
-                if (arg) args.push(arg)
-                
-                if (this.match('COMMA')) {
-                    this.advance()
-                }
-            }
-            
-            this.expect('RPAREN')
-        } else if (this.match('COLON')) {
-            this.advance()
-            return this.parseFunctionWithColon(funcName, funcToken.loc)
-        }
-        
-        return new AST.FunctionCall(funcName, cssFuncName, args, funcToken.loc)
-    }
-
-    parseFunctionWithColon(funcName, loc) {
-        const args = []
-        
-        while (!this.match('NEWLINE', 'EOF', 'IMPORTANT', 'RBRACE')) {
-            if (this.match('COMMA')) {
-                this.advance()
-                continue
-            }
-            
-            const arg = this.parseSingleValue()
-            if (arg) {
-                args.push(arg)
-            } else {
-                break
-            }
-        }
-        
-        const cssFuncName = this.translateFunction(funcName)
-        return new AST.FunctionCall(funcName, cssFuncName, args, loc)
-    }
-
-    translateColor(colorName) {
-        const colors = this.i18n.colors || {}
-        const lowerName = colorName.toLowerCase()
-        
-        for (const [key, color] of Object.entries(colors)) {
-            if (typeof color === 'object') {
-                for (const [lang, translation] of Object.entries(color)) {
-                    if (typeof translation === 'string' && translation.toLowerCase() === lowerName) {
-                        return color.en || key
-                    }
-                }
-            }
-        }
-        
-        const shades = this.i18n.colorShades || {}
-        for (const [key, shade] of Object.entries(shades)) {
-            if (typeof shade === 'object') {
-                for (const translation of Object.values(shade)) {
-                    if (typeof translation === 'string' && lowerName.includes(translation.toLowerCase())) {
-                        return colorName
-                    }
-                }
-            }
-        }
-        
-        return colorName
-    }
-
-    translateValue(value) {
-        const lowerValue = value.toLowerCase()
-        
-        for (const category of Object.values(this.i18n)) {
-            if (typeof category === 'object' && category !== null) {
-                for (const item of Object.values(category)) {
-                    if (typeof item === 'object' && item !== null && item.css) {
-                        for (const [lang, translation] of Object.entries(item)) {
-                            if (lang !== 'css' && typeof translation === 'string' && translation.toLowerCase() === lowerValue) {
-                                return item.css
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        
-        return value
-    }
-
-    translateFunction(funcName) {
-        const map = {
-            'degrade lineaire': 'linear-gradient', 'dégradé linéaire': 'linear-gradient', 'linear-gradient': 'linear-gradient',
-            'degradado lineal': 'linear-gradient', 'линейный градиент': 'linear-gradient', '线性渐变': 'linear-gradient', '線形グラデーション': 'linear-gradient',
-            'degrade radial': 'radial-gradient', 'dégradé radial': 'radial-gradient', 'radial-gradient': 'radial-gradient',
-            'degradado radial': 'radial-gradient', 'радиальный градиент': 'radial-gradient', '径向渐变': 'radial-gradient', '放射グラデーション': 'radial-gradient',
-            'degrade conique': 'conic-gradient', 'dégradé conique': 'conic-gradient', 'conic-gradient': 'conic-gradient',
-            'degradado conico': 'conic-gradient', 'degradado cónico': 'conic-gradient', 'конический градиент': 'conic-gradient', '锥形渐变': 'conic-gradient', '円錐グラデーション': 'conic-gradient',
-            'repeter': 'repeat', 'répéter': 'repeat', 'repeat': 'repeat', 'repetir': 'repeat', 'повторить': 'repeat', '重复': 'repeat', '繰り返し': 'repeat',
-            'minmax': 'minmax', 'мин макс': 'minmax', '最小最大': 'minmax', '最小最大': 'minmax',
-            'ajuster contenu': 'fit-content', 'fit-content': 'fit-content', 'ajustar contenido': 'fit-content', 'подогнать содержимое': 'fit-content', '适应内容': 'fit-content', 'コンテンツに合わせる': 'fit-content',
-            'calculer': 'calc', 'calc': 'calc', 'calcular': 'calc', 'вычислить': 'calc', '计算': 'calc', '計算': 'calc',
-            'minimum': 'min', 'min': 'min', 'mínimo': 'min', 'minimo': 'min', 'минимум': 'min', '最小': 'min',
-            'maximum': 'max', 'max': 'max', 'máximo': 'max', 'maximo': 'max', 'максимум': 'max', '最大': 'max',
-            'borner': 'clamp', 'clamp': 'clamp', 'limitar': 'clamp', 'ограничить': 'clamp', '限制': 'clamp', 'クランプ': 'clamp',
-            'variable': 'var', 'var': 'var', 'переменная': 'var', '变量': 'var', '変数': 'var',
-            'url': 'url', 'enlace': 'url', 'ссылка': 'url', '链接': 'url', 'URL': 'url',
-            'rgb': 'rgb', 'rgba': 'rgba',
-            'hsl': 'hsl', 'hsla': 'hsla',
-            'hwb': 'hwb', 'lab': 'lab', 'lch': 'lch',
-            'oklab': 'oklab', 'oklch': 'oklch',
-            'melange couleur': 'color-mix', 'mélange couleur': 'color-mix', 'color-mix': 'color-mix',
-            'mezcla color': 'color-mix', 'смешение цветов': 'color-mix', '颜色混合': 'color-mix', '色の混合': 'color-mix',
-            'clair sombre': 'light-dark', 'light-dark': 'light-dark',
-            'claro oscuro': 'light-dark', 'светлый темный': 'light-dark', '明暗': 'light-dark',
-            'translation': 'translate', 'translate': 'translate', 'traduccion': 'translate', 'traducción': 'translate', 'перемещение': 'translate', '平移': 'translate', '移動': 'translate',
-            'translation x': 'translateX', 'translateX': 'translateX', 'traduccion x': 'translateX', 'перемещение x': 'translateX', 'x平移': 'translateX', 'x移動': 'translateX',
-            'translation y': 'translateY', 'translateY': 'translateY', 'traduccion y': 'translateY', 'перемещение y': 'translateY', 'y平移': 'translateY', 'y移動': 'translateY',
-            'translation z': 'translateZ', 'translateZ': 'translateZ', 'traduccion z': 'translateZ', 'перемещение z': 'translateZ', 'z平移': 'translateZ', 'z移動': 'translateZ',
-            'rotation': 'rotate', 'rotate': 'rotate', 'rotacion': 'rotate', 'rotación': 'rotate', 'вращение': 'rotate', '旋转': 'rotate', '回転': 'rotate',
-            'echelle': 'scale', 'échelle': 'scale', 'scale': 'scale', 'escala': 'scale', 'масштаб': 'scale', '缩放': 'scale', 'スケール': 'scale',
-            'inclinaison': 'skew', 'skew': 'skew', 'inclinacion': 'skew', 'inclinación': 'skew', 'наклон': 'skew', '倾斜': 'skew', '傾斜': 'skew',
-            'flou': 'blur', 'blur': 'blur', 'desenfoque': 'blur', 'размытие': 'blur', '模糊': 'blur', 'ぼかし': 'blur',
-            'luminosite': 'brightness', 'luminosité': 'brightness', 'brightness': 'brightness', 'brillo': 'brightness', 'яркость': 'brightness', '亮度': 'brightness', '明るさ': 'brightness',
-            'contraste': 'contrast', 'contrast': 'contrast', 'контраст': 'contrast', '对比度': 'contrast', 'コントラスト': 'contrast',
-            'niveaux gris': 'grayscale', 'grayscale': 'grayscale', 'escala grises': 'grayscale', 'оттенки серого': 'grayscale', '灰度': 'grayscale', 'グレースケール': 'grayscale',
-            'inverser': 'invert', 'invert': 'invert', 'invertir': 'invert', 'инвертировать': 'invert', '反转': 'invert', '反転': 'invert',
-            'saturation': 'saturate', 'saturate': 'saturate', 'saturacion': 'saturate', 'saturación': 'saturate', 'насыщенность': 'saturate', '饱和度': 'saturate', '彩度': 'saturate',
-            'sepia': 'sepia', 'sépia': 'sepia', 'сепия': 'sepia', '深褐色': 'sepia', 'セピア': 'sepia',
-            'teinte rotation': 'hue-rotate', 'hue-rotate': 'hue-rotate', 'rotacion tono': 'hue-rotate', 'rotación tono': 'hue-rotate', 'вращение оттенка': 'hue-rotate', '色相旋转': 'hue-rotate', '色相回転': 'hue-rotate',
-            'ombre portee': 'drop-shadow', 'ombre portée': 'drop-shadow', 'drop-shadow': 'drop-shadow', 'sombra proyectada': 'drop-shadow', 'тень': 'drop-shadow', '投影': 'drop-shadow', 'ドロップシャドウ': 'drop-shadow',
-            'cercle': 'circle', 'circle': 'circle', 'circulo': 'circle', 'círculo': 'circle', 'круг': 'circle', '圆形': 'circle', '円': 'circle',
-            'ellipse': 'ellipse', 'elipse': 'ellipse', 'эллипс': 'ellipse', '椭圆': 'ellipse', '楕円': 'ellipse',
-            'polygone': 'polygon', 'polygon': 'polygon', 'poligono': 'polygon', 'polígono': 'polygon', 'многоугольник': 'polygon', '多边形': 'polygon', '多角形': 'polygon',
-            'encart': 'inset', 'inset': 'inset', 'inserto': 'inset', 'вставка': 'inset', '内嵌': 'inset', 'インセット': 'inset',
-            'chemin': 'path', 'path': 'path', 'camino': 'path', 'путь': 'path', '路径': 'path', 'パス': 'path',
-            'courbe bezier': 'cubic-bezier', 'courbe bézier': 'cubic-bezier', 'cubic-bezier': 'cubic-bezier',
-            'curva bezier': 'cubic-bezier', 'curva bézier': 'cubic-bezier', 'кривая безье': 'cubic-bezier', '贝塞尔曲线': 'cubic-bezier', 'ベジェ曲線': 'cubic-bezier',
-            'etapes': 'steps', 'étapes': 'steps', 'steps': 'steps', 'pasos': 'steps', 'шаги': 'steps', '步骤': 'steps', 'ステップ': 'steps',
-            'lineaire': 'linear', 'linéaire': 'linear', 'linear': 'linear', 'lineal': 'linear', 'линейный': 'linear', '线性': 'linear', 'リニア': 'linear',
-            'attribut': 'attr', 'attr': 'attr', 'atributo': 'attr', 'атрибут': 'attr', '属性': 'attr', '属性': 'attr',
-            'compteur': 'counter', 'counter': 'counter', 'contador': 'counter', 'счетчик': 'counter', '计数器': 'counter', 'カウンター': 'counter',
-            'env': 'env', 'entorno': 'env', 'окружение': 'env', '环境': 'env', '環境': 'env',
-            'ensemble images': 'image-set', 'image-set': 'image-set', 'conjunto imagenes': 'image-set', 'conjunto imágenes': 'image-set', 'набор изображений': 'image-set', '图像集': 'image-set', '画像セット': 'image-set',
-            'fondu croise': 'cross-fade', 'fondu croisé': 'cross-fade', 'cross-fade': 'cross-fade', 'fundido cruzado': 'cross-fade', 'перекрестное затухание': 'cross-fade', '交叉淡入淡出': 'cross-fade', 'クロスフェード': 'cross-fade',
-            'facile': 'ease', 'ease': 'ease', 'suave': 'ease', 'плавно': 'ease', '缓动': 'ease', 'イーズ': 'ease',
-            'facile entree': 'ease-in', 'facile entrée': 'ease-in', 'ease-in': 'ease-in', 'suave entrada': 'ease-in', 'плавно вначале': 'ease-in', '缓入': 'ease-in', 'イーズイン': 'ease-in',
-            'facile sortie': 'ease-out', 'ease-out': 'ease-out', 'suave salida': 'ease-out', 'плавно вконце': 'ease-out', '缓出': 'ease-out', 'イーズアウト': 'ease-out',
-            'facile entree sortie': 'ease-in-out', 'facile entrée sortie': 'ease-in-out', 'ease-in-out': 'ease-in-out', 'suave entrada salida': 'ease-in-out', 'плавно вначале вконце': 'ease-in-out', '缓入缓出': 'ease-in-out', 'イーズインアウト': 'ease-in-out'
-        }
-        
-        return map[funcName.toLowerCase()] || funcName
-    }
-}
-
-class CSSCodeGenerator {
-    constructor() {
-        this.indent = 0
-        this.indentStr = '  '
-    }
-
-    generate(ast) {
-        if (!ast) return ''
-        
-        switch (ast.type) {
-            case 'StyleSheet':
-                return this.generateStyleSheet(ast)
-            case 'Rule':
-                return this.generateRule(ast)
-            case 'MediaQuery':
-                return this.generateMediaQuery(ast)
-            case 'KeyframesRule':
-                return this.generateKeyframes(ast)
-            case 'FontFaceRule':
-                return this.generateFontFace(ast)
-            case 'ImportRule':
-                return this.generateImport(ast)
-            case 'SupportsRule':
-                return this.generateSupports(ast)
-            case 'LayerRule':
-                return this.generateLayer(ast)
-            case 'ContainerQuery':
-                return this.generateContainer(ast)
-            case 'ScopeRule':
-                return this.generateScope(ast)
-            case 'PageRule':
-                return this.generatePage(ast)
-            case 'PropertyRule':
-                return this.generatePropertyRule(ast)
-            case 'CounterStyleRule':
-                return this.generateCounterStyle(ast)
-            case 'StartingStyleRule':
-                return this.generateStartingStyle(ast)
-            case 'EtherAlias':
-                return this.generateEtherAlias(ast)
-            case 'EtherState':
-                return this.generateEtherState(ast)
-            default:
-                return ''
-        }
-    }
-
-    generateStyleSheet(ast) {
-        return ast.rules.map(rule => this.generate(rule)).filter(Boolean).join('\n\n')
-    }
-
-    generateRule(ast) {
-        const selectors = this.generateSelectorList(ast.selectors)
-        const declarations = this.generateDeclarations(ast.declarations)
-        return `${selectors} {\n${declarations}\n}`
-    }
-
-    generateSelectorList(ast) {
-        if (!ast) return ''
-        if (ast.type === 'SelectorList') {
-            return ast.selectors.map(s => this.generateSelector(s)).join(', ')
-        }
-        return this.generateSelector(ast)
-    }
-
-    generateSelector(ast) {
-        if (!ast) return ''
-        
-        switch (ast.type) {
-            case 'SimpleSelector':
-                if (ast.selectorType === 'class') return '.' + ast.value
-                if (ast.selectorType === 'id') return '#' + ast.value
-                if (ast.selectorType === 'universal') return '*'
-                return ast.value
-            case 'CompoundSelector':
-                return ast.selectors.map(s => this.generateSelector(s)).join('')
-            case 'ComplexSelector':
-                const left = this.generateSelector(ast.left)
-                const right = this.generateSelector(ast.right)
-                if (ast.combinator === ' ') return `${left} ${right}`
-                return `${left} ${ast.combinator} ${right}`
-            case 'PseudoClassSelector':
-                return ast.argument ? `:${ast.name}(${ast.argument})` : `:${ast.name}`
-            case 'PseudoElementSelector':
-                return `::${ast.name}`
-            case 'AttributeSelector':
-                let attr = `[${ast.attribute}`
-                if (ast.operator) {
-                    attr += `${ast.operator}"${ast.value}"`
-                    if (ast.flags) attr += ` ${ast.flags}`
-                }
-                return attr + ']'
-            default:
-                return ''
-        }
-    }
-
-    generateDeclarations(declarations) {
-        return declarations.map(d => this.generateDeclaration(d)).join('\n')
-    }
-
-    generateDeclaration(ast) {
-        const prop = ast.property.cssName || ast.property.name
-        const val = this.generateValue(ast.value)
-        const important = ast.important ? ' !important' : ''
-        return `${this.indentStr}${prop}: ${val}${important};`
-    }
-
-    generateValue(ast) {
-        if (!ast) return ''
-        
-        switch (ast.type) {
-            case 'Value':
-                return ast.cssValue || ast.value
-            case 'ValueList':
-                return ast.values.map(v => this.generateValue(v)).join(ast.separator)
-            case 'NumberValue':
-                return ast.unit ? `${ast.value}${ast.unit}` : String(ast.value)
-            case 'PercentageValue':
-                return `${ast.value}%`
-            case 'ColorValue':
-                return ast.cssValue
-            case 'StringValue':
-                return `${ast.quote}${ast.value}${ast.quote}`
-            case 'Identifier':
-                return ast.cssName || ast.name
-            case 'FunctionCall':
-                const args = ast.args.map(a => this.generateValue(a)).join(', ')
-                return `${ast.cssName}(${args})`
-            case 'UrlValue':
-                return `url(${ast.url})`
-            case 'Variable':
-                return `var(--${ast.name})`
-            default:
-                return ''
-        }
-    }
-
-    generateMediaQuery(ast) {
-        let query = '@media'
-        if (ast.mediaType) query += ` ${ast.mediaType}`
-        if (ast.conditions.length > 0) {
-            const conds = ast.conditions.map(c => {
-                if (c.type === 'operator') return c.value
-                if (c.type === 'MediaCondition') {
-                    if (c.value) {
-                        return `(${c.feature}: ${this.generateValue(c.value)})`
-                    }
-                    return `(${c.feature})`
-                }
-                return ''
-            }).join(' ')
-            if (ast.mediaType) query += ' and '
-            query += conds
-        }
-        
-        this.indent++
-        const rules = ast.rules.map(r => this.generate(r)).join('\n\n')
-        this.indent--
-        
-        return `${query} {\n${rules}\n}`
-    }
-
-    generateKeyframes(ast) {
-        const keyframes = ast.keyframes.map(kf => {
-            const decls = this.generateDeclarations(kf.declarations)
-            return `  ${kf.selector} {\n${decls.split('\n').map(d => '  ' + d).join('\n')}\n  }`
-        }).join('\n')
-        
-        return `@keyframes ${ast.name} {\n${keyframes}\n}`
-    }
-
-    generateFontFace(ast) {
-        const decls = this.generateDeclarations(ast.declarations)
-        return `@font-face {\n${decls}\n}`
-    }
-
-    generateImport(ast) {
-        let rule = `@import url("${ast.url}")`
-        if (ast.layer) rule += ` layer(${ast.layer === true ? '' : ast.layer})`
-        return rule + ';'
-    }
-
-    generateSupports(ast) {
-        const cond = ast.condition.map(c => {
-            if (c.operator) return c.operator
-            if (c.property) {
-                return `(${c.property}: ${this.generateValue(c.value)})`
-            }
-            return ''
-        }).join(' ')
-        
-        const rules = ast.rules.map(r => this.generate(r)).join('\n\n')
-        return `@supports ${cond} {\n${rules}\n}`
-    }
-
-    generateLayer(ast) {
-        if (ast.rules === null) {
-            return `@layer ${ast.name};`
-        }
-        const rules = ast.rules.map(r => this.generate(r)).join('\n\n')
-        return `@layer ${ast.name} {\n${rules}\n}`
-    }
-
-    generateContainer(ast) {
-        let query = '@container'
-        if (ast.name) query += ` ${ast.name}`
-        if (ast.conditions.length > 0) {
-            const conds = ast.conditions.map(c => {
-                if (c.value) return `(${c.feature}: ${this.generateValue(c.value)})`
-                return `(${c.feature})`
-            }).join(' and ')
-            query += ` ${conds}`
-        }
-        
-        const rules = ast.rules.map(r => this.generate(r)).join('\n\n')
-        return `${query} {\n${rules}\n}`
-    }
-
-    generateScope(ast) {
-        let rule = '@scope'
-        if (ast.start) rule += ` (${this.generateSelector(ast.start)})`
-        if (ast.end) rule += ` to (${this.generateSelector(ast.end)})`
-        
-        const rules = ast.rules.map(r => this.generate(r)).join('\n\n')
-        return `${rule} {\n${rules}\n}`
-    }
-
-    generatePage(ast) {
-        let rule = '@page'
-        if (ast.selector) rule += ` :${ast.selector}`
-        const decls = this.generateDeclarations(ast.declarations)
-        return `${rule} {\n${decls}\n}`
-    }
-
-    generatePropertyRule(ast) {
-        const decls = [
-            `  syntax: '${ast.syntax}';`,
-            `  inherits: ${ast.inherits};`
-        ]
-        if (ast.initialValue) {
-            decls.push(`  initial-value: ${this.generateValue(ast.initialValue)};`)
-        }
-        return `@property ${ast.name} {\n${decls.join('\n')}\n}`
-    }
-
-    generateCounterStyle(ast) {
-        const decls = this.generateDeclarations(ast.declarations)
-        return `@counter-style ${ast.name} {\n${decls}\n}`
-    }
-
-    generateStartingStyle(ast) {
-        const rules = ast.rules.map(r => this.generate(r)).join('\n\n')
-        return `@starting-style {\n${rules}\n}`
-    }
-
-    generateEtherAlias(ast) {
-        return ast.expandedDeclarations.map(d => this.generateDeclaration(d)).join('\n')
-    }
-
-    generateEtherState(ast) {
-        return ast.declarations.map(d => this.generateDeclaration(d)).join('\n')
-    }
-}
-
-module.exports = {
-    CSSLexer,
-    CSSParser,
-    CSSCodeGenerator
-}