@hyperfixi/core 2.0.0

package/dist/ast-utils/index.mjs

@@ -0,0 +1,3320 @@
+class VisitorContextImpl {
+    constructor(path = [], parent = null) {
+        this._skipped = false;
+        this._stopped = false;
+        this._replaced = undefined;
+        this._hasReplacement = false;
+        this._path = [];
+        this._parent = null;
+        this._scope = new Map();
+        this._path = [...path];
+        this._parent = parent;
+    }
+    skip() {
+        this._skipped = true;
+    }
+    stop() {
+        this._stopped = true;
+    }
+    replace(node) {
+        this._replaced = node;
+        this._hasReplacement = true;
+    }
+    getPath() {
+        return [...this._path];
+    }
+    getParent() {
+        return this._parent;
+    }
+    getScope() {
+        return new Map(this._scope);
+    }
+    setScope(key, value) {
+        this._scope.set(key, value);
+    }
+    get skipped() {
+        return this._skipped;
+    }
+    get stopped() {
+        return this._stopped;
+    }
+    get replacement() {
+        return this._replaced;
+    }
+    get hasReplacement() {
+        return this._hasReplacement;
+    }
+    createChild(key, parent) {
+        const child = new VisitorContextImpl([...this._path, key], parent);
+        for (const [k, v] of this._scope) {
+            child._scope.set(k, v);
+        }
+        return child;
+    }
+}
+class ASTVisitor {
+    constructor(handlers) {
+        this.handlers = handlers;
+    }
+    visit(node, context) {
+        if (!node)
+            return null;
+        if (this.handlers.enter) {
+            this.handlers.enter(node, context);
+        }
+        const typeHandler = this.handlers[node.type];
+        if (typeHandler) {
+            typeHandler(node, context);
+        }
+        if (context.stopped || context.hasReplacement) {
+            return context.replacement;
+        }
+        if (!context.skipped) {
+            const visitedNode = this.visitChildren(node, context);
+            if (visitedNode !== node) {
+                node = visitedNode;
+            }
+        }
+        if (this.handlers.exit) {
+            this.handlers.exit(node, context);
+        }
+        if (context.hasReplacement) {
+            return context.replacement;
+        }
+        return node;
+    }
+    visitChildren(node, context) {
+        const result = { ...node };
+        let modified = false;
+        for (const [key, value] of Object.entries(node)) {
+            if (key === 'type' ||
+                key === 'start' ||
+                key === 'end' ||
+                key === 'line' ||
+                key === 'column') {
+                continue;
+            }
+            if (Array.isArray(value)) {
+                const newArray = [];
+                for (let i = 0; i < value.length; i++) {
+                    const item = value[i];
+                    if (this.isASTNode(item)) {
+                        const childContext = context.createChild(`${key}/${i}`, node);
+                        const visitedChild = this.visit(item, childContext);
+                        if (visitedChild === null) {
+                            modified = true;
+                        }
+                        else if (Array.isArray(visitedChild)) {
+                            newArray.push(...visitedChild);
+                            modified = true;
+                        }
+                        else {
+                            newArray.push(visitedChild);
+                            if (visitedChild !== item) {
+                                modified = true;
+                            }
+                        }
+                        if (childContext.stopped) {
+                            break;
+                        }
+                    }
+                    else {
+                        newArray.push(item);
+                    }
+                }
+                if (modified || newArray.length !== value.length) {
+                    result[key] = newArray;
+                    modified = true;
+                }
+            }
+            else if (this.isASTNode(value)) {
+                const childContext = context.createChild(key, node);
+                const visitedChild = this.visit(value, childContext);
+                if (visitedChild !== value) {
+                    result[key] = visitedChild;
+                    modified = true;
+                }
+                if (childContext.stopped) {
+                    break;
+                }
+            }
+        }
+        return modified ? result : node;
+    }
+    isASTNode(value) {
+        return value && typeof value === 'object' && typeof value.type === 'string';
+    }
+}
+function visit(ast, visitor) {
+    if (!ast)
+        return null;
+    const context = new VisitorContextImpl();
+    const result = visitor.visit(ast, context);
+    if (result === null)
+        return null;
+    if (Array.isArray(result))
+        return result.length > 0 ? result[0] : null;
+    return result;
+}
+function findNodes(ast, predicate) {
+    if (!ast)
+        return [];
+    const results = [];
+    const visitor = new ASTVisitor({
+        enter(node) {
+            if (predicate(node)) {
+                results.push(node);
+            }
+        },
+    });
+    visit(ast, visitor);
+    return results;
+}
+function findFirst(ast, predicate) {
+    if (!ast)
+        return null;
+    let result = null;
+    const visitor = new ASTVisitor({
+        enter(node, context) {
+            if (predicate(node)) {
+                result = node;
+                context.stop();
+            }
+        },
+    });
+    visit(ast, visitor);
+    return result;
+}
+function getAncestors(ast, targetNode) {
+    if (!ast || !targetNode)
+        return [];
+    const ancestors = [];
+    function findPath(node, path) {
+        if (node === targetNode) {
+            ancestors.push(...path.reverse());
+            return true;
+        }
+        for (const [key, value] of Object.entries(node)) {
+            if (key === 'type' ||
+                key === 'start' ||
+                key === 'end' ||
+                key === 'line' ||
+                key === 'column') {
+                continue;
+            }
+            if (Array.isArray(value)) {
+                for (const item of value) {
+                    if (item && typeof item === 'object' && typeof item.type === 'string') {
+                        if (findPath(item, [...path, node]))
+                            return true;
+                    }
+                }
+            }
+            else if (value && typeof value === 'object' && typeof value.type === 'string') {
+                if (findPath(value, [...path, node]))
+                    return true;
+            }
+        }
+        return false;
+    }
+    findPath(ast, []);
+    return ancestors;
+}
+function createTypeCollector(types) {
+    const typeSet = new Set(types);
+    const collected = {};
+    for (const type of types) {
+        collected[type] = [];
+    }
+    return new ASTVisitor({
+        enter(node) {
+            if (typeSet.has(node.type)) {
+                collected[node.type].push(node);
+            }
+        },
+    });
+}
+function measureDepth(ast) {
+    let maxDepth = 0;
+    let currentDepth = 0;
+    const visitor = new ASTVisitor({
+        enter() {
+            currentDepth++;
+            maxDepth = Math.max(maxDepth, currentDepth);
+        },
+        exit() {
+            currentDepth--;
+        },
+    });
+    visit(ast, visitor);
+    return maxDepth;
+}
+function countNodeTypes(ast) {
+    const counts = {};
+    const visitor = new ASTVisitor({
+        enter(node) {
+            counts[node.type] = (counts[node.type] || 0) + 1;
+        },
+    });
+    visit(ast, visitor);
+    return counts;
+}
+function createVisitorContext() {
+    return new VisitorContextImpl();
+}
+
+function calculateComplexity(ast) {
+    return {
+        cyclomatic: calculateCyclomaticComplexity(ast),
+        cognitive: calculateCognitiveComplexity(ast),
+        halstead: calculateHalsteadMetrics(ast),
+    };
+}
+function calculateCyclomaticComplexity(ast) {
+    let complexity = 1;
+    const visitor = new ASTVisitor({
+        enter(node) {
+            if (isDecisionNode(node))
+                complexity++;
+        },
+    });
+    visit(ast, visitor);
+    return complexity;
+}
+function calculateCognitiveComplexity(ast) {
+    let complexity = 0;
+    let depth = 0;
+    const visitor = new ASTVisitor({
+        enter(node) {
+            if (isNestingNode(node))
+                depth++;
+            if (isDecisionNode(node))
+                complexity += 1 + depth;
+        },
+        exit(node) {
+            if (isNestingNode(node))
+                depth--;
+        },
+    });
+    visit(ast, visitor);
+    return complexity;
+}
+function calculateHalsteadMetrics(ast) {
+    const operators = new Set();
+    const operands = new Set();
+    let totalOperators = 0;
+    let totalOperands = 0;
+    const visitor = new ASTVisitor({
+        enter(node) {
+            if (node.operator) {
+                operators.add(node.operator);
+                totalOperators++;
+            }
+            if (node.name) {
+                operands.add(node.name);
+                totalOperands++;
+            }
+            if (node.value !== undefined) {
+                operands.add(String(node.value));
+                totalOperands++;
+            }
+            if (node.type && ['command', 'conditional', 'binaryExpression'].includes(node.type)) {
+                operators.add(node.type);
+                totalOperators++;
+            }
+        },
+    });
+    visit(ast, visitor);
+    const vocabulary = operators.size + operands.size;
+    const length = totalOperators + totalOperands;
+    const difficulty = vocabulary > 0 ? (operators.size / 2) * (totalOperands / Math.max(operands.size, 1)) : 0;
+    const effort = difficulty * length;
+    return { vocabulary, length, difficulty, effort };
+}
+function isDecisionNode(node) {
+    return (['conditional', 'binaryExpression', 'logicalExpression'].includes(node.type) ||
+        (node.operator && ['&&', '||', '?'].includes(node.operator)));
+}
+function isNestingNode(node) {
+    return ['conditional', 'loop', 'function', 'block'].includes(node.type);
+}
+function detectCodeSmells(ast) {
+    const smells = [];
+    smells.push(...detectExcessiveNesting(ast));
+    smells.push(...detectDuplicateCode(ast));
+    smells.push(...detectLongCommandChains(ast));
+    smells.push(...detectComplexConditions(ast));
+    return smells;
+}
+function detectExcessiveNesting(ast) {
+    const smells = [];
+    const maxDepth = 3;
+    const currentDepth = measureDepth(ast);
+    if (currentDepth > maxDepth) {
+        smells.push({
+            type: 'excessive-nesting',
+            severity: 'high',
+            location: {
+                ...(ast.start !== undefined && { start: ast.start }),
+                ...(ast.end !== undefined && { end: ast.end }),
+                ...(ast.line !== undefined && { line: ast.line }),
+                ...(ast.column !== undefined && { column: ast.column }),
+            },
+            message: `Nesting depth of ${currentDepth} exceeds recommended maximum of ${maxDepth}`,
+            suggestion: 'Consider extracting nested logic into separate functions or using early returns',
+        });
+    }
+    return smells;
+}
+function detectDuplicateCode(ast) {
+    const smells = [];
+    const nodeStrings = new Map();
+    const visitor = new ASTVisitor({
+        enter(node) {
+            if (node.type === 'command' || node.type === 'conditional') {
+                const nodeString = JSON.stringify(node, ['type', 'name', 'value', 'operator']);
+                if (!nodeStrings.has(nodeString))
+                    nodeStrings.set(nodeString, []);
+                nodeStrings.get(nodeString).push(node);
+            }
+        },
+    });
+    visit(ast, visitor);
+    for (const [, nodes] of nodeStrings) {
+        if (nodes.length > 1) {
+            const firstNode = nodes[0];
+            smells.push({
+                type: 'duplicate-code',
+                severity: 'medium',
+                location: {
+                    ...(firstNode.start !== undefined && { start: firstNode.start }),
+                    ...(firstNode.end !== undefined && { end: firstNode.end }),
+                    ...(firstNode.line !== undefined && { line: firstNode.line }),
+                    ...(firstNode.column !== undefined && { column: firstNode.column }),
+                },
+                message: `Duplicate code found (${nodes.length} occurrences)`,
+                suggestion: 'Consider extracting common logic into a reusable function',
+            });
+        }
+    }
+    return smells;
+}
+function detectLongCommandChains(ast) {
+    const smells = [];
+    const maxCommands = 5;
+    const visitor = new ASTVisitor({
+        enter(node) {
+            if (node.commands && Array.isArray(node.commands)) {
+                const commands = node.commands;
+                if (commands.length > maxCommands) {
+                    smells.push({
+                        type: 'long-command-chain',
+                        severity: 'medium',
+                        location: {
+                            ...(node.start !== undefined && { start: node.start }),
+                            ...(node.end !== undefined && { end: node.end }),
+                            ...(node.line !== undefined && { line: node.line }),
+                            ...(node.column !== undefined && { column: node.column }),
+                        },
+                        message: `Command chain with ${commands.length} commands exceeds recommended maximum of ${maxCommands}`,
+                        suggestion: 'Consider breaking into smaller, focused handlers',
+                    });
+                }
+            }
+        },
+    });
+    visit(ast, visitor);
+    return smells;
+}
+function detectComplexConditions(ast) {
+    const smells = [];
+    const visitor = new ASTVisitor({
+        enter(node) {
+            if (node.type === 'conditional' && node.condition) {
+                const conditionComplexity = calculateExpressionComplexity(node.condition);
+                if (conditionComplexity > 3) {
+                    smells.push({
+                        type: 'complex-condition',
+                        severity: 'medium',
+                        location: {
+                            ...(node.start !== undefined && { start: node.start }),
+                            ...(node.end !== undefined && { end: node.end }),
+                            ...(node.line !== undefined && { line: node.line }),
+                            ...(node.column !== undefined && { column: node.column }),
+                        },
+                        message: `Condition complexity of ${conditionComplexity} is too high`,
+                        suggestion: 'Consider extracting condition logic into named variables',
+                    });
+                }
+            }
+        },
+    });
+    visit(ast, visitor);
+    return smells;
+}
+function calculateExpressionComplexity(expr) {
+    let complexity = 1;
+    const visitor = new ASTVisitor({
+        enter(node) {
+            if (node.operator && ['&&', '||', '!'].includes(node.operator)) {
+                complexity++;
+            }
+        },
+    });
+    visit(expr, visitor);
+    return complexity;
+}
+function analyzeDependencies(ast) {
+    const nodes = new Set();
+    const edges = new Map();
+    const visitor = new ASTVisitor({
+        enter(node) {
+            if (node.name === 'set' && node.variable) {
+                const varName = node.variable.name;
+                nodes.add(varName);
+                if (node.value) {
+                    const deps = extractDependencies(node.value);
+                    if (!edges.has(varName))
+                        edges.set(varName, new Set());
+                    deps.forEach(dep => {
+                        nodes.add(dep);
+                        edges.get(varName).add(dep);
+                    });
+                }
+            }
+        },
+    });
+    visit(ast, visitor);
+    const cycles = detectCycles(nodes, edges);
+    return { nodes, edges, cycles };
+}
+function extractDependencies(valueNode) {
+    const deps = [];
+    const visitor = new ASTVisitor({
+        enter(node) {
+            if (node.type === 'identifier')
+                deps.push(node.name);
+        },
+    });
+    visit(valueNode, visitor);
+    return deps;
+}
+function detectCycles(nodes, edges) {
+    const visited = new Set();
+    const recursionStack = new Set();
+    const cycles = [];
+    function dfs(node, path) {
+        if (recursionStack.has(node)) {
+            const cycleStart = path.indexOf(node);
+            cycles.push(path.slice(cycleStart));
+            return;
+        }
+        if (visited.has(node))
+            return;
+        visited.add(node);
+        recursionStack.add(node);
+        path.push(node);
+        const neighbors = edges.get(node) || new Set();
+        for (const neighbor of neighbors) {
+            dfs(neighbor, [...path]);
+        }
+        recursionStack.delete(node);
+    }
+    for (const node of nodes) {
+        if (!visited.has(node))
+            dfs(node, []);
+    }
+    return cycles;
+}
+function findDeadCode(ast) {
+    const deadCode = [];
+    const definedVars = new Set();
+    const usedVars = new Set();
+    const varDefinitions = new Map();
+    const definitionIdentifiers = new Set();
+    const visitor = new ASTVisitor({
+        enter(node) {
+            if (node.name === 'set' && node.variable) {
+                const varName = node.variable.name;
+                definedVars.add(varName);
+                varDefinitions.set(varName, node);
+                definitionIdentifiers.add(varName);
+            }
+            if (node.type === 'identifier' && node.name) {
+                const name = node.name;
+                if (!definitionIdentifiers.has(name))
+                    usedVars.add(name);
+            }
+        },
+    });
+    visit(ast, visitor);
+    for (const varName of definedVars) {
+        if (!usedVars.has(varName)) {
+            const defNode = varDefinitions.get(varName);
+            deadCode.push({
+                type: 'unused-variable',
+                name: varName,
+                location: {
+                    ...(defNode.start !== undefined && { start: defNode.start }),
+                    ...(defNode.end !== undefined && { end: defNode.end }),
+                    ...(defNode.line !== undefined && { line: defNode.line }),
+                    ...(defNode.column !== undefined && { column: defNode.column }),
+                },
+                message: `Variable '${varName}' is defined but never used`,
+            });
+        }
+    }
+    let afterHalt = false;
+    const visitor2 = new ASTVisitor({
+        enter(node) {
+            if (node.name === 'halt' || node.name === 'throw') {
+                afterHalt = true;
+            }
+            else if (afterHalt && node.type === 'command') {
+                deadCode.push({
+                    type: 'unreachable-code',
+                    location: {
+                        ...(node.start !== undefined && { start: node.start }),
+                        ...(node.end !== undefined && { end: node.end }),
+                        ...(node.line !== undefined && { line: node.line }),
+                        ...(node.column !== undefined && { column: node.column }),
+                    },
+                    message: 'Unreachable code after halt/throw statement',
+                });
+            }
+        },
+    });
+    visit(ast, visitor2);
+    return deadCode;
+}
+function suggestOptimizations(ast) {
+    const suggestions = [];
+    suggestions.push(...suggestBatchOperations(ast));
+    suggestions.push(...suggestSimplifyConditionals(ast));
+    return suggestions;
+}
+function suggestBatchOperations(ast) {
+    const suggestions = [];
+    const visitor = new ASTVisitor({
+        enter(node) {
+            if (node.commands && Array.isArray(node.commands)) {
+                const commands = node.commands;
+                const sameCmdGroups = groupConsecutiveSameCommands(commands);
+                for (const group of sameCmdGroups) {
+                    if (group.length >= 3 && group[0].name === 'add' && sameTarget(group)) {
+                        suggestions.push({
+                            type: 'batch-operations',
+                            description: 'Group class operations',
+                            suggestion: `Combine multiple add operations: add ${group.map((c) => c.args[0].value).join(' ')} to ${group[0].target?.name || 'target'}`,
+                            impact: 'high',
+                            confidence: 0.9,
+                        });
+                    }
+                }
+            }
+        },
+    });
+    visit(ast, visitor);
+    return suggestions;
+}
+function suggestSimplifyConditionals(ast) {
+    const suggestions = [];
+    const complexity = calculateComplexity(ast);
+    if (complexity.cognitive > 3 || complexity.cyclomatic > 3) {
+        suggestions.push({
+            type: 'simplification',
+            description: 'Simplify complex conditionals',
+            suggestion: 'Break down complex conditional logic into smaller, named functions',
+            impact: 'maintainability',
+            confidence: 0.8,
+        });
+    }
+    return suggestions;
+}
+function groupConsecutiveSameCommands(commands) {
+    const groups = [];
+    let currentGroup = [];
+    for (const cmd of commands) {
+        if (currentGroup.length === 0 || cmd.name === currentGroup[0].name) {
+            currentGroup.push(cmd);
+        }
+        else {
+            if (currentGroup.length > 0)
+                groups.push(currentGroup);
+            currentGroup = [cmd];
+        }
+    }
+    if (currentGroup.length > 0)
+        groups.push(currentGroup);
+    return groups;
+}
+function sameTarget(commands) {
+    if (commands.length === 0)
+        return true;
+    const firstTarget = commands[0].target?.name;
+    return commands.every((cmd) => cmd.target?.name === firstTarget);
+}
+function analyzePatterns(ast) {
+    const patterns = [];
+    if (ast.type === 'eventHandler') {
+        patterns.push({
+            type: 'event-handler',
+            pattern: 'event-handler',
+            node: ast,
+            bindings: { event: ast.event },
+            confidence: 0.9,
+            suggestion: 'Consider using event delegation for multiple similar handlers',
+        });
+    }
+    const visitor = new ASTVisitor({
+        enter(node) {
+            if (node.commands && Array.isArray(node.commands)) {
+                const commands = node.commands;
+                const toggleCommands = commands.filter((cmd) => cmd.name === 'toggle');
+                if (toggleCommands.length >= 2) {
+                    patterns.push({
+                        type: 'toggle-pair',
+                        pattern: 'toggle-pair',
+                        node,
+                        bindings: {
+                            count: toggleCommands.length,
+                            targets: toggleCommands.map((cmd) => cmd.target?.name || cmd.target?.value),
+                        },
+                        confidence: 0.85,
+                        suggestion: 'Consider using a single toggle with multiple targets',
+                    });
+                }
+            }
+        },
+    });
+    visit(ast, visitor);
+    return patterns;
+}
+function analyzeMetrics(ast) {
+    const complexity = calculateComplexity(ast);
+    const smells = detectCodeSmells(ast);
+    const patterns = analyzePatterns(ast);
+    const dependencies = analyzeDependencies(ast);
+    const maintainabilityIndex = calculateMaintainabilityIndex(complexity, smells);
+    const readabilityScore = calculateReadabilityScore(ast, smells);
+    return { complexity, smells, patterns, dependencies, maintainabilityIndex, readabilityScore };
+}
+function calculateMaintainabilityIndex(complexity, smells) {
+    let score = 100;
+    score -= Math.min(complexity.cyclomatic * 2, 30);
+    score -= Math.min(complexity.cognitive, 20);
+    const highSeveritySmells = smells.filter(s => s.severity === 'high').length;
+    const mediumSeveritySmells = smells.filter(s => s.severity === 'medium').length;
+    score -= highSeveritySmells * 15;
+    score -= mediumSeveritySmells * 8;
+    return Math.max(0, Math.min(100, score));
+}
+function calculateReadabilityScore(ast, smells) {
+    let score = 100;
+    const depth = measureDepth(ast);
+    const excessDepth = Math.max(0, depth - 3);
+    score -= Math.min(excessDepth * 5, 25);
+    const longChains = smells.filter(s => s.type === 'long-command-chain').length;
+    score -= longChains * 10;
+    const complexConditions = smells.filter(s => s.type === 'complex-condition').length;
+    score -= complexConditions * 12;
+    return Math.max(0, Math.min(100, score));
+}
+
+function generate(ast, options = {}) {
+    const opts = {
+        minify: false,
+        indentation: '  ',
+        preserveRaw: true,
+        _indentLevel: 0,
+        ...options,
+    };
+    return generateNode(ast, opts);
+}
+function generateWithMetadata(ast, options = {}) {
+    let nodeCount = 0;
+    const opts = {
+        minify: false,
+        indentation: '  ',
+        preserveRaw: true,
+        _indentLevel: 0,
+        ...options,
+    };
+    const code = generateNode(ast, opts);
+    countNodes(ast, () => nodeCount++);
+    return { code, nodeCount };
+}
+function generateNode(node, opts) {
+    if (!node || typeof node !== 'object')
+        return '';
+    if (opts.preserveRaw && node.raw && typeof node.raw === 'string') {
+        return node.raw;
+    }
+    switch (node.type) {
+        case 'program':
+            return generateProgram(node, opts);
+        case 'eventHandler':
+            return generateEventHandler(node, opts);
+        case 'command':
+            return generateCommand(node, opts);
+        case 'conditional':
+            return generateConditional(node, opts);
+        case 'behavior':
+            return generateBehavior(node, opts);
+        case 'function':
+        case 'def':
+            return generateFunction(node, opts);
+        case 'selector':
+            return generateSelector(node);
+        case 'literal':
+            return generateLiteral(node);
+        case 'identifier':
+            return generateIdentifier(node);
+        case 'binaryExpression':
+            return generateBinaryExpression(node, opts);
+        case 'logicalExpression':
+            return generateLogicalExpression(node, opts);
+        case 'unaryExpression':
+            return generateUnaryExpression(node, opts);
+        case 'memberExpression':
+            return generateMemberExpression(node, opts);
+        case 'possessiveExpression':
+            return generatePossessiveExpression(node, opts);
+        case 'callExpression':
+            return generateCallExpression(node, opts);
+        case 'returnStatement':
+            return generateReturnStatement(node, opts);
+        default:
+            return generateFallback(node);
+    }
+}
+function generateProgram(node, opts) {
+    const features = node.features || [];
+    const separator = opts.minify ? ' ' : '\n\n';
+    return features
+        .map((f) => generateNode(f, opts))
+        .filter(Boolean)
+        .join(separator);
+}
+function generateEventHandler(node, opts) {
+    const data = node;
+    const parts = ['on'];
+    if (data.events && data.events.length > 1) {
+        parts.push(data.events.join(' or '));
+    }
+    else {
+        parts.push(data.event || 'click');
+    }
+    if (data.selector && data.selector !== 'me')
+        parts.push('from', data.selector);
+    if (data.condition)
+        parts.push(`[${generateNode(data.condition, opts)}]`);
+    const commands = data.commands || [];
+    if (commands.length > 0) {
+        const cmdSeparator = opts.minify ? ' then ' : '\n' + indent(opts);
+        const commandsStr = commands
+            .map((cmd) => generateNode(cmd, { ...opts, _indentLevel: (opts._indentLevel || 0) + 1 }))
+            .join(cmdSeparator);
+        if (opts.minify) {
+            parts.push(commandsStr);
+        }
+        else {
+            parts.push('\n' + indent(opts) + commandsStr);
+        }
+    }
+    return parts.join(' ');
+}
+function generateBehavior(node, opts) {
+    const data = node;
+    const parts = ['behavior'];
+    const params = data.parameters || [];
+    parts.push(params.length > 0 ? `${data.name || 'unnamed'}(${params.join(', ')})` : data.name || 'unnamed');
+    const body = data.body || data.eventHandlers || [];
+    if (body.length > 0) {
+        const bodyStr = body
+            .map((item) => generateNode(item, { ...opts, _indentLevel: (opts._indentLevel || 0) + 1 }))
+            .join(opts.minify ? ' ' : '\n' + indent(opts));
+        if (opts.minify) {
+            parts.push(bodyStr, 'end');
+        }
+        else {
+            parts.push('\n' + indent(opts) + bodyStr + '\n' + 'end');
+        }
+    }
+    else {
+        parts.push('end');
+    }
+    return parts.join(' ');
+}
+function generateFunction(node, opts) {
+    const data = node;
+    const parts = ['def'];
+    const params = data.parameters || data.params || [];
+    parts.push(params.length > 0 ? `${data.name || 'unnamed'}(${params.join(', ')})` : data.name || 'unnamed');
+    if (data.body) {
+        const bodyStr = generateNode(data.body, {
+            ...opts,
+            _indentLevel: (opts._indentLevel || 0) + 1,
+        });
+        if (opts.minify) {
+            parts.push(bodyStr, 'end');
+        }
+        else {
+            parts.push('\n' + indent(opts) + bodyStr + '\n' + 'end');
+        }
+    }
+    else {
+        parts.push('end');
+    }
+    return parts.join(' ');
+}
+function generateCommand(node, opts = {}) {
+    const data = node;
+    const parts = [data.name || 'unknown'];
+    const args = data.args || [];
+    for (const arg of args)
+        parts.push(generateNode(arg, opts));
+    if (data.modifiers) {
+        for (const [key, value] of Object.entries(data.modifiers)) {
+            if (value)
+                parts.push(key, generateNode(value, opts));
+        }
+    }
+    if (data.target) {
+        parts.push(getTargetPreposition(data.name), generateNode(data.target, opts));
+    }
+    if (data.implicitTarget)
+        parts.push(generateNode(data.implicitTarget, opts));
+    return parts.join(' ');
+}
+function generateConditional(node, opts) {
+    const data = node;
+    const parts = ['if'];
+    if (data.condition)
+        parts.push(generateNode(data.condition, opts));
+    parts.push('then');
+    if (data.then)
+        parts.push(generateNode(data.then, opts));
+    if (data.else)
+        parts.push('else', generateNode(data.else, opts));
+    parts.push('end');
+    return parts.join(' ');
+}
+function generateReturnStatement(node, opts) {
+    const data = node;
+    return data.argument ? `return ${generateNode(data.argument, opts)}` : 'return';
+}
+function generateExpression(node, opts = {}) {
+    return generateNode(node, opts);
+}
+function generateSelector(node) {
+    return node.value || '';
+}
+function generateLiteral(node) {
+    const value = node.value;
+    if (typeof value === 'string')
+        return `'${escapeString(value)}'`;
+    if (typeof value === 'boolean')
+        return value ? 'true' : 'false';
+    if (value === null)
+        return 'null';
+    if (value === undefined)
+        return 'undefined';
+    return String(value);
+}
+function generateIdentifier(node) {
+    return node.name || '';
+}
+function generateBinaryExpression(node, opts) {
+    const data = node;
+    return `${generateNode(data.left, opts)} ${data.operator || '+'} ${generateNode(data.right, opts)}`;
+}
+function generateLogicalExpression(node, opts) {
+    const data = node;
+    return `${generateNode(data.left, opts)} ${data.operator || 'and'} ${generateNode(data.right, opts)}`;
+}
+function generateUnaryExpression(node, opts) {
+    const data = node;
+    const argument = generateNode(data.argument, opts);
+    const operator = data.operator || 'not';
+    return data.prefix !== false ? `${operator} ${argument}` : `${argument} ${operator}`;
+}
+function generateMemberExpression(node, opts) {
+    const data = node;
+    const object = data.object ? generateNode(data.object, opts) : '';
+    const property = data.property ? generateNode(data.property, opts) : '';
+    if (data.computed)
+        return `${object}[${property}]`;
+    return object ? `${object}.${property}` : property;
+}
+function generatePossessiveExpression(node, opts) {
+    const data = node;
+    return `${generateNode(data.object, opts)}'s ${generateNode(data.property, opts)}`;
+}
+function generateCallExpression(node, opts) {
+    const data = node;
+    const callee = data.callee ? generateNode(data.callee, opts) : 'call';
+    const args = (data.arguments || data.args || [])
+        .map((arg) => generateNode(arg, opts))
+        .join(', ');
+    return `${callee}(${args})`;
+}
+function generateFallback(node) {
+    const data = node;
+    if (data.value !== undefined)
+        return String(data.value);
+    if (data.name)
+        return data.name;
+    return '';
+}
+function indent(opts) {
+    if (opts.minify)
+        return '';
+    return (opts.indentation || '  ').repeat(opts._indentLevel || 0);
+}
+function escapeString(str) {
+    return str
+        .replace(/\\/g, '\\\\')
+        .replace(/'/g, "\\'")
+        .replace(/\n/g, '\\n')
+        .replace(/\r/g, '\\r')
+        .replace(/\t/g, '\\t');
+}
+function getTargetPreposition(commandName) {
+    switch (commandName) {
+        case 'put':
+            return 'into';
+        case 'add':
+        case 'remove':
+            return 'from';
+        case 'toggle':
+        case 'set':
+            return 'on';
+        default:
+            return 'to';
+    }
+}
+function countNodes(node, callback) {
+    if (!node || typeof node !== 'object')
+        return;
+    callback();
+    for (const value of Object.values(node)) {
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                if (item && typeof item === 'object' && item.type)
+                    countNodes(item, callback);
+            }
+        }
+        else if (value && typeof value === 'object' && value.type) {
+            countNodes(value, callback);
+        }
+    }
+}
+function minify(ast) {
+    return generate(ast, { minify: true });
+}
+function format(ast, indentation = '  ') {
+    return generate(ast, { minify: false, indentation });
+}
+
+function generateDocumentation(ast) {
+    const eventHandlers = documentEventHandlers(ast);
+    const behaviors = documentBehaviors(ast);
+    const functions = documentFunctions(ast);
+    const metrics = calculateCodeMetrics(ast);
+    let title = 'Hyperscript Documentation';
+    const firstBehavior = behaviors[0];
+    if (firstBehavior) {
+        title = `${firstBehavior.name} Behavior Documentation`;
+    }
+    else if (eventHandlers.length > 0) {
+        const events = eventHandlers.map(h => h.event).filter((e, i, arr) => arr.indexOf(e) === i);
+        title = `Event Handlers: ${events.join(', ')}`;
+    }
+    const description = generateOverallDescription(eventHandlers, behaviors, functions);
+    return {
+        title,
+        description,
+        eventHandlers,
+        behaviors,
+        functions,
+        metrics,
+        generatedAt: new Date().toISOString(),
+    };
+}
+function generateMarkdown(ast, options = {}) {
+    const { includeSource = true, includeMetrics = true, includeToc = true, headingLevel = 1, } = options;
+    const doc = generateDocumentation(ast);
+    const h = (level) => '#'.repeat(headingLevel + level - 1);
+    const lines = [];
+    lines.push(`${h(1)} ${doc.title}`, '', doc.description, '');
+    if (includeToc && doc.eventHandlers.length + doc.behaviors.length + doc.functions.length > 2) {
+        lines.push(`${h(2)} Table of Contents`, '');
+        if (doc.eventHandlers.length > 0) {
+            lines.push('- [Event Handlers](#event-handlers)');
+            for (const handler of doc.eventHandlers) {
+                lines.push(`  - [${handler.event}](#${slugify(handler.event)})`);
+            }
+        }
+        if (doc.behaviors.length > 0) {
+            lines.push('- [Behaviors](#behaviors)');
+            for (const behavior of doc.behaviors) {
+                lines.push(`  - [${behavior.name}](#${slugify(behavior.name)})`);
+            }
+        }
+        if (doc.functions.length > 0) {
+            lines.push('- [Functions](#functions)');
+            for (const fn of doc.functions) {
+                lines.push(`  - [${fn.name}](#${slugify(fn.name)})`);
+            }
+        }
+        if (includeMetrics)
+            lines.push('- [Metrics](#metrics)');
+        lines.push('');
+    }
+    if (doc.eventHandlers.length > 0) {
+        lines.push(`${h(2)} Event Handlers`, '');
+        for (const handler of doc.eventHandlers) {
+            lines.push(`${h(3)} ${handler.event}`, '');
+            if (handler.selector)
+                lines.push(`**Source:** \`${handler.selector}\``, '');
+            lines.push(handler.description, '');
+            if (handler.commands.length > 0) {
+                lines.push('**Commands:**', '');
+                for (const cmd of handler.commands)
+                    lines.push(`- \`${cmd.name}\`: ${cmd.description}`);
+                lines.push('');
+            }
+            if (includeSource) {
+                lines.push('**Source Code:**', '', '```hyperscript', handler.source, '```', '');
+            }
+        }
+    }
+    if (doc.behaviors.length > 0) {
+        lines.push(`${h(2)} Behaviors`, '');
+        for (const behavior of doc.behaviors) {
+            const params = behavior.parameters.length > 0 ? `(${behavior.parameters.join(', ')})` : '';
+            lines.push(`${h(3)} ${behavior.name}${params}`, '', behavior.description, '');
+            if (behavior.parameters.length > 0) {
+                lines.push('**Parameters:**', '');
+                for (const param of behavior.parameters)
+                    lines.push(`- \`${param}\``);
+                lines.push('');
+            }
+            if (behavior.eventHandlers.length > 0) {
+                lines.push('**Event Handlers:**', '');
+                for (const handler of behavior.eventHandlers)
+                    lines.push(`- \`on ${handler.event}\`: ${handler.description}`);
+                lines.push('');
+            }
+            if (includeSource) {
+                lines.push('**Source Code:**', '', '```hyperscript', behavior.source, '```', '');
+            }
+        }
+    }
+    if (doc.functions.length > 0) {
+        lines.push(`${h(2)} Functions`, '');
+        for (const fn of doc.functions) {
+            const params = fn.parameters.length > 0 ? `(${fn.parameters.join(', ')})` : '()';
+            lines.push(`${h(3)} ${fn.name}${params}`, '', fn.description, '');
+            if (fn.parameters.length > 0) {
+                lines.push('**Parameters:**', '');
+                for (const param of fn.parameters)
+                    lines.push(`- \`${param}\``);
+                lines.push('');
+            }
+            if (fn.returns)
+                lines.push(`**Returns:** ${fn.returns}`, '');
+            if (includeSource) {
+                lines.push('**Source Code:**', '', '```hyperscript', fn.source, '```', '');
+            }
+        }
+    }
+    if (includeMetrics) {
+        lines.push(`${h(2)} Metrics`, '', '| Metric | Value |', '|--------|-------|', `| Event Handlers | ${doc.metrics.eventHandlerCount} |`, `| Behaviors | ${doc.metrics.behaviorCount} |`, `| Functions | ${doc.metrics.functionCount} |`, `| Commands | ${doc.metrics.commandCount} |`, `| Complexity | ${doc.metrics.complexity} |`, `| Cyclomatic Complexity | ${doc.metrics.cyclomaticComplexity} |`, '', `*Generated: ${doc.generatedAt}*`);
+    }
+    return lines.join('\n');
+}
+function generateHTML(ast, options = {}) {
+    const doc = generateDocumentation(ast);
+    const title = options.title || doc.title;
+    const sections = [];
+    if (doc.eventHandlers.length > 0) {
+        sections.push(`
+      <section class="event-handlers">
+        <h2>Event Handlers</h2>
+        ${doc.eventHandlers
+            .map(h => `
+          <article class="event-handler">
+            <h3>on ${escapeHtml(h.event)}</h3>
+            ${h.selector ? `<p class="selector">Source: <code>${escapeHtml(h.selector)}</code></p>` : ''}
+            <p>${escapeHtml(h.description)}</p>
+            <ul class="commands">
+              ${h.commands.map(c => `<li><code>${escapeHtml(c.name)}</code>: ${escapeHtml(c.description)}</li>`).join('')}
+            </ul>
+            <pre><code class="language-hyperscript">${escapeHtml(h.source)}</code></pre>
+          </article>
+        `)
+            .join('')}
+      </section>`);
+    }
+    if (doc.behaviors.length > 0) {
+        sections.push(`
+      <section class="behaviors">
+        <h2>Behaviors</h2>
+        ${doc.behaviors
+            .map(b => `
+          <article class="behavior">
+            <h3>${escapeHtml(b.name)}${b.parameters.length ? `(${escapeHtml(b.parameters.join(', '))})` : ''}</h3>
+            <p>${escapeHtml(b.description)}</p>
+            ${b.parameters.length ? `<h4>Parameters</h4><ul>${b.parameters.map(p => `<li><code>${escapeHtml(p)}</code></li>`).join('')}</ul>` : ''}
+            <pre><code class="language-hyperscript">${escapeHtml(b.source)}</code></pre>
+          </article>
+        `)
+            .join('')}
+      </section>`);
+    }
+    if (doc.functions.length > 0) {
+        sections.push(`
+      <section class="functions">
+        <h2>Functions</h2>
+        ${doc.functions
+            .map(f => `
+          <article class="function">
+            <h3>${escapeHtml(f.name)}(${escapeHtml(f.parameters.join(', '))})</h3>
+            <p>${escapeHtml(f.description)}</p>
+            ${f.returns ? `<p><strong>Returns:</strong> ${escapeHtml(f.returns)}</p>` : ''}
+            <pre><code class="language-hyperscript">${escapeHtml(f.source)}</code></pre>
+          </article>
+        `)
+            .join('')}
+      </section>`);
+    }
+    sections.push(`
+    <section class="metrics">
+      <h2>Metrics</h2>
+      <table>
+        <tr><th>Metric</th><th>Value</th></tr>
+        <tr><td>Event Handlers</td><td>${doc.metrics.eventHandlerCount}</td></tr>
+        <tr><td>Behaviors</td><td>${doc.metrics.behaviorCount}</td></tr>
+        <tr><td>Functions</td><td>${doc.metrics.functionCount}</td></tr>
+        <tr><td>Commands</td><td>${doc.metrics.commandCount}</td></tr>
+        <tr><td>Complexity</td><td>${doc.metrics.complexity}</td></tr>
+      </table>
+      <p class="timestamp">Generated: ${doc.generatedAt}</p>
+    </section>`);
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${escapeHtml(title)}</title>
+  <style>
+    body { font-family: system-ui, -apple-system, sans-serif; max-width: 900px; margin: 0 auto; padding: 2rem; }
+    h1 { border-bottom: 2px solid #333; padding-bottom: 0.5rem; }
+    h2 { color: #2563eb; margin-top: 2rem; }
+    h3 { color: #374151; }
+    pre { background: #f3f4f6; padding: 1rem; border-radius: 0.5rem; overflow-x: auto; }
+    code { font-family: 'SF Mono', Monaco, monospace; }
+    .selector { color: #6b7280; font-size: 0.9rem; }
+    .commands { list-style-type: none; padding-left: 1rem; }
+    .commands li { margin: 0.5rem 0; }
+    table { border-collapse: collapse; width: 100%; }
+    th, td { border: 1px solid #d1d5db; padding: 0.5rem; text-align: left; }
+    th { background: #f9fafb; }
+    .timestamp { color: #9ca3af; font-size: 0.8rem; }
+    article { margin: 1.5rem 0; padding: 1rem; border: 1px solid #e5e7eb; border-radius: 0.5rem; }
+  </style>
+</head>
+<body>
+  <h1>${escapeHtml(title)}</h1>
+  <p>${escapeHtml(doc.description)}</p>
+  ${sections.join('\n')}
+</body>
+</html>`;
+}
+function generateJSON(ast) {
+    return JSON.stringify(generateDocumentation(ast), null, 2);
+}
+function documentEventHandlers(ast) {
+    const handlers = findNodes(ast, node => node.type === 'eventHandler');
+    return handlers.map(handler => {
+        const data = handler;
+        return {
+            event: data.event || 'unknown',
+            selector: data.selector,
+            description: generateEventHandlerDescription(data),
+            commands: documentCommands(data.commands || []),
+            source: generate(handler),
+        };
+    });
+}
+function documentBehaviors(ast) {
+    const behaviors = findNodes(ast, node => node.type === 'behavior');
+    return behaviors.map(behavior => {
+        const data = behavior;
+        return {
+            name: data.name || 'unnamed',
+            parameters: data.parameters || [],
+            description: generateBehaviorDescription(data),
+            eventHandlers: documentEventHandlers(behavior),
+            source: generate(behavior),
+        };
+    });
+}
+function documentFunctions(ast) {
+    const functions = findNodes(ast, node => node.type === 'function' || node.type === 'def');
+    return functions.map(fn => {
+        const data = fn;
+        return {
+            name: data.name || 'unnamed',
+            parameters: data.parameters || data.params || [],
+            returns: inferReturnType(data),
+            description: generateFunctionDescription(data),
+            source: generate(fn),
+        };
+    });
+}
+function documentCommands(commands) {
+    return commands.map(cmd => {
+        const data = cmd;
+        return {
+            name: data.name || 'unknown',
+            description: getCommandDescription(data.name),
+            target: data.target ? generate(data.target) : undefined,
+        };
+    });
+}
+function generateEventHandlerDescription(handler) {
+    const event = handler.event || 'event';
+    const selector = handler.selector;
+    const commandCount = (handler.commands || []).length;
+    let desc = `Handles the '${event}' event`;
+    if (selector)
+        desc += ` from elements matching '${selector}'`;
+    desc += `. Executes ${commandCount} command${commandCount !== 1 ? 's' : ''}.`;
+    return desc;
+}
+function generateBehaviorDescription(behavior) {
+    const name = behavior.name || 'This behavior';
+    const params = behavior.parameters || [];
+    const body = behavior.body || behavior.eventHandlers || [];
+    let desc = `${name} is a reusable behavior`;
+    if (params.length > 0)
+        desc += ` that takes ${params.length} parameter${params.length !== 1 ? 's' : ''} (${params.join(', ')})`;
+    if (body.length > 0)
+        desc += ` and defines ${body.length} event handler${body.length !== 1 ? 's' : ''}`;
+    desc += '.';
+    return desc;
+}
+function generateFunctionDescription(fn) {
+    const name = fn.name || 'This function';
+    const params = fn.parameters || fn.params || [];
+    let desc = `${name} is a custom function`;
+    if (params.length > 0)
+        desc += ` that takes ${params.length} parameter${params.length !== 1 ? 's' : ''} (${params.join(', ')})`;
+    desc += '.';
+    return desc;
+}
+function getCommandDescription(name) {
+    const descriptions = {
+        add: 'Adds a class or attribute to an element',
+        remove: 'Removes a class or attribute from an element',
+        toggle: 'Toggles a class on an element',
+        put: 'Puts content into an element',
+        set: 'Sets a variable or property value',
+        fetch: 'Makes an HTTP request',
+        send: 'Sends a custom event',
+        trigger: 'Triggers an event on an element',
+        wait: 'Pauses execution for a duration',
+        show: 'Shows an element',
+        hide: 'Hides an element',
+        log: 'Logs a message to the console',
+        call: 'Calls a function',
+        go: 'Navigates to a URL',
+        take: 'Removes a class from other elements and adds it to this one',
+    };
+    return descriptions[name] || `Executes the '${name}' command`;
+}
+function inferReturnType(fn) {
+    if (fn.body && fn.body.type === 'returnStatement') {
+        const arg = fn.body.argument;
+        if (arg)
+            return arg.type === 'literal' ? typeof arg.value : 'value';
+    }
+    return undefined;
+}
+function generateOverallDescription(handlers, behaviors, functions) {
+    const parts = [];
+    if (handlers.length > 0) {
+        const events = handlers.map(h => h.event).filter((e, i, arr) => arr.indexOf(e) === i);
+        parts.push(`Responds to ${events.join(', ')} event${events.length > 1 ? 's' : ''}`);
+    }
+    if (behaviors.length > 0)
+        parts.push(`defines ${behaviors.length} reusable behavior${behaviors.length > 1 ? 's' : ''}`);
+    if (functions.length > 0)
+        parts.push(`includes ${functions.length} custom function${functions.length > 1 ? 's' : ''}`);
+    if (parts.length === 0)
+        return 'No documented features.';
+    return parts.join(', ') + '.';
+}
+function calculateCodeMetrics(ast) {
+    const eventHandlers = findNodes(ast, node => node.type === 'eventHandler');
+    const behaviors = findNodes(ast, node => node.type === 'behavior');
+    const functions = findNodes(ast, node => node.type === 'function' || node.type === 'def');
+    const commands = findNodes(ast, node => node.type === 'command');
+    const complexity = calculateComplexity(ast);
+    const cyclomatic = complexity.cyclomatic;
+    let complexityRating;
+    if (cyclomatic <= 3)
+        complexityRating = 'simple';
+    else if (cyclomatic <= 7)
+        complexityRating = 'moderate';
+    else if (cyclomatic <= 10)
+        complexityRating = 'complex';
+    else
+        complexityRating = 'very complex';
+    return {
+        eventHandlerCount: eventHandlers.length,
+        behaviorCount: behaviors.length,
+        functionCount: functions.length,
+        commandCount: commands.length,
+        complexity: complexityRating,
+        cyclomaticComplexity: cyclomatic,
+    };
+}
+function slugify(text) {
+    return text
+        .toLowerCase()
+        .replace(/[^\w\s-]/g, '')
+        .replace(/\s+/g, '-')
+        .trim();
+}
+function escapeHtml(text) {
+    return text
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#039;');
+}
+
+function query(ast, selector) {
+    const matches = queryAll(ast, selector);
+    return matches.length > 0 ? matches[0] : null;
+}
+function queryAll(ast, selector) {
+    if (!ast)
+        return [];
+    const selectorParts = selector.split(',').map(s => s.trim());
+    const allMatches = [];
+    for (const selectorPart of selectorParts) {
+        const parsedSelector = parseSingleSelector(selectorPart);
+        const matches = [];
+        const ancestorStack = [];
+        function traverse(node, path, parent, siblingIndex, siblings) {
+            const queryContext = {
+                getParent: () => parent,
+                getPath: () => path,
+                getAncestors: () => [...ancestorStack],
+                getSiblingIndex: () => siblingIndex,
+                getSiblings: () => siblings,
+            };
+            if (matchesSelector(node, parsedSelector, queryContext)) {
+                matches.push({
+                    node,
+                    path: [...path],
+                    matches: extractCaptures(node, parsedSelector, queryContext),
+                });
+            }
+            ancestorStack.push(node);
+            for (const [key, value] of Object.entries(node)) {
+                if (key === 'type' ||
+                    key === 'start' ||
+                    key === 'end' ||
+                    key === 'line' ||
+                    key === 'column') {
+                    continue;
+                }
+                if (Array.isArray(value)) {
+                    const childNodes = value.filter((v) => v && typeof v === 'object' && typeof v.type === 'string');
+                    for (let i = 0; i < value.length; i++) {
+                        const item = value[i];
+                        if (item && typeof item === 'object' && typeof item.type === 'string') {
+                            traverse(item, [...path, `${key}/${i}`], node, i, childNodes);
+                        }
+                    }
+                }
+                else if (value && typeof value === 'object' && typeof value.type === 'string') {
+                    traverse(value, [...path, key], node, 0, [value]);
+                }
+            }
+            ancestorStack.pop();
+        }
+        traverse(ast, [], null, 0, [ast]);
+        allMatches.push(...matches);
+    }
+    return allMatches;
+}
+function parseSelector(selector) {
+    return parseSingleSelector(selector.trim());
+}
+function parseSingleSelector(selector) {
+    const result = {
+        type: null,
+        attributes: [],
+        pseudos: [],
+        combinator: null,
+    };
+    selector = selector.trim();
+    if (/\[\[/.test(selector)) {
+        throw new Error(`Invalid selector syntax: "${selector}" - unexpected [[`);
+    }
+    if (/([>+~])\s*([>+~])/.test(selector)) {
+        throw new Error(`Invalid selector syntax: "${selector}" - consecutive combinators`);
+    }
+    const combinatorMatch = selector.match(/^([^\s>+~]+(?:\[[^\]]*\])*(?::[a-zA-Z-]+(?:\([^)]*\))?)*)\s*([>+~]|\s)\s*(.+)$/);
+    if (combinatorMatch) {
+        const [, left, combinator, right] = combinatorMatch;
+        if (combinator && left && right) {
+            result.combinator = {
+                type: (combinator.trim() || ' '),
+                right: parseSingleSelector(right),
+            };
+            selector = left.trim();
+        }
+    }
+    const typeMatch = selector.match(/^([a-zA-Z_][a-zA-Z0-9_-]*)/);
+    if (typeMatch) {
+        result.type = typeMatch[1] ?? null;
+        selector = selector.substring(typeMatch[0].length);
+    }
+    const pseudoRegex = /:([a-zA-Z-]+)(?:\(([^)]*(?:\([^)]*\))*[^)]*)\))?/g;
+    let pseudoMatch;
+    const pseudoRanges = [];
+    while ((pseudoMatch = pseudoRegex.exec(selector)) !== null) {
+        const [fullMatch, name, argument] = pseudoMatch;
+        result.pseudos.push({
+            name: name ?? '',
+            argument: argument || null,
+        });
+        pseudoRanges.push([pseudoMatch.index, pseudoMatch.index + fullMatch.length]);
+    }
+    const attributeRegex = /\[([a-zA-Z_][a-zA-Z0-9_-]*)(?:(\^=|\$=|\*=|\|=|~=|!=|=)([^\]]*))?\]/g;
+    let attributeMatch;
+    while ((attributeMatch = attributeRegex.exec(selector)) !== null) {
+        const matchStart = attributeMatch.index;
+        const matchEnd = matchStart + attributeMatch[0].length;
+        const insidePseudo = pseudoRanges.some(([start, end]) => matchStart >= start && matchEnd <= end);
+        if (insidePseudo)
+            continue;
+        const [, name, operator, value] = attributeMatch;
+        if (name) {
+            result.attributes.push({
+                name: name.trim(),
+                operator: (operator || 'exists'),
+                value: value !== undefined ? parseAttributeValue(value.trim()) : null,
+            });
+        }
+    }
+    return result;
+}
+function parseAttributeValue(value) {
+    if ((value.startsWith('"') && value.endsWith('"')) ||
+        (value.startsWith("'") && value.endsWith("'"))) {
+        return value.slice(1, -1);
+    }
+    const num = Number(value);
+    if (!isNaN(num)) {
+        return num;
+    }
+    if (value === 'true')
+        return true;
+    if (value === 'false')
+        return false;
+    if (value === 'null')
+        return null;
+    if (value === 'undefined')
+        return undefined;
+    return value;
+}
+function matchesSelector(node, selector, context) {
+    if (selector.combinator) {
+        const rightmost = getRightmostSelector(selector);
+        if (!matchesSimpleSelector(node, rightmost)) {
+            return false;
+        }
+        return checkCombinatorChain(node, selector, context);
+    }
+    return matchesSimpleSelector(node, selector, context);
+}
+function getRightmostSelector(selector) {
+    if (selector.combinator) {
+        return getRightmostSelector(selector.combinator.right);
+    }
+    return selector;
+}
+function checkCombinatorChain(node, selector, context) {
+    if (!selector.combinator) {
+        return true;
+    }
+    const combinatorType = selector.combinator.type;
+    const rightSelector = selector.combinator.right;
+    const leftSelector = {
+        type: selector.type,
+        attributes: selector.attributes,
+        pseudos: selector.pseudos};
+    if (rightSelector.combinator) {
+        if (!checkCombinatorChain(node, rightSelector, context)) {
+            return false;
+        }
+        const immediateRight = {
+            type: rightSelector.type,
+            attributes: rightSelector.attributes,
+            pseudos: rightSelector.pseudos};
+        return checkCombinatorRelationship(node, combinatorType, leftSelector, context, immediateRight);
+    }
+    return checkCombinatorRelationship(node, combinatorType, leftSelector, context);
+}
+function matchesSimpleSelector(node, selector, context) {
+    if (selector.type && node.type !== selector.type) {
+        return false;
+    }
+    for (const attr of selector.attributes) {
+        if (!matchesAttribute(node, attr)) {
+            return false;
+        }
+    }
+    for (const pseudo of selector.pseudos) {
+        if (context) {
+            if (!matchesPseudo(node, pseudo, context)) {
+                return false;
+            }
+        }
+        else {
+            if (!matchesPseudoSimple(node, pseudo)) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+function matchesAttribute(node, attr) {
+    const value = node[attr.name];
+    switch (attr.operator) {
+        case 'exists':
+            return value !== undefined;
+        case '=':
+            return value === attr.value;
+        case '!=':
+            return value !== attr.value;
+        case '^=':
+            return typeof value === 'string' && value.startsWith(String(attr.value));
+        case '$=':
+            return typeof value === 'string' && value.endsWith(String(attr.value));
+        case '*=':
+            return typeof value === 'string' && value.includes(String(attr.value));
+        case '|=':
+            return (typeof value === 'string' && (value === attr.value || value.startsWith(attr.value + '-')));
+        case '~=':
+            return typeof value === 'string' && value.split(/\s+/).includes(String(attr.value));
+        default:
+            return false;
+    }
+}
+function matchesPseudo(node, pseudo, context) {
+    switch (pseudo.name) {
+        case 'first-child':
+            return isFirstChild(node, context);
+        case 'last-child':
+            return isLastChild(node, context);
+        case 'has':
+            return hasDescendant(node, pseudo.argument);
+        case 'not':
+            return !matchesSelector(node, parseSelector(pseudo.argument), context);
+        case 'contains':
+            return containsText(node, pseudo.argument);
+        default:
+            return false;
+    }
+}
+function matchesPseudoSimple(node, pseudo) {
+    switch (pseudo.name) {
+        case 'has':
+            return hasDescendant(node, pseudo.argument);
+        case 'not':
+            return !matchesSimpleSelector(node, parseSelector(pseudo.argument));
+        case 'contains':
+            return containsText(node, pseudo.argument);
+        default:
+            return false;
+    }
+}
+function checkCombinatorRelationship(node, combinatorType, leftSelector, context, intermediateSelector) {
+    switch (combinatorType) {
+        case '>': {
+            const parent = context.getParent();
+            if (!parent)
+                return false;
+            if (intermediateSelector) {
+                return (matchesSimpleSelector(parent, intermediateSelector) &&
+                    hasAncestorMatching(parent, context, leftSelector));
+            }
+            return matchesSimpleSelector(parent, leftSelector);
+        }
+        case '+':
+            return hasPreviousSiblingMatching(node, context, leftSelector);
+        case '~':
+            return hasAnyPreviousSiblingMatching(node, context, leftSelector);
+        case ' ':
+            if (intermediateSelector) {
+                return hasAncestorMatchingWithFurtherAncestor(node, context, intermediateSelector, leftSelector);
+            }
+            return hasAncestorMatching(node, context, leftSelector);
+        default:
+            return false;
+    }
+}
+function hasAncestorMatchingWithFurtherAncestor(node, context, intermediateSelector, leftSelector) {
+    if (!context.getAncestors) {
+        return false;
+    }
+    const ancestors = context.getAncestors();
+    for (let i = ancestors.length - 1; i >= 0; i--) {
+        const ancestor = ancestors[i];
+        if (matchesSimpleSelector(ancestor, intermediateSelector)) {
+            for (let j = i - 1; j >= 0; j--) {
+                if (matchesSimpleSelector(ancestors[j], leftSelector)) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}
+function isFirstChild(node, context) {
+    if (context.getSiblingIndex) {
+        return context.getSiblingIndex() === 0;
+    }
+    const parent = context.getParent();
+    if (!parent)
+        return false;
+    for (const [, value] of Object.entries(parent)) {
+        if (Array.isArray(value) && value.length > 0 && value[0] === node) {
+            return true;
+        }
+    }
+    return false;
+}
+function isLastChild(node, context) {
+    if (context.getSiblingIndex && context.getSiblings) {
+        const siblings = context.getSiblings();
+        return context.getSiblingIndex() === siblings.length - 1;
+    }
+    const parent = context.getParent();
+    if (!parent)
+        return false;
+    for (const [, value] of Object.entries(parent)) {
+        if (Array.isArray(value) && value.length > 0 && value[value.length - 1] === node) {
+            return true;
+        }
+    }
+    return false;
+}
+function hasDescendant(node, selector) {
+    const descendants = findNodes(node, () => true);
+    const parsedSelector = parseSelector(selector);
+    return descendants.some(descendant => matchesSelector(descendant, parsedSelector, { getParent: () => null }));
+}
+function containsText(node, text) {
+    let searchText = text;
+    if ((text.startsWith('"') && text.endsWith('"')) ||
+        (text.startsWith("'") && text.endsWith("'"))) {
+        searchText = text.slice(1, -1);
+    }
+    const nodeStr = JSON.stringify(node);
+    return nodeStr.includes(searchText);
+}
+function hasAncestorMatching(node, context, selector) {
+    if (context.getAncestors) {
+        const ancestors = context.getAncestors();
+        for (const ancestor of ancestors) {
+            if (matchesSimpleSelector(ancestor, selector)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    const parent = context.getParent();
+    return parent ? matchesSimpleSelector(parent, selector) : false;
+}
+function hasPreviousSiblingMatching(node, context, selector) {
+    if (!context.getSiblings || !context.getSiblingIndex) {
+        return false;
+    }
+    const siblings = context.getSiblings();
+    const index = context.getSiblingIndex();
+    if (index > 0) {
+        const prevSibling = siblings[index - 1];
+        return prevSibling ? matchesSimpleSelector(prevSibling, selector) : false;
+    }
+    return false;
+}
+function hasAnyPreviousSiblingMatching(node, context, selector) {
+    if (!context.getSiblings || !context.getSiblingIndex) {
+        return false;
+    }
+    const siblings = context.getSiblings();
+    const index = context.getSiblingIndex();
+    for (let i = 0; i < index; i++) {
+        const sibling = siblings[i];
+        if (sibling && matchesSimpleSelector(sibling, selector)) {
+            return true;
+        }
+    }
+    return false;
+}
+function extractCaptures(node, selector, context) {
+    const captures = {};
+    const rightmost = getRightmostSelector(selector);
+    for (const attr of rightmost.attributes) {
+        if (attr.operator === '=' || attr.operator === 'exists') {
+            const key = rightmost.type ? `${rightmost.type}[${attr.name}]` : `[${attr.name}]`;
+            captures[key] = node[attr.name];
+        }
+    }
+    if (selector.combinator && context?.getAncestors) {
+        const ancestors = context.getAncestors();
+        extractCapturesFromCombinatorChain(selector, ancestors, captures);
+    }
+    return captures;
+}
+function extractCapturesFromCombinatorChain(selector, ancestors, captures) {
+    if (!selector.combinator)
+        return;
+    const leftSelector = {
+        type: selector.type,
+        attributes: selector.attributes,
+        pseudos: selector.pseudos};
+    for (const ancestor of ancestors) {
+        if (matchesSimpleSelector(ancestor, leftSelector)) {
+            for (const attr of leftSelector.attributes) {
+                if (attr.operator === '=' || attr.operator === 'exists') {
+                    const key = leftSelector.type ? `${leftSelector.type}[${attr.name}]` : `[${attr.name}]`;
+                    captures[key] = ancestor[attr.name];
+                }
+            }
+            break;
+        }
+    }
+    if (selector.combinator.right.combinator) {
+        extractCapturesFromCombinatorChain(selector.combinator.right, ancestors, captures);
+    }
+}
+function queryXPath(ast, xpath) {
+    if (!ast)
+        return [];
+    if (xpath === '//*') {
+        return findNodes(ast, () => true);
+    }
+    const descendantMatch = xpath.match(/^\/\/([a-zA-Z_][a-zA-Z0-9_]*)/);
+    if (descendantMatch) {
+        const nodeType = descendantMatch[1];
+        return findNodes(ast, node => node.type === nodeType);
+    }
+    throw new Error(`XPath query "${xpath}" not supported in basic implementation`);
+}
+
+function normalizeVisitResult(result, fallback) {
+    if (result === null) {
+        return fallback;
+    }
+    if (Array.isArray(result)) {
+        return result.length > 0 ? result[0] : fallback;
+    }
+    return result;
+}
+function transform(ast, visitor, options = {}) {
+    const transformVisitor = new ASTVisitor(visitor);
+    const visitResult = transformVisitor.visit(ast, createVisitorContext());
+    let result;
+    if (visitResult === null) {
+        result = ast;
+    }
+    else if (Array.isArray(visitResult)) {
+        result = visitResult.length > 0 ? visitResult[0] : ast;
+    }
+    else {
+        result = visitResult;
+    }
+    if (options.optimize) {
+        result = optimize(result, options);
+    }
+    if (options.minify) {
+        result = minifyAST(result);
+    }
+    return result;
+}
+function optimize(ast, options = {}) {
+    const passes = [];
+    if (options.batchOperations || options.batchSimilarOperations || options.optimize) {
+        passes.push(createBatchOperationsPass());
+    }
+    if (options.redundantClassOperations || options.optimize) {
+        passes.push(createRemoveRedundantOperationsPass());
+    }
+    if (options.optimize) {
+        passes.push(createSimplifyConditionsPass());
+    }
+    return applyOptimizationPasses(ast, passes);
+}
+function applyOptimizationPasses(ast, passes) {
+    let result = ast;
+    for (const pass of passes) {
+        result = applyOptimizationPass(result, pass);
+    }
+    return result;
+}
+function applyOptimizationPass(ast, pass) {
+    const visitor = new ASTVisitor({
+        enter(node, context) {
+            if (!pass.shouldRun || pass.shouldRun(node)) {
+                pass.transform(node, context);
+            }
+        },
+    });
+    return normalizeVisitResult(visitor.visit(ast, createVisitorContext()), ast);
+}
+function createBatchOperationsPass() {
+    return {
+        name: 'batch-operations',
+        transform: (node, context) => {
+            if (node.commands && Array.isArray(node.commands)) {
+                const commands = node.commands;
+                const batched = batchSimilarCommands(commands);
+                if (batched.length !== commands.length) {
+                    context.replace({ ...node, commands: batched });
+                }
+            }
+            return node;
+        },
+    };
+}
+function createRemoveRedundantOperationsPass() {
+    return {
+        name: 'remove-redundant',
+        transform: (node, context) => {
+            if (node.commands && Array.isArray(node.commands)) {
+                const commands = node.commands;
+                const optimized = removeRedundantOperations(commands);
+                if (optimized.length !== commands.length) {
+                    context.replace({ ...node, commands: optimized });
+                }
+            }
+            return node;
+        },
+    };
+}
+function createSimplifyConditionsPass() {
+    return {
+        name: 'simplify-conditions',
+        transform: (node, context) => {
+            if (node.type === 'conditional' && node.condition) {
+                const simplified = simplifyCondition(node.condition);
+                if (simplified !== node.condition) {
+                    context.replace({ ...node, condition: simplified });
+                }
+            }
+            return node;
+        },
+    };
+}
+function normalize(ast) {
+    const visitor = new ASTVisitor({
+        exit(node, context) {
+            const normalized = {
+                type: node.type,
+                start: node.start,
+                end: node.end,
+                line: node.line,
+                column: node.column,
+            };
+            if (node.type === 'command') {
+                normalized.name = node.name;
+                normalized.args = node.args;
+                normalized.target = node.target;
+            }
+            else if (node.type === 'eventHandler') {
+                normalized.event = node.event;
+                normalized.commands = node.commands;
+            }
+            else if (node.type === 'selector') {
+                normalized.value = node.value;
+            }
+            else if (node.type === 'identifier') {
+                normalized.name = node.name;
+            }
+            else if (node.type === 'literal') {
+                normalized.value = node.value;
+            }
+            context.replace(normalized);
+        },
+    });
+    return normalizeVisitResult(visitor.visit(ast, createVisitorContext()), ast);
+}
+function inlineVariables(ast) {
+    const variables = new Map();
+    const collectVisitor = new ASTVisitor({
+        enter(node) {
+            if (node.name === 'set' &&
+                node.variable &&
+                node.value &&
+                isSimpleValue(node.value)) {
+                const varName = node.variable.name;
+                variables.set(varName, node.value);
+            }
+        },
+    });
+    visit(ast, collectVisitor);
+    const inlineVisitor = new ASTVisitor({
+        enter(node, context) {
+            if (node.type === 'identifier' && variables.has(node.name)) {
+                context.replace(variables.get(node.name));
+            }
+        },
+    });
+    return normalizeVisitResult(inlineVisitor.visit(ast, createVisitorContext()), ast);
+}
+function extractCommonExpressions(ast) {
+    const expressionCounts = new Map();
+    const countVisitor = new ASTVisitor({
+        enter(node) {
+            if (node.type === 'binaryExpression' && isComplexExpression(node)) {
+                const expr = JSON.stringify(node, ['type', 'operator', 'left', 'right', 'name', 'value']);
+                if (!expressionCounts.has(expr)) {
+                    expressionCounts.set(expr, { count: 0, node, nodes: [] });
+                }
+                const entry = expressionCounts.get(expr);
+                entry.count++;
+                entry.nodes.push(node);
+            }
+        },
+    });
+    visit(ast, countVisitor);
+    let varCounter = 0;
+    const extractions = new Map();
+    const newCommands = [];
+    for (const [expr, data] of expressionCounts) {
+        if (data.count > 1) {
+            const varName = `temp${++varCounter}`;
+            extractions.set(expr, varName);
+            newCommands.push({
+                type: 'command',
+                name: 'set',
+                start: 0,
+                end: 0,
+                line: 1,
+                column: 1,
+                variable: { type: 'identifier', name: varName, start: 0, end: 0, line: 1, column: 1 },
+                value: data.node,
+            });
+        }
+    }
+    const replaceVisitor = new ASTVisitor({
+        enter(node, context) {
+            if (node.type === 'binaryExpression') {
+                const expr = JSON.stringify(node, ['type', 'operator', 'left', 'right', 'name', 'value']);
+                if (extractions.has(expr)) {
+                    context.replace({
+                        type: 'identifier',
+                        name: extractions.get(expr),
+                        start: node.start ?? 0,
+                        end: node.end ?? 0,
+                        line: node.line ?? 1,
+                        column: node.column ?? 1,
+                    });
+                }
+            }
+        },
+    });
+    let result = normalizeVisitResult(replaceVisitor.visit(ast, createVisitorContext()), ast);
+    if (newCommands.length > 0 && result.commands) {
+        result = {
+            ...result,
+            commands: [...newCommands, ...result.commands],
+        };
+    }
+    return result;
+}
+function createOptimizationPass(config) {
+    return {
+        name: config.name,
+        transform: config.transform,
+        shouldRun: config.shouldRun,
+    };
+}
+function batchSimilarCommands(commands) {
+    const groups = new Map();
+    const result = [];
+    for (const cmd of commands) {
+        if (cmd.name === 'add' || cmd.name === 'remove') {
+            const key = `${cmd.name}:${cmd.target?.name || 'default'}`;
+            if (!groups.has(key)) {
+                groups.set(key, []);
+            }
+            groups.get(key).push(cmd);
+        }
+        else {
+            for (const [, group] of groups) {
+                if (group.length > 1) {
+                    result.push(createBatchedCommand(group));
+                }
+                else {
+                    result.push(...group);
+                }
+            }
+            groups.clear();
+            result.push(cmd);
+        }
+    }
+    for (const [, group] of groups) {
+        if (group.length > 1) {
+            result.push(createBatchedCommand(group));
+        }
+        else {
+            result.push(...group);
+        }
+    }
+    return result;
+}
+function createBatchedCommand(commands) {
+    return {
+        ...commands[0],
+        args: commands.map(cmd => cmd.args[0]).filter(Boolean),
+    };
+}
+function removeRedundantOperations(commands) {
+    const result = [];
+    const operationTracker = new Map();
+    for (let i = 0; i < commands.length; i++) {
+        const cmd = commands[i];
+        if (cmd.name === 'add' || cmd.name === 'remove') {
+            const target = cmd.target?.name || 'default';
+            const selector = cmd.args?.[0]?.value;
+            const key = `${target}:${selector}`;
+            const lastOp = operationTracker.get(key);
+            if (lastOp) {
+                if ((lastOp.operation === 'add' && cmd.name === 'remove') ||
+                    (lastOp.operation === 'remove' && cmd.name === 'add')) {
+                    result.splice(lastOp.index, 1);
+                    for (const [_, v] of operationTracker) {
+                        if (v.index > lastOp.index) {
+                            v.index--;
+                        }
+                    }
+                }
+            }
+            operationTracker.set(key, { operation: cmd.name, index: result.length });
+            result.push(cmd);
+        }
+        else {
+            result.push(cmd);
+        }
+    }
+    return result;
+}
+function simplifyCondition(condition) {
+    if (condition.operator === '&&') {
+        const left = condition.left;
+        const right = condition.right;
+        if (left.type === 'literal' && left.value === true)
+            return right;
+        if (right.type === 'literal' && right.value === true)
+            return left;
+        if (left.type === 'literal' && left.value === false)
+            return left;
+        if (right.type === 'literal' && right.value === false)
+            return right;
+    }
+    return condition;
+}
+function isSimpleValue(node) {
+    return node.type === 'literal' || node.type === 'identifier';
+}
+function isComplexExpression(node) {
+    return (node.type === 'binaryExpression' &&
+        (node.left?.type === 'binaryExpression' ||
+            node.right?.type === 'binaryExpression'));
+}
+function minifyAST(ast) {
+    const visitor = new ASTVisitor({
+        enter(node, context) {
+            const minified = {
+                type: node.type,
+            };
+            for (const [key, value] of Object.entries(node)) {
+                if (!['start', 'end', 'line', 'column'].includes(key)) {
+                    minified[key] = value;
+                }
+            }
+            context.replace(minified);
+        },
+    });
+    return normalizeVisitResult(visitor.visit(ast, createVisitorContext()), ast);
+}
+
+function pos(node) {
+    const p = {};
+    if (typeof node.start === 'number')
+        p.start = node.start;
+    if (typeof node.end === 'number')
+        p.end = node.end;
+    if (typeof node.line === 'number')
+        p.line = node.line;
+    if (typeof node.column === 'number')
+        p.column = node.column;
+    return p;
+}
+function fromCoreAST(node) {
+    if (!node)
+        return { type: 'literal', value: null };
+    switch (node.type) {
+        case 'eventHandler':
+            return convertEventHandler(node);
+        case 'command':
+            return convertCommand$1(node);
+        case 'CommandSequence':
+            return convertCommandSequence(node);
+        case 'block':
+            return convertBlock(node);
+        case 'literal':
+            return {
+                type: 'literal',
+                value: node.value,
+                ...pos(node),
+            };
+        case 'string':
+            return { type: 'literal', value: node.value, ...pos(node) };
+        case 'selector':
+            return {
+                type: 'selector',
+                value: (node.value ?? node.selector ?? ''),
+                ...pos(node),
+            };
+        case 'contextReference':
+            return {
+                type: 'identifier',
+                value: (node.name ?? node.contextType ?? ''),
+                ...pos(node),
+            };
+        case 'identifier':
+            return {
+                type: 'identifier',
+                value: (node.name ?? node.value ?? ''),
+                name: (node.name ?? ''),
+                ...pos(node),
+            };
+        case 'propertyAccess':
+        case 'possessiveExpression':
+            return convertPossessive(node);
+        case 'memberExpression':
+            return convertMember(node);
+        case 'binaryExpression':
+            return convertBinary(node);
+        case 'callExpression':
+            return convertCall(node);
+        case 'unaryExpression':
+            return {
+                type: 'unary',
+                operator: node.operator,
+                operand: fromCoreAST(node.argument ?? node.operand),
+                ...pos(node),
+            };
+        case 'timeExpression':
+            return { type: 'literal', value: node.value, ...pos(node) };
+        case 'templateLiteral':
+            return { type: 'literal', value: (node.raw ?? ''), ...pos(node) };
+        case 'variable':
+            return {
+                type: 'variable',
+                name: (node.name ?? ''),
+                scope: (node.scope ?? 'local'),
+                ...pos(node),
+            };
+        case 'htmlSelector':
+            return {
+                type: 'selector',
+                value: (node.value ?? node.selector ?? ''),
+                ...pos(node),
+            };
+        case 'positional':
+            return {
+                type: 'positional',
+                position: node.position,
+                ...(node.target ? { target: fromCoreAST(node.target) } : {}),
+                ...pos(node),
+            };
+        case 'positionalExpression':
+            return {
+                type: 'positional',
+                position: node.operator,
+                ...(node.argument ? { target: fromCoreAST(node.argument) } : {}),
+                ...pos(node),
+            };
+        default:
+            return {
+                type: 'literal',
+                value: node.value ?? null,
+                ...pos(node),
+            };
+    }
+}
+function convertEventHandler(node) {
+    const event = (node.event ?? 'click');
+    const commands = (node.commands ?? node.body ?? []);
+    const body = commands.map(cmd => fromCoreAST(cmd));
+    const modifiers = buildEventModifiers(node);
+    return { type: 'event', event, modifiers, body, ...pos(node) };
+}
+function convertCommand$1(node) {
+    const name = node.name;
+    if (name === 'if' || name === 'unless') {
+        return convertIfCommand(node);
+    }
+    if (name === 'repeat') {
+        return convertRepeatCommand(node);
+    }
+    const args = (node.args ?? []).map(arg => fromCoreAST(arg));
+    const target = node.target ? fromCoreAST(node.target) : undefined;
+    const modifiers = node.modifiers
+        ? convertModifiers(node.modifiers)
+        : undefined;
+    const roles = inferRoles(name, args, modifiers, target);
+    return {
+        type: 'command',
+        name,
+        args,
+        ...(target ? { target } : {}),
+        ...(modifiers && Object.keys(modifiers).length > 0 ? { modifiers } : {}),
+        ...(roles ? { roles } : {}),
+        ...pos(node),
+    };
+}
+function convertIfCommand(node) {
+    const args = (node.args ?? []);
+    let condition;
+    let thenBranch;
+    let elseBranch;
+    if (node.condition) {
+        condition = fromCoreAST(node.condition);
+        thenBranch = (node.thenBranch ?? node.then ?? []).map(n => fromCoreAST(n));
+        elseBranch = node.elseBranch
+            ? node.elseBranch.map(n => fromCoreAST(n))
+            : node.else
+                ? node.else.map(n => fromCoreAST(n))
+                : undefined;
+    }
+    else {
+        condition = args[0] ? fromCoreAST(args[0]) : { type: 'literal', value: true };
+        thenBranch = extractBlockCommands(args[1]);
+        elseBranch = args[2] ? extractBlockCommands(args[2]) : undefined;
+    }
+    if (node.name === 'unless') {
+        condition = { type: 'unary', operator: 'not', operand: condition };
+    }
+    return {
+        type: 'if',
+        condition,
+        thenBranch,
+        ...(elseBranch ? { elseBranch } : {}),
+        ...pos(node),
+    };
+}
+function convertRepeatCommand(node) {
+    const args = (node.args ?? []);
+    if (args.length === 0) {
+        return { type: 'repeat', body: [], ...pos(node) };
+    }
+    const loopTypeNode = args[0];
+    const loopType = (loopTypeNode?.name ?? loopTypeNode?.value ?? 'forever');
+    const bodyBlock = args[args.length - 1];
+    switch (loopType) {
+        case 'times': {
+            const count = args[1] ? fromCoreAST(args[1]) : undefined;
+            return {
+                type: 'repeat',
+                count,
+                body: extractBlockCommands(bodyBlock),
+                ...pos(node),
+            };
+        }
+        case 'for': {
+            const itemName = (args[1]?.value ?? 'item');
+            const collection = args[2]
+                ? fromCoreAST(args[2])
+                : { type: 'identifier', value: '[]' };
+            return {
+                type: 'foreach',
+                itemName,
+                collection,
+                body: extractBlockCommands(bodyBlock),
+                ...pos(node),
+            };
+        }
+        case 'while': {
+            const condition = args[1]
+                ? fromCoreAST(args[1])
+                : { type: 'literal', value: true };
+            return {
+                type: 'while',
+                condition,
+                body: extractBlockCommands(bodyBlock),
+                ...pos(node),
+            };
+        }
+        default:
+            return { type: 'repeat', body: extractBlockCommands(bodyBlock), ...pos(node) };
+    }
+}
+function convertCommandSequence(node) {
+    const commands = (node.commands ?? []);
+    if (commands.length === 1) {
+        return fromCoreAST(commands[0]);
+    }
+    return {
+        type: 'event',
+        event: 'click',
+        body: commands.map(cmd => fromCoreAST(cmd)),
+        ...pos(node),
+    };
+}
+function convertBlock(node) {
+    const commands = (node.commands ?? []);
+    if (commands.length === 1) {
+        return fromCoreAST(commands[0]);
+    }
+    return {
+        type: 'event',
+        event: 'click',
+        body: commands.map(cmd => fromCoreAST(cmd)),
+        ...pos(node),
+    };
+}
+function convertPossessive(node) {
+    const object = node.object
+        ? fromCoreAST(node.object)
+        : { type: 'identifier', value: 'me' };
+    const property = typeof node.property === 'string'
+        ? node.property
+        : (node.property?.name ?? node.property?.value ?? '');
+    return { type: 'possessive', object, property, ...pos(node) };
+}
+function convertMember(node) {
+    const object = node.object
+        ? fromCoreAST(node.object)
+        : { type: 'identifier', value: 'me' };
+    const property = typeof node.property === 'string'
+        ? node.property
+        : node.property
+            ? fromCoreAST(node.property)
+            : { type: 'literal', value: '' };
+    return {
+        type: 'member',
+        object,
+        property,
+        computed: (node.computed ?? false),
+        ...pos(node),
+    };
+}
+function convertBinary(node) {
+    return {
+        type: 'binary',
+        operator: (node.operator ?? ''),
+        left: fromCoreAST(node.left),
+        right: fromCoreAST(node.right),
+        ...pos(node),
+    };
+}
+function convertCall(node) {
+    const callee = typeof node.callee === 'string'
+        ? { type: 'identifier', value: node.callee, name: node.callee }
+        : fromCoreAST(node.callee);
+    const args = (node.arguments ?? node.args ?? []).map(a => fromCoreAST(a));
+    return { type: 'call', callee, args, ...pos(node) };
+}
+function convertModifiers(modifiers) {
+    const result = {};
+    for (const [key, value] of Object.entries(modifiers)) {
+        result[key] = fromCoreAST(value);
+    }
+    return result;
+}
+function buildEventModifiers(node) {
+    return {
+        ...(node.once ? { once: true } : {}),
+        ...(node.debounce ? { debounce: node.debounce } : {}),
+        ...(node.throttle ? { throttle: node.throttle } : {}),
+        ...(node.prevent ? { prevent: true } : {}),
+        ...(node.stop ? { stop: true } : {}),
+        ...(node.capture ? { capture: true } : {}),
+        ...(node.passive ? { passive: true } : {}),
+        ...(node.from ? { from: node.from } : {}),
+        ...(node.selector && !node.from ? { from: node.selector } : {}),
+    };
+}
+function extractBlockCommands(block) {
+    if (!block)
+        return [];
+    if (block.type === 'block') {
+        return (block.commands ?? []).map(cmd => fromCoreAST(cmd));
+    }
+    return [fromCoreAST(block)];
+}
+function inferRoles(name, args, modifiers, target) {
+    const roles = {};
+    switch (name) {
+        case 'set': {
+            if (args[0])
+                roles.destination = args[0];
+            const toVal = modifiers?.to;
+            if (toVal && typeof toVal === 'object' && 'type' in toVal) {
+                roles.patient = toVal;
+            }
+            else if (args[1]) {
+                roles.patient = args[1];
+            }
+            break;
+        }
+        case 'put': {
+            if (args[0])
+                roles.patient = args[0];
+            if (modifiers) {
+                for (const key of ['into', 'before', 'after']) {
+                    const val = modifiers[key];
+                    if (val && typeof val === 'object' && 'type' in val) {
+                        roles.destination = val;
+                        roles.method = { type: 'literal', value: key };
+                        break;
+                    }
+                }
+                if (typeof modifiers.position === 'string') {
+                    roles.method = { type: 'literal', value: modifiers.position };
+                }
+            }
+            if (!roles.destination && target) {
+                roles.destination = target;
+            }
+            break;
+        }
+        case 'increment':
+        case 'decrement': {
+            if (args[0])
+                roles.destination = args[0];
+            const byVal = modifiers?.by;
+            if (byVal && typeof byVal === 'object' && 'type' in byVal) {
+                roles.quantity = byVal;
+            }
+            else if (args[1]) {
+                roles.quantity = args[1];
+            }
+            break;
+        }
+        case 'fetch': {
+            if (args[0])
+                roles.source = args[0];
+            const asVal = modifiers?.as;
+            if (asVal && typeof asVal === 'object' && 'type' in asVal) {
+                roles.responseType = asVal;
+            }
+            else if (typeof asVal === 'string') {
+                roles.responseType = { type: 'identifier', value: asVal, name: asVal };
+            }
+            break;
+        }
+        case 'wait':
+        case 'settle': {
+            if (args[0])
+                roles.duration = args[0];
+            break;
+        }
+        case 'toggle': {
+            if (args[0])
+                roles.patient = args[0];
+            if (target)
+                roles.destination = target;
+            break;
+        }
+        case 'add': {
+            if (args[0])
+                roles.patient = args[0];
+            if (target)
+                roles.destination = target;
+            break;
+        }
+        case 'remove': {
+            if (args[0])
+                roles.patient = args[0];
+            if (target)
+                roles.source = target;
+            break;
+        }
+        case 'send':
+        case 'trigger': {
+            if (args[0])
+                roles.patient = args[0];
+            if (target)
+                roles.destination = target;
+            break;
+        }
+        default:
+            return null;
+    }
+    return Object.keys(roles).length > 0 ? roles : null;
+}
+
+const POS = { start: 0, end: 0, line: 1, column: 0 };
+function nodePos(node) {
+    return {
+        start: node.start ?? POS.start,
+        end: node.end ?? POS.end,
+        line: node.line ?? POS.line,
+        column: node.column ?? POS.column,
+    };
+}
+function toCoreAST(node) {
+    if (!node)
+        return { type: 'literal', value: null, raw: 'null', ...POS };
+    switch (node.type) {
+        case 'event':
+            return convertEvent(node);
+        case 'command':
+            return convertCommand(node);
+        case 'if':
+            return convertIf(node);
+        case 'repeat':
+            return convertRepeat(node);
+        case 'foreach':
+            return convertForEach(node);
+        case 'while':
+            return convertWhile(node);
+        case 'literal':
+            return {
+                type: 'literal',
+                value: node.value,
+                raw: node.value === null ? 'null' : node.value === undefined ? '' : String(node.value),
+                ...nodePos(node),
+            };
+        case 'identifier':
+            return { type: 'identifier', name: node.name ?? node.value, ...nodePos(node) };
+        case 'selector':
+            return { type: 'selector', value: node.value, ...nodePos(node) };
+        case 'variable':
+            return { type: 'identifier', name: node.name, scope: node.scope, ...nodePos(node) };
+        case 'binary':
+            return {
+                type: 'binaryExpression',
+                operator: node.operator,
+                left: toCoreAST(node.left),
+                right: toCoreAST(node.right),
+                ...nodePos(node),
+            };
+        case 'unary':
+            return {
+                type: 'unaryExpression',
+                operator: node.operator,
+                argument: toCoreAST(node.operand),
+                prefix: true,
+                ...nodePos(node),
+            };
+        case 'member':
+            return {
+                type: 'memberExpression',
+                object: toCoreAST(node.object),
+                property: typeof node.property === 'string'
+                    ? { type: 'identifier', name: node.property, ...POS }
+                    : toCoreAST(node.property),
+                computed: node.computed ?? false,
+                ...nodePos(node),
+            };
+        case 'possessive':
+            return {
+                type: 'possessiveExpression',
+                object: toCoreAST(node.object),
+                property: { type: 'identifier', name: node.property, ...POS },
+                ...nodePos(node),
+            };
+        case 'call':
+            return {
+                type: 'callExpression',
+                callee: toCoreAST(node.callee),
+                arguments: (node.args ?? []).map(a => toCoreAST(a)),
+                ...nodePos(node),
+            };
+        case 'positional':
+            return {
+                type: 'callExpression',
+                callee: { type: 'identifier', name: node.position, ...POS },
+                arguments: node.target ? [toCoreAST(node.target)] : [],
+                ...nodePos(node),
+            };
+        default: {
+            return { type: 'literal', value: null, raw: 'null', ...POS };
+        }
+    }
+}
+function convertEvent(node) {
+    const commands = (node.body ?? []).map(cmd => toCoreAST(cmd));
+    const modifiers = flattenEventModifiers(node.modifiers);
+    return {
+        type: 'eventHandler',
+        event: node.event,
+        commands,
+        ...modifiers,
+        ...nodePos(node),
+    };
+}
+function convertCommand(node) {
+    const result = {
+        type: 'command',
+        name: node.name,
+        args: (node.args ?? []).map(a => toCoreAST(a)),
+        isBlocking: false,
+        ...nodePos(node),
+    };
+    if (node.target) {
+        result.target = toCoreAST(node.target);
+    }
+    if (node.modifiers && Object.keys(node.modifiers).length > 0) {
+        const convertedModifiers = {};
+        for (const [key, value] of Object.entries(node.modifiers)) {
+            convertedModifiers[key] =
+                value && typeof value === 'object' && 'type' in value
+                    ? toCoreAST(value)
+                    : value;
+        }
+        result.modifiers = convertedModifiers;
+    }
+    return result;
+}
+function convertIf(node) {
+    const result = {
+        type: 'command',
+        name: 'if',
+        isBlocking: true,
+        condition: toCoreAST(node.condition),
+        thenBranch: node.thenBranch.map(n => toCoreAST(n)),
+        args: [],
+        ...nodePos(node),
+    };
+    if (node.elseBranch) {
+        result.elseBranch = node.elseBranch.map(n => toCoreAST(n));
+    }
+    return result;
+}
+function convertRepeat(node) {
+    const result = {
+        type: 'command',
+        name: 'repeat',
+        isBlocking: true,
+        body: node.body.map(n => toCoreAST(n)),
+        args: [],
+        ...nodePos(node),
+    };
+    if (node.count !== undefined) {
+        result.count =
+            typeof node.count === 'number'
+                ? { type: 'literal', value: node.count, raw: String(node.count), ...POS }
+                : toCoreAST(node.count);
+        result.loopVariant = 'times';
+    }
+    return result;
+}
+function convertForEach(node) {
+    return {
+        type: 'command',
+        name: 'repeat',
+        isBlocking: true,
+        loopVariant: 'for',
+        itemName: node.itemName,
+        ...(node.indexName ? { indexName: node.indexName } : {}),
+        collection: toCoreAST(node.collection),
+        body: node.body.map(n => toCoreAST(n)),
+        args: [],
+        ...nodePos(node),
+    };
+}
+function convertWhile(node) {
+    return {
+        type: 'command',
+        name: 'repeat',
+        isBlocking: true,
+        loopVariant: 'while',
+        condition: toCoreAST(node.condition),
+        body: node.body.map(n => toCoreAST(n)),
+        args: [],
+        ...nodePos(node),
+    };
+}
+function flattenEventModifiers(modifiers) {
+    if (!modifiers)
+        return {};
+    const flat = {};
+    if (modifiers.once)
+        flat.once = true;
+    if (modifiers.prevent)
+        flat.prevent = true;
+    if (modifiers.stop)
+        flat.stop = true;
+    if (modifiers.capture)
+        flat.capture = true;
+    if (modifiers.passive)
+        flat.passive = true;
+    if (modifiers.debounce)
+        flat.debounce = modifiers.debounce;
+    if (modifiers.throttle)
+        flat.throttle = modifiers.throttle;
+    if (modifiers.from)
+        flat.from = modifiers.from;
+    return flat;
+}
+
+var DiagnosticSeverity;
+(function (DiagnosticSeverity) {
+    DiagnosticSeverity[DiagnosticSeverity["Error"] = 1] = "Error";
+    DiagnosticSeverity[DiagnosticSeverity["Warning"] = 2] = "Warning";
+    DiagnosticSeverity[DiagnosticSeverity["Information"] = 3] = "Information";
+    DiagnosticSeverity[DiagnosticSeverity["Hint"] = 4] = "Hint";
+})(DiagnosticSeverity || (DiagnosticSeverity = {}));
+var SymbolKind;
+(function (SymbolKind) {
+    SymbolKind[SymbolKind["File"] = 1] = "File";
+    SymbolKind[SymbolKind["Module"] = 2] = "Module";
+    SymbolKind[SymbolKind["Namespace"] = 3] = "Namespace";
+    SymbolKind[SymbolKind["Package"] = 4] = "Package";
+    SymbolKind[SymbolKind["Class"] = 5] = "Class";
+    SymbolKind[SymbolKind["Method"] = 6] = "Method";
+    SymbolKind[SymbolKind["Property"] = 7] = "Property";
+    SymbolKind[SymbolKind["Field"] = 8] = "Field";
+    SymbolKind[SymbolKind["Constructor"] = 9] = "Constructor";
+    SymbolKind[SymbolKind["Enum"] = 10] = "Enum";
+    SymbolKind[SymbolKind["Interface"] = 11] = "Interface";
+    SymbolKind[SymbolKind["Function"] = 12] = "Function";
+    SymbolKind[SymbolKind["Variable"] = 13] = "Variable";
+    SymbolKind[SymbolKind["Constant"] = 14] = "Constant";
+    SymbolKind[SymbolKind["String"] = 15] = "String";
+    SymbolKind[SymbolKind["Number"] = 16] = "Number";
+    SymbolKind[SymbolKind["Boolean"] = 17] = "Boolean";
+    SymbolKind[SymbolKind["Array"] = 18] = "Array";
+    SymbolKind[SymbolKind["Object"] = 19] = "Object";
+    SymbolKind[SymbolKind["Key"] = 20] = "Key";
+    SymbolKind[SymbolKind["Null"] = 21] = "Null";
+    SymbolKind[SymbolKind["EnumMember"] = 22] = "EnumMember";
+    SymbolKind[SymbolKind["Struct"] = 23] = "Struct";
+    SymbolKind[SymbolKind["Event"] = 24] = "Event";
+    SymbolKind[SymbolKind["Operator"] = 25] = "Operator";
+    SymbolKind[SymbolKind["TypeParameter"] = 26] = "TypeParameter";
+})(SymbolKind || (SymbolKind = {}));
+var CompletionItemKind;
+(function (CompletionItemKind) {
+    CompletionItemKind[CompletionItemKind["Text"] = 1] = "Text";
+    CompletionItemKind[CompletionItemKind["Method"] = 2] = "Method";
+    CompletionItemKind[CompletionItemKind["Function"] = 3] = "Function";
+    CompletionItemKind[CompletionItemKind["Constructor"] = 4] = "Constructor";
+    CompletionItemKind[CompletionItemKind["Field"] = 5] = "Field";
+    CompletionItemKind[CompletionItemKind["Variable"] = 6] = "Variable";
+    CompletionItemKind[CompletionItemKind["Class"] = 7] = "Class";
+    CompletionItemKind[CompletionItemKind["Interface"] = 8] = "Interface";
+    CompletionItemKind[CompletionItemKind["Module"] = 9] = "Module";
+    CompletionItemKind[CompletionItemKind["Property"] = 10] = "Property";
+    CompletionItemKind[CompletionItemKind["Unit"] = 11] = "Unit";
+    CompletionItemKind[CompletionItemKind["Value"] = 12] = "Value";
+    CompletionItemKind[CompletionItemKind["Enum"] = 13] = "Enum";
+    CompletionItemKind[CompletionItemKind["Keyword"] = 14] = "Keyword";
+    CompletionItemKind[CompletionItemKind["Snippet"] = 15] = "Snippet";
+    CompletionItemKind[CompletionItemKind["Color"] = 16] = "Color";
+    CompletionItemKind[CompletionItemKind["File"] = 17] = "File";
+    CompletionItemKind[CompletionItemKind["Reference"] = 18] = "Reference";
+    CompletionItemKind[CompletionItemKind["Folder"] = 19] = "Folder";
+    CompletionItemKind[CompletionItemKind["EnumMember"] = 20] = "EnumMember";
+    CompletionItemKind[CompletionItemKind["Constant"] = 21] = "Constant";
+    CompletionItemKind[CompletionItemKind["Struct"] = 22] = "Struct";
+    CompletionItemKind[CompletionItemKind["Event"] = 23] = "Event";
+    CompletionItemKind[CompletionItemKind["Operator"] = 24] = "Operator";
+    CompletionItemKind[CompletionItemKind["TypeParameter"] = 25] = "TypeParameter";
+})(CompletionItemKind || (CompletionItemKind = {}));
+function interchangeToLSPDiagnostics(nodes, options) {
+    const source = options?.source ?? 'lokascript';
+    const cyclomaticThreshold = options?.cyclomaticThreshold ?? 10;
+    const cognitiveThreshold = options?.cognitiveThreshold ?? 15;
+    const diagnostics = [];
+    for (const node of nodes) {
+        const cyclomatic = calculateCyclomatic(node);
+        const cognitive = calculateCognitive(node);
+        const smells = detectSmells(node);
+        for (const smell of smells) {
+            diagnostics.push({
+                range: nodeToRange(smell.node),
+                severity: smell.severity,
+                code: smell.code,
+                source,
+                message: smell.message,
+            });
+        }
+        if (cyclomatic > cyclomaticThreshold) {
+            diagnostics.push({
+                range: nodeToRange(node),
+                severity: DiagnosticSeverity.Warning,
+                code: 'high-cyclomatic-complexity',
+                source,
+                message: `High cyclomatic complexity: ${cyclomatic} (recommended: <= ${cyclomaticThreshold})`,
+            });
+        }
+        if (cognitive > cognitiveThreshold) {
+            diagnostics.push({
+                range: nodeToRange(node),
+                severity: DiagnosticSeverity.Information,
+                code: 'high-cognitive-complexity',
+                source,
+                message: `High cognitive complexity: ${cognitive} (recommended: <= ${cognitiveThreshold})`,
+            });
+        }
+    }
+    return diagnostics;
+}
+function interchangeToLSPSymbols(nodes) {
+    const symbols = [];
+    for (const node of nodes) {
+        const symbol = nodeToSymbol(node);
+        if (symbol)
+            symbols.push(symbol);
+    }
+    return symbols;
+}
+function interchangeToLSPHover(nodes, position) {
+    const node = findNodeAtPosition(nodes, position);
+    if (!node)
+        return null;
+    let contents = `**${friendlyTypeName(node)}**\n\n`;
+    switch (node.type) {
+        case 'event':
+            contents += `Event: \`${node.event}\`\n\n`;
+            break;
+        case 'command':
+            contents += `Command: \`${node.name}\`\n\n`;
+            break;
+        case 'if':
+            contents += 'Conditional branch\n\n';
+            break;
+        case 'repeat':
+        case 'foreach':
+        case 'while':
+            contents += 'Loop construct\n\n';
+            break;
+    }
+    if (['event', 'if', 'repeat', 'foreach', 'while'].includes(node.type)) {
+        const cyclomatic = calculateCyclomatic(node);
+        const cognitive = calculateCognitive(node);
+        contents += `**Complexity:** cyclomatic ${cyclomatic}, cognitive ${cognitive}\n`;
+    }
+    return {
+        contents,
+        range: nodeToRange(node),
+    };
+}
+function interchangeToLSPCompletions(nodes, position) {
+    const node = findNodeAtPosition(nodes, position);
+    if (!node) {
+        return [
+            { label: 'on', kind: CompletionItemKind.Keyword, detail: 'Event handler' },
+            { label: 'init', kind: CompletionItemKind.Keyword, detail: 'Initialization' },
+            { label: 'behavior', kind: CompletionItemKind.Keyword, detail: 'Behavior definition' },
+            { label: 'def', kind: CompletionItemKind.Keyword, detail: 'Function definition' },
+        ];
+    }
+    switch (node.type) {
+        case 'event':
+            return [
+                { label: 'add', kind: CompletionItemKind.Method, detail: 'Add class/attribute' },
+                { label: 'remove', kind: CompletionItemKind.Method, detail: 'Remove class/attribute' },
+                { label: 'toggle', kind: CompletionItemKind.Method, detail: 'Toggle class/attribute' },
+                { label: 'put', kind: CompletionItemKind.Method, detail: 'Set content/value' },
+                { label: 'set', kind: CompletionItemKind.Method, detail: 'Set variable/property' },
+                { label: 'fetch', kind: CompletionItemKind.Method, detail: 'HTTP request' },
+                { label: 'if', kind: CompletionItemKind.Keyword, detail: 'Conditional' },
+                { label: 'repeat', kind: CompletionItemKind.Keyword, detail: 'Loop' },
+            ];
+        case 'if':
+            return [
+                { label: 'then', kind: CompletionItemKind.Keyword, detail: 'Then clause' },
+                { label: 'else', kind: CompletionItemKind.Keyword, detail: 'Else clause' },
+                { label: 'end', kind: CompletionItemKind.Keyword, detail: 'End conditional' },
+            ];
+        case 'repeat':
+        case 'foreach':
+        case 'while':
+            return [{ label: 'end', kind: CompletionItemKind.Keyword, detail: 'End loop' }];
+        default:
+            return [
+                { label: 'me', kind: CompletionItemKind.Variable, detail: 'Current element' },
+                { label: 'it', kind: CompletionItemKind.Variable, detail: 'Current context' },
+                { label: 'you', kind: CompletionItemKind.Variable, detail: 'Event target' },
+            ];
+    }
+}
+function calculateCyclomatic(node) {
+    let complexity = 1;
+    walkInterchange(node, n => {
+        if (isDecisionPoint(n))
+            complexity++;
+    });
+    return complexity;
+}
+function calculateCognitive(node) {
+    let complexity = 0;
+    function walk(n, depth) {
+        const nests = isNestingConstruct(n);
+        const newDepth = nests ? depth + 1 : depth;
+        if (isDecisionPoint(n)) {
+            complexity += 1 + depth;
+        }
+        for (const child of getChildren(n)) {
+            walk(child, newDepth);
+        }
+    }
+    walk(node, 0);
+    return complexity;
+}
+function detectSmells(root) {
+    const smells = [];
+    checkNesting(root, 0, smells);
+    if (root.type === 'event') {
+        const body = root.body ?? [];
+        if (body.length > 15) {
+            smells.push({
+                node: root,
+                code: 'long-event-handler',
+                message: `Event handler has ${body.length} commands (consider extracting behavior)`,
+                severity: DiagnosticSeverity.Information,
+            });
+        }
+    }
+    return smells;
+}
+function checkNesting(node, depth, smells) {
+    if (depth > 4 && isNestingConstruct(node)) {
+        smells.push({
+            node,
+            code: 'deep-nesting',
+            message: `Deeply nested ${node.type} (depth ${depth}, recommended: <= 4)`,
+            severity: DiagnosticSeverity.Warning,
+        });
+    }
+    const children = getChildren(node);
+    const newDepth = isNestingConstruct(node) ? depth + 1 : depth;
+    for (const child of children) {
+        checkNesting(child, newDepth, smells);
+    }
+}
+function walkInterchange(node, visitor) {
+    visitor(node);
+    for (const child of getChildren(node)) {
+        walkInterchange(child, visitor);
+    }
+}
+function getChildren(node) {
+    const children = [];
+    switch (node.type) {
+        case 'event': {
+            const e = node;
+            if (e.body)
+                children.push(...e.body);
+            if (e.target)
+                children.push(e.target);
+            break;
+        }
+        case 'command': {
+            const c = node;
+            if (c.args)
+                children.push(...c.args);
+            if (c.target)
+                children.push(c.target);
+            break;
+        }
+        case 'if': {
+            const i = node;
+            children.push(i.condition);
+            children.push(...i.thenBranch);
+            if (i.elseBranch)
+                children.push(...i.elseBranch);
+            if (i.elseIfBranches) {
+                for (const branch of i.elseIfBranches) {
+                    children.push(branch.condition);
+                    children.push(...branch.body);
+                }
+            }
+            break;
+        }
+        case 'repeat': {
+            const r = node;
+            if (r.count && typeof r.count !== 'number')
+                children.push(r.count);
+            if (r.whileCondition)
+                children.push(r.whileCondition);
+            children.push(...r.body);
+            break;
+        }
+        case 'foreach': {
+            const f = node;
+            children.push(f.collection);
+            children.push(...f.body);
+            break;
+        }
+        case 'while': {
+            const w = node;
+            children.push(w.condition);
+            children.push(...w.body);
+            break;
+        }
+        case 'binary':
+            children.push(node.left, node.right);
+            break;
+        case 'unary':
+            children.push(node.operand);
+            break;
+        case 'member':
+            children.push(node.object);
+            if (typeof node.property !== 'string')
+                children.push(node.property);
+            break;
+        case 'possessive':
+            children.push(node.object);
+            break;
+        case 'call':
+            children.push(node.callee);
+            if (node.args)
+                children.push(...node.args);
+            break;
+    }
+    return children;
+}
+function isDecisionPoint(node) {
+    return node.type === 'if' || node.type === 'while' || node.type === 'foreach';
+}
+function isNestingConstruct(node) {
+    return (node.type === 'if' ||
+        node.type === 'repeat' ||
+        node.type === 'foreach' ||
+        node.type === 'while' ||
+        node.type === 'event');
+}
+function nodeToRange(node) {
+    const startLine = (node.line ?? 1) - 1;
+    const startChar = node.column ?? 0;
+    if (node.end !== undefined && node.start !== undefined) {
+        const length = node.end - node.start;
+        return {
+            start: { line: startLine, character: startChar },
+            end: { line: startLine, character: startChar + length },
+        };
+    }
+    const estimatedLength = estimateLength(node);
+    return {
+        start: { line: startLine, character: startChar },
+        end: { line: startLine, character: startChar + estimatedLength },
+    };
+}
+function estimateLength(node) {
+    switch (node.type) {
+        case 'event':
+            return 3 + (node.event?.length ?? 5);
+        case 'command':
+            return node.name?.length ?? 5;
+        case 'selector':
+            return (node.value?.length ?? 5) + 1;
+        case 'identifier':
+            return node.value?.length ?? 2;
+        case 'literal':
+            return String(node.value ?? '').length + 2;
+        default:
+            return 10;
+    }
+}
+function findNodeAtPosition(nodes, position) {
+    const targetLine = position.line + 1;
+    const targetChar = position.character;
+    let best = null;
+    let bestSize = Infinity;
+    for (const root of nodes) {
+        walkInterchange(root, node => {
+            const nodeLine = node.line ?? 1;
+            if (nodeLine !== targetLine)
+                return;
+            const nodeStart = node.column ?? 0;
+            let nodeEnd;
+            if (node.end !== undefined && node.start !== undefined) {
+                nodeEnd = nodeStart + (node.end - node.start);
+            }
+            else {
+                nodeEnd = nodeStart + estimateLength(node);
+            }
+            if (targetChar >= nodeStart && targetChar <= nodeEnd) {
+                const size = nodeEnd - nodeStart;
+                if (size < bestSize) {
+                    best = node;
+                    bestSize = size;
+                }
+            }
+        });
+    }
+    if (!best) {
+        for (const root of nodes) {
+            walkInterchange(root, node => {
+                if ((node.line ?? 1) === targetLine) {
+                    const priority = getNodePriority(node.type);
+                    if (!best || priority > getNodePriority(best.type)) {
+                        best = node;
+                    }
+                }
+            });
+        }
+    }
+    return best;
+}
+function getNodePriority(type) {
+    switch (type) {
+        case 'event':
+            return 3;
+        case 'command':
+            return 2;
+        case 'if':
+            return 2;
+        case 'selector':
+            return 1;
+        case 'identifier':
+            return 1;
+        default:
+            return 0;
+    }
+}
+function friendlyTypeName(node) {
+    switch (node.type) {
+        case 'event':
+            return 'Event Handler';
+        case 'command':
+            return `Command (${node.name})`;
+        case 'if':
+            return 'Conditional';
+        case 'repeat':
+            return 'Repeat Loop';
+        case 'foreach':
+            return 'For Each Loop';
+        case 'while':
+            return 'While Loop';
+        case 'binary':
+            return `Binary Expression (${node.operator})`;
+        case 'unary':
+            return `Unary Expression (${node.operator})`;
+        case 'literal':
+            return 'Literal';
+        case 'identifier':
+            return 'Identifier';
+        case 'selector':
+            return 'CSS Selector';
+        case 'variable':
+            return 'Variable';
+        case 'member':
+            return 'Member Access';
+        case 'possessive':
+            return 'Possessive Expression';
+        case 'call':
+            return 'Function Call';
+        default:
+            return node.type;
+    }
+}
+function nodeToSymbol(node) {
+    switch (node.type) {
+        case 'event': {
+            const e = node;
+            const range = nodeToRange(node);
+            return {
+                name: `on ${e.event}`,
+                detail: 'Event Handler',
+                kind: SymbolKind.Event,
+                range,
+                selectionRange: range,
+                children: extractBodySymbols(e.body ?? []),
+            };
+        }
+        case 'command': {
+            const c = node;
+            const range = nodeToRange(node);
+            return {
+                name: c.name,
+                detail: 'Command',
+                kind: SymbolKind.Method,
+                range,
+                selectionRange: range,
+            };
+        }
+        case 'if': {
+            const range = nodeToRange(node);
+            return {
+                name: 'if',
+                detail: 'Conditional',
+                kind: SymbolKind.Struct,
+                range,
+                selectionRange: range,
+                children: extractBodySymbols(node.thenBranch),
+            };
+        }
+        case 'repeat': {
+            const range = nodeToRange(node);
+            return {
+                name: 'repeat',
+                detail: 'Loop',
+                kind: SymbolKind.Enum,
+                range,
+                selectionRange: range,
+                children: extractBodySymbols(node.body),
+            };
+        }
+        case 'foreach': {
+            const f = node;
+            const range = nodeToRange(node);
+            return {
+                name: `for each ${f.itemName}`,
+                detail: 'Loop',
+                kind: SymbolKind.Enum,
+                range,
+                selectionRange: range,
+                children: extractBodySymbols(f.body),
+            };
+        }
+        case 'while': {
+            const range = nodeToRange(node);
+            return {
+                name: 'while',
+                detail: 'Loop',
+                kind: SymbolKind.Enum,
+                range,
+                selectionRange: range,
+                children: extractBodySymbols(node.body),
+            };
+        }
+        default:
+            return null;
+    }
+}
+function extractBodySymbols(body) {
+    const symbols = [];
+    for (const node of body) {
+        const symbol = nodeToSymbol(node);
+        if (symbol)
+            symbols.push(symbol);
+    }
+    return symbols;
+}
+
+export { ASTVisitor, analyzeDependencies, analyzeMetrics, analyzePatterns, applyOptimizationPasses, calculateCognitive, calculateComplexity, calculateCyclomatic, countNodeTypes, createOptimizationPass, createTypeCollector, createVisitorContext, detectCodeSmells, extractCommonExpressions, findDeadCode, findFirst, findNodes, format, fromCoreAST, generate, generateCommand, generateDocumentation, generateExpression, generateHTML, generateJSON, generateMarkdown, generateWithMetadata, getAncestors, inlineVariables, interchangeToLSPCompletions, interchangeToLSPDiagnostics, interchangeToLSPHover, interchangeToLSPSymbols, measureDepth, minify, normalize, optimize, parseSelector, query, queryAll, queryXPath, suggestOptimizations, toCoreAST, transform, visit };
+//# sourceMappingURL=index.mjs.map