исправь ошибки при выполнении 
// Получение элементов из DOM
const runButton = document.getElementById('runButton');
const codeArea = document.getElementById('codeArea');
const outputArea = document.getElementById('outputArea');

// Основной объект состояния
const state = {
    variables: {},
    functions: {},
    output: []
};

// Функция для добавления вывода
function addOutput(message) {
    state.output.push(message);
}

// Функция для очистки состояния
function resetState() {
    state.variables = {};
    state.functions = {};
    state.output = [];
}

// Основной интерпретатор
function interpret(source) {
    resetState();
    const lines = source.split('\n');
    let i = 0;

    while (i < lines.length) {
        let line = lines[i].trim();

        // Игнорирование пустых строк и комментариев
        if (line === '' || line.startsWith('#')) {
            i++;
            continue;
        }

        // Обработка функций
        if (line.startsWith('function')) {
            const funcMatch = line.match(/^function\s+(\w+)\s*\((.*?)\)\s*\{$/);
            if (funcMatch) {
                const funcName = funcMatch[1];
                const params = funcMatch[2].split(',').map(p => p.trim()).filter(p => p !== '');
                // Найти конец функции
                let funcBody = [];
                i++;
                let braceCount = 1;
                while (i < lines.length && braceCount > 0) {
                    let funcLine = lines[i].trim();
                    if (funcLine.includes('{')) braceCount++;
                    if (funcLine.includes('}')) braceCount--;
                    if (braceCount > 0) funcBody.push(lines[i]);
                    i++;
                }
                // Сохранить функцию
                state.functions[funcName] = {
                    params,
                    body: funcBody.join('\n')
                };
                continue;
            } else {
                addOutput(`Ошибка синтаксиса: неверное определение функции на строке ${i + 1}`);
                break;
            }
        }

        // Обработка условных операторов
        if (line.startsWith('if')) {
            const conditionMatch = line.match(/^if\s+(.*?)\s*\{$/);
            if (conditionMatch) {
                const condition = evaluateExpression(conditionMatch[1], i + 1);
                // Найти конец блока if
                let ifBody = [];
                i++;
                let braceCount = 1;
                while (i < lines.length && braceCount > 0) {
                    let ifLine = lines[i].trim();
                    if (ifLine.includes('{')) braceCount++;
                    if (ifLine.includes('}')) braceCount--;
                    if (braceCount > 0) ifBody.push(lines[i]);
                    i++;
                }
                if (condition) {
                    interpret(ifBody.join('\n'));
                } else {
                    // Проверить на наличие else
                    if (i < lines.length) {
                        let nextLine = lines[i].trim();
                        if (nextLine.startsWith('else')) {
                            // Найти начало блока else
                            const elseMatch = nextLine.match(/^else\s*\{$/);
                            if (elseMatch) {
                                let elseBody = [];
                                i++;
                                braceCount = 1;
                                while (i < lines.length && braceCount > 0) {
                                    let elseLine = lines[i].trim();
                                    if (elseLine.includes('{')) braceCount++;
                                    if (elseLine.includes('}')) braceCount--;
                                    if (braceCount > 0) elseBody.push(lines[i]);
                                    i++;
                                }
                                interpret(elseBody.join('\n'));
                            }
                        }
                    }
                }
                continue;
            } else {
                addOutput(`Ошибка синтаксиса: неверный if-оператор на строке ${i + 1}`);
                break;
            }
        }

        // Обработка циклов while
        if (line.startsWith('while')) {
            const conditionMatch = line.match(/^while\s+(.*?)\s*\{$/);
            if (conditionMatch) {
                const conditionExpr = conditionMatch[1];
                // Найти тело цикла
                let loopBody = [];
                i++;
                let braceCount = 1;
                while (i < lines.length && braceCount > 0) {
                    let loopLine = lines[i].trim();
                    if (loopLine.includes('{')) braceCount++;
                    if (loopLine.includes('}')) braceCount--;
                    if (braceCount > 0) loopBody.push(lines[i]);
                    i++;
                }
                // Выполнение цикла
                while (evaluateExpression(conditionExpr, i + 1)) {
                    interpret(loopBody.join('\n'));
                }
                continue;
            } else {
                addOutput(`Ошибка синтаксиса: неверный while-оператор на строке ${i + 1}`);
                break;
            }
        }

        // Обработка циклов for
        if (line.startsWith('for')) {
            const forMatch = line.match(/^for\s+(.*?);(.*?);(.*?)\s*\{$/);
            if (forMatch) {
                const init = forMatch[1].trim();
                const conditionExpr = forMatch[2].trim();
                const increment = forMatch[3].trim();
                // Выполнение инициализации
                executeLine(init, i + 1);
                // Найти тело цикла
                let loopBody = [];
                i++;
                let braceCount = 1;
                while (i < lines.length && braceCount > 0) {
                    let loopLine = lines[i].trim();
                    if (loopLine.includes('{')) braceCount++;
                    if (loopLine.includes('}')) braceCount--;
                    if (braceCount > 0) loopBody.push(lines[i]);
                    i++;
                }
                // Выполнение цикла
                while (evaluateExpression(conditionExpr, i + 1)) {
                    interpret(loopBody.join('\n'));
                    executeLine(increment, i + 1);
                }
                continue;
            } else {
                addOutput(`Ошибка синтаксиса: неверный for-оператор на строке ${i + 1}`);
                break;
            }
        }

        // Обработка команд print
        if (line.startsWith('print')) {
            const printMatch = line.match(/^print\s+(.*)$/);
            if (printMatch) {
                const expr = printMatch[1].trim();
                const output = evaluateExpression(expr, i + 1);
                if (output !== undefined) {
                    addOutput(output);
                }
                i++;
                continue;
            } else {
                addOutput(`Ошибка синтаксиса: неверная команда print на строке ${i + 1}`);
                break;
            }
        }

        // Обработка вызова функции или переменной
        const funcCallMatch = line.match(/^(\w+)\s+(.*)$/);
        if (funcCallMatch) {
            const funcName = funcCallMatch[1];
            const args = funcCallMatch[2].trim();
            if (state.functions.hasOwnProperty(funcName)) {
                const func = state.functions[funcName];
                const argValues = parseArguments(args, i + 1);
                if (argValues.length !== func.params.length) {
                    addOutput(`Ошибка: функция ${funcName} ожидает ${func.params.length} аргументов, получено ${argValues.length} на строке ${i + 1}`);
                    break;
                }
                // Создание локального состояния для функции
                const previousVariables = { ...state.variables };
                func.params.forEach((param, index) => {
                    state.variables[param] = argValues[index];
                });
                interpret(func.body);
                // Восстановление предыдущего состояния
                state.variables = previousVariables;
                i++;
                continue;
            } else {
                // Попытка вызвать переменную как функцию или неизвестную функцию
                addOutput(`Ошибка: неопределенная функция "${funcName}" на строке ${i + 1}`);
                break;
            }
        }

        // Обработка присваивания или выражения
        if (line.includes('=')) {
            executeLine(line, i + 1);
            i++;
            continue;
        } else {
            // Если строка не является известной командой или присваиванием
            addOutput(`Ошибка: Неизвестная команда или выражение на строке ${i + 1}`);
            break;
        }
    }
}

// Функция для выполнения строки кода (присваивание)
function executeLine(line, lineNumber) {
    const assignMatch = line.match(/^(\w+)\s*=\s*(.+)$/);
    if (assignMatch) {
        const varName = assignMatch[1];
        const expr = assignMatch[2].trim();
        const value = evaluateExpression(expr, lineNumber);
        if (value !== undefined) {
            state.variables[varName] = value;
        }
        return;
    }

    // Если строка не соответствует присваиванию
    addOutput(`Ошибка: Неверный синтаксис присваивания на строке ${lineNumber}`);
}

// Функция для разбора аргументов вызова функции
function parseArguments(argsString, lineNumber) {
    const args = [];
    let currentArg = '';
    let inQuotes = false;
    let quoteChar = '';

    for (let i = 0; i < argsString.length; i++) {
        const char = argsString[i];
        if (char === '"' || char === "'") {
            if (!inQuotes) {
                inQuotes = true;
                quoteChar = char;
                currentArg += char;
            } else if (char === quoteChar) {
                inQuotes = false;
                currentArg += char;
            } else {
                currentArg += char;
            }
        } else if (char === ' ' && !inQuotes) {
            if (currentArg !== '') {
                args.push(evaluateExpression(currentArg.trim(), lineNumber));
                currentArg = '';
            }
        } else {
            currentArg += char;
        }
    }

    if (currentArg !== '') {
        args.push(evaluateExpression(currentArg.trim(), lineNumber));
    }

    return args;
}

// Функция для оценки выражений
function evaluateExpression(expr, lineNumber) {
    expr = expr.trim();

    // Обработка строк
    if ((expr.startsWith('"') && expr.endsWith('"')) || (expr.startsWith("'") && expr.endsWith("'"))) {
        return expr.substring(1, expr.length - 1);
    }

    // Обработка массивов
    if (expr.startsWith('[') && expr.endsWith(']')) {
        const items = expr.substring(1, expr.length - 1).split(',').map(item => evaluateExpression(item.trim(), lineNumber));
        return items;
    }

    // Обработка индексов массива
    const arrayIndexMatch = expr.match(/^(\w+)\[(\d+)\]$/);
    if (arrayIndexMatch) {
        const arrayName = arrayIndexMatch[1];
        const index = parseInt(arrayIndexMatch[2], 10);
        if (state.variables.hasOwnProperty(arrayName) && Array.isArray(state.variables[arrayName])) {
            return state.variables[arrayName][index];
        } else {
            addOutput(`Ошибка: "${arrayName}" не является массивом или не определен на строке ${lineNumber}`);
            return undefined;
        }
    }

    // Обработка чисел
    if (!isNaN(Number(expr))) {
        return Number(expr);
    }

    // Обработка переменных
    if (state.variables.hasOwnProperty(expr)) {
        return state.variables[expr];
    }

    // Обработка арифметических и логических выражений
    try {
        // Создание безопасного выражения для eval
        const safeExpr = expr.replace(/([a-zA-Z_]\w*)/g, (match) => {
            if (state.variables.hasOwnProperty(match)) {
                return state.variables[match];
            }
            return match;
        });
        // Использование eval для вычисления выражения
        // **Важно**: Использование eval потенциально небезопасно и может привести к выполнению произвольного кода.
        // В реальных приложениях рекомендуется использовать безопасные парсеры и вычислители.
        return eval(safeExpr);
    } catch (error) {
        addOutput(`Ошибка при вычислении выражения "${expr}" на строке ${lineNumber}: ${error.message}`);
        return undefined;
    }
}

// Функция для разбора и добавления вывода
function addOutput(message) {
    state.output.push(message);
}

// Обработчик события клика на кнопку "Run"
runButton.addEventListener('click', () => {
    const sourceCode = codeArea.value;
    state.output = [];
    interpret(sourceCode);
    outputArea.textContent = state.output.join('\n');
});
body {
    font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
    background-color: #282c34;
    color: #ffffff;
    margin: 0;
    padding: 20px;
}

.container {
    max-width: 900px;
    margin: 0 auto;
}

h1, h2 {
    text-align: center;
    color: #61dafb;
}

textarea {
    width: 100%;
    height: 400px;
    padding: 15px;
    font-family: 'Courier New', Courier, monospace;
    font-size: 14px;
    background-color: #1e1e1e;
    color: #d4d4d4;
    border: none;
    border-radius: 4px;
    resize: vertical;
    box-sizing: border-box;
    margin-bottom: 10px;
}

button {
    display: block;
    width: 100%;
    padding: 15px;
    margin-bottom: 20px;
    font-size: 18px;
    background-color: #61dafb;
    color: #282c34;
    border: none;
    border-radius: 4px;
    cursor: pointer;
    transition: background-color 0.3s;
}

button:hover {
    background-color: #21a1f1;
}

pre {
    background-color: #1e1e1e;
    color: #d4d4d4;
    padding: 15px;
    border-radius: 4px;
    overflow-x: auto;
    max-height: 400px;
    white-space: pre-wrap;
    word-wrap: break-word;
}
<!DOCTYPE html>
<html lang="ru">
<head>
    <meta charset="UTF-8">
    <title>SimpleLang Интерпретатор</title>
    <link rel="stylesheet" href="styles.css">
</head>
<body>
    <div class="container">
        <h1>SimpleLang Интерпретатор</h1>
        <textarea id="codeArea" placeholder="Введите ваш код здесь...">
# Объявление переменных
x = 10
y = 20

# Вывод суммы
print "Сумма x и y:"
print x + y

# Условное выражение
if x < y {
    print "x меньше y"
} else {
    print "x не меньше y"
}

# Цикл while
i = 0
while i < 5 {
    print "Цикл while: " + i
    i = i + 1
}

# Цикл for
for j = 0; j < 3; j = j + 1 {
    print "Цикл for: " + j
}

# Функции
function greet(name) {
    print "Hello, " + name + "!"
}

greet "Alice"
greet "Bob"

# Массивы
arr = [10, 20, 30, 40, 50]
print "Первый элемент массива: " + arr[0]
print "Последний элемент массива: " + arr[4]
        </textarea>
        <button id="runButton">Run</button>
        <h2>Вывод:</h2>
        <pre id="outputArea"></pre>
    </div>

    <script src="interpreter.js"></script>
</body>
</html>