ether-code 0.1.6 → 0.1.8

package/parsers/react-parser.js

@@ -1,1035 +0,0 @@
-const fs = require('fs')
-const { JSLexer, JSParser, JSCodeGenerator } = require('./js-parser')
-const AST = require('./ast-react')
-
-const SELF_CLOSING_TAGS = new Set([
-    'area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input',
-    'link', 'meta', 'param', 'source', 'track', 'wbr'
-])
-
-const REACT_HOOKS = {
-    'useState': 'useState', 'utiliser etat': 'useState', 'utiliser état': 'useState', 'usar estado': 'useState',
-    'использовать состояние': 'useState', '使用状态': 'useState', 'ステート使用': 'useState',
-    
-    'useEffect': 'useEffect', 'utiliser effet': 'useEffect', 'usar efecto': 'useEffect',
-    'использовать эффект': 'useEffect', '使用副作用': 'useEffect', 'エフェクト使用': 'useEffect',
-    
-    'useContext': 'useContext', 'utiliser contexte': 'useContext', 'usar contexto': 'useContext',
-    'использовать контекст': 'useContext', '使用上下文': 'useContext', 'コンテキスト使用': 'useContext',
-    
-    'useReducer': 'useReducer', 'utiliser reducteur': 'useReducer', 'utiliser réducteur': 'useReducer', 'usar reductor': 'useReducer',
-    'использовать редьюсер': 'useReducer', '使用归约器': 'useReducer', 'リデューサー使用': 'useReducer',
-    
-    'useCallback': 'useCallback', 'utiliser rappel': 'useCallback', 'usar callback': 'useCallback',
-    'использовать колбэк': 'useCallback', '使用回调': 'useCallback', 'コールバック使用': 'useCallback',
-    
-    'useMemo': 'useMemo', 'utiliser memo': 'useMemo', 'utiliser mémo': 'useMemo', 'usar memo': 'useMemo',
-    'использовать мемо': 'useMemo', '使用记忆': 'useMemo', 'メモ使用': 'useMemo',
-    
-    'useRef': 'useRef', 'utiliser reference': 'useRef', 'utiliser référence': 'useRef', 'usar referencia': 'useRef',
-    'использовать ссылку': 'useRef', '使用引用': 'useRef', 'リファレンス使用': 'useRef',
-    
-    'useImperativeHandle': 'useImperativeHandle', 'utiliser handle imperatif': 'useImperativeHandle', 'utiliser handle impératif': 'useImperativeHandle',
-    'usar handle imperativo': 'useImperativeHandle', 'использовать императивный хэндл': 'useImperativeHandle',
-    '使用命令式句柄': 'useImperativeHandle', '命令型ハンドル使用': 'useImperativeHandle',
-    
-    'useLayoutEffect': 'useLayoutEffect', 'utiliser effet mise en page': 'useLayoutEffect',
-    'usar efecto diseño': 'useLayoutEffect', 'usar efecto diseno': 'useLayoutEffect',
-    'использовать эффект макета': 'useLayoutEffect', '使用布局副作用': 'useLayoutEffect', 'レイアウトエフェクト使用': 'useLayoutEffect',
-    
-    'useInsertionEffect': 'useInsertionEffect', 'utiliser effet insertion': 'useInsertionEffect',
-    'usar efecto insercion': 'useInsertionEffect', 'usar efecto inserción': 'useInsertionEffect',
-    'использовать эффект вставки': 'useInsertionEffect', '使用插入副作用': 'useInsertionEffect', '挿入エフェクト使用': 'useInsertionEffect',
-    
-    'useDebugValue': 'useDebugValue', 'utiliser valeur debug': 'useDebugValue',
-    'usar valor debug': 'useDebugValue', 'использовать значение отладки': 'useDebugValue',
-    '使用调试值': 'useDebugValue', 'デバッグ値使用': 'useDebugValue',
-    
-    'useTransition': 'useTransition', 'utiliser transition': 'useTransition',
-    'usar transicion': 'useTransition', 'usar transición': 'useTransition',
-    'использовать переход': 'useTransition', '使用过渡': 'useTransition', 'トランジション使用': 'useTransition',
-    
-    'useDeferredValue': 'useDeferredValue', 'utiliser valeur differee': 'useDeferredValue', 'utiliser valeur différée': 'useDeferredValue',
-    'usar valor diferido': 'useDeferredValue', 'использовать отложенное значение': 'useDeferredValue',
-    '使用延迟值': 'useDeferredValue', '遅延値使用': 'useDeferredValue',
-    
-    'useId': 'useId', 'utiliser identifiant': 'useId', 'usar id': 'useId', 'usar identificador': 'useId',
-    'использовать идентификатор': 'useId', '使用ID': 'useId', 'ID使用': 'useId',
-    
-    'useSyncExternalStore': 'useSyncExternalStore', 'utiliser etat synchronise': 'useSyncExternalStore', 'utiliser état synchronisé': 'useSyncExternalStore',
-    'usar almacen externo sincronizado': 'useSyncExternalStore', 'usar almacén externo sincronizado': 'useSyncExternalStore',
-    'использовать синхронизированное внешнее хранилище': 'useSyncExternalStore',
-    '使用同步外部存储': 'useSyncExternalStore', '外部ストア同期使用': 'useSyncExternalStore',
-    
-    'useActionState': 'useActionState', 'utiliser etat action': 'useActionState', 'utiliser état action': 'useActionState',
-    'usar estado accion': 'useActionState', 'usar estado acción': 'useActionState',
-    'использовать состояние действия': 'useActionState', '使用动作状态': 'useActionState', 'アクション状態使用': 'useActionState',
-    
-    'useFormStatus': 'useFormStatus', 'utiliser statut formulaire': 'useFormStatus',
-    'usar estado formulario': 'useFormStatus', 'использовать статус формы': 'useFormStatus',
-    '使用表单状态': 'useFormStatus', 'フォームステータス使用': 'useFormStatus',
-    
-    'useOptimistic': 'useOptimistic', 'utiliser optimiste': 'useOptimistic',
-    'usar optimista': 'useOptimistic', 'использовать оптимистичный': 'useOptimistic',
-    '使用乐观': 'useOptimistic', 'オプティミスティック使用': 'useOptimistic',
-    
-    'use': 'use', 'utiliser': 'use', 'usar': 'use', 'использовать': 'use', '使用': 'use', '使う': 'use'
-}
-
-const REACT_COMPONENTS = {
-    'Fragment': 'Fragment', 'fragment': 'Fragment', 'fragmento': 'Fragment',
-    'фрагмент': 'Fragment', '片段': 'Fragment', 'フラグメント': 'Fragment',
-    
-    'Suspense': 'Suspense', 'suspense': 'Suspense', 'suspenso': 'Suspense',
-    'ожидание': 'Suspense', '悬念': 'Suspense', 'サスペンス': 'Suspense',
-    
-    'StrictMode': 'StrictMode', 'strict mode': 'StrictMode', 'mode strict': 'StrictMode', 'modo estricto': 'StrictMode',
-    'строгий режим': 'StrictMode', '严格模式': 'StrictMode', 'ストリクトモード': 'StrictMode',
-    
-    'Profiler': 'Profiler', 'profileur': 'Profiler', 'perfilador': 'Profiler',
-    'профайлер': 'Profiler', '性能分析器': 'Profiler', 'プロファイラー': 'Profiler',
-    
-    'ErrorBoundary': 'ErrorBoundary', 'limite erreur': 'ErrorBoundary', 'límite error': 'ErrorBoundary', 'limite error': 'ErrorBoundary',
-    'граница ошибки': 'ErrorBoundary', '错误边界': 'ErrorBoundary', 'エラーバウンダリ': 'ErrorBoundary',
-    
-    'Provider': 'Provider', 'fournisseur': 'Provider', 'proveedor': 'Provider',
-    'провайдер': 'Provider', '提供者': 'Provider', 'プロバイダー': 'Provider',
-    
-    'Consumer': 'Consumer', 'consommateur': 'Consumer', 'consumidor': 'Consumer',
-    'потребитель': 'Consumer', '消费者': 'Consumer', 'コンシューマー': 'Consumer',
-    
-    'Portal': 'Portal', 'portail': 'Portal', 'portal': 'Portal',
-    'портал': 'Portal', '传送门': 'Portal', 'ポータル': 'Portal',
-    
-    'Lazy': 'Lazy', 'lazy': 'Lazy', 'paresseux': 'Lazy', 'perezoso': 'Lazy',
-    'ленивый': 'Lazy', '懒加载': 'Lazy', 'レイジー': 'Lazy',
-    
-    'Memo': 'Memo', 'memo': 'Memo', 'мемо': 'Memo', '记忆': 'Memo', 'メモ': 'Memo',
-    
-    'ForwardRef': 'ForwardRef', 'reference avancee': 'ForwardRef', 'référence avancée': 'ForwardRef',
-    'referencia adelantada': 'ForwardRef', 'перенаправленная ссылка': 'ForwardRef',
-    '转发引用': 'ForwardRef', 'フォワードリファレンス': 'ForwardRef'
-}
-
-class ReactLexer extends JSLexer {
-    constructor(source, i18n) {
-        super(source, i18n)
-        this.inJSX = false
-    }
-
-    tokenize() {
-        while (this.pos < this.source.length) {
-            this.skipWhitespace()
-            if (this.pos >= this.source.length) break
-            
-            const loc = { line: this.line, column: this.column }
-            const char = this.peek()
-            
-            if (char === '<') {
-                if (this.peek(1) === '/' || this.peek(1) === '>' || /[a-zA-Z_]/.test(this.peek(1))) {
-                    this.tokens.push(this.readJSXToken())
-                    continue
-                }
-            }
-            
-            if (char === '"' || char === "'") {
-                this.tokens.push(this.readString(char))
-                continue
-            }
-            
-            if (char === '`') {
-                this.tokens.push(this.readTemplateLiteral())
-                continue
-            }
-            
-            if (/[0-9]/.test(char) || (char === '.' && /[0-9]/.test(this.peek(1)))) {
-                this.tokens.push(this.readNumber())
-                continue
-            }
-            
-            if (/[a-zA-ZÀ-ÿА-яぁ-ゟァ-ヿ一-龯_$]/.test(char)) {
-                const { word, loc: wordLoc } = this.readWord()
-                const tokenType = this.classifyReactWord(word)
-                this.tokens.push({ type: tokenType, value: word, loc: wordLoc })
-                continue
-            }
-            
-            if (char === '{') {
-                this.tokens.push({ type: 'LBRACE', loc })
-                this.advance()
-                continue
-            }
-            if (char === '}') {
-                this.tokens.push({ type: 'RBRACE', loc })
-                this.advance()
-                continue
-            }
-            if (char === '(') {
-                this.tokens.push({ type: 'LPAREN', loc })
-                this.advance()
-                continue
-            }
-            if (char === ')') {
-                this.tokens.push({ type: 'RPAREN', loc })
-                this.advance()
-                continue
-            }
-            if (char === '[') {
-                this.tokens.push({ type: 'LBRACKET', loc })
-                this.advance()
-                continue
-            }
-            if (char === ']') {
-                this.tokens.push({ type: 'RBRACKET', loc })
-                this.advance()
-                continue
-            }
-            
-            const threeChar = this.source.slice(this.pos, this.pos + 3)
-            const twoChar = this.source.slice(this.pos, this.pos + 2)
-            
-            if (threeChar === '...') {
-                this.tokens.push({ type: 'SPREAD', value: '...', loc })
-                this.advance(); this.advance(); this.advance()
-                continue
-            }
-            if (twoChar === '=>') {
-                this.tokens.push({ type: 'ARROW', value: '=>', loc })
-                this.advance(); this.advance()
-                continue
-            }
-            if (twoChar === '?.') {
-                this.tokens.push({ type: 'OPTIONAL_CHAIN', value: '?.', loc })
-                this.advance(); this.advance()
-                continue
-            }
-            if (twoChar === '&&') {
-                this.tokens.push({ type: 'AND', value: '&&', loc })
-                this.advance(); this.advance()
-                continue
-            }
-            if (twoChar === '||') {
-                this.tokens.push({ type: 'OR', value: '||', loc })
-                this.advance(); this.advance()
-                continue
-            }
-            if (twoChar === '??') {
-                this.tokens.push({ type: 'NULLISH', value: '??', loc })
-                this.advance(); this.advance()
-                continue
-            }
-            if (twoChar === '===') {
-                this.tokens.push({ type: 'STRICT_EQUAL', value: '===', loc })
-                this.advance(); this.advance(); this.advance()
-                continue
-            }
-            if (twoChar === '==') {
-                this.tokens.push({ type: 'EQUAL', value: '==', loc })
-                this.advance(); this.advance()
-                continue
-            }
-            if (twoChar === '!==') {
-                this.tokens.push({ type: 'STRICT_NOT_EQUAL', value: '!==', loc })
-                this.advance(); this.advance(); this.advance()
-                continue
-            }
-            if (twoChar === '!=') {
-                this.tokens.push({ type: 'NOT_EQUAL', value: '!=', loc })
-                this.advance(); this.advance()
-                continue
-            }
-            
-            if (char === '=') {
-                this.tokens.push({ type: 'ASSIGN', value: '=', loc })
-                this.advance()
-                continue
-            }
-            if (char === '+') {
-                this.tokens.push({ type: 'PLUS', value: '+', loc })
-                this.advance()
-                continue
-            }
-            if (char === '-') {
-                this.tokens.push({ type: 'MINUS', value: '-', loc })
-                this.advance()
-                continue
-            }
-            if (char === '*') {
-                this.tokens.push({ type: 'STAR', value: '*', loc })
-                this.advance()
-                continue
-            }
-            if (char === '/') {
-                this.tokens.push({ type: 'SLASH', value: '/', loc })
-                this.advance()
-                continue
-            }
-            if (char === '%') {
-                this.tokens.push({ type: 'PERCENT', value: '%', loc })
-                this.advance()
-                continue
-            }
-            if (char === '<') {
-                this.tokens.push({ type: 'LT', value: '<', loc })
-                this.advance()
-                continue
-            }
-            if (char === '>') {
-                this.tokens.push({ type: 'GT', value: '>', loc })
-                this.advance()
-                continue
-            }
-            if (char === '!') {
-                this.tokens.push({ type: 'NOT', value: '!', loc })
-                this.advance()
-                continue
-            }
-            if (char === '?') {
-                this.tokens.push({ type: 'QUESTION', value: '?', loc })
-                this.advance()
-                continue
-            }
-            if (char === ':') {
-                this.tokens.push({ type: 'COLON', value: ':', loc })
-                this.advance()
-                continue
-            }
-            if (char === '.') {
-                this.tokens.push({ type: 'DOT', value: '.', loc })
-                this.advance()
-                continue
-            }
-            if (char === ',') {
-                this.tokens.push({ type: 'COMMA', value: ',', loc })
-                this.advance()
-                continue
-            }
-            if (char === ';') {
-                this.tokens.push({ type: 'SEMICOLON', value: ';', loc })
-                this.advance()
-                continue
-            }
-            
-            this.advance()
-        }
-        
-        this.tokens.push({ type: 'EOF', loc: { line: this.line, column: this.column } })
-        return this.tokens
-    }
-
-    readJSXToken() {
-        const loc = { line: this.line, column: this.column }
-        this.advance()
-        
-        if (this.peek() === '/') {
-            this.advance()
-            if (this.peek() === '>') {
-                this.advance()
-                return { type: 'JSX_FRAGMENT_CLOSE', loc }
-            }
-            const name = this.readJSXName()
-            this.skipWhitespace()
-            if (this.peek() === '>') this.advance()
-            return { type: 'JSX_CLOSE', name, loc }
-        }
-        
-        if (this.peek() === '>') {
-            this.advance()
-            return { type: 'JSX_FRAGMENT_OPEN', loc }
-        }
-        
-        const name = this.readJSXName()
-        const attributes = []
-        let selfClosing = false
-        
-        while (this.pos < this.source.length) {
-            this.skipWhitespace()
-            const char = this.peek()
-            
-            if (char === '>') {
-                this.advance()
-                break
-            }
-            
-            if (char === '/' && this.peek(1) === '>') {
-                selfClosing = true
-                this.advance()
-                this.advance()
-                break
-            }
-            
-            if (char === '{') {
-                this.advance()
-                if (this.peek() === '.') {
-                    this.advance()
-                    this.advance()
-                    this.advance()
-                    let expr = ''
-                    let braceCount = 1
-                    while (braceCount > 0 && this.pos < this.source.length) {
-                        const c = this.peek()
-                        if (c === '{') braceCount++
-                        if (c === '}') braceCount--
-                        if (braceCount > 0) expr += this.advance()
-                        else this.advance()
-                    }
-                    attributes.push({ type: 'spread', value: expr.trim() })
-                }
-                continue
-            }
-            
-            if (/[a-zA-Z_\-]/.test(char)) {
-                const attrName = this.readJSXAttributeName()
-                let attrValue = true
-                
-                this.skipWhitespace()
-                if (this.peek() === '=') {
-                    this.advance()
-                    this.skipWhitespace()
-                    
-                    if (this.peek() === '"' || this.peek() === "'") {
-                        const quote = this.advance()
-                        attrValue = ''
-                        while (this.pos < this.source.length && this.peek() !== quote) {
-                            attrValue += this.advance()
-                        }
-                        if (this.peek() === quote) this.advance()
-                    } else if (this.peek() === '{') {
-                        this.advance()
-                        attrValue = { type: 'expression', value: '' }
-                        let braceCount = 1
-                        while (braceCount > 0 && this.pos < this.source.length) {
-                            const c = this.peek()
-                            if (c === '{') braceCount++
-                            if (c === '}') braceCount--
-                            if (braceCount > 0) attrValue.value += this.advance()
-                            else this.advance()
-                        }
-                        attrValue.value = attrValue.value.trim()
-                    }
-                }
-                
-                attributes.push({ name: attrName, value: attrValue })
-                continue
-            }
-            
-            this.advance()
-        }
-        
-        return { type: 'JSX_OPEN', name, attributes, selfClosing, loc }
-    }
-
-    readJSXName() {
-        let name = ''
-        while (this.pos < this.source.length) {
-            const char = this.peek()
-            if (/[a-zA-Z0-9_\-:.]/.test(char)) {
-                name += this.advance()
-            } else {
-                break
-            }
-        }
-        return name
-    }
-
-    readJSXAttributeName() {
-        let name = ''
-        while (this.pos < this.source.length) {
-            const char = this.peek()
-            if (/[a-zA-Z0-9_\-:]/.test(char)) {
-                name += this.advance()
-            } else {
-                break
-            }
-        }
-        return name
-    }
-
-    classifyReactWord(word) {
-        const lowerWord = word.toLowerCase()
-        
-        if (REACT_HOOKS[lowerWord] || REACT_HOOKS[word]) {
-            return 'REACT_HOOK'
-        }
-        
-        if (REACT_COMPONENTS[lowerWord] || REACT_COMPONENTS[word]) {
-            return 'REACT_COMPONENT'
-        }
-        
-        return this.classifyWord(word)
-    }
-}
-
-class ReactParser extends JSParser {
-    constructor(i18nPath = null, jsI18nPath = null) {
-        super(jsI18nPath)
-        this.reactI18n = {}
-        
-        if (i18nPath) {
-            this.loadReactI18n(i18nPath)
-        }
-    }
-
-    loadReactI18n(filePath) {
-        try {
-            const content = fs.readFileSync(filePath, 'utf-8')
-            this.reactI18n = JSON.parse(content)
-        } catch (e) {
-            console.error(`Erreur chargement i18n React: ${e.message}`)
-            this.reactI18n = {}
-        }
-    }
-
-    setReactI18n(i18nData) {
-        this.reactI18n = i18nData
-    }
-
-    parse(source) {
-        const lexer = new ReactLexer(source, this.i18n)
-        this.tokens = lexer.tokenize()
-        this.pos = 0
-        return this.parseProgram()
-    }
-
-    parsePrimaryExpression() {
-        const token = this.peek()
-        
-        if (token.type === 'JSX_OPEN' || token.type === 'JSX_FRAGMENT_OPEN') {
-            return this.parseJSXElement()
-        }
-        
-        if (token.type === 'REACT_HOOK') {
-            return this.parseHookCall()
-        }
-        
-        return super.parsePrimaryExpression()
-    }
-
-    parseJSXElement() {
-        const token = this.peek()
-        
-        if (token.type === 'JSX_FRAGMENT_OPEN') {
-            return this.parseJSXFragment()
-        }
-        
-        const openingToken = this.advance()
-        const name = this.parseJSXElementName(openingToken.name)
-        const attributes = this.parseJSXAttributes(openingToken.attributes)
-        
-        const openingElement = new AST.JSXOpeningElement(
-            name,
-            attributes,
-            openingToken.selfClosing,
-            openingToken.loc
-        )
-        
-        if (openingToken.selfClosing) {
-            return new AST.JSXElement(openingElement, null, [], openingToken.loc)
-        }
-        
-        const children = this.parseJSXChildren(openingToken.name)
-        
-        let closingElement = null
-        if (this.match('JSX_CLOSE')) {
-            const closeToken = this.advance()
-            closingElement = new AST.JSXClosingElement(
-                this.parseJSXElementName(closeToken.name),
-                closeToken.loc
-            )
-        }
-        
-        return new AST.JSXElement(openingElement, closingElement, children, openingToken.loc)
-    }
-
-    parseJSXFragment() {
-        const openToken = this.advance()
-        const openingFragment = new AST.JSXOpeningFragment(openToken.loc)
-        
-        const children = this.parseJSXChildren(null)
-        
-        let closingFragment = null
-        if (this.match('JSX_FRAGMENT_CLOSE')) {
-            const closeToken = this.advance()
-            closingFragment = new AST.JSXClosingFragment(closeToken.loc)
-        }
-        
-        return new AST.JSXFragment(openingFragment, closingFragment, children, openToken.loc)
-    }
-
-    parseJSXElementName(name) {
-        if (!name) return new AST.JSXIdentifier('', null)
-        
-        if (name.includes(':')) {
-            const [ns, local] = name.split(':')
-            return new AST.JSXNamespacedName(
-                new AST.JSXIdentifier(ns, null),
-                new AST.JSXIdentifier(local, null),
-                null
-            )
-        }
-        
-        if (name.includes('.')) {
-            const parts = name.split('.')
-            let result = new AST.JSXIdentifier(parts[0], null)
-            for (let i = 1; i < parts.length; i++) {
-                result = new AST.JSXMemberExpression(
-                    result,
-                    new AST.JSXIdentifier(parts[i], null),
-                    null
-                )
-            }
-            return result
-        }
-        
-        return new AST.JSXIdentifier(name, null)
-    }
-
-    parseJSXAttributes(attrs) {
-        const attributes = []
-        
-        for (const attr of attrs) {
-            if (attr.type === 'spread') {
-                const parser = new ReactParser()
-                parser.setI18n(this.i18n)
-                parser.setReactI18n(this.reactI18n)
-                const ast = parser.parse(attr.value)
-                const expr = ast.body[0]?.expression || new AST.Identifier(attr.value, null)
-                attributes.push(new AST.JSXSpreadAttribute(expr, null))
-            } else {
-                const attrName = this.parseJSXAttributeName(attr.name)
-                let attrValue = null
-                
-                if (attr.value !== true) {
-                    if (typeof attr.value === 'string') {
-                        attrValue = new AST.StringLiteral(attr.value, `"${attr.value}"`, null)
-                    } else if (attr.value?.type === 'expression') {
-                        const parser = new ReactParser()
-                        parser.setI18n(this.i18n)
-                        parser.setReactI18n(this.reactI18n)
-                        const ast = parser.parse(attr.value.value)
-                        const expr = ast.body[0]?.expression || new AST.Identifier(attr.value.value, null)
-                        attrValue = new AST.JSXExpressionContainer(expr, null)
-                    }
-                }
-                
-                attributes.push(new AST.JSXAttribute(attrName, attrValue, null))
-            }
-        }
-        
-        return attributes
-    }
-
-    parseJSXAttributeName(name) {
-        if (name.includes(':')) {
-            const [ns, local] = name.split(':')
-            return new AST.JSXNamespacedName(
-                new AST.JSXIdentifier(ns, null),
-                new AST.JSXIdentifier(local, null),
-                null
-            )
-        }
-        return new AST.JSXIdentifier(name, null)
-    }
-
-    parseJSXChildren(parentName) {
-        const children = []
-        
-        while (this.pos < this.tokens.length) {
-            const token = this.peek()
-            
-            if (token.type === 'JSX_CLOSE') {
-                if (token.name === parentName || parentName === null) break
-            }
-            
-            if (token.type === 'JSX_FRAGMENT_CLOSE') {
-                if (parentName === null) break
-            }
-            
-            if (token.type === 'EOF') break
-            
-            if (token.type === 'JSX_OPEN' || token.type === 'JSX_FRAGMENT_OPEN') {
-                children.push(this.parseJSXElement())
-                continue
-            }
-            
-            if (token.type === 'LBRACE') {
-                children.push(this.parseJSXExpressionContainer())
-                continue
-            }
-            
-            if (token.type === 'STRING') {
-                const strToken = this.advance()
-                children.push(new AST.JSXText(strToken.value, strToken.value, strToken.loc))
-                continue
-            }
-            
-            if (token.type === 'IDENTIFIER' || token.type === 'KEYWORD') {
-                const textToken = this.advance()
-                children.push(new AST.JSXText(textToken.value, textToken.value, textToken.loc))
-                continue
-            }
-            
-            this.advance()
-        }
-        
-        return children
-    }
-
-    parseJSXExpressionContainer() {
-        const loc = this.peek().loc
-        this.expect('LBRACE')
-        
-        if (this.match('RBRACE')) {
-            this.advance()
-            return new AST.JSXExpressionContainer(new AST.JSXEmptyExpression(loc), loc)
-        }
-        
-        if (this.match('SPREAD')) {
-            this.advance()
-            const expr = this.parseAssignmentExpression()
-            this.expect('RBRACE')
-            return new AST.JSXSpreadChild(expr, loc)
-        }
-        
-        const expression = this.parseExpression()
-        this.expect('RBRACE')
-        
-        return new AST.JSXExpressionContainer(expression, loc)
-    }
-
-    parseHookCall() {
-        const token = this.advance()
-        const hookName = this.translateHook(token.value)
-        
-        this.expect('LPAREN')
-        const args = []
-        
-        while (!this.match('RPAREN', 'EOF')) {
-            args.push(this.parseAssignmentExpression())
-            if (!this.match('RPAREN')) {
-                this.expect('COMMA')
-            }
-        }
-        
-        this.expect('RPAREN')
-        
-        return new AST.ReactHookCall(hookName, args, token.loc)
-    }
-
-    translateHook(name) {
-        const lowerName = name.toLowerCase()
-        return REACT_HOOKS[lowerName] || REACT_HOOKS[name] || name
-    }
-
-    translateComponent(name) {
-        const lowerName = name.toLowerCase()
-        return REACT_COMPONENTS[lowerName] || REACT_COMPONENTS[name] || name
-    }
-}
-
-class ReactCodeGenerator extends JSCodeGenerator {
-    constructor(options = {}) {
-        super(options)
-    }
-
-    generate(ast) {
-        if (!ast) return ''
-        
-        const method = `generate${ast.type}`
-        if (this[method]) {
-            return this[method](ast)
-        }
-        
-        return super.generate(ast)
-    }
-
-    generateJSXElement(node) {
-        let result = this.generate(node.openingElement)
-        
-        if (!node.openingElement.selfClosing) {
-            for (const child of node.children) {
-                result += this.generate(child)
-            }
-            if (node.closingElement) {
-                result += this.generate(node.closingElement)
-            }
-        }
-        
-        return result
-    }
-
-    generateJSXOpeningElement(node) {
-        let result = '<' + this.generate(node.name)
-        
-        for (const attr of node.attributes) {
-            result += ' ' + this.generate(attr)
-        }
-        
-        if (node.selfClosing) {
-            result += ' />'
-        } else {
-            result += '>'
-        }
-        
-        return result
-    }
-
-    generateJSXClosingElement(node) {
-        return '</' + this.generate(node.name) + '>'
-    }
-
-    generateJSXFragment(node) {
-        let result = '<>'
-        
-        for (const child of node.children) {
-            result += this.generate(child)
-        }
-        
-        result += '</>'
-        return result
-    }
-
-    generateJSXOpeningFragment() {
-        return '<>'
-    }
-
-    generateJSXClosingFragment() {
-        return '</>'
-    }
-
-    generateJSXIdentifier(node) {
-        return node.name
-    }
-
-    generateJSXMemberExpression(node) {
-        return this.generate(node.object) + '.' + this.generate(node.property)
-    }
-
-    generateJSXNamespacedName(node) {
-        return this.generate(node.namespace) + ':' + this.generate(node.name)
-    }
-
-    generateJSXAttribute(node) {
-        let result = this.generate(node.name)
-        
-        if (node.value !== null) {
-            result += '='
-            if (node.value.type === 'StringLiteral') {
-                result += this.generate(node.value)
-            } else {
-                result += this.generate(node.value)
-            }
-        }
-        
-        return result
-    }
-
-    generateJSXSpreadAttribute(node) {
-        return '{...' + this.generate(node.argument) + '}'
-    }
-
-    generateJSXText(node) {
-        return node.value
-    }
-
-    generateJSXExpressionContainer(node) {
-        return '{' + this.generate(node.expression) + '}'
-    }
-
-    generateJSXSpreadChild(node) {
-        return '{...' + this.generate(node.expression) + '}'
-    }
-
-    generateJSXEmptyExpression() {
-        return ''
-    }
-
-    generateReactHookCall(node) {
-        const args = node.arguments.map(a => this.generate(a)).join(', ')
-        return `${node.hookName}(${args})`
-    }
-
-    generateReactComponent(node) {
-        const props = node.props.length > 0 ? `{ ${node.props.join(', ')} }` : ''
-        
-        if (node.componentType === 'function') {
-            return `function ${node.name}(${props}) ${this.generate(node.body)}`
-        } else {
-            return `class ${node.name} extends React.Component ${this.generate(node.body)}`
-        }
-    }
-
-    generateReactDirective(node) {
-        return `"${node.directive}";`
-    }
-
-    generateUseStateHook(node) {
-        const init = node.initialValue ? this.generate(node.initialValue) : ''
-        return `const [${node.stateName}, ${node.setterName}] = useState(${init})`
-    }
-
-    generateUseEffectHook(node) {
-        const callback = this.generate(node.callback)
-        const deps = node.dependencies ? this.generate(node.dependencies) : ''
-        return `useEffect(${callback}${deps ? ', ' + deps : ''})`
-    }
-
-    generateUseRefHook(node) {
-        const init = node.initialValue ? this.generate(node.initialValue) : 'null'
-        return `const ${node.refName} = useRef(${init})`
-    }
-
-    generateUseContextHook(node) {
-        return `useContext(${this.generate(node.context)})`
-    }
-
-    generateUseReducerHook(node) {
-        const reducer = this.generate(node.reducer)
-        const init = this.generate(node.initialState)
-        return `const [${node.stateName}, ${node.dispatchName}] = useReducer(${reducer}, ${init})`
-    }
-
-    generateUseMemoHook(node) {
-        const factory = this.generate(node.factory)
-        const deps = this.generate(new AST.ArrayExpression(node.dependencies, null))
-        return `useMemo(${factory}, ${deps})`
-    }
-
-    generateUseCallbackHook(node) {
-        const callback = this.generate(node.callback)
-        const deps = this.generate(new AST.ArrayExpression(node.dependencies, null))
-        return `useCallback(${callback}, ${deps})`
-    }
-
-    generateUseTransitionHook(node) {
-        return `const [${node.isPendingName}, ${node.startTransitionName}] = useTransition()`
-    }
-
-    generateUseDeferredValueHook(node) {
-        return `useDeferredValue(${this.generate(node.value)})`
-    }
-
-    generateUseIdHook(node) {
-        return `const ${node.idName} = useId()`
-    }
-
-    generateCreateContextCall(node) {
-        const defaultVal = node.defaultValue ? this.generate(node.defaultValue) : ''
-        return `createContext(${defaultVal})`
-    }
-
-    generateContextProvider(node) {
-        const value = this.generate(node.value)
-        const children = node.children.map(c => this.generate(c)).join('')
-        return `<${this.generate(node.context)}.Provider value={${value}}>${children}</${this.generate(node.context)}.Provider>`
-    }
-
-    generateForwardRefCall(node) {
-        return `forwardRef(${this.generate(node.render)})`
-    }
-
-    generateMemoCall(node) {
-        const component = this.generate(node.component)
-        const areEqual = node.areEqual ? ', ' + this.generate(node.areEqual) : ''
-        return `memo(${component}${areEqual})`
-    }
-
-    generateLazyCall(node) {
-        return `lazy(${this.generate(node.load)})`
-    }
-
-    generateSuspenseComponent(node) {
-        const fallback = this.generate(node.fallback)
-        const children = node.children.map(c => this.generate(c)).join('')
-        return `<Suspense fallback={${fallback}}>${children}</Suspense>`
-    }
-
-    generateStrictModeComponent(node) {
-        const children = node.children.map(c => this.generate(c)).join('')
-        return `<StrictMode>${children}</StrictMode>`
-    }
-
-    generateProfilerComponent(node) {
-        const id = this.generate(node.id)
-        const onRender = this.generate(node.onRender)
-        const children = node.children.map(c => this.generate(c)).join('')
-        return `<Profiler id=${id} onRender={${onRender}}>${children}</Profiler>`
-    }
-
-    generateCreatePortalCall(node) {
-        const children = this.generate(node.children)
-        const container = this.generate(node.container)
-        const key = node.key ? ', ' + this.generate(node.key) : ''
-        return `createPortal(${children}, ${container}${key})`
-    }
-
-    generateCreateRootCall(node) {
-        const container = this.generate(node.container)
-        const options = node.options ? ', ' + this.generate(node.options) : ''
-        return `createRoot(${container}${options})`
-    }
-
-    generateHydrateRootCall(node) {
-        const container = this.generate(node.container)
-        const children = this.generate(node.initialChildren)
-        const options = node.options ? ', ' + this.generate(node.options) : ''
-        return `hydrateRoot(${container}, ${children}${options})`
-    }
-
-    generateStartTransitionCall(node) {
-        return `startTransition(${this.generate(node.callback)})`
-    }
-
-    generateFlushSyncCall(node) {
-        return `flushSync(${this.generate(node.callback)})`
-    }
-
-    generateCreateElementCall(node) {
-        const type = typeof node.elementType === 'string' ? `"${node.elementType}"` : this.generate(node.elementType)
-        const props = node.props ? this.generate(node.props) : 'null'
-        const children = node.children.map(c => this.generate(c)).join(', ')
-        return `createElement(${type}, ${props}${children ? ', ' + children : ''})`
-    }
-
-    generateCloneElementCall(node) {
-        const element = this.generate(node.element)
-        const props = node.props ? this.generate(node.props) : 'null'
-        const children = node.children.map(c => this.generate(c)).join(', ')
-        return `cloneElement(${element}, ${props}${children ? ', ' + children : ''})`
-    }
-
-    generateServerActionFunction(node) {
-        const params = node.params.map(p => this.generate(p)).join(', ')
-        return `async function ${node.name}(${params}) {\n  "use server";\n${this.generate(node.body)}\n}`
-    }
-
-    generateEtherReactComponent(node) {
-        const props = node.props.length > 0 ? `{ ${node.props.join(', ')} }` : ''
-        const hooks = node.hooks.map(h => '  ' + this.generate(h)).join('\n')
-        const jsx = this.generate(node.returnJSX)
-        
-        return `function ${node.name}(${props}) {\n${hooks}\n  return (\n    ${jsx}\n  );\n}`
-    }
-
-    generateEtherHookDeclaration(node) {
-        const bindings = node.bindings.join(', ')
-        const args = node.arguments.map(a => this.generate(a)).join(', ')
-        
-        if (node.bindings.length === 1) {
-            return `const ${bindings} = ${node.hookType}(${args});`
-        } else if (node.bindings.length === 2) {
-            return `const [${bindings}] = ${node.hookType}(${args});`
-        }
-        
-        return `${node.hookType}(${args});`
-    }
-}
-
-module.exports = {
-    ReactLexer,
-    ReactParser,
-    ReactCodeGenerator,
-    REACT_HOOKS,
-    REACT_COMPONENTS,
-    SELF_CLOSING_TAGS
-}