ether-code 0.1.5 → 0.1.7

package/parsers/html-parser.js

@@ -1,1182 +0,0 @@
-const fs = require('fs')
-const path = require('path')
-const AST = require('./ast-html')
-
-const VOID_ELEMENTS = new Set([
-    'area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input',
-    'link', 'meta', 'source', 'track', 'wbr'
-])
-
-class HTMLLexer {
-    constructor(source, i18n) {
-        this.source = source
-        this.i18n = i18n
-        this.pos = 0
-        this.line = 1
-        this.column = 1
-        this.tokens = []
-    }
-
-    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
-    }
-
-    skipWhitespaceInline() {
-        while (this.pos < this.source.length) {
-            const char = this.peek()
-            if (char === ' ' || char === '\t' || char === '\r') {
-                this.advance()
-            } 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()
-                const escaped = this.advance()
-                switch (escaped) {
-                    case 'n': value += '\n'; break
-                    case 't': value += '\t'; break
-                    case 'r': value += '\r'; break
-                    default: value += escaped
-                }
-            } 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()
-            }
-        }
-        return parseFloat(value)
-    }
-
-    readWord() {
-        let words = []
-        let currentWord = ''
-        
-        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À-ÿА-яぁ-ゟァ-ヿ一-龯0-9]/.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 = [
-            'titre 1', 'titre 2', 'titre 3', 'titre 4', 'titre 5', 'titre 6',
-            'heading 1', 'heading 2', 'heading 3', 'heading 4', 'heading 5', 'heading 6',
-            'título 1', 'título 2', 'título 3', 'título 4', 'título 5', 'título 6',
-            'заголовок 1', 'заголовок 2', 'заголовок 3', 'заголовок 4', 'заголовок 5', 'заголовок 6',
-            '标题 1', '标题 2', '标题 3', '标题 4', '标题 5', '标题 6',
-            '見出し 1', '見出し 2', '見出し 3', '見出し 4', '見出し 5', '見出し 6',
-            'liste ordonnee', 'liste ordonnée', 'liste non ordonnee', 'liste non ordonnée', 'liste description',
-            'ordered list', 'unordered list', 'description list',
-            'lista ordenada', 'lista no ordenada', 'lista descripción',
-            'упорядоченный список', 'неупорядоченный список', 'список описания',
-            '有序列表', '无序列表', '描述列表',
-            '順序付きリスト', '順序なしリスト', '説明リスト',
-            'retour ligne', 'line break', 'salto linea', 'salto línea', 'перенос строки', '换行', '改行',
-            'ligne horizontale', 'horizontal rule', 'linea horizontal', 'línea horizontal', 'горизонтальная линия', '水平线', '水平線',
-            'citation bloc', 'blockquote', 'cita bloque', 'блок цитаты', '块引用', 'ブロック引用',
-            'legende figure', 'légende figure', 'figure caption', 'leyenda figura', 'подпись рисунка', '图片说明', '図のキャプション',
-            'element liste', 'élément liste', 'list item', 'elemento lista', 'элемент списка', '列表项', 'リスト項目',
-            'entree clavier', 'entrée clavier', 'keyboard input', 'entrada teclado', 'ввод клавиатуры', '键盘输入', 'キーボード入力',
-            'sortie exemple', 'sample output', 'salida ejemplo', 'пример вывода', '示例输出', 'サンプル出力',
-            'image reactive', 'image réactive', 'picture', 'imagen reactiva', 'адаптивное изображение', '响应式图片', 'レスポンシブ画像',
-            'carte image', 'image map', 'mapa imagen', 'карта изображения', '图像映射', 'イメージマップ',
-            'cadre en ligne', 'inline frame', 'marco en linea', 'встроенный фрейм', '内联框架', 'インラインフレーム',
-            'entete tableau', 'entête tableau', 'table header', 'encabezado tabla', 'заголовок таблицы', '表头', 'テーブルヘッダー',
-            'corps tableau', 'table body', 'cuerpo tabla', 'тело таблицы', '表体', 'テーブル本体',
-            'pied tableau', 'table footer', 'pie tabla', 'подвал таблицы', '表脚', 'テーブルフッター',
-            'cellule entete', 'cellule entête', 'header cell', 'celda encabezado', 'ячейка заголовка', '表头单元格', 'ヘッダーセル',
-            'groupe colonnes', 'column group', 'grupo columnas', 'группа колонок', '列组', '列グループ',
-            'champ texte', 'text field', 'campo texto', 'текстовое поле', '文本字段', 'テキストフィールド',
-            'zone texte', 'text area', 'area texto', 'área texto', 'текстовая область', '文本区域', 'テキストエリア',
-            'case a cocher', 'case à cocher', 'checkbox', 'casilla verificacion', 'casilla verificación', 'флажок', '复选框', 'チェックボックス',
-            'bouton radio', 'radio button', 'boton radio', 'botón radio', 'радиокнопка', '单选按钮', 'ラジオボタン',
-            'liste deroulante', 'liste déroulante', 'dropdown', 'lista desplegable', 'выпадающий список', '下拉列表', 'ドロップダウン',
-            'groupe options', 'option group', 'grupo opciones', 'группа опций', '选项组', 'オプショングループ',
-            'groupe champs', 'fieldset', 'grupo campos', 'группа полей', '字段组', 'フィールドセット',
-            'nouvelle fenetre', 'nouvelle fenêtre', 'new window', 'nueva ventana', 'новое окно', '新窗口', '新しいウィンドウ',
-            'meme fenetre', 'même fenêtre', 'same window', 'misma ventana', 'то же окно', '同一窗口', '同じウィンドウ',
-            'lien vers', 'link to', 'enlace a', 'ссылка на', '链接到', 'リンク先',
-            'isolation bidi', 'bidi isolation', 'aislamiento bidi', 'изоляция bidi', '双向隔离', '双方向分離',
-            'remplacement bidi', 'bidi override', 'reemplazo bidi', 'переопределение bidi', '双向覆盖', '双方向オーバーライド',
-            'annotation ruby', 'ruby text', 'anotacion ruby', 'anotación ruby', 'аннотация ruby', 'ruby注释', 'ルビ注釈',
-            'parentheses ruby', 'parenthèses ruby', 'ruby parenthesis', 'paréntesis ruby', 'скобки ruby', 'ruby括号', 'ルビ括弧',
-            'retour ligne possible', 'word break opportunity', 'oportunidad salto', 'возможность переноса', '换行机会', '改行可能',
-            'lecture auto', 'autoplay', 'reproduccion automatica', 'reproducción automática', 'автовоспроизведение', '自动播放', '自動再生',
-            'en boucle', 'loop', 'en bucle', 'цикл', '循环', 'ループ',
-            'lecture seule', 'readonly', 'solo lectura', 'только чтение', '只读', '読み取り専用',
-            'champ email', 'email field', 'campo email', 'поле email', '邮箱字段', 'メールフィールド',
-            'champ mot de passe', 'password field', 'campo contraseña', 'поле пароля', '密码字段', 'パスワードフィールド',
-            'champ numero', 'champ numéro', 'number field', 'campo numero', 'campo número', 'числовое поле', '数字字段', '数値フィールド',
-            'champ date', 'date field', 'campo fecha', 'поле даты', '日期字段', '日付フィールド',
-            'champ heure', 'time field', 'campo hora', 'поле времени', '时间字段', '時間フィールド',
-            'champ couleur', 'color field', 'campo color', 'поле цвета', '颜色字段', '色フィールド',
-            'champ fichier', 'file field', 'campo archivo', 'поле файла', '文件字段', 'ファイルフィールド',
-            'champ cache', 'champ caché', 'hidden field', 'campo oculto', 'скрытое поле', '隐藏字段', '非表示フィールド',
-            'champ recherche', 'search field', 'campo busqueda', 'campo búsqueda', 'поле поиска', '搜索字段', '検索フィールド',
-            'champ url', 'url field', 'campo url', 'поле url', 'URL字段', 'URLフィールド',
-            'champ telephone', 'champ téléphone', 'phone field', 'campo telefono', 'campo teléfono', 'поле телефона', '电话字段', '電話フィールド',
-            'champ plage', 'range field', 'campo rango', 'поле диапазона', '范围字段', '範囲フィールド',
-            'bouton envoyer', 'submit button', 'boton enviar', 'botón enviar', 'кнопка отправки', '提交按钮', '送信ボタン',
-            'bouton reinitialiser', 'bouton réinitialiser', 'reset button', 'boton reiniciar', 'botón reiniciar', 'кнопка сброса', '重置按钮', 'リセットボタン'
-        ]
-        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
-            }
-
-            if (this.peek() === ' ' || this.peek() === '\t' || this.peek() === '\r') {
-                this.skipWhitespaceInline()
-                continue
-            }
-
-            if (this.peek() === '-' && this.peek(1) === '-' && this.peek(2) !== '-') {
-                this.skipLineComment()
-                continue
-            }
-
-            if (this.peek() === '{' && this.peek(1) === '-') {
-                this.skipBlockComment()
-                continue
-            }
-
-            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)))) {
-                const value = this.readNumber()
-                this.tokens.push({ type: 'NUMBER', value, loc: newLoc })
-            } else if (char === '#') {
-                this.advance()
-                const id = this.readWord()
-                this.tokens.push({ type: 'ID_SHORTHAND', value: id, loc: newLoc })
-            } else if (char === '.') {
-                this.advance()
-                const className = this.readWord()
-                this.tokens.push({ type: 'CLASS_SHORTHAND', value: className, loc: newLoc })
-            } else if (char === '@') {
-                this.advance()
-                const directive = this.readWord()
-                this.tokens.push({ type: 'DIRECTIVE', value: directive, loc: newLoc })
-            } else if (char === '=') {
-                this.advance()
-                this.tokens.push({ type: 'EQUALS', loc: newLoc })
-            } else if (char === ':') {
-                this.advance()
-                this.tokens.push({ type: 'COLON', 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()
-                if (this.peek() === '{') {
-                    this.advance()
-                    this.tokens.push({ type: 'EXPR_START', loc: newLoc })
-                } else {
-                    this.tokens.push({ type: 'LBRACE', loc: newLoc })
-                }
-            } else if (char === '}') {
-                this.advance()
-                if (this.peek() === '}') {
-                    this.advance()
-                    this.tokens.push({ type: 'EXPR_END', loc: newLoc })
-                } else {
-                    this.tokens.push({ type: 'RBRACE', loc: newLoc })
-                }
-            } else if (char === '/') {
-                this.advance()
-                this.tokens.push({ type: 'SLASH', loc: newLoc })
-            } else if (char === '>') {
-                this.advance()
-                this.tokens.push({ type: 'GT', loc: newLoc })
-            } else if (char === '<') {
-                this.advance()
-                this.tokens.push({ type: 'LT', 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
-    }
-
-    classifyWord(word) {
-        const lowerWord = word.toLowerCase()
-        
-        if (this.isEtherKeyword(lowerWord)) return 'ETHER_KEYWORD'
-        if (this.isElement(lowerWord)) return 'ELEMENT'
-        if (this.isAttribute(lowerWord)) return 'ATTRIBUTE'
-        if (this.isBooleanAttribute(lowerWord)) return 'BOOLEAN_ATTR'
-        
-        return 'IDENTIFIER'
-    }
-
-    isEtherKeyword(word) {
-        const keywords = [
-            'si', 'if', 'sinon', 'else', 'sinonsi', 'elif',
-            'pour', 'for', 'dans', 'in', 'tantque', 'while',
-            'créer', 'create', 'ajouter', 'add',
-            'vers', 'to', 'nouvelle fenêtre', 'new window',
-            'même fenêtre', 'same window'
-        ]
-        return keywords.includes(word.toLowerCase())
-    }
-
-    isElement(word) {
-        for (const category of Object.values(this.i18n)) {
-            if (typeof category === 'object' && category !== null && !Array.isArray(category)) {
-                for (const item of Object.values(category)) {
-                    if (typeof item === 'object' && item !== null && item.html) {
-                        for (const [lang, translation] of Object.entries(item)) {
-                            if (lang !== 'html' && typeof translation === 'string' && 
-                                translation.toLowerCase() === word.toLowerCase()) {
-                                return true
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        return false
-    }
-
-    isAttribute(word) {
-        const attrs = this.i18n.globalAttributes || {}
-        for (const item of Object.values(attrs)) {
-            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
-    }
-
-    isBooleanAttribute(word) {
-        const boolAttrs = [
-            'requis', 'required', 'requerido', 'обязательный', '必填', '必須',
-            'désactivé', 'disabled', 'desactivado', 'отключен', '禁用', '無効',
-            'coché', 'checked', 'marcado', 'отмечен', '选中', 'チェック済み',
-            'sélectionné', 'selected', 'seleccionado', 'выбран', '已选', '選択済み',
-            'lecture seule', 'readonly', 'solo lectura', 'только чтение', '只读', '読み取り専用',
-            'multiple', 'múltiple', 'множественный', '多选', '複数',
-            'autofocus', 'autocompléter', 'autocomplete',
-            'contrôles', 'controls', 'controles', 'управление', '控件', 'コントロール',
-            'lecture auto', 'autoplay', 'reproducción auto', 'автозапуск', '自动播放', '自動再生',
-            'muet', 'muted', 'silenciado', 'без звука', '静音', 'ミュート',
-            'en boucle', 'loop', 'bucle', 'цикл', '循环', 'ループ',
-            'ouvert', 'open', 'abierto', 'открыт', '打开', '開く',
-            'caché', 'hidden', 'oculto', 'скрытый', '隐藏', '非表示',
-            'novalidate', 'formnovalidate', 'async', 'defer', 'inert'
-        ]
-        return boolAttrs.includes(word.toLowerCase())
-    }
-}
-
-class HTMLParser {
-    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 HTMLLexer(source, this.i18n)
-        this.tokens = lexer.tokenize()
-        this.pos = 0
-        return this.parseDocument()
-    }
-
-    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()
-        }
-    }
-
-    parseDocument() {
-        let doctype = null
-        let html = null
-        
-        this.skipNewlines()
-        
-        if (this.match('ELEMENT', 'IDENTIFIER')) {
-            const word = this.peek().value.toLowerCase()
-            if (word === 'document' || word === 'documento' || word === 'документ' || word === '文档' || word === 'ドキュメント') {
-                this.advance()
-                doctype = new AST.Doctype('html')
-                this.skipNewlines()
-            }
-        }
-        
-        const children = []
-        while (!this.match('EOF')) {
-            const child = this.parseNode()
-            if (child) {
-                children.push(child)
-            }
-            this.skipNewlines()
-        }
-        
-        if (children.length === 1 && children[0].type === 'Element' && children[0].htmlTag === 'html') {
-            html = children[0]
-        } else {
-            html = new AST.Element('html', 'html', [], children)
-        }
-        
-        return new AST.Document(doctype, html)
-    }
-
-    parseNode() {
-        const token = this.peek()
-        
-        if (token.type === 'DIRECTIVE') {
-            return this.parseDirective()
-        }
-        
-        if (token.type === 'ETHER_KEYWORD') {
-            return this.parseEtherConstruct()
-        }
-        
-        if (token.type === 'ELEMENT' || token.type === 'IDENTIFIER') {
-            return this.parseElement()
-        }
-        
-        if (token.type === 'STRING') {
-            return this.parseTextNode()
-        }
-        
-        if (token.type === 'ID_SHORTHAND' || token.type === 'CLASS_SHORTHAND') {
-            return this.parseShorthandElement()
-        }
-        
-        if (token.type === 'EXPR_START') {
-            return this.parseExpression()
-        }
-        
-        this.advance()
-        return null
-    }
-
-    parseElement() {
-        const elemToken = this.advance()
-        const tagName = elemToken.value
-        const htmlTag = this.translateElement(tagName)
-        const loc = elemToken.loc
-        const elemIndent = loc.column - 1
-        
-        const attributes = this.parseAttributes()
-        
-        let textContent = null
-        if (this.match('STRING')) {
-            textContent = this.advance().value
-        }
-        
-        const selfClosing = VOID_ELEMENTS.has(htmlTag)
-        
-        let children = []
-        if (!selfClosing) {
-            if (textContent) {
-                children.push(new AST.TextNode(textContent))
-            }
-            
-            const childElements = this.parseChildren(elemIndent)
-            children = children.concat(childElements)
-        }
-        
-        return new AST.Element(tagName, htmlTag, attributes, children, selfClosing, loc)
-    }
-
-    parseShorthandElement() {
-        const firstToken = this.peek()
-        const elemIndent = firstToken.loc ? firstToken.loc.column - 1 : 0
-        
-        const attributes = []
-        let tagName = 'div'
-        let htmlTag = 'div'
-        
-        while (this.match('ID_SHORTHAND', 'CLASS_SHORTHAND')) {
-            if (this.match('ID_SHORTHAND')) {
-                const idToken = this.advance()
-                attributes.push(new AST.Attribute('id', 'id', idToken.value, idToken.loc))
-            } else if (this.match('CLASS_SHORTHAND')) {
-                const classToken = this.advance()
-                const existing = attributes.find(a => a.htmlName === 'class')
-                if (existing) {
-                    existing.value += ' ' + classToken.value
-                } else {
-                    attributes.push(new AST.Attribute('classe', 'class', classToken.value, classToken.loc))
-                }
-            }
-        }
-        
-        const moreAttrs = this.parseAttributes()
-        attributes.push(...moreAttrs)
-        
-        let textContent = null
-        if (this.match('STRING')) {
-            textContent = this.advance().value
-        }
-        
-        const children = []
-        if (textContent) {
-            children.push(new AST.TextNode(textContent))
-        }
-        
-        const childElements = this.parseChildren(elemIndent)
-        children.push(...childElements)
-        
-        return new AST.Element(tagName, htmlTag, attributes, children, false)
-    }
-
-    parseAttributes() {
-        const attributes = []
-        
-        while (this.match('ATTRIBUTE', 'BOOLEAN_ATTR', 'IDENTIFIER', 'ID_SHORTHAND', 'CLASS_SHORTHAND')) {
-            if (this.match('ID_SHORTHAND')) {
-                const idToken = this.advance()
-                attributes.push(new AST.Attribute('id', 'id', idToken.value, idToken.loc))
-                continue
-            }
-            
-            if (this.match('CLASS_SHORTHAND')) {
-                const classToken = this.advance()
-                const existing = attributes.find(a => a.htmlName === 'class')
-                if (existing) {
-                    existing.value += ' ' + classToken.value
-                } else {
-                    attributes.push(new AST.Attribute('classe', 'class', classToken.value, classToken.loc))
-                }
-                continue
-            }
-            
-            if (this.match('BOOLEAN_ATTR')) {
-                const boolToken = this.advance()
-                const htmlAttr = this.translateAttribute(boolToken.value)
-                attributes.push(new AST.BooleanAttribute(boolToken.value, htmlAttr, boolToken.loc))
-                continue
-            }
-            
-            const attrToken = this.advance()
-            const attrName = attrToken.value
-            const htmlAttr = this.translateAttribute(attrName)
-            
-            if (this.match('EQUALS')) {
-                this.advance()
-                let value = null
-                if (this.match('STRING')) {
-                    value = this.advance().value
-                } else if (this.match('NUMBER')) {
-                    value = String(this.advance().value)
-                } else if (this.match('IDENTIFIER')) {
-                    value = this.advance().value
-                }
-                attributes.push(new AST.Attribute(attrName, htmlAttr, value, attrToken.loc))
-            } else {
-                attributes.push(new AST.BooleanAttribute(attrName, htmlAttr, attrToken.loc))
-            }
-        }
-        
-        return attributes
-    }
-
-    parseChildren(parentIndent = -1) {
-        const children = []
-        
-        while (!this.match('EOF')) {
-            this.skipNewlines()
-            
-            if (this.currentIndent <= parentIndent) {
-                break
-            }
-            
-            if (this.match('ELEMENT', 'IDENTIFIER', 'STRING', 'ID_SHORTHAND', 'CLASS_SHORTHAND', 'ETHER_KEYWORD', 'DIRECTIVE', 'EXPR_START')) {
-                const child = this.parseNode()
-                if (child) {
-                    children.push(child)
-                }
-            } else {
-                break
-            }
-        }
-        
-        return children
-    }
-
-    parseTextNode() {
-        const strToken = this.advance()
-        return new AST.TextNode(strToken.value, strToken.loc)
-    }
-
-    parseExpression() {
-        this.expect('EXPR_START')
-        let expr = ''
-        while (!this.match('EXPR_END', 'EOF')) {
-            expr += this.advance().value || ''
-        }
-        if (this.match('EXPR_END')) {
-            this.advance()
-        }
-        return new AST.EtherExpression(expr.trim())
-    }
-
-    parseDirective() {
-        const dirToken = this.advance()
-        const name = dirToken.value.toLowerCase()
-        
-        let value = null
-        if (this.match('STRING', 'IDENTIFIER', 'NUMBER')) {
-            value = this.advance().value
-        }
-        
-        return new AST.EtherDirective(name, value, dirToken.loc)
-    }
-
-    parseEtherConstruct() {
-        const keyword = this.peek().value.toLowerCase()
-        
-        if (['si', 'if'].includes(keyword)) {
-            return this.parseConditional()
-        }
-        
-        if (['pour', 'for'].includes(keyword)) {
-            return this.parseLoop()
-        }
-        
-        this.advance()
-        return null
-    }
-
-    parseConditional() {
-        this.advance()
-        
-        let condition = ''
-        while (!this.match('NEWLINE', 'EOF')) {
-            condition += (this.advance().value || '') + ' '
-        }
-        condition = condition.trim()
-        
-        const thenBranch = this.parseChildren()
-        let elseBranch = null
-        
-        this.skipNewlines()
-        if (this.match('ETHER_KEYWORD')) {
-            const word = this.peek().value.toLowerCase()
-            if (['sinon', 'else'].includes(word)) {
-                this.advance()
-                elseBranch = this.parseChildren()
-            }
-        }
-        
-        return new AST.EtherConditional(condition, thenBranch, elseBranch)
-    }
-
-    parseLoop() {
-        this.advance()
-        
-        let variable = ''
-        if (this.match('IDENTIFIER')) {
-            variable = this.advance().value
-        }
-        
-        if (this.match('ETHER_KEYWORD', 'IDENTIFIER')) {
-            const word = this.peek().value.toLowerCase()
-            if (['dans', 'in'].includes(word)) {
-                this.advance()
-            }
-        }
-        
-        let iterable = ''
-        while (!this.match('NEWLINE', 'EOF')) {
-            iterable += (this.advance().value || '') + ' '
-        }
-        iterable = iterable.trim()
-        
-        const children = this.parseChildren()
-        
-        return new AST.EtherLoop(variable, iterable, children)
-    }
-
-    translateElement(name) {
-        const lowerName = name.toLowerCase()
-        
-        for (const category of Object.values(this.i18n)) {
-            if (typeof category === 'object' && category !== null && !Array.isArray(category)) {
-                for (const item of Object.values(category)) {
-                    if (typeof item === 'object' && item !== null && item.html) {
-                        for (const [lang, translation] of Object.entries(item)) {
-                            if (lang !== 'html' && typeof translation === 'string' && 
-                                translation.toLowerCase() === lowerName) {
-                                return item.html.replace(/<|>/g, '')
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        
-        const directMap = {
-            'document': 'html', 'documento': 'html', 'документ': 'html', '文档': 'html', 'ドキュメント': 'html',
-            'tete': 'head', 'tête': 'head', 'head': 'head', 'cabeza': 'head', 'голова': 'head', '头部': 'head', 'ヘッド': 'head',
-            'corps': 'body', 'body': 'body', 'cuerpo': 'body', 'тело': 'body', '主体': 'body', 'ボディ': 'body',
-            'titre': 'title', 'title': 'title', 'título': 'title', 'titulo': 'title', 'заголовок': 'title', '标题': 'title', 'タイトル': 'title',
-            'titre 1': 'h1', 'titre1': 'h1', 'heading 1': 'h1', 'título 1': 'h1', 'titulo 1': 'h1', 'заголовок 1': 'h1', '标题 1': 'h1', '見出し 1': 'h1',
-            'titre 2': 'h2', 'titre2': 'h2', 'heading 2': 'h2', 'título 2': 'h2', 'titulo 2': 'h2', 'заголовок 2': 'h2', '标题 2': 'h2', '見出し 2': 'h2',
-            'titre 3': 'h3', 'titre3': 'h3', 'heading 3': 'h3', 'título 3': 'h3', 'titulo 3': 'h3', 'заголовок 3': 'h3', '标题 3': 'h3', '見出し 3': 'h3',
-            'titre 4': 'h4', 'titre4': 'h4', 'heading 4': 'h4', 'título 4': 'h4', 'titulo 4': 'h4', 'заголовок 4': 'h4', '标题 4': 'h4', '見出し 4': 'h4',
-            'titre 5': 'h5', 'titre5': 'h5', 'heading 5': 'h5', 'título 5': 'h5', 'titulo 5': 'h5', 'заголовок 5': 'h5', '标题 5': 'h5', '見出し 5': 'h5',
-            'titre 6': 'h6', 'titre6': 'h6', 'heading 6': 'h6', 'título 6': 'h6', 'titulo 6': 'h6', 'заголовок 6': 'h6', '标题 6': 'h6', '見出し 6': 'h6',
-            'paragraphe': 'p', 'paragraph': 'p', 'párrafo': 'p', 'parrafo': 'p', 'параграф': 'p', '段落': 'p',
-            'division': 'div', 'div': 'div', 'bloque': 'div', 'блок': 'div', '块': 'div', 'ディブ': 'div',
-            'etendue': 'span', 'étendue': 'span', 'span': 'span', 'extensión': 'span', 'extension': 'span', 'спан': 'span', '跨度': 'span', 'スパン': 'span',
-            'lien': 'a', 'anchor': 'a', 'link': 'a', 'enlace': 'a', 'ссылка': 'a', '链接': 'a', 'リンク': 'a',
-            'image': 'img', 'img': 'img', 'imagen': 'img', 'изображение': 'img', '图片': 'img', '画像': 'img',
-            'liste ordonnee': 'ol', 'liste ordonnée': 'ol', 'ordered list': 'ol', 'lista ordenada': 'ol', 'упорядоченный список': 'ol', '有序列表': 'ol', '順序付きリスト': 'ol',
-            'liste non ordonnee': 'ul', 'liste non ordonnée': 'ul', 'unordered list': 'ul', 'lista no ordenada': 'ul', 'неупорядоченный список': 'ul', '无序列表': 'ul', '順序なしリスト': 'ul',
-            'element liste': 'li', 'élément liste': 'li', 'list item': 'li', 'elemento lista': 'li', 'элемент списка': 'li', '列表项': 'li', 'リスト項目': 'li',
-            'tableau': 'table', 'table': 'table', 'tabla': 'table', 'таблица': 'table', '表格': 'table', 'テーブル': 'table',
-            'ligne': 'tr', 'row': 'tr', 'fila': 'tr', 'строка': 'tr', '行': 'tr',
-            'cellule': 'td', 'cell': 'td', 'celda': 'td', 'ячейка': 'td', '单元格': 'td', 'セル': 'td',
-            'cellule entete': 'th', 'cellule entête': 'th', 'header cell': 'th', 'celda encabezado': 'th', 'ячейка заголовка': 'th', '表头单元格': 'th', 'ヘッダーセル': 'th',
-            'entete': 'header', 'entête': 'header', 'header': 'header', 'encabezado': 'header', 'шапка': 'header', '头部': 'header', 'ヘッダー': 'header',
-            'pied': 'footer', 'footer': 'footer', 'pie': 'footer', 'подвал': 'footer', '页脚': 'footer', 'フッター': 'footer',
-            'navigation': 'nav', 'nav': 'nav', 'navegación': 'nav', 'navegacion': 'nav', 'навигация': 'nav', '导航': 'nav', 'ナビ': 'nav',
-            'principal': 'main', 'main': 'main', 'основной': 'main', '主要': 'main', 'メイン': 'main',
-            'section': 'section', 'sección': 'section', 'seccion': 'section', 'секция': 'section', '部分': 'section', 'セクション': 'section',
-            'article': 'article', 'artículo': 'article', 'articulo': 'article', 'статья': 'article', '文章': 'article', '記事': 'article',
-            'aside': 'aside', 'aparte': 'aside', 'боковой': 'aside', '侧边': 'aside', 'アサイド': 'aside',
-            'formulaire': 'form', 'form': 'form', 'formulario': 'form', 'форма': 'form', '表单': 'form', 'フォーム': 'form',
-            'entree': 'input', 'entrée': 'input', 'input': 'input', 'entrada': 'input', 'ввод': 'input', '输入': 'input', '入力': 'input',
-            'champ': 'input', 'field': 'input', 'campo': 'input', 'поле': 'input', '字段': 'input', 'フィールド': 'input',
-            'champ texte': 'input', 'text field': 'input', 'campo texto': 'input', 'текстовое поле': 'input', '文本字段': 'input', 'テキストフィールド': 'input',
-            'champ email': 'input', 'email field': 'input', 'campo email': 'input', 'поле email': 'input', '邮箱字段': 'input', 'メールフィールド': 'input',
-            'champ mot de passe': 'input', 'password field': 'input', 'campo contraseña': 'input', 'campo contrasena': 'input', 'поле пароля': 'input', '密码字段': 'input', 'パスワードフィールド': 'input',
-            'champ numero': 'input', 'champ numéro': 'input', 'number field': 'input', 'campo numero': 'input', 'campo número': 'input', 'числовое поле': 'input', '数字字段': 'input', '数値フィールド': 'input',
-            'champ date': 'input', 'date field': 'input', 'campo fecha': 'input', 'поле даты': 'input', '日期字段': 'input', '日付フィールド': 'input',
-            'champ heure': 'input', 'time field': 'input', 'campo hora': 'input', 'поле времени': 'input', '时间字段': 'input', '時間フィールド': 'input',
-            'champ couleur': 'input', 'color field': 'input', 'campo color': 'input', 'поле цвета': 'input', '颜色字段': 'input', '色フィールド': 'input',
-            'champ fichier': 'input', 'file field': 'input', 'campo archivo': 'input', 'поле файла': 'input', '文件字段': 'input', 'ファイルフィールド': 'input',
-            'champ cache': 'input', 'champ caché': 'input', 'hidden field': 'input', 'campo oculto': 'input', 'скрытое поле': 'input', '隐藏字段': 'input', '非表示フィールド': 'input',
-            'champ recherche': 'input', 'search field': 'input', 'campo busqueda': 'input', 'campo búsqueda': 'input', 'поле поиска': 'input', '搜索字段': 'input', '検索フィールド': 'input',
-            'champ url': 'input', 'url field': 'input', 'campo url': 'input', 'поле url': 'input', 'URL字段': 'input', 'URLフィールド': 'input',
-            'champ telephone': 'input', 'champ téléphone': 'input', 'phone field': 'input', 'campo telefono': 'input', 'campo teléfono': 'input', 'поле телефона': 'input', '电话字段': 'input', '電話フィールド': 'input',
-            'champ plage': 'input', 'range field': 'input', 'campo rango': 'input', 'поле диапазона': 'input', '范围字段': 'input', '範囲フィールド': 'input',
-            'case a cocher': 'input', 'case à cocher': 'input', 'checkbox': 'input', 'casilla verificacion': 'input', 'casilla verificación': 'input', 'флажок': 'input', '复选框': 'input', 'チェックボックス': 'input',
-            'bouton radio': 'input', 'radio button': 'input', 'boton radio': 'input', 'botón radio': 'input', 'радиокнопка': 'input', '单选按钮': 'input', 'ラジオボタン': 'input',
-            'bouton': 'button', 'button': 'button', 'botón': 'button', 'boton': 'button', 'кнопка': 'button', '按钮': 'button', 'ボタン': 'button',
-            'bouton envoyer': 'button', 'submit button': 'button', 'boton enviar': 'button', 'botón enviar': 'button', 'кнопка отправки': 'button', '提交按钮': 'button', '送信ボタン': 'button',
-            'bouton reinitialiser': 'button', 'bouton réinitialiser': 'button', 'reset button': 'button', 'boton reiniciar': 'button', 'botón reiniciar': 'button', 'кнопка сброса': 'button', '重置按钮': 'button', 'リセットボタン': 'button',
-            'zone texte': 'textarea', 'textarea': 'textarea', 'area texto': 'textarea', 'área texto': 'textarea', 'текстовая область': 'textarea', '文本区域': 'textarea', 'テキストエリア': 'textarea',
-            'selection': 'select', 'sélection': 'select', 'select': 'select', 'selección': 'select', 'seleccion': 'select', 'выбор': 'select', '选择': 'select', 'セレクト': 'select',
-            'liste deroulante': 'select', 'liste déroulante': 'select', 'dropdown': 'select', 'lista desplegable': 'select', 'выпадающий список': 'select', '下拉列表': 'select', 'ドロップダウン': 'select',
-            'option': 'option', 'opción': 'option', 'opcion': 'option', 'опция': 'option', '选项': 'option', 'オプション': 'option',
-            'groupe options': 'optgroup', 'option group': 'optgroup', 'grupo opciones': 'optgroup', 'группа опций': 'optgroup', '选项组': 'optgroup', 'オプショングループ': 'optgroup',
-            'etiquette': 'label', 'étiquette': 'label', 'label': 'label', 'etiqueta': 'label', 'метка': 'label', '标签': 'label', 'ラベル': 'label',
-            'groupe champs': 'fieldset', 'fieldset': 'fieldset', 'grupo campos': 'fieldset', 'группа полей': 'fieldset', '字段组': 'fieldset', 'フィールドセット': 'fieldset',
-            'legende': 'legend', 'légende': 'legend', 'legend': 'legend', 'leyenda': 'legend', 'легенда': 'legend', '图例': 'legend', '凡例': 'legend',
-            'liste donnees': 'datalist', 'liste données': 'datalist', 'datalist': 'datalist', 'lista datos': 'datalist', 'список данных': 'datalist', '数据列表': 'datalist', 'データリスト': 'datalist',
-            'sortie': 'output', 'output': 'output', 'salida': 'output', 'вывод': 'output', '输出': 'output', '出力': 'output',
-            'progression': 'progress', 'progress': 'progress', 'progreso': 'progress', 'прогресс': 'progress', '进度': 'progress', 'プログレス': 'progress',
-            'metre': 'meter', 'mètre': 'meter', 'meter': 'meter', 'medidor': 'meter', 'метр': 'meter', '计量器': 'meter', 'メーター': 'meter',
-            'video': 'video', 'vidéo': 'video', 'vídeo': 'video', 'видео': 'video', '视频': 'video', 'ビデオ': 'video',
-            'audio': 'audio', 'аудио': 'audio', '音频': 'audio', 'オーディオ': 'audio',
-            'source': 'source', 'fuente': 'source', 'источник': 'source', '来源': 'source', 'ソース': 'source',
-            'piste': 'track', 'track': 'track', 'дорожка': 'track', '轨道': 'track', 'トラック': 'track',
-            'canevas': 'canvas', 'canvas': 'canvas', 'lienzo': 'canvas', 'холст': 'canvas', '画布': 'canvas', 'キャンバス': 'canvas',
-            'svg': 'svg',
-            'math': 'math', 'mathématiques': 'math', 'matematicas': 'math', 'matemáticas': 'math', 'математика': 'math', '数学': 'math',
-            'cadre en ligne': 'iframe', 'iframe': 'iframe', 'inline frame': 'iframe', 'marco en linea': 'iframe', 'встроенный фрейм': 'iframe', '内联框架': 'iframe', 'インラインフレーム': 'iframe',
-            'objet': 'object', 'object': 'object', 'objeto': 'object', 'объект': 'object', '对象': 'object', 'オブジェクト': 'object',
-            'incorporation': 'embed', 'embed': 'embed', 'incrustar': 'embed', 'встраивание': 'embed', '嵌入': 'embed', '埋め込み': 'embed',
-            'script': 'script', 'скрипт': 'script', '脚本': 'script', 'スクリプト': 'script',
-            'noscript': 'noscript',
-            'style': 'style', 'estilo': 'style', 'стиль': 'style', '样式': 'style', 'スタイル': 'style',
-            'lien css': 'link', 'link': 'link',
-            'meta': 'meta', 'méta': 'meta', 'мета': 'meta', '元': 'meta', 'メタ': 'meta',
-            'base': 'base',
-            'retour ligne': 'br', 'line break': 'br', 'salto linea': 'br', 'salto línea': 'br', 'перенос строки': 'br', '换行': 'br', '改行': 'br',
-            'ligne horizontale': 'hr', 'horizontal rule': 'hr', 'linea horizontal': 'hr', 'línea horizontal': 'hr', 'горизонтальная линия': 'hr', '水平线': 'hr', '水平線': 'hr',
-            'gras': 'b', 'bold': 'b', 'negrita': 'b', 'жирный': 'b', '粗体': 'b', '太字': 'b',
-            'italique': 'i', 'italic': 'i', 'cursiva': 'i', 'курсив': 'i', '斜体': 'i', 'イタリック': 'i',
-            'souligne': 'u', 'souligné': 'u', 'underline': 'u', 'subrayado': 'u', 'подчеркнутый': 'u', '下划线': 'u', '下線': 'u',
-            'barre': 's', 'barré': 's', 'strikethrough': 's', 'tachado': 's', 'зачеркнутый': 's', '删除线': 's', '取り消し線': 's',
-            'fort': 'strong', 'strong': 'strong', 'fuerte': 'strong', 'важный': 'strong', '强调': 'strong', '強調': 'strong',
-            'emphase': 'em', 'emphasis': 'em', 'énfasis': 'em', 'enfasis': 'em', 'акцент': 'em', '着重': 'em', '強調': 'em',
-            'marque': 'mark', 'mark': 'mark', 'marca': 'mark', 'маркер': 'mark', '标记': 'mark', 'マーク': 'mark',
-            'petit': 'small', 'small': 'small', 'pequeño': 'small', 'pequeno': 'small', 'маленький': 'small', '小': 'small', '小さい': 'small',
-            'supprime': 'del', 'supprimé': 'del', 'deleted': 'del', 'eliminado': 'del', 'удаленный': 'del', '删除': 'del', '削除': 'del',
-            'insere': 'ins', 'inséré': 'ins', 'inserted': 'ins', 'insertado': 'ins', 'вставленный': 'ins', '插入': 'ins', '挿入': 'ins',
-            'indice': 'sub', 'subscript': 'sub', 'subíndice': 'sub', 'subindice': 'sub', 'подстрочный': 'sub', '下标': 'sub', '下付き': 'sub',
-            'exposant': 'sup', 'superscript': 'sup', 'superíndice': 'sup', 'superindice': 'sup', 'надстрочный': 'sup', '上标': 'sup', '上付き': 'sup',
-            'code': 'code', 'código': 'code', 'codigo': 'code', 'код': 'code', '代码': 'code', 'コード': 'code',
-            'preformate': 'pre', 'préformaté': 'pre', 'preformatted': 'pre', 'preformateado': 'pre', 'предформатированный': 'pre', '预格式化': 'pre', '整形済み': 'pre',
-            'variable': 'var', 'var': 'var', 'переменная': 'var', '变量': 'var', '変数': 'var',
-            'echantillon': 'samp', 'échantillon': 'samp', 'sample': 'samp', 'muestra': 'samp', 'образец': 'samp', '示例': 'samp', 'サンプル': 'samp',
-            'clavier': 'kbd', 'keyboard': 'kbd', 'teclado': 'kbd', 'клавиатура': 'kbd', '键盘': 'kbd', 'キーボード': 'kbd',
-            'citation': 'q', 'quote': 'q', 'cita': 'q', 'цитата': 'q', '引用': 'q', '引用符': 'q',
-            'citation bloc': 'blockquote', 'blockquote': 'blockquote', 'cita bloque': 'blockquote', 'блок цитаты': 'blockquote', '块引用': 'blockquote', 'ブロック引用': 'blockquote',
-            'abbreviation': 'abbr', 'abreviatura': 'abbr', 'abbr': 'abbr', 'аббревиатура': 'abbr', '缩写': 'abbr', '略語': 'abbr',
-            'adresse': 'address', 'address': 'address', 'dirección': 'address', 'direccion': 'address', 'адрес': 'address', '地址': 'address', 'アドレス': 'address',
-            'date temps': 'time', 'time': 'time', 'tiempo': 'time', 'время': 'time', '时间': 'time', '時間': 'time',
-            'definition': 'dfn', 'définition': 'dfn', 'dfn': 'dfn', 'definición': 'dfn', 'определение': 'dfn', '定义': 'dfn', '定義': 'dfn',
-            'figure': 'figure', 'figura': 'figure', 'рисунок': 'figure', '图': 'figure', '図': 'figure',
-            'legende figure': 'figcaption', 'légende figure': 'figcaption', 'figure caption': 'figcaption', 'leyenda figura': 'figcaption', 'подпись рисунка': 'figcaption', '图片说明': 'figcaption', '図のキャプション': 'figcaption',
-            'details': 'details', 'détails': 'details', 'detalles': 'details', 'детали': 'details', '详情': 'details', '詳細': 'details',
-            'resume': 'summary', 'résumé': 'summary', 'summary': 'summary', 'resumen': 'summary', 'итог': 'summary', '摘要': 'summary', '概要': 'summary',
-            'dialogue': 'dialog', 'dialog': 'dialog', 'diálogo': 'dialog', 'dialogo': 'dialog', 'диалог': 'dialog', '对话框': 'dialog', 'ダイアログ': 'dialog',
-            'modele': 'template', 'modèle': 'template', 'template': 'template', 'plantilla': 'template', 'шаблон': 'template', '模板': 'template', 'テンプレート': 'template',
-            'emplacement': 'slot', 'slot': 'slot', 'ranura': 'slot', 'слот': 'slot', '插槽': 'slot', 'スロット': 'slot',
-            'carte': 'map', 'map': 'map', 'mapa': 'map', 'карта': 'map', '地图': 'map', 'マップ': 'map',
-            'zone': 'area', 'area': 'area', 'область': 'area', '区域': 'area', 'エリア': 'area',
-            'liste description': 'dl', 'description list': 'dl', 'lista descripcion': 'dl', 'lista descripción': 'dl', 'список описания': 'dl', '描述列表': 'dl', '説明リスト': 'dl',
-            'terme': 'dt', 'term': 'dt', 'término': 'dt', 'termino': 'dt', 'термин': 'dt', '术语': 'dt', '用語': 'dt',
-            'description': 'dd', 'descripción': 'dd', 'descripcion': 'dd', 'описание': 'dd', '描述': 'dd', '説明': 'dd',
-            'entete tableau': 'thead', 'entête tableau': 'thead', 'table header': 'thead', 'encabezado tabla': 'thead', 'заголовок таблицы': 'thead', '表头': 'thead', 'テーブルヘッダー': 'thead',
-            'corps tableau': 'tbody', 'table body': 'tbody', 'cuerpo tabla': 'tbody', 'тело таблицы': 'tbody', '表体': 'tbody', 'テーブル本体': 'tbody',
-            'pied tableau': 'tfoot', 'table footer': 'tfoot', 'pie tabla': 'tfoot', 'подвал таблицы': 'tfoot', '表脚': 'tfoot', 'テーブルフッター': 'tfoot',
-            'groupe colonnes': 'colgroup', 'column group': 'colgroup', 'grupo columnas': 'colgroup', 'группа колонок': 'colgroup', '列组': 'colgroup', '列グループ': 'colgroup',
-            'colonne': 'col', 'column': 'col', 'columna': 'col', 'колонка': 'col', '列': 'col',
-            'legende tableau': 'caption', 'légende tableau': 'caption', 'table caption': 'caption', 'leyenda tabla': 'caption', 'подпись таблицы': 'caption', '表格标题': 'caption', 'テーブルキャプション': 'caption',
-            'image reactive': 'picture', 'image réactive': 'picture', 'picture': 'picture', 'imagen reactiva': 'picture', 'адаптивное изображение': 'picture', '响应式图片': 'picture', 'レスポンシブ画像': 'picture',
-            'ruby': 'ruby', 'рубин': 'ruby', '注音': 'ruby', 'ルビ': 'ruby',
-            'annotation ruby': 'rt', 'ruby text': 'rt', 'anotacion ruby': 'rt', 'anotación ruby': 'rt', 'аннотация ruby': 'rt', 'ruby注释': 'rt', 'ルビ注釈': 'rt',
-            'parentheses ruby': 'rp', 'parenthèses ruby': 'rp', 'ruby parenthesis': 'rp', 'paréntesis ruby': 'rp', 'скобки ruby': 'rp', 'ruby括号': 'rp', 'ルビ括弧': 'rp',
-            'isolation bidi': 'bdi', 'bidi isolation': 'bdi', 'aislamiento bidi': 'bdi', 'изоляция bidi': 'bdi', '双向隔离': 'bdi', '双方向分離': 'bdi',
-            'remplacement bidi': 'bdo', 'bidi override': 'bdo', 'reemplazo bidi': 'bdo', 'переопределение bidi': 'bdo', '双向覆盖': 'bdo', '双方向オーバーライド': 'bdo',
-            'retour ligne possible': 'wbr', 'word break': 'wbr', 'wbr': 'wbr', 'oportunidad salto': 'wbr', 'возможность переноса': 'wbr', '换行机会': 'wbr', '改行可能': 'wbr',
-            'donnees': 'data', 'données': 'data', 'data': 'data', 'datos': 'data', 'данные': 'data', '数据': 'data', 'データ': 'data'
-        }
-        
-        return directMap[lowerName] || name
-    }
-
-    translateAttribute(name) {
-        const lowerName = name.toLowerCase()
-        
-        const attrs = this.i18n.globalAttributes || {}
-        for (const item of Object.values(attrs)) {
-            if (typeof item === 'object' && item !== null && item.html) {
-                for (const [lang, translation] of Object.entries(item)) {
-                    if (lang !== 'html' && typeof translation === 'string' && 
-                        translation.toLowerCase() === lowerName) {
-                        return item.html
-                    }
-                }
-            }
-        }
-        
-        const directMap = {
-            'id': 'id', 'identifiant': 'id', 'identificador': 'id', 'идентификатор': 'id', '标识': 'id', '識別子': 'id',
-            'classe': 'class', 'class': 'class', 'clase': 'class', 'класс': 'class', '类': 'class', 'クラス': 'class',
-            'style': 'style', 'estilo': 'style', 'стиль': 'style', '样式': 'style', 'スタイル': 'style',
-            'titre': 'title', 'title': 'title', 'título': 'title', 'titulo': 'title', 'заголовок': 'title', '标题': 'title', 'タイトル': 'title',
-            'source': 'src', 'src': 'src', 'fuente': 'src', 'источник': 'src', '来源': 'src', 'ソース': 'src',
-            'alternative': 'alt', 'alt': 'alt', 'alternativa': 'alt', 'альтернатива': 'alt', '替代': 'alt', '代替': 'alt',
-            'largeur': 'width', 'width': 'width', 'ancho': 'width', 'ширина': 'width', '宽度': 'width', '幅': 'width',
-            'hauteur': 'height', 'height': 'height', 'alto': 'height', 'высота': 'height', '高度': 'height', '高さ': 'height',
-            'href': 'href', 'lien': 'href', 'enlace': 'href', 'ссылка': 'href', '链接': 'href', 'リンク': 'href',
-            'cible': 'target', 'target': 'target', 'objetivo': 'target', 'цель': 'target', '目标': 'target', 'ターゲット': 'target',
-            'type': 'type', 'tipo': 'type', 'тип': 'type', '类型': 'type', 'タイプ': 'type',
-            'nom': 'name', 'name': 'name', 'nombre': 'name', 'имя': 'name', '名称': 'name', '名前': 'name',
-            'valeur': 'value', 'value': 'value', 'valor': 'value', 'значение': 'value', '值': 'value', '値': 'value',
-            'placeholder': 'placeholder', 'marcador': 'placeholder', 'заполнитель': 'placeholder', '占位符': 'placeholder', 'プレースホルダー': 'placeholder',
-            'action': 'action', 'acción': 'action', 'accion': 'action', 'действие': 'action', '动作': 'action', 'アクション': 'action',
-            'methode': 'method', 'méthode': 'method', 'method': 'method', 'método': 'method', 'metodo': 'method', 'метод': 'method', '方法': 'method', 'メソッド': 'method',
-            'pour': 'for', 'for': 'for', 'para': 'for', 'для': 'for', '为': 'for', 'フォー': 'for',
-            'donnees': 'data', 'données': 'data', 'data': 'data', 'datos': 'data', 'данные': 'data', '数据': 'data', 'データ': 'data',
-            'role': 'role', 'rôle': 'role', 'rol': 'role', 'роль': 'role', '角色': 'role', 'ロール': 'role',
-            'tabindex': 'tabindex', 'indice tab': 'tabindex', 'índice tab': 'tabindex', 'индекс tab': 'tabindex', 'Tab索引': 'tabindex', 'タブインデックス': 'tabindex',
-            'lang': 'lang', 'langue': 'lang', 'idioma': 'lang', 'язык': 'lang', '语言': 'lang', '言語': 'lang',
-            'dir': 'dir', 'direction': 'dir', 'dirección': 'dir', 'direccion': 'dir', 'направление': 'dir', '方向': 'dir',
-            'rel': 'rel', 'relation': 'rel', 'relación': 'rel', 'relacion': 'rel', 'отношение': 'rel', '关系': 'rel', '関係': 'rel',
-            'media': 'media', 'média': 'media', 'медиа': 'media', '媒体': 'media', 'メディア': 'media',
-            'contenu': 'content', 'content': 'content', 'contenido': 'content', 'содержимое': 'content', '内容': 'content', 'コンテンツ': 'content',
-            'charset': 'charset', 'encodage': 'charset', 'codificación': 'charset', 'codificacion': 'charset', 'кодировка': 'charset', '字符集': 'charset', '文字セット': 'charset',
-            'colonnes': 'cols', 'cols': 'cols', 'columnas': 'cols', 'колонки': 'cols', '列数': 'cols',
-            'lignes': 'rows', 'rows': 'rows', 'filas': 'rows', 'строки': 'rows', '行数': 'rows',
-            'fusion colonnes': 'colspan', 'colspan': 'colspan', 'combinacion columnas': 'colspan', 'объединение колонок': 'colspan', '合并列': 'colspan', '列結合': 'colspan',
-            'fusion lignes': 'rowspan', 'rowspan': 'rowspan', 'combinacion filas': 'rowspan', 'объединение строк': 'rowspan', '合并行': 'rowspan', '行結合': 'rowspan',
-            'min': 'min', 'minimum': 'min', 'mínimo': 'min', 'minimo': 'min', 'минимум': 'min', '最小': 'min',
-            'max': 'max', 'maximum': 'max', 'máximo': 'max', 'maximo': 'max', 'максимум': 'max', '最大': 'max',
-            'pas': 'step', 'step': 'step', 'paso': 'step', 'шаг': 'step', '步长': 'step', 'ステップ': 'step',
-            'motif': 'pattern', 'pattern': 'pattern', 'patrón': 'pattern', 'patron': 'pattern', 'шаблон': 'pattern', '模式': 'pattern', 'パターン': 'pattern',
-            'requis': 'required', 'required': 'required', 'requerido': 'required', 'обязательный': 'required', '必填': 'required', '必須': 'required',
-            'obligatoire': 'required', 'obligatorio': 'required',
-            'desactive': 'disabled', 'désactivé': 'disabled', 'disabled': 'disabled', 'desactivado': 'disabled', 'отключенный': 'disabled', '禁用': 'disabled', '無効': 'disabled',
-            'inactif': 'disabled', 'inactivo': 'disabled',
-            'coche': 'checked', 'coché': 'checked', 'checked': 'checked', 'marcado': 'checked', 'отмеченный': 'checked', '选中': 'checked', 'チェック済み': 'checked',
-            'selectionne': 'selected', 'sélectionné': 'selected', 'selected': 'selected', 'seleccionado': 'selected', 'выбранный': 'selected', '已选择': 'selected', '選択済み': 'selected',
-            'lecture seule': 'readonly', 'readonly': 'readonly', 'solo lectura': 'readonly', 'только чтение': 'readonly', '只读': 'readonly', '読み取り専用': 'readonly',
-            'multiple': 'multiple', 'múltiple': 'multiple', 'множественный': 'multiple', '多个': 'multiple', '複数': 'multiple',
-            'autofocus': 'autofocus', 'focus auto': 'autofocus', 'enfoque automatico': 'autofocus', 'enfoque automático': 'autofocus', 'автофокус': 'autofocus', '自动聚焦': 'autofocus', '自動フォーカス': 'autofocus',
-            'autocompleter': 'autocomplete', 'autocompléter': 'autocomplete', 'autocomplete': 'autocomplete', 'autocompletar': 'autocomplete', 'автозаполнение': 'autocomplete', '自动完成': 'autocomplete', 'オートコンプリート': 'autocomplete',
-            'controles': 'controls', 'contrôles': 'controls', 'controls': 'controls', 'управление': 'controls', '控件': 'controls', 'コントロール': 'controls',
-            'lecture auto': 'autoplay', 'autoplay': 'autoplay', 'reproduccion automatica': 'autoplay', 'reproducción automática': 'autoplay', 'автовоспроизведение': 'autoplay', '自动播放': 'autoplay', '自動再生': 'autoplay',
-            'muet': 'muted', 'muted': 'muted', 'silenciado': 'muted', 'без звука': 'muted', '静音': 'muted', 'ミュート': 'muted',
-            'en boucle': 'loop', 'loop': 'loop', 'en bucle': 'loop', 'цикл': 'loop', '循环': 'loop', 'ループ': 'loop',
-            'affiche': 'poster', 'poster': 'poster', 'cartel': 'poster', 'постер': 'poster', '海报': 'poster', 'ポスター': 'poster',
-            'prechargement': 'preload', 'préchargement': 'preload', 'preload': 'preload', 'precarga': 'preload', 'предзагрузка': 'preload', '预加载': 'preload', 'プリロード': 'preload',
-            'ouvert': 'open', 'open': 'open', 'abierto': 'open', 'открытый': 'open', '打开': 'open', '開く': 'open',
-            'cache': 'hidden', 'caché': 'hidden', 'hidden': 'hidden', 'oculto': 'hidden', 'скрытый': 'hidden', '隐藏': 'hidden', '非表示': 'hidden',
-            'draggable': 'draggable', 'deplacable': 'draggable', 'déplaçable': 'draggable', 'arrastrable': 'draggable', 'перетаскиваемый': 'draggable', '可拖动': 'draggable', 'ドラッグ可能': 'draggable',
-            'editable': 'contenteditable', 'éditable': 'contenteditable', 'contenteditable': 'contenteditable', 'редактируемый': 'contenteditable', '可编辑': 'contenteditable', '編集可能': 'contenteditable',
-            'chargement': 'loading', 'loading': 'loading', 'carga': 'loading', 'загрузка': 'loading', '加载': 'loading', 'ローディング': 'loading',
-            'decodage': 'decoding', 'décodage': 'decoding', 'decoding': 'decoding', 'decodificación': 'decoding', 'декодирование': 'decoding', '解码': 'decoding', 'デコード': 'decoding',
-            'integrite': 'integrity', 'intégrité': 'integrity', 'integrity': 'integrity', 'integridad': 'integrity', 'целостность': 'integrity', '完整性': 'integrity', '整合性': 'integrity',
-            'origine croisee': 'crossorigin', 'origine croisée': 'crossorigin', 'crossorigin': 'crossorigin', 'origen cruzado': 'crossorigin', 'кросс-происхождение': 'crossorigin', '跨域': 'crossorigin', 'クロスオリジン': 'crossorigin',
-            'accepter': 'accept', 'accept': 'accept', 'aceptar': 'accept', 'принимать': 'accept', '接受': 'accept', '受け入れ': 'accept',
-            'taille': 'size', 'size': 'size', 'tamaño': 'size', 'tamano': 'size', 'размер': 'size', '大小': 'size', 'サイズ': 'size',
-            'longueur max': 'maxlength', 'maxlength': 'maxlength', 'longitud maxima': 'maxlength', 'longitud máxima': 'maxlength', 'макс длина': 'maxlength', '最大长度': 'maxlength', '最大長': 'maxlength',
-            'longueur min': 'minlength', 'minlength': 'minlength', 'longitud minima': 'minlength', 'longitud mínima': 'minlength', 'мин длина': 'minlength', '最小长度': 'minlength', '最小長': 'minlength',
-            'formulaire': 'form', 'form': 'form', 'formulario': 'form', 'форма': 'form', '表单': 'form', 'フォーム': 'form',
-            'liste': 'list', 'list': 'list', 'lista': 'list', 'список': 'list', '列表': 'list', 'リスト': 'list',
-            'wrap': 'wrap', 'ajuste': 'wrap', 'перенос': 'wrap', '换行': 'wrap', 'ラップ': 'wrap',
-            'spellcheck': 'spellcheck', 'verification orthographe': 'spellcheck', 'vérification orthographe': 'spellcheck', 'corrector ortografico': 'spellcheck', 'corrector ortográfico': 'spellcheck', 'проверка орфографии': 'spellcheck', '拼写检查': 'spellcheck', 'スペルチェック': 'spellcheck',
-            'inputmode': 'inputmode', 'mode saisie': 'inputmode', 'modo entrada': 'inputmode', 'режим ввода': 'inputmode', '输入模式': 'inputmode', '入力モード': 'inputmode',
-            'enterkeyhint': 'enterkeyhint', 'touche entree': 'enterkeyhint', 'tecla enter': 'enterkeyhint', 'подсказка enter': 'enterkeyhint', 'Enter提示': 'enterkeyhint', 'Enterキーヒント': 'enterkeyhint',
-            'scope': 'scope', 'portee': 'scope', 'portée': 'scope', 'alcance': 'scope', 'область': 'scope', '范围': 'scope', 'スコープ': 'scope',
-            'headers': 'headers', 'entetes': 'headers', 'entêtes': 'headers', 'encabezados': 'headers', 'заголовки': 'headers', '表头': 'headers', 'ヘッダー': 'headers',
-            'defer': 'defer', 'differer': 'defer', 'différer': 'defer', 'diferir': 'defer', 'отложить': 'defer', '延迟': 'defer', '遅延': 'defer',
-            'async': 'async', 'asynchrone': 'async', 'asíncrono': 'async', 'asincrono': 'async', 'асинхронный': 'async', '异步': 'async', '非同期': 'async',
-            'novalidate': 'novalidate', 'sans validation': 'novalidate', 'sin validacion': 'novalidate', 'sin validación': 'novalidate', 'без валидации': 'novalidate', '无验证': 'novalidate', '検証なし': 'novalidate',
-            'enctype': 'enctype', 'encodage type': 'enctype', 'tipo codificacion': 'enctype', 'tipo codificación': 'enctype', 'тип кодировки': 'enctype', '编码类型': 'enctype', 'エンコードタイプ': 'enctype',
-            'download': 'download', 'telecharger': 'download', 'télécharger': 'download', 'descargar': 'download', 'скачать': 'download', '下载': 'download', 'ダウンロード': 'download',
-            'ping': 'ping', 'пинг': 'ping',
-            'referrerpolicy': 'referrerpolicy', 'politique referent': 'referrerpolicy', 'politique référent': 'referrerpolicy', 'politica referente': 'referrerpolicy', 'política referente': 'referrerpolicy', 'политика реферера': 'referrerpolicy', '引用策略': 'referrerpolicy', 'リファラーポリシー': 'referrerpolicy',
-            'sandbox': 'sandbox', 'bac a sable': 'sandbox', 'bac à sable': 'sandbox', 'zona arena': 'sandbox', 'песочница': 'sandbox', '沙盒': 'sandbox', 'サンドボックス': 'sandbox',
-            'allow': 'allow', 'autoriser': 'allow', 'permitir': 'allow', 'разрешить': 'allow', '允许': 'allow', '許可': 'allow',
-            'srcdoc': 'srcdoc', 'document source': 'srcdoc', 'documento fuente': 'srcdoc', 'исходный документ': 'srcdoc', '源文档': 'srcdoc', 'ソースドキュメント': 'srcdoc',
-            'usemap': 'usemap', 'utiliser carte': 'usemap', 'usar mapa': 'usemap', 'использовать карту': 'usemap', '使用地图': 'usemap', 'マップ使用': 'usemap',
-            'ismap': 'ismap', 'est carte': 'ismap', 'es mapa': 'ismap', 'это карта': 'ismap', '是地图': 'ismap', 'マップである': 'ismap',
-            'coords': 'coords', 'coordonnees': 'coords', 'coordonnées': 'coords', 'coordenadas': 'coords', 'координаты': 'coords', '坐标': 'coords', '座標': 'coords',
-            'shape': 'shape', 'forme': 'shape', 'forma': 'shape', 'форма': 'shape', '形状': 'shape', '形': 'shape',
-            'datetime': 'datetime', 'date heure': 'datetime', 'fecha hora': 'datetime', 'дата время': 'datetime', '日期时间': 'datetime', '日時': 'datetime',
-            'cite': 'cite', 'citer': 'cite', 'citar': 'cite', 'цитировать': 'cite', '引用': 'cite',
-            'reversed': 'reversed', 'inverse': 'reversed', 'invertido': 'reversed', 'обратный': 'reversed', '反转': 'reversed', '逆順': 'reversed',
-            'start': 'start', 'debut': 'start', 'début': 'start', 'inicio': 'start', 'начало': 'start', '开始': 'start', '開始': 'start',
-            'high': 'high', 'haut': 'high', 'alto': 'high', 'высокий': 'high', '高': 'high',
-            'low': 'low', 'bas': 'low', 'bajo': 'low', 'низкий': 'low', '低': 'low',
-            'optimum': 'optimum', 'optimal': 'optimum', 'óptimo': 'optimum', 'optimo': 'optimum', 'оптимальный': 'optimum', '最佳': 'optimum', '最適': 'optimum'
-        }
-        
-        return directMap[lowerName] || name
-    }
-}
-
-class HTMLCodeGenerator {
-    constructor(options = {}) {
-        this.indent = 0
-        this.indentStr = options.indentStr || '  '
-        this.selfClosingStyle = options.selfClosingStyle || 'html'
-    }
-
-    generate(ast) {
-        if (!ast) return ''
-        
-        switch (ast.type) {
-            case 'Document':
-                return this.generateDocument(ast)
-            case 'Doctype':
-                return this.generateDoctype(ast)
-            case 'Element':
-                return this.generateElement(ast)
-            case 'TextNode':
-                return this.escapeHtml(ast.content)
-            case 'Comment':
-                return `<!-- ${ast.content} -->`
-            case 'Fragment':
-                return ast.children.map(c => this.generate(c)).join('')
-            case 'EtherDirective':
-                return ''
-            case 'EtherLoop':
-                return this.generateLoop(ast)
-            case 'EtherConditional':
-                return this.generateConditional(ast)
-            case 'EtherExpression':
-                return `<!-- ${ast.expression} -->`
-            default:
-                return ''
-        }
-    }
-
-    generateDocument(ast) {
-        let html = ''
-        if (ast.doctype) {
-            html += this.generateDoctype(ast.doctype) + '\n'
-        }
-        if (ast.html) {
-            html += this.generate(ast.html)
-        }
-        return html
-    }
-
-    generateDoctype(ast) {
-        if (ast.publicId) {
-            return `<!DOCTYPE ${ast.name} PUBLIC "${ast.publicId}" "${ast.systemId || ''}">`
-        }
-        return `<!DOCTYPE ${ast.name}>`
-    }
-
-    generateElement(ast) {
-        const tag = ast.htmlTag
-        const attrs = this.generateAttributes(ast.attributes)
-        const attrStr = attrs ? ' ' + attrs : ''
-        
-        if (ast.selfClosing || VOID_ELEMENTS.has(tag)) {
-            if (this.selfClosingStyle === 'xhtml') {
-                return `<${tag}${attrStr} />`
-            }
-            return `<${tag}${attrStr}>`
-        }
-        
-        const children = ast.children.map(c => this.generate(c)).join('')
-        
-        if (children.includes('\n') || children.length > 80) {
-            const indentedChildren = this.indentContent(children)
-            return `<${tag}${attrStr}>\n${indentedChildren}\n${this.getIndent()}</${tag}>`
-        }
-        
-        return `<${tag}${attrStr}>${children}</${tag}>`
-    }
-
-    generateAttributes(attributes) {
-        return attributes.map(attr => {
-            if (attr.type === 'BooleanAttribute') {
-                return attr.htmlName
-            }
-            const value = this.escapeAttr(attr.value || '')
-            return `${attr.htmlName}="${value}"`
-        }).join(' ')
-    }
-
-    generateLoop(ast) {
-        return ast.children.map(c => this.generate(c)).join('')
-    }
-
-    generateConditional(ast) {
-        return ast.thenBranch.map(c => this.generate(c)).join('')
-    }
-
-    escapeHtml(str) {
-        if (!str) return ''
-        return str
-            .replace(/&/g, '&amp;')
-            .replace(/</g, '&lt;')
-            .replace(/>/g, '&gt;')
-    }
-
-    escapeAttr(str) {
-        if (!str) return ''
-        return str
-            .replace(/&/g, '&amp;')
-            .replace(/"/g, '&quot;')
-            .replace(/</g, '&lt;')
-            .replace(/>/g, '&gt;')
-    }
-
-    getIndent() {
-        return this.indentStr.repeat(this.indent)
-    }
-
-    indentContent(content) {
-        this.indent++
-        const lines = content.split('\n').map(line => this.getIndent() + line.trim()).join('\n')
-        this.indent--
-        return lines
-    }
-}
-
-module.exports = {
-    HTMLLexer,
-    HTMLParser,
-    HTMLCodeGenerator,
-    VOID_ELEMENTS
-}