Fix the XCSS.saveToFile function:

import fs from 'fs';

class XCSS {
    static compile(code: string): string {
        // Stores function definitions
        const functions: Record<string, { params: string[], body: string[] }> = {};

        // Split the code into lines for processing
        const lines = code.split(/\r?\n/);

        // Root block to hold all top-level CSS
        const rootBlock: { selector: string, declarations: string[], children: any[] } = { selector: '', declarations: [], children: [] };
        let currentBlock = rootBlock;

        // Stack to keep track of nested blocks
        const blockStack = [rootBlock];

        // Flags for parsing functions
        let inFunction = false;
        let currentFunctionName = '';
        let currentFunctionParams: string[] = [];
        let currentFunctionBody: string[] = [];

        for (let line of lines) {
            line = line.trim();

            if (line === '') {
                continue; // Skip empty lines
            }

            if (line.startsWith('@import')) {
                // Handle @import directives
                currentBlock.declarations.push(line + ';');

            } else if (line.startsWith('@function')) {
                // Start of a function definition
                const funcMatch = line.match(/@function\s+([^(]+)\(([^)]*)\)\s*{/);
                if (funcMatch) {
                    inFunction = true;
                    currentFunctionName = funcMatch[1].trim();
                    currentFunctionParams = funcMatch[2].split(',').map(p => p.trim());
                    currentFunctionBody = [];
                }

            } else if (inFunction) {
                if (line === '}') {
                    // End of function definition, store it
                    functions[currentFunctionName] = {
                        params: currentFunctionParams,
                        body: currentFunctionBody,
                    };
                    inFunction = false;
                    currentFunctionName = '';
                    currentFunctionParams = [];
                    currentFunctionBody = [];
                } else {
                    // Accumulate function body lines
                    currentFunctionBody.push(line);
                }

            } else if (line.startsWith('@include')) {
                // Handle @include directives
                const includeMatch = line.match(/@include\s+([^(]+)\(([^)]*)\);?/);
                if (includeMatch) {
                    const includeName = includeMatch[1].trim();
                    const includeArgs = includeMatch[2].split(',').map(a => a.trim().replace(/['"]/g, ''));

                    const func = functions[includeName];
                    if (func) {
                        const paramValues: Record<string, string> = {};
                        func.params.forEach((param, index) => {
                            paramValues[param] = includeArgs[index] || '';
                        });

                        // Replace variables in the function body and add to current block
                        for (let funcLine of func.body) {
                            let processedLine = funcLine;
                            for (const [param, value] of Object.entries(paramValues)) {
                                const regex = new RegExp('\\' + param + '\\b', 'g');
                                processedLine = processedLine.replace(regex, value);
                            }

                            currentBlock.declarations.push(processedLine);
                        }
                    } else {
                        console.error(`Function ${includeName} not defined.`);
                    }
                }

            } else if (line.endsWith('{')) {
                // Start of a new block
                const selector = line.slice(0, -1).trim();
                const newBlock: { selector: string, declarations: string[], children: any[] } = { selector, declarations: [], children: [] };
                currentBlock.children.push(newBlock);
                blockStack.push(newBlock);
                currentBlock = newBlock;

            } else if (line === '}') {
                // End of the current block
                blockStack.pop();
                currentBlock = blockStack[blockStack.length - 1];

            } else {
                // Add declarations to the current block
                currentBlock.declarations.push(line);
            }
        }

        // Now, generate the final CSS from the block tree
        const outputLines: string[] = [];

        function generateCSS(block: { selector: string, declarations: string[], children: any[] }, parentSelectors: string[] = ['']): void {
            let currentSelectors: string[] = [];

            if (block.selector) {
                let selectorParts = block.selector.split(',').map(s => s.trim());
                for (let parentSelector of parentSelectors) {
                    for (let part of selectorParts) {
                        if (part.includes('&')) {
                            currentSelectors.push(part.replace(/&/g, parentSelector));
                        } else {
                            currentSelectors.push((parentSelector + ' ' + part).trim());
                        }
                    }
                }
            } else {
                // If there's no selector, inherit the parent selectors
                currentSelectors = parentSelectors;
            }

            if (block.declarations.length > 0) {
                if (currentSelectors.length > 0) {
                    for (const selector of currentSelectors) {
                        outputLines.push(`${selector} {`);
                        outputLines.push(...block.declarations.map((decl: string) => '  ' + decl));
                        outputLines.push('}');
                    }
                } else {
                    // Top-level declarations (e.g., @import)
                    outputLines.push(...block.declarations);
                }
            }

            // Process children blocks
            for (const child of block.children) {
                generateCSS(child, currentSelectors);
            }
        }

        generateCSS(rootBlock);

        // Combine the output lines into a single string
        return outputLines.join('\n');
    }

    static loadFromFile(file: string): Promise<string> {
        if (!file.endsWith('.xcss')) {
            throw new Error('File must have a .xcss extension');
        }
        if (!fs.existsSync(file)) {
            throw new Error(`File '${file}' does not exist`);
        }

        return new Promise((resolve, reject) => {
            fs.readFile(file, 'utf8', (err, data) => {
                if (err) {
                    reject(err);
                } else {
                    const cssOutput = XCSS.compile(data);
                    resolve(cssOutput);
                }
            });
        });
    }

    static saveToFile(code: string, output: string) {
        if (!output.endsWith('.css')) {
            throw new Error('Output file must have a .css extension');
        }
        fs.writeFileSync(output, code);
    }
}

export default XCSS;