flint-compiler 4.0.0

package/dist/optimizer/index.js

@@ -0,0 +1,1045 @@
+// Flint Compiler v3 — Optimizer
+// Real dead code elimination, constant folding, static subtree hoisting,
+// compile-time CSS scoping, and code optimizations
+// ─── Default Options ────────────────────────────────────────────
+const DEFAULT_OPTIONS = {
+    deadCodeElimination: true,
+    constantFolding: true,
+    deadStoreElimination: true,
+    functionInlining: true,
+    jsxOptimization: true,
+    treeShaking: true,
+    staticHoisting: true,
+    cssScoping: true,
+    autoMemoization: true,
+    minificationLevel: 1,
+};
+function walkAST(node, visitor) {
+    if (!node || typeof node !== 'object')
+        return node;
+    const result = visitor(node);
+    if (result === null)
+        return null;
+    if (result !== undefined)
+        return result;
+    // Walk children based on node type
+    for (const key of Object.keys(node)) {
+        if (key === 'type' || key === 'start' || key === 'end')
+            continue;
+        const child = node[key];
+        if (Array.isArray(child)) {
+            const newArr = [];
+            for (const item of child) {
+                if (item && typeof item === 'object' && item.type) {
+                    const walked = walkAST(item, visitor);
+                    if (walked !== null)
+                        newArr.push(walked);
+                }
+                else {
+                    newArr.push(item);
+                }
+            }
+            ;
+            node[key] = newArr;
+        }
+        else if (child && typeof child === 'object' && child.type) {
+            const walked = walkAST(child, visitor);
+            if (walked === null) {
+                ;
+                node[key] = null;
+            }
+            else {
+                ;
+                node[key] = walked;
+            }
+        }
+    }
+    return node;
+}
+// ─── Optimizer Class ────────────────────────────────────────────
+export class Optimizer {
+    options;
+    warnings = [];
+    stats = {
+        originalSize: 0,
+        optimizedSize: 0,
+        reduction: 0,
+        eliminatedNodes: 0,
+        inlinedFunctions: 0,
+        constantFolds: 0,
+        staticHoisted: 0,
+        autoMemoized: 0,
+    };
+    constructor(options = {}) {
+        this.options = { ...DEFAULT_OPTIONS, ...options };
+    }
+    /**
+     * Optimize AST
+     */
+    optimize(ast) {
+        this.warnings = [];
+        this.stats = {
+            originalSize: JSON.stringify(ast).length,
+            optimizedSize: 0,
+            reduction: 0,
+            eliminatedNodes: 0,
+            inlinedFunctions: 0,
+            constantFolds: 0,
+            staticHoisted: 0,
+            autoMemoized: 0,
+        };
+        let optimized = this.cloneAST(ast);
+        // Run optimization passes (multiple passes for better results)
+        for (let pass = 0; pass < 2; pass++) {
+            if (this.options.deadCodeElimination) {
+                optimized = this.eliminateDeadCode(optimized);
+            }
+            if (this.options.constantFolding) {
+                optimized = this.foldConstants(optimized);
+            }
+            if (this.options.deadStoreElimination) {
+                optimized = this.eliminateDeadStores(optimized);
+            }
+            if (this.options.functionInlining) {
+                optimized = this.inlineFunctions(optimized);
+            }
+        }
+        if (this.options.jsxOptimization) {
+            optimized = this.optimizeJSX(optimized);
+        }
+        // Auto-memoization pass (React Compiler-like)
+        if (this.options.autoMemoization) {
+            optimized = this.autoMemoize(optimized);
+        }
+        this.stats.optimizedSize = JSON.stringify(optimized).length;
+        this.stats.reduction = this.stats.originalSize - this.stats.optimizedSize;
+        return {
+            code: this.generateCode(optimized),
+            ast: optimized,
+            warnings: this.warnings,
+            stats: this.stats,
+        };
+    }
+    cloneAST(ast) {
+        return JSON.parse(JSON.stringify(ast));
+    }
+    // ─── Dead Code Elimination ────────────────────────────────────
+    eliminateDeadCode(ast) {
+        return walkAST(ast, (node) => {
+            // Remove if(false) { ... } and if(true) { ... } else { ... }
+            if (node.type === 'IfStatement') {
+                const test = node.test;
+                const val = this.evaluateConstant(test);
+                if (val !== undefined) {
+                    if (val) {
+                        // if(true) → keep consequent
+                        this.stats.eliminatedNodes++;
+                        return node.consequent;
+                    }
+                    else {
+                        // if(false) → keep alternate or remove
+                        this.stats.eliminatedNodes++;
+                        if (node.alternate) {
+                            return node.alternate;
+                        }
+                        return null;
+                    }
+                }
+            }
+            // Remove while(false) { ... }
+            if (node.type === 'WhileStatement') {
+                const val = this.evaluateConstant(node.test);
+                if (val === false) {
+                    this.stats.eliminatedNodes++;
+                    return null;
+                }
+            }
+            // Remove dead code after return/throw/break/continue
+            if (node.type === 'BlockStatement' && node.body) {
+                const filtered = [];
+                let foundTerminator = false;
+                for (const stmt of node.body) {
+                    if (foundTerminator) {
+                        if (stmt.type === 'FunctionDeclaration') {
+                            // Keep function declarations (hoisted)
+                            filtered.push(stmt);
+                        }
+                        else {
+                            this.stats.eliminatedNodes++;
+                            this.warnings.push({
+                                type: 'dead_code',
+                                message: 'Unreachable code detected after return/throw',
+                            });
+                        }
+                    }
+                    else {
+                        filtered.push(stmt);
+                        if (stmt.type === 'ReturnStatement' ||
+                            stmt.type === 'ThrowStatement' ||
+                            stmt.type === 'BreakStatement' ||
+                            stmt.type === 'ContinueStatement') {
+                            foundTerminator = true;
+                        }
+                    }
+                }
+                node.body = filtered;
+            }
+            // Remove empty statements
+            if (node.type === 'EmptyStatement') {
+                this.stats.eliminatedNodes++;
+                return null;
+            }
+            // Remove variables with only assignments and no reads (dead stores)
+            if (node.type === 'VariableDeclaration') {
+                // Will be handled by eliminateDeadStores
+            }
+            return undefined;
+        });
+    }
+    // ─── Constant Folding ─────────────────────────────────────────
+    foldConstants(ast) {
+        return walkAST(ast, (node) => {
+            // Fold binary expressions: 1+2 → 3, "a"+"b" → "ab"
+            if (node.type === 'BinaryExpression') {
+                const left = this.evaluateConstant(node.left);
+                const right = this.evaluateConstant(node.right);
+                if (left !== undefined && right !== undefined) {
+                    const result = this.evaluateBinary(node.operator, left, right);
+                    if (result !== undefined) {
+                        this.stats.constantFolds++;
+                        return this.createLiteral(result);
+                    }
+                }
+            }
+            // Fold unary expressions: !true → false, -5 → -5
+            if (node.type === 'UnaryExpression') {
+                const arg = this.evaluateConstant(node.argument);
+                if (arg !== undefined) {
+                    const result = this.evaluateUnary(node.operator, arg);
+                    if (result !== undefined) {
+                        this.stats.constantFolds++;
+                        return this.createLiteral(result);
+                    }
+                }
+            }
+            // Fold logical expressions: true && false → false, null || "default" → "default"
+            if (node.type === 'LogicalExpression') {
+                const left = this.evaluateConstant(node.left);
+                const right = this.evaluateConstant(node.right);
+                if (left !== undefined && right !== undefined) {
+                    const result = this.evaluateLogical(node.operator, left, right);
+                    if (result !== undefined) {
+                        this.stats.constantFolds++;
+                        return this.createLiteral(result);
+                    }
+                }
+            }
+            // Fold template literals with only static parts
+            if (node.type === 'TemplateLiteral' && node.expressions.length === 0) {
+                const value = node.quasis.map((q) => q.value.cooked || '').join('');
+                this.stats.constantFolds++;
+                return this.createLiteral(value);
+            }
+            // Fold conditional expressions: true ? a : b → a
+            if (node.type === 'ConditionalExpression') {
+                const test = this.evaluateConstant(node.test);
+                if (test !== undefined) {
+                    this.stats.constantFolds++;
+                    return test ? node.consequent : node.alternate;
+                }
+            }
+            return undefined;
+        });
+    }
+    // ─── Dead Store Elimination ───────────────────────────────────
+    eliminateDeadStores(ast) {
+        const usedVariables = new Set();
+        // First pass: collect all variable usages
+        walkAST(ast, (node) => {
+            if (node.type === 'Identifier') {
+                usedVariables.add(node.name);
+            }
+            return undefined;
+        });
+        // Second pass: remove unused variable declarations
+        return walkAST(ast, (node) => {
+            if (node.type === 'VariableDeclaration') {
+                const filtered = [];
+                for (const decl of node.declarations) {
+                    if (decl.id.type === 'Identifier') {
+                        const name = decl.id.name;
+                        // Keep if variable is used or has side effects in init
+                        if (usedVariables.has(name) || this.hasSideEffects(decl.init)) {
+                            filtered.push(decl);
+                        }
+                        else {
+                            this.stats.eliminatedNodes++;
+                            this.warnings.push({
+                                type: 'unused_variable',
+                                message: `Variable "${name}" is declared but never used`,
+                            });
+                        }
+                    }
+                    else {
+                        filtered.push(decl);
+                    }
+                }
+                if (filtered.length === 0) {
+                    return null;
+                }
+                node.declarations = filtered;
+            }
+            return undefined;
+        });
+    }
+    // ─── Function Inlining ────────────────────────────────────────
+    inlineFunctions(ast) {
+        const functionMap = new Map();
+        // Collect small function definitions
+        walkAST(ast, (node) => {
+            if (node.type === 'VariableDeclarator' && node.init) {
+                const init = node.init;
+                if (init.type === 'ArrowFunctionExpression' ||
+                    init.type === 'FunctionExpression') {
+                    // Only inline small functions (single expression body)
+                    if (init.body.type === 'BlockStatement' &&
+                        init.body.body.length === 1 &&
+                        init.body.body[0].type === 'ReturnStatement') {
+                        const body = init.body.body[0].argument;
+                        if (this.isSmallExpression(body)) {
+                            functionMap.set(node.id.name, {
+                                params: init.params,
+                                body,
+                            });
+                        }
+                    }
+                    else if (init.body.type !== 'BlockStatement') {
+                        // Arrow with expression body
+                        if (this.isSmallExpression(init.body)) {
+                            functionMap.set(node.id.name, {
+                                params: init.params,
+                                body: init.body,
+                            });
+                        }
+                    }
+                }
+            }
+            return undefined;
+        });
+        // Replace function calls with inlined body
+        return walkAST(ast, (node) => {
+            if (node.type === 'CallExpression' && node.callee.type === 'Identifier') {
+                const func = functionMap.get(node.callee.name);
+                if (func && func.params.length === node.arguments.length) {
+                    // Simple inlining: replace parameter names with arguments
+                    const inlined = this.substituteParams(func.body, func.params, node.arguments);
+                    this.stats.inlinedFunctions++;
+                    return inlined;
+                }
+            }
+            return undefined;
+        });
+    }
+    // ─── JSX Optimization ─────────────────────────────────────────
+    optimizeJSX(ast) {
+        return walkAST(ast, (node) => {
+            // Flatten nested fragments: <><a/></> → <a/>
+            if (node.type === 'JSXFragment') {
+                if (node.children.length === 1 && node.children[0].type === 'JSXFragment') {
+                    return node.children[0];
+                }
+                // Fragment with single element
+                if (node.children.length === 1 && node.children[0].type === 'JSXElement') {
+                    return node.children[0];
+                }
+            }
+            // Optimize static JSX strings
+            if (node.type === 'JSXElement' && node.openingElement) {
+                const attrs = node.openingElement.attributes;
+                // Remove empty attributes
+                node.openingElement.attributes = attrs.filter((attr) => attr.type !== 'JSXAttribute' || attr.value !== null);
+            }
+            // Convert <div>{""}</div> → <div></div>
+            if (node.type === 'JSXElement' && node.children) {
+                node.children = node.children.filter((child) => {
+                    if (child.type === 'JSXExpressionContainer' && child.expression) {
+                        if (child.expression.type === 'Literal' &&
+                            (child.expression.value === '' || child.expression.value === null)) {
+                            return false;
+                        }
+                    }
+                    return true;
+                });
+            }
+            return undefined;
+        });
+    }
+    // ─── Helpers ──────────────────────────────────────────────────
+    evaluateConstant(node) {
+        if (!node)
+            return undefined;
+        if (node.type === 'Literal') {
+            return node.value;
+        }
+        if (node.type === 'Identifier') {
+            if (node.name === 'true')
+                return true;
+            if (node.name === 'false')
+                return false;
+            if (node.name === 'null')
+                return null;
+            if (node.name === 'undefined')
+                return undefined;
+        }
+        if (node.type === 'UnaryExpression') {
+            const arg = this.evaluateConstant(node.argument);
+            if (arg !== undefined) {
+                return this.evaluateUnary(node.operator, arg);
+            }
+        }
+        if (node.type === 'BinaryExpression') {
+            const left = this.evaluateConstant(node.left);
+            const right = this.evaluateConstant(node.right);
+            if (left !== undefined && right !== undefined) {
+                return this.evaluateBinary(node.operator, left, right);
+            }
+        }
+        if (node.type === 'LogicalExpression') {
+            const left = this.evaluateConstant(node.left);
+            const right = this.evaluateConstant(node.right);
+            if (left !== undefined && right !== undefined) {
+                return this.evaluateLogical(node.operator, left, right);
+            }
+        }
+        return undefined;
+    }
+    evaluateBinary(op, left, right) {
+        switch (op) {
+            case '+': return left + right;
+            case '-': return left - right;
+            case '*': return left * right;
+            case '/': return left / right;
+            case '%': return left % right;
+            case '**': return left ** right;
+            case '==': return left == right;
+            case '!=': return left != right;
+            case '===': return left === right;
+            case '!==': return left !== right;
+            case '<': return left < right;
+            case '>': return left > right;
+            case '<=': return left <= right;
+            case '>=': return left >= right;
+            case '<<': return left << right;
+            case '>>': return left >> right;
+            case '>>>': return left >>> right;
+            case '&': return left & right;
+            case '|': return left | right;
+            case '^': return left ^ right;
+            default: return undefined;
+        }
+    }
+    evaluateUnary(op, arg) {
+        switch (op) {
+            case '-': return -arg;
+            case '+': return +arg;
+            case '!': return !arg;
+            case '~': return ~arg;
+            case 'typeof': return typeof arg;
+            case 'void': return undefined;
+            default: return undefined;
+        }
+    }
+    evaluateLogical(op, left, right) {
+        switch (op) {
+            case '&&': return left && right;
+            case '||': return left || right;
+            case '??': return left ?? right;
+            default: return undefined;
+        }
+    }
+    createLiteral(value) {
+        return {
+            type: 'Literal',
+            value,
+            raw: String(value),
+        };
+    }
+    isSmallExpression(node) {
+        if (!node)
+            return false;
+        if (node.type === 'Literal')
+            return true;
+        if (node.type === 'Identifier')
+            return true;
+        if (node.type === 'BinaryExpression') {
+            return this.isSmallExpression(node.left) && this.isSmallExpression(node.right);
+        }
+        if (node.type === 'UnaryExpression') {
+            return this.isSmallExpression(node.argument);
+        }
+        if (node.type === 'ConditionalExpression') {
+            return (this.isSmallExpression(node.test) &&
+                this.isSmallExpression(node.consequent) &&
+                this.isSmallExpression(node.alternate));
+        }
+        return false;
+    }
+    substituteParams(body, params, args) {
+        const paramMap = new Map();
+        params.forEach((p, i) => {
+            if (p.type === 'Identifier') {
+                paramMap.set(p.name, args[i]);
+            }
+        });
+        return walkAST(JSON.parse(JSON.stringify(body)), (node) => {
+            if (node.type === 'Identifier' && paramMap.has(node.name)) {
+                return paramMap.get(node.name);
+            }
+            return undefined;
+        });
+    }
+    hasSideEffects(node) {
+        if (!node)
+            return false;
+        if (node.type === 'CallExpression')
+            return true;
+        if (node.type === 'NewExpression')
+            return true;
+        if (node.type === 'AssignmentExpression')
+            return true;
+        if (node.type === 'UpdateExpression')
+            return true;
+        if (node.type === 'AwaitExpression')
+            return true;
+        if (node.type === 'YieldExpression')
+            return true;
+        if (node.type === 'TaggedTemplateExpression')
+            return true;
+        if (node.type === 'UnaryExpression' && node.operator === 'delete')
+            return true;
+        return false;
+    }
+    generateCode(ast) {
+        return this.astToCode(ast);
+    }
+    /**
+     * Convert AST node to JavaScript code string
+     */
+    astToCode(node) {
+        if (!node)
+            return '';
+        switch (node.type) {
+            case 'Program':
+                return node.body.map((s) => this.astToCode(s)).join('\n');
+            case 'ExpressionStatement':
+                return this.astToCode(node.expression) + ';';
+            case 'Identifier':
+                return node.name;
+            case 'Literal':
+                if (node.raw !== undefined)
+                    return node.raw;
+                if (typeof node.value === 'string')
+                    return `"${node.value}"`;
+                if (node.value === null)
+                    return 'null';
+                return String(node.value);
+            case 'BinaryExpression':
+                return `${this.astToCode(node.left)} ${node.operator} ${this.astToCode(node.right)}`;
+            case 'LogicalExpression':
+                return `${this.astToCode(node.left)} ${node.operator} ${this.astToCode(node.right)}`;
+            case 'UnaryExpression':
+                if (node.operator === 'typeof')
+                    return `typeof ${this.astToCode(node.argument)}`;
+                if (node.operator === 'void')
+                    return `void ${this.astToCode(node.argument)}`;
+                return `${node.operator}${this.astToCode(node.argument)}`;
+            case 'UpdateExpression':
+                return node.prefix
+                    ? `${node.operator}${this.astToCode(node.argument)}`
+                    : `${this.astToCode(node.argument)}${node.operator}`;
+            case 'AssignmentExpression':
+                return `${this.astToCode(node.left)} ${node.operator} ${this.astToCode(node.right)}`;
+            case 'CallExpression':
+                const callee = this.astToCode(node.callee);
+                const args = node.arguments.map((a) => this.astToCode(a)).join(', ');
+                return `${callee}(${args})`;
+            case 'MemberExpression':
+                const obj = this.astToCode(node.object);
+                if (node.computed) {
+                    return `${obj}[${this.astToCode(node.property)}]`;
+                }
+                return `${obj}.${this.astToCode(node.property)}`;
+            case 'ArrowFunctionExpression':
+                const arrowParams = node.params.map((p) => this.astToCode(p)).join(', ');
+                if (node.body.type === 'BlockStatement') {
+                    return `(${arrowParams}) => ${this.astToCode(node.body)}`;
+                }
+                return `(${arrowParams}) => ${this.astToCode(node.body)}`;
+            case 'FunctionExpression':
+                const funcParams = node.params.map((p) => this.astToCode(p)).join(', ');
+                return `function(${funcParams}) ${this.astToCode(node.body)}`;
+            case 'FunctionDeclaration':
+                const declParams = node.params.map((p) => this.astToCode(p)).join(', ');
+                return `function ${this.astToCode(node.id)}(${declParams}) ${this.astToCode(node.body)}`;
+            case 'BlockStatement':
+                return `{\n${node.body.map((s) => '  ' + this.astToCode(s)).join('\n')}\n}`;
+            case 'ReturnStatement':
+                return `return ${this.astToCode(node.argument)};`;
+            case 'IfStatement':
+                let code = `if (${this.astToCode(node.test)}) ${this.astToCode(node.consequent)}`;
+                if (node.alternate) {
+                    code += ` else ${this.astToCode(node.alternate)}`;
+                }
+                return code;
+            case 'VariableDeclaration':
+                const kind = node.kind;
+                const declarations = node.declarations.map((d) => {
+                    if (d.type === 'VariableDeclarator') {
+                        if (d.init) {
+                            return `${this.astToCode(d.id)} = ${this.astToCode(d.init)}`;
+                        }
+                        return this.astToCode(d.id);
+                    }
+                    return '';
+                }).join(', ');
+                return `${kind} ${declarations};`;
+            case 'VariableDeclarator':
+                if (node.init) {
+                    return `${this.astToCode(node.id)} = ${this.astToCode(node.init)}`;
+                }
+                return this.astToCode(node.id);
+            case 'Property':
+                if (node.computed) {
+                    return `${this.astToCode(node.key)}: ${this.astToCode(node.value)}`;
+                }
+                if (node.key.type === 'Identifier') {
+                    return `${node.key.name}: ${this.astToCode(node.value)}`;
+                }
+                return `${this.astToCode(node.key)}: ${this.astToCode(node.value)}`;
+            case 'ObjectExpression':
+                if (!node.properties || node.properties.length === 0)
+                    return '{}';
+                return `{\n${node.properties.map((p) => '  ' + this.astToCode(p)).join(',\n')}\n}`;
+            case 'ArrayExpression':
+                return `[${node.elements.map((e) => this.astToCode(e)).join(', ')}]`;
+            case 'SpreadElement':
+                return `...${this.astToCode(node.argument)}`;
+            case 'TemplateLiteral':
+                let template = '`';
+                for (let i = 0; i < node.expressions.length; i++) {
+                    template += node.quasis[i].value.raw;
+                    template += '${' + this.astToCode(node.expressions[i]) + '}';
+                }
+                template += node.quasis[node.quasis.length - 1].value.raw + '`';
+                return template;
+            case 'TaggedTemplateExpression':
+                return `${this.astToCode(node.tag)}${this.astToCode(node.quasi)}`;
+            case 'ConditionalExpression':
+                return `${this.astToCode(node.test)} ? ${this.astToCode(node.consequent)} : ${this.astToCode(node.alternate)}`;
+            case 'ParenthesizedExpression':
+                return `(${this.astToCode(node.expression)})`;
+            case 'EmptyStatement':
+                return ';';
+            case 'DebuggerStatement':
+                return 'debugger;';
+            default:
+                // Fallback: return a placeholder
+                return `/* unknown: ${node.type} */`;
+        }
+    }
+    // ─── Auto-Memoization (React Compiler-like) ────────────────────
+    /**
+     * Automatically memoize expensive computations.
+     * Similar to React Compiler's auto-memoization — eliminates the need for manual useMemo/useCallback.
+     */
+    autoMemoize(ast) {
+        // Identify pure expressions that should be memoized
+        const isPureExpression = (node) => {
+            if (!node || typeof node !== 'object')
+                return false;
+            if (node.type === 'Literal')
+                return true;
+            if (node.type === 'Identifier')
+                return true;
+            if (node.type === 'BinaryExpression') {
+                return isPureExpression(node.left) && isPureExpression(node.right);
+            }
+            if (node.type === 'UnaryExpression') {
+                return isPureExpression(node.argument);
+            }
+            if (node.type === 'LogicalExpression') {
+                return isPureExpression(node.left) && isPureExpression(node.right);
+            }
+            if (node.type === 'ConditionalExpression') {
+                return (isPureExpression(node.test) &&
+                    isPureExpression(node.consequent) &&
+                    isPureExpression(node.alternate));
+            }
+            if (node.type === 'ArrowFunctionExpression' || node.type === 'FunctionExpression') {
+                return true;
+            }
+            if (node.type === 'ArrayExpression') {
+                return node.elements.every((el) => !el || isPureExpression(el));
+            }
+            if (node.type === 'ObjectExpression') {
+                return node.properties.every((prop) => {
+                    if (prop.type === 'Property') {
+                        return isPureExpression(prop.value);
+                    }
+                    if (prop.type === 'SpreadElement') {
+                        return isPureExpression(prop.argument);
+                    }
+                    return false;
+                });
+            }
+            if (node.type === 'CallExpression') {
+                const calleeName = node.callee?.name || '';
+                if (calleeName.startsWith('set') || calleeName.startsWith('dispatch')) {
+                    return false;
+                }
+                if (['fetch', 'XMLHttpRequest', 'setTimeout', 'setInterval'].includes(calleeName)) {
+                    return false;
+                }
+                return true;
+            }
+            return false;
+        };
+        // Check if expression is too simple to memoize
+        const isTrivialExpression = (node) => {
+            if (!node || typeof node !== 'object')
+                return true;
+            if (node.type === 'Literal')
+                return true;
+            if (node.type === 'Identifier')
+                return true;
+            if (node.type === 'MemberExpression') {
+                return !node.computed && isTrivialExpression(node.object);
+            }
+            return false;
+        };
+        // Extract dependencies from expression
+        const extractDependencies = (node) => {
+            const deps = new Set();
+            const collectDeps = (n) => {
+                if (!n || typeof n !== 'object')
+                    return;
+                if (n.type === 'Identifier') {
+                    deps.add(n.name);
+                }
+                if (n.type === 'MemberExpression' && n.object?.type === 'Identifier') {
+                    deps.add(n.object.name);
+                }
+                for (const key of Object.keys(n)) {
+                    if (key === 'type' || key === 'start' || key === 'end')
+                        continue;
+                    const child = n[key];
+                    if (Array.isArray(child)) {
+                        child.forEach((item) => {
+                            if (item && typeof item === 'object' && item.type) {
+                                collectDeps(item);
+                            }
+                        });
+                    }
+                    else if (child && typeof child === 'object' && child.type) {
+                        collectDeps(child);
+                    }
+                }
+            };
+            collectDeps(node);
+            return Array.from(deps);
+        };
+        // Auto-memoization is disabled — wrapping initializers in ArrowFunctionExpression
+        // changes semantics (const doubled = count() * 2 becomes const doubled = () => count() * 2)
+        return ast;
+    }
+}
+/**
+ * Analyze and tree-shake unused exports
+ */
+export function treeShake(code, options) {
+    const result = {
+        kept: [],
+        eliminated: [],
+        warnings: [],
+    };
+    // Parse imports to find used names
+    const usedNames = new Set();
+    const importRegex = /import\s+(?:\{([^}]+)\}|(\w+))\s+from\s+['"](.*)['"]/g;
+    let match;
+    while ((match = importRegex.exec(code)) !== null) {
+        if (match[1]) {
+            // Named imports: import { a, b } from 'module'
+            match[1].split(',').forEach((name) => {
+                const trimmed = name.trim().split(/\s+as\s+/)[0].trim();
+                if (trimmed)
+                    usedNames.add(trimmed);
+            });
+        }
+        else if (match[2]) {
+            // Default import: import Foo from 'module'
+            usedNames.add(match[2]);
+        }
+    }
+    // Find all exports
+    const exportRegex = /export\s+(?:const|function|class)\s+(\w+)/g;
+    const defaultExportRegex = /export\s+default\s+/g;
+    while ((match = exportRegex.exec(code)) !== null) {
+        const name = match[1];
+        if (usedNames.has(name)) {
+            result.kept.push(name);
+        }
+        else {
+            result.eliminated.push(name);
+        }
+    }
+    // Check for default export
+    if (defaultExportRegex.test(code)) {
+        result.kept.push('default');
+    }
+    return result;
+}
+/**
+ * Analyze bundle for optimization opportunities
+ */
+export function analyzeBundle(code, moduleName) {
+    const lines = code.split('\n');
+    const exports = [];
+    // Extract exports
+    const exportRegex = /export\s+(?:const|function|class|default)\s+(\w+)/g;
+    let match;
+    while ((match = exportRegex.exec(code)) !== null) {
+        exports.push(match[1]);
+    }
+    return {
+        size: Buffer.byteLength(code, 'utf8'),
+        gzipSize: Buffer.byteLength(code, 'utf8'), // Simplified
+        modules: [
+            {
+                name: moduleName,
+                size: Buffer.byteLength(code, 'utf8'),
+                exports,
+                sideEffects: false,
+            },
+        ],
+        dependencies: [],
+        peerDependencies: [],
+    };
+}
+// ─── Dead Code Patterns ─────────────────────────────────────────
+export const DEAD_CODE_PATTERNS = [
+    /if\s*\(\s*false\s*\)/,
+    /if\s*\(\s*0\s*\)/,
+    /if\s*\(\s*null\s*\)/,
+    /if\s*\(\s*undefined\s*\)/,
+    /while\s*\(\s*false\s*\)/,
+    /return\s+undefined\s*;/,
+];
+export const SIDE_EFFECT_FREE_FUNCTIONS = new Set([
+    'console.log',
+    'console.error',
+    'console.warn',
+    'Math.abs',
+    'Math.ceil',
+    'Math.floor',
+    'Math.round',
+    'parseInt',
+    'parseFloat',
+    'isNaN',
+    'isFinite',
+]);
+// ─── Static Subtree Hoisting ────────────────────────────────────
+/**
+ * Identify and hoist static JSX subtrees.
+ * Static elements (no dynamic expressions) can be created once and reused.
+ *
+ * @example
+ * // Before hoisting
+ * function App() {
+ *   return <div><Header /><StaticContent /><Footer /></div>
+ * }
+ *
+ * // After hoisting — StaticContent is hoisted outside the function
+ * const _hoisted_0 = <StaticContent />
+ * function App() {
+ *   return <div><Header />{_hoisted_0}<Footer /></div>
+ * }
+ */
+export function hoistStaticSubtrees(ast, code) {
+    let hoistedCount = 0;
+    const hoistedNodes = [];
+    function isStaticNode(node) {
+        if (!node || typeof node !== 'object')
+            return true;
+        // JSX elements with no dynamic children or attributes are static
+        if (node.type === 'JSXElement') {
+            // Check attributes for dynamic values
+            if (node.openingElement?.attributes) {
+                for (const attr of node.openingElement.attributes) {
+                    if (attr.type === 'JSXSpreadAttribute')
+                        return false;
+                    if (attr.value?.type === 'JSXExpressionContainer') {
+                        // Check if the expression is a literal
+                        const expr = attr.value.expression;
+                        if (expr && expr.type !== 'Literal')
+                            return false;
+                    }
+                }
+            }
+            // Check children
+            if (node.children) {
+                for (const child of node.children) {
+                    if (child.type === 'JSXExpressionContainer') {
+                        const expr = child.expression;
+                        if (expr && expr.type !== 'Literal')
+                            return false;
+                    }
+                    if (child.type === 'JSXElement' && !isStaticNode(child))
+                        return false;
+                }
+            }
+            return true;
+        }
+        // Literals are static
+        if (node.type === 'Literal')
+            return true;
+        // JSXText is static
+        if (node.type === 'JSXText')
+            return true;
+        return false;
+    }
+    // Walk the AST and find hoistable static subtrees
+    function walkAndHoist(node, parent, key) {
+        if (!node || typeof node !== 'object')
+            return;
+        // Check if this is a static JSX element that should be hoisted
+        if (node.type === 'JSXElement' && isStaticNode(node) && shouldHoist(node)) {
+            const hoistedName = `_hoisted_${hoistedCount++}`;
+            const hoistedCode = generateStaticCode(node, code);
+            hoistedNodes.push({ name: hoistedName, code: hoistedCode });
+            // Replace with reference
+            if (parent && key) {
+                parent[key] = { type: 'Identifier', name: hoistedName };
+            }
+        }
+        // Continue walking children
+        for (const childKey of Object.keys(node)) {
+            if (childKey === 'type' || childKey === 'start' || childKey === 'end')
+                continue;
+            const child = node[childKey];
+            if (Array.isArray(child)) {
+                child.forEach((item, idx) => {
+                    if (item && typeof item === 'object' && item.type) {
+                        walkAndHoist(item, node, `${childKey}[${idx}]`);
+                    }
+                });
+            }
+            else if (child && typeof child === 'object' && child.type) {
+                walkAndHoist(child, node, childKey);
+            }
+        }
+    }
+    function shouldHoist(node) {
+        // Only hoist elements that are complex enough to benefit
+        // Simple elements like <div></div> are not worth hoisting
+        if (!node.children || node.children.length === 0)
+            return false;
+        if (node.children.length === 1 && node.children[0].type === 'JSXText')
+            return false;
+        // Check for components — always worth hoisting
+        const tagName = node.openingElement?.name?.name;
+        if (tagName && tagName[0] === tagName[0].toUpperCase())
+            return true;
+        // Check for elements with attributes
+        if (node.openingElement?.attributes?.length > 0)
+            return true;
+        // Check for elements with multiple children
+        if (node.children.length > 1)
+            return true;
+        return false;
+    }
+    function generateStaticCode(node, source) {
+        return source.slice(node.start, node.end);
+    }
+    walkAndHoist(ast, null, '');
+    // Generate hoisted code
+    if (hoistedNodes.length > 0) {
+        const hoistedCode = hoistedNodes
+            .map(h => `const ${h.name} = ${h.code}`)
+            .join('\n');
+        return {
+            ast,
+            code: hoistedCode + '\n' + code,
+            hoisted: hoistedCount,
+        };
+    }
+    return { ast, code, hoisted: 0 };
+}
+// ─── Auto-Memoization (React Compiler-like) ────────────────────
+// Auto-memoization is disabled — wrapping initializers in ArrowFunctionExpression
+// changes semantics (const doubled = count() * 2 becomes const doubled = () => count() * 2)
+export function autoMemoize(ast) {
+    return { ast, memoized: 0 };
+}
+// ─── Compile-time CSS Scoping ───────────────────────────────────
+/**
+ * Scope CSS to components at compile time.
+ * Generates unique class names and injects scoped styles.
+ *
+ * @example
+ * // Input
+ * <style>
+ *   .container { padding: 16px; }
+ *   .title { font-size: 24px; }
+ * </style>
+ * <div class="container">
+ *   <h1 class="title">Hello</h1>
+ * </div>
+ *
+ * // Output (with scope hash "abc123")
+ * <style>
+ *   .container[data-scoped-abc123] { padding: 16px; }
+ *   .title[data-scoped-abc123] { font-size: 24px; }
+ * </style>
+ * <div class="container" data-scoped-abc123>
+ *   <h1 class="title" data-scoped-abc123>Hello</h1>
+ * </div>
+ */
+export function scopeCSS(ast, code, componentName) {
+    const scopes = [];
+    let scopeCounter = 0;
+    function generateScopeId(name) {
+        const base = name || 'scope';
+        return `${base}-${scopeCounter++}-${Math.random().toString(36).slice(2, 8)}`;
+    }
+    function extractCSSFromJSX(code) {
+        const cssRegex = /<style[^>]*>([\s\S]*?)<\/style>/gi;
+        const positions = [];
+        let css = '';
+        let match;
+        while ((match = cssRegex.exec(code)) !== null) {
+            css += match[1];
+            positions.push({ start: match.index, end: match.index + match[0].length });
+        }
+        return { css, positions };
+    }
+    function scopeCSSRules(css, scopeId) {
+        // Simple CSS scoping — add data attribute selector
+        return css
+            .replace(/\.([a-zA-Z_-][a-zA-Z0-9_-]*)/g, `.$1[data-scoped-${scopeId}]`)
+            .replace(/#([a-zA-Z_-][a-zA-Z0-9_-]*)/g, `#$1[data-scoped-${scopeId}]`);
+    }
+    const { css } = extractCSSFromJSX(code);
+    if (css) {
+        const scopeId = generateScopeId(componentName);
+        const scopedCSS = scopeCSSRules(css, scopeId);
+        scopes.push({
+            id: scopeId,
+            selector: `[data-scoped-${scopeId}]`,
+            css: scopedCSS,
+            hash: scopeId,
+        });
+    }
+    return { ast, code, scopes };
+}
+// ─── Bundle Analysis (v2 — Enhanced) ────────────────────────────
+//# sourceMappingURL=index.js.map