lny-interpreter 0.99.0

package/dist/browser.js

@@ -0,0 +1,1067 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const parser_1 = require("./parser/parser");
+const interpreter_1 = require("./interpreter/interpreter");
+const world_1 = require("./world/world");
+const uiStrings = {
+    de: {
+        placeholder: 'Schreib hier deinen Lny-Code...',
+        executing: 'Fuehre Code aus...',
+        finished: 'Ausfuehrung abgeschlossen.',
+        errorLabel: 'Fehler',
+        helpTitle: 'Kurzreferenz',
+        exampleLoaded: 'Beispiel geladen',
+        exampleLoadFailed: 'Beispiel konnte nicht geladen werden',
+        stateTitle: 'Lenny Status',
+        fieldSize: 'Feldgroesse',
+        pos: 'Pos',
+        dir: 'Richtung',
+        bones: 'Knochen',
+        runs: 'Laeufe',
+        saveFile: 'Speichern',
+        savePrompt: 'Dateiname (ohne Erweiterung):',
+        loadFile: 'Laden',
+        fileLoaded: 'Datei geladen',
+        fileLoadFailed: 'Datei konnte nicht geladen werden',
+    },
+    en: {
+        placeholder: 'Write your Lny code here...',
+        executing: 'Executing code...',
+        finished: 'Execution finished.',
+        errorLabel: 'Error',
+        helpTitle: 'Quick Reference',
+        exampleLoaded: 'Example loaded',
+        exampleLoadFailed: 'Could not load example',
+        stateTitle: 'Lenny State',
+        fieldSize: 'Field Size',
+        pos: 'Pos',
+        dir: 'Direction',
+        bones: 'Bones',
+        runs: 'Runs',
+        saveFile: 'Save',
+        savePrompt: 'File name (without extension):',
+        loadFile: 'Load',
+        fileLoaded: 'File loaded',
+        fileLoadFailed: 'Could not load file',
+    },
+    fr: {
+        placeholder: 'Ecrivez votre code Lny ici...',
+        executing: 'Execution du code...',
+        finished: 'Execution terminee.',
+        errorLabel: 'Erreur',
+        helpTitle: 'Reference Rapide',
+        exampleLoaded: 'Exemple charge',
+        exampleLoadFailed: 'Impossible de charger l\'exemple',
+        stateTitle: 'Etat de Lenny',
+        fieldSize: 'Taille',
+        pos: 'Pos',
+        dir: 'Direction',
+        bones: 'Os',
+        runs: 'Courses',
+        saveFile: 'Sauvegarder',
+        savePrompt: 'Nom du fichier (sans extension) :',
+        loadFile: 'Charger',
+        fileLoaded: 'Fichier charge',
+        fileLoadFailed: 'Impossible de charger le fichier',
+    },
+    es: {
+        placeholder: 'Escribe tu codigo Lny aqui...',
+        executing: 'Ejecutando codigo...',
+        finished: 'Ejecucion finalizada.',
+        errorLabel: 'Error',
+        helpTitle: 'Referencia Rapida',
+        exampleLoaded: 'Ejemplo cargado',
+        exampleLoadFailed: 'No se pudo cargar el ejemplo',
+        stateTitle: 'Estado de Lenny',
+        fieldSize: 'Tamano',
+        pos: 'Pos',
+        dir: 'Direccion',
+        bones: 'Huesos',
+        runs: 'Carreras',
+        saveFile: 'Guardar',
+        savePrompt: 'Nombre de archivo (sin extensión):',
+        loadFile: 'Cargar',
+        fileLoaded: 'Archivo cargado',
+        fileLoadFailed: 'No se pudo cargar el archivo',
+    },
+    it: {
+        placeholder: 'Scrivi qui il tuo codice Lny...',
+        executing: 'Esecuzione del codice...',
+        finished: 'Esecuzione completata.',
+        errorLabel: 'Errore',
+        helpTitle: 'Riferimento Rapido',
+        exampleLoaded: 'Esempio caricato',
+        exampleLoadFailed: 'Impossibile caricare l\'esempio',
+        stateTitle: 'Stato di Lenny',
+        fieldSize: 'Dimensione',
+        pos: 'Pos',
+        dir: 'Direzione',
+        bones: 'Ossa',
+        runs: 'Corse',
+        saveFile: 'Salva',
+        savePrompt: 'Nome file (senza estensione):',
+        loadFile: 'Carica',
+        fileLoaded: 'File caricato',
+        fileLoadFailed: 'Impossibile caricare il file',
+    },
+};
+const referenceLists = {
+    de: {
+        core: ['WENN', 'DANN', 'SONST', 'ENDE', 'SOLANGE', 'FUER', 'IN', 'VAR', 'SETZE', 'SCHREIB', 'PROZEDUR', 'BEMERKUNG'],
+        world: ['LAUF', 'DREH_LINKS', 'NIMM', 'GIB', 'IST_FREI', 'IST_KNOCHEN', 'SPRING', 'SCHAU'],
+        operators: ['+', '-', '*', '/', '%', '**', '<', '>', '<<', '<=', '>=', '==', '<>', 'UND', 'ODER', 'NICHT'],
+    },
+    en: {
+        core: ['IF', 'THEN', 'ELSE', 'END', 'WHILE', 'FOR', 'IN', 'VAR', 'SET', 'LOG', 'PROC', 'REM'],
+        world: ['RUN', 'TURN_LEFT', 'TAKE', 'GIVE', 'FREE_AHEAD', 'THING_THERE', 'JUMP', 'LOOK'],
+        operators: ['+', '-', '*', '/', '%', '**', '<', '>', '<<', '<=', '>=', '==', '<>', 'AND', 'OR', 'NOT'],
+    },
+    fr: {
+        core: ['SI', 'ALORS', 'SINON', 'FIN', 'TANT', 'POUR', 'DANS', 'VAR', 'DEFINI', 'ECRIS', 'PROCEDURE', 'REMARQUE'],
+        world: ['MARCHE', 'TOURNE_GAUCHE', 'PRENDRE', 'DONNER', 'EST_LIBRE', 'EST_OS', 'SAUTE', 'REGARDE'],
+        operators: ['+', '-', '*', '/', '%', '**', '<', '>', '<<', '<=', '>=', '==', '<>', 'ET', 'OU', 'NON'],
+    },
+    es: {
+        core: ['SI', 'ENTONCES', 'SINO', 'FIN', 'MIENTRAS', 'PARA', 'EN', 'VAR', 'ASIGNA', 'ESCRIBE', 'PROCEDIMIENTO', 'COMENTARIO'],
+        world: ['CORRE', 'GIRA_IZQUIERDA', 'TOMA', 'DA', 'ES_LIBRE', 'ES_HUESO', 'SALTA', 'MIRA'],
+        operators: ['+', '-', '*', '/', '%', '**', '<', '>', '<<', '<=', '>=', '==', '<>', 'Y', 'O', 'NO'],
+    },
+    it: {
+        core: ['SE', 'ALLORA', 'ALTRIMENTI', 'FINE', 'MENTRE', 'PER', 'IN', 'VAR', 'ASSEGNA', 'SCRIVI', 'PROCEDURA', 'COMMENTO'],
+        world: ['CORRI', 'GIRA_SINISTRA', 'PRENDI', 'DAI', 'E_LIBERO', 'E_OSSO', 'SALTA', 'GUARDA'],
+        operators: ['+', '-', '*', '/', '%', '**', '<', '>', '<<', '<=', '>=', '==', '<>', 'E', 'O', 'NON'],
+    },
+};
+const helpLabels = {
+    de: {
+        title: 'Vollstaendige Dokumentation',
+        close: 'Schliessen',
+        loading: 'Dokumentation wird geladen...',
+        empty: 'Dokumentation konnte nicht geladen werden.',
+        docsSection: 'Befehle und Referenz',
+        examplesSection: 'Alle Beispielskripte',
+    },
+    en: {
+        title: 'Complete Documentation',
+        close: 'Close',
+        loading: 'Loading documentation...',
+        empty: 'Documentation could not be loaded.',
+        docsSection: 'Commands and Reference',
+        examplesSection: 'All Example Scripts',
+    },
+    fr: {
+        title: 'Documentation Complete',
+        close: 'Fermer',
+        loading: 'Chargement de la documentation...',
+        empty: 'La documentation n\'a pas pu etre chargee.',
+        docsSection: 'Commandes et Reference',
+        examplesSection: 'Tous les Scripts Exemple',
+    },
+    es: {
+        title: 'Documentacion Completa',
+        close: 'Cerrar',
+        loading: 'Cargando documentacion...',
+        empty: 'No se pudo cargar la documentacion.',
+        docsSection: 'Comandos y Referencia',
+        examplesSection: 'Todos los Scripts de Ejemplo',
+    },
+    it: {
+        title: 'Documentazione Completa',
+        close: 'Chiudi',
+        loading: 'Caricamento documentazione...',
+        empty: 'Impossibile caricare la documentazione.',
+        docsSection: 'Comandi e Riferimento',
+        examplesSection: 'Tutti gli Script di Esempio',
+    },
+};
+const documentationFiles = [
+    {
+        titles: {
+            de: 'Lny Befehlsreferenz',
+            en: 'Lny Command Reference',
+            fr: 'Reference des commandes Lny',
+            es: 'Referencia de comandos Lny',
+            it: 'Riferimento comandi Lny',
+        },
+        sourcePath: 'docs/lny-referenz.md',
+        fetchPath: './docs/lny-referenz.md',
+    },
+    {
+        titles: {
+            de: 'Lny Interpreter Handbuch',
+            en: 'Lny Interpreter Manual',
+            fr: 'Manuel de l\'interpreteur Lny',
+            es: 'Manual del interprete Lny',
+            it: 'Manuale interprete Lny',
+        },
+        sourcePath: 'docs/INTERPRETER.md',
+        fetchPath: './docs/INTERPRETER.md',
+    },
+];
+const exampleFileNames = [
+    '00-demo.lny',
+    '01-variable-assignment.lny',
+    '02-conditional.lny',
+    '03-while-loop.lny',
+    '04-for-loop.lny',
+    '05-lenny-movement.lny',
+    '06-procedure.lny',
+];
+const supportedLanguages = ['de', 'en', 'fr', 'es', 'it'];
+const exampleTranslationCategories = ['core', 'world'];
+const helpTranslationCategories = ['core', 'world'];
+const helpAdditionalKeywordTranslations = {
+    TRUE: { de: 'WAHR', en: 'TRUE', fr: 'VRAI', es: 'VERDADERO', it: 'VERO' },
+    FALSE: { de: 'FALSCH', en: 'FALSE', fr: 'FAUX', es: 'FALSO', it: 'FALSO' },
+    NOTHING: { de: 'NICHTS', en: 'NOTHING', fr: 'RIEN', es: 'NADA', it: 'NULLA' },
+    PRIVATE: { de: 'PRIVAT', en: 'PRIVATE', fr: 'PRIVE', es: 'PRIVADO', it: 'PRIVATO' },
+    GLOBAL: { de: 'GLOBAL', en: 'GLOBAL', fr: 'GLOBAL', es: 'GLOBAL', it: 'GLOBALE' },
+};
+class BrowserRunner {
+    constructor() {
+        this.echoMode = false;
+        this.echoBtn = document.getElementById('echoBtn');
+        this.fontSize = 13;
+        this.fontFamily = "";
+        this.language = 'de';
+        this.worldWidth = world_1.DEFAULT_WORLD_WIDTH;
+        this.worldHeight = world_1.DEFAULT_WORLD_HEIGHT;
+        this.interpreter = new interpreter_1.Interpreter(this.language, {
+            worldWidth: world_1.DEFAULT_WORLD_WIDTH,
+            worldHeight: world_1.DEFAULT_WORLD_HEIGHT,
+        });
+        this.codeEditor = document.getElementById('codeEditor');
+        this.consoleEl = document.getElementById('console');
+        this.kernCommandsList = document.getElementById('kernCommandsList');
+        this.worldCommandsList = document.getElementById('worldCommandsList');
+        this.operatorsList = document.getElementById('operatorsList');
+        this.exampleScriptsList = document.getElementById('exampleScriptsList');
+        this.lennyState = document.getElementById('lennyState');
+        this.helpModal = document.getElementById('helpModal');
+        this.helpModalTitle = document.getElementById('helpModalTitle');
+        this.helpContent = document.getElementById('helpContent');
+        this.closeHelpBtn = document.getElementById('closeHelpBtn');
+        this.fileInput = document.getElementById('fileInput');
+        this.aboutBtn = document.getElementById('aboutBtn');
+        this.aboutModal = document.getElementById('aboutModal');
+        this.aboutContent = document.getElementById('aboutContent');
+        this.closeAboutBtn = document.getElementById('closeAboutBtn');
+        // About/Lny-Book UI elements removed
+        this.loadedHelpSections = null;
+        this.exampleScriptCache = new Map();
+        this.exampleKeywordMaps = new Map();
+        this.helpKeywordMaps = new Map();
+        this.selectedExampleScript = null;
+    }
+    setupEchoButton() {
+        if (!this.echoBtn)
+            return;
+        this.echoBtn.addEventListener('click', () => {
+            this.echoMode = !this.echoMode;
+            this.echoBtn.textContent = this.echoMode ? 'ECHO ON' : 'ECHO OFF';
+        });
+    }
+    async init() {
+        this.setupEchoButton();
+        // Settings laden (fontSize, fontFamily)
+        try {
+            const resp = await fetch('./settings.json', { cache: 'no-store' });
+            if (resp.ok) {
+                const settings = await resp.json();
+                if (settings.fontSize && typeof settings.fontSize === 'number') {
+                    this.fontSize = settings.fontSize;
+                }
+                if (settings.fontFamily && typeof settings.fontFamily === 'string') {
+                    this.fontFamily = settings.fontFamily;
+                }
+            }
+        }
+        catch { }
+        // Theme aus LocalStorage setzen
+        const theme = localStorage.getItem('theme');
+        if (theme === 'dark') {
+            document.body.classList.add('dark');
+            const btn = document.getElementById('themeToggleBtn');
+            if (btn)
+                btn.textContent = '☀️';
+        }
+        else {
+            document.body.classList.remove('dark');
+            const btn = document.getElementById('themeToggleBtn');
+            if (btn)
+                btn.textContent = '🌙';
+        }
+        await this.loadConfig();
+        this.interpreter = new interpreter_1.Interpreter(this.language, {
+            worldWidth: this.worldWidth,
+            worldHeight: this.worldHeight,
+        });
+        // Schriftgröße anwenden
+        this.applyFontSize();
+        // About/Lny-Book modals removed
+        this.bindEvents();
+        this.refreshUi();
+        // Global ESC handler for modals
+        document.addEventListener('keydown', (event) => {
+            if (event.key === 'Escape' && this.helpModal.classList.contains('open')) {
+                this.hideHelp();
+            }
+            if (event.key === 'Escape' && this.aboutModal.classList.contains('open')) {
+                this.hideAbout();
+            }
+        });
+    }
+    async loadConfig() {
+        try {
+            const response = await fetch('./lny-config.yml', { cache: 'no-store' });
+            if (!response.ok) {
+                return;
+            }
+            const configContent = await response.text();
+            const parsedFieldSize = this.parseFieldSizeFromConfig(configContent);
+            if (parsedFieldSize) {
+                this.worldWidth = parsedFieldSize.width;
+                this.worldHeight = parsedFieldSize.height;
+            }
+        }
+        catch {
+            // Keep defaults when config is unavailable in browser runtime.
+        }
+    }
+    parseFieldSizeFromConfig(configContent) {
+        const lines = configContent.replace(/^\uFEFF/, '').split(/\r?\n/);
+        let width = world_1.DEFAULT_WORLD_WIDTH;
+        let height = world_1.DEFAULT_WORLD_HEIGHT;
+        let foundSizeConfig = false;
+        for (const rawLine of lines) {
+            const line = rawLine.trim();
+            if (!line || line.startsWith('#')) {
+                continue;
+            }
+            const sizeMatch = line.match(/^field(?:_|-)?size\s*:\s*(.+)$/i);
+            if (sizeMatch) {
+                const parsedSize = this.parseCombinedFieldSize(this.normalizeConfigValue(sizeMatch[1]));
+                if (parsedSize) {
+                    width = parsedSize.width;
+                    height = parsedSize.height;
+                    foundSizeConfig = true;
+                }
+                continue;
+            }
+            const widthMatch = line.match(/^field(?:_|-)?width\s*:\s*(.+)$/i);
+            if (widthMatch) {
+                const parsedWidth = this.parsePositiveInt(this.normalizeConfigValue(widthMatch[1]));
+                if (parsedWidth !== null) {
+                    width = parsedWidth;
+                    foundSizeConfig = true;
+                }
+                continue;
+            }
+            const heightMatch = line.match(/^field(?:_|-)?height\s*:\s*(.+)$/i);
+            if (heightMatch) {
+                const parsedHeight = this.parsePositiveInt(this.normalizeConfigValue(heightMatch[1]));
+                if (parsedHeight !== null) {
+                    height = parsedHeight;
+                    foundSizeConfig = true;
+                }
+            }
+        }
+        return foundSizeConfig ? { width, height } : null;
+    }
+    normalizeConfigValue(rawValue) {
+        return rawValue.split('#')[0].trim().replace(/^['"]|['"]$/g, '').trim();
+    }
+    parseCombinedFieldSize(rawValue) {
+        const match = rawValue.match(/^(\d+)\s*[xX]\s*(\d+)$/);
+        if (!match) {
+            return null;
+        }
+        const width = this.parsePositiveInt(match[1]);
+        const height = this.parsePositiveInt(match[2]);
+        if (width === null || height === null) {
+            return null;
+        }
+        return { width, height };
+    }
+    parsePositiveInt(rawValue) {
+        const numericValue = Number(rawValue);
+        return Number.isInteger(numericValue) && numericValue > 0 ? numericValue : null;
+    }
+    bindEvents() {
+        // Schriftgröße dynamisch setzen, falls settings.json geändert wird
+        // (Optional: Hot-Reload, hier nicht implementiert)
+        // Theme Toggle Button
+        const themeToggleBtn = document.getElementById('themeToggleBtn');
+        if (themeToggleBtn) {
+            themeToggleBtn.addEventListener('click', () => {
+                const isDark = document.body.classList.toggle('dark');
+                localStorage.setItem('theme', isDark ? 'dark' : 'light');
+                themeToggleBtn.textContent = isDark ? '☀️' : '🌙';
+                console.log('[ThemeToggle]', isDark ? 'Darkmode aktiviert' : 'Lightmode aktiviert');
+            });
+        }
+        const runBtn = document.getElementById('runBtn');
+        const clearBtn = document.getElementById('clearBtn');
+        const clearConsoleBtn = document.getElementById('clearConsoleBtn');
+        const helpBtn = document.getElementById('helpBtn');
+        const saveBtn = document.getElementById('saveBtn');
+        const loadBtn = document.getElementById('loadBtn');
+        runBtn.addEventListener('click', () => this.runCode());
+        clearBtn.addEventListener('click', () => this.clearConsole());
+        clearConsoleBtn.addEventListener('click', () => this.clearConsole());
+        helpBtn.addEventListener('click', () => {
+            void this.showHelp();
+        });
+        saveBtn.addEventListener('click', () => this.saveFile());
+        loadBtn.addEventListener('click', () => this.fileInput.click());
+        this.fileInput.addEventListener('change', () => {
+            void this.loadFile();
+        });
+        this.closeHelpBtn.addEventListener('click', () => this.hideHelp());
+        this.helpModal.addEventListener('click', (event) => {
+            if (event.target === this.helpModal) {
+                this.hideHelp();
+            }
+        });
+        // About button logic
+        this.aboutBtn.addEventListener('click', () => {
+            this.showAbout();
+        });
+        this.closeAboutBtn.addEventListener('click', () => this.hideAbout());
+        this.aboutModal.addEventListener('click', (event) => {
+            if (event.target === this.aboutModal) {
+                this.hideAbout();
+            }
+        });
+    }
+    // --- About modal logic ---
+    async showAbout() {
+        this.aboutModal.style.display = '';
+        this.aboutModal.setAttribute('aria-hidden', 'false');
+        document.body.classList.add('help-open');
+        this.aboutContent.innerHTML = '<p>Lade Info...</p>';
+        const content = await this.fetchTextFile('./docs/About.md');
+        if (content) {
+            this.aboutContent.innerHTML = this.renderMarkdownDocument(content);
+        }
+        else {
+            this.aboutContent.innerHTML = '<p>About.md nicht gefunden.</p>';
+        }
+    }
+    hideAbout() {
+        this.aboutModal.style.display = 'none';
+        this.aboutModal.setAttribute('aria-hidden', 'true');
+        document.body.classList.remove('help-open');
+    }
+    // About/Lny-Book event listeners removed
+    // Language button and example script event bindings
+    // (remains in bindEvents as before)
+    runCode() {
+        const code = this.codeEditor.value;
+        if (!code.trim()) {
+            return;
+        }
+        this.appendConsoleLine(uiStrings[this.language].executing, 'info');
+        const start = performance.now();
+        try {
+            this.interpreter.clearOutput();
+            const parser = new parser_1.Parser(code, this.language);
+            const ast = parser.parse();
+            // --- ECHO-Modus: Hook für LAUF/DREH_LINKS ---
+            const world = this.interpreter.getWorld();
+            world.setEchoCallback(this.echoMode ? (state) => {
+                let lines = [
+                    `State:`,
+                    `  Pos:       (${state.x},${state.y})`,
+                    `  Dir:       ${state.direction}`,
+                    `  Bones:     ${state.bones}`,
+                    `  Runs:      ${state.howManyRun}`,
+                    `  Turns:     ${state.howManyTurn}`,
+                    `  IST_KNOCHEN: ${state.ist_knochen}`
+                ];
+                if (state.field) {
+                    lines.push(`  Feld:`);
+                    lines.push(`    Bones:   ${state.field.bones}`);
+                    lines.push(`    Log:     ${state.field.hasLog ? 'ja' : 'nein'}`);
+                    lines.push(`    Doghut:  ${state.field.hasDoghut ? 'ja' : 'nein'}`);
+                }
+                else {
+                    lines.push('  Feld: ungültig');
+                }
+                this.appendConsoleLine(lines.join('\n'));
+            } : undefined);
+            this.interpreter.interpret(ast);
+            const output = this.interpreter.getOutput();
+            if (output.trim().length > 0) {
+                output.split('\n').forEach((line) => {
+                    this.appendConsoleLine(line);
+                });
+            }
+            const end = performance.now();
+            const ms = Math.round(end - start);
+            this.appendConsoleLine(`${uiStrings[this.language].finished} (${ms} ms)`, 'info');
+        }
+        catch (error) {
+            const message = error.message;
+            this.appendConsoleLine(`${uiStrings[this.language].errorLabel}: ${message}`, 'error');
+        }
+        this.renderState();
+    }
+    clearConsole() {
+        this.consoleEl.innerHTML = '';
+    }
+    applyFontSize() {
+        if (this.codeEditor) {
+            this.codeEditor.style.fontSize = this.fontSize + 'px';
+            if (this.fontFamily) {
+                this.codeEditor.style.fontFamily = this.fontFamily;
+            }
+        }
+        if (this.consoleEl) {
+            this.consoleEl.style.fontSize = this.fontSize + 'px';
+            if (this.fontFamily) {
+                this.consoleEl.style.fontFamily = this.fontFamily;
+            }
+        }
+    }
+    saveFile() {
+        const ui = uiStrings[this.language];
+        if (!this.codeEditor.value.trim()) {
+            return;
+        }
+        const defaultName = this.selectedExampleScript
+            ? this.selectedExampleScript.replace(/\.lny$/, '')
+            : 'script';
+        const input = window.prompt(ui.savePrompt, defaultName);
+        if (input === null) {
+            return;
+        }
+        const sanitized = input.trim().replace(/[/\\?%*:|"<>]/g, '_') || 'script';
+        const fileName = sanitized.endsWith('.lny') ? sanitized : `${sanitized}.lny`;
+        const code = this.codeEditor.value;
+        const blob = new Blob([code], { type: 'text/plain' });
+        const url = URL.createObjectURL(blob);
+        const anchor = document.createElement('a');
+        anchor.href = url;
+        anchor.download = fileName;
+        anchor.click();
+        URL.revokeObjectURL(url);
+    }
+    async loadFile() {
+        const file = this.fileInput.files?.[0];
+        if (!file) {
+            return;
+        }
+        try {
+            const text = await file.text();
+            this.codeEditor.value = text.replace(/^\uFEFF/, '');
+            this.selectedExampleScript = null;
+            this.renderExampleScriptsList();
+            this.appendConsoleLine(`${uiStrings[this.language].fileLoaded}: ${file.name}`, 'info');
+        }
+        catch {
+            this.appendConsoleLine(uiStrings[this.language].fileLoadFailed, 'error');
+        }
+        finally {
+            this.fileInput.value = '';
+        }
+    }
+    async showHelp() {
+        const labels = helpLabels[this.language];
+        this.helpModalTitle.textContent = labels.title;
+        this.closeHelpBtn.textContent = labels.close;
+        this.openHelpModal();
+        if (!this.loadedHelpSections) {
+            this.helpContent.innerHTML = `<p class="help-status">${this.escapeHtml(labels.loading)}</p>`;
+            this.loadedHelpSections = await this.loadHelpSections(this.language);
+        }
+        this.helpContent.innerHTML = this.renderHelpSections(this.loadedHelpSections);
+    }
+    refreshUi() {
+        this.codeEditor.placeholder = uiStrings[this.language].placeholder;
+        this.helpModalTitle.textContent = helpLabels[this.language].title;
+        this.closeHelpBtn.textContent = helpLabels[this.language].close;
+        if (this.loadedHelpSections && this.helpModal.classList.contains('open')) {
+            this.helpContent.innerHTML = this.renderHelpSections(this.loadedHelpSections);
+        }
+        this.renderReferenceLists();
+        this.renderState();
+    }
+    renderReferenceLists() {
+        this.kernCommandsList.innerHTML = referenceLists[this.language].core.map((cmd) => `<li>${cmd}</li>`).join('');
+        this.worldCommandsList.innerHTML = referenceLists[this.language].world.map((cmd) => `<li>${cmd}</li>`).join('');
+        this.operatorsList.innerHTML = referenceLists[this.language].operators.map((cmd) => `<li>${cmd}</li>`).join('');
+        this.renderExampleScriptsList();
+    }
+    renderExampleScriptsList() {
+        this.exampleScriptsList.innerHTML = exampleFileNames.map((fileName) => {
+            const isActive = this.selectedExampleScript === fileName ? ' active' : '';
+            return `<li class="example-script-item${isActive}" data-example-file="${this.escapeHtml(fileName)}">${this.escapeHtml(fileName)}</li>`;
+        }).join('');
+        // Event Delegation: Click on example loads it
+        this.exampleScriptsList.querySelectorAll('.example-script-item').forEach((el) => {
+            el.addEventListener('click', (e) => {
+                const file = el.getAttribute('data-example-file');
+                if (file && this.isExampleFileName(file)) {
+                    void this.loadExampleIntoEditor(file);
+                }
+            });
+        });
+    }
+    async loadExampleIntoEditor(fileName, announce = true) {
+        let content = this.exampleScriptCache.get(fileName) ?? null;
+        if (!content) {
+            content = await this.fetchTextFile(`./examples/${fileName}`);
+            if (!content) {
+                this.appendConsoleLine(`${uiStrings[this.language].exampleLoadFailed}: ${fileName}`, 'error');
+                return;
+            }
+            this.exampleScriptCache.set(fileName, content);
+        }
+        this.codeEditor.value = this.localizeExampleScript(content, this.language);
+        this.selectedExampleScript = fileName;
+        this.renderExampleScriptsList();
+        if (announce) {
+            this.appendConsoleLine(`${uiStrings[this.language].exampleLoaded}: ${fileName}`, 'info');
+        }
+    }
+    isExampleFileName(fileName) {
+        return exampleFileNames.includes(fileName);
+    }
+    localizeExampleScript(content, targetLanguage) {
+        const keywordMap = this.getExampleKeywordMap(targetLanguage);
+        return this.localizeContentByTokenMap(content, keywordMap);
+    }
+    getExampleKeywordMap(targetLanguage) {
+        const cachedMap = this.exampleKeywordMaps.get(targetLanguage);
+        if (cachedMap) {
+            return cachedMap;
+        }
+        const keywordMap = new Map();
+        exampleTranslationCategories.forEach((category) => {
+            const targetTokens = referenceLists[targetLanguage][category];
+            for (let index = 0; index < targetTokens.length; index += 1) {
+                const translatedToken = targetTokens[index];
+                supportedLanguages.forEach((sourceLanguage) => {
+                    const sourceToken = referenceLists[sourceLanguage][category][index];
+                    keywordMap.set(this.normalizeLanguageToken(sourceToken), translatedToken);
+                });
+            }
+        });
+        this.exampleKeywordMaps.set(targetLanguage, keywordMap);
+        return keywordMap;
+    }
+    getHelpKeywordMap(targetLanguage) {
+        const cachedMap = this.helpKeywordMaps.get(targetLanguage);
+        if (cachedMap) {
+            return cachedMap;
+        }
+        const keywordMap = new Map();
+        helpTranslationCategories.forEach((category) => {
+            const targetTokens = referenceLists[targetLanguage][category];
+            for (let index = 0; index < targetTokens.length; index += 1) {
+                const translatedToken = targetTokens[index];
+                supportedLanguages.forEach((sourceLanguage) => {
+                    const sourceToken = referenceLists[sourceLanguage][category][index];
+                    keywordMap.set(this.normalizeLanguageToken(sourceToken), translatedToken);
+                });
+            }
+        });
+        Object.values(helpAdditionalKeywordTranslations).forEach((tokenByLanguage) => {
+            const translatedToken = tokenByLanguage[targetLanguage];
+            supportedLanguages.forEach((sourceLanguage) => {
+                keywordMap.set(this.normalizeLanguageToken(tokenByLanguage[sourceLanguage]), translatedToken);
+            });
+        });
+        this.helpKeywordMaps.set(targetLanguage, keywordMap);
+        return keywordMap;
+    }
+    localizeHelpDocumentation(content, targetLanguage) {
+        const keywordMap = this.getHelpKeywordMap(targetLanguage);
+        return this.localizeContentByTokenMap(content, keywordMap);
+    }
+    localizeContentByTokenMap(content, keywordMap) {
+        return content.replace(/\b[A-Za-z_À-ÖØ-öø-ÿ][A-Za-z_0-9À-ÖØ-öø-ÿ]*\b/g, (token) => {
+            const replacement = keywordMap.get(this.normalizeLanguageToken(token));
+            return replacement ?? token;
+        });
+    }
+    normalizeLanguageToken(token) {
+        return token
+            .normalize('NFD')
+            .replace(/[\u0300-\u036f]/g, '')
+            .toUpperCase();
+    }
+    getLocalizedHelpSectionTitle(section) {
+        return section.localizedTitles?.[this.language] ?? section.title;
+    }
+    renderState() {
+        const state = this.interpreter.getWorld().getLennyState();
+        const ui = uiStrings[this.language];
+        this.lennyState.innerHTML = `
+      <div class="lenny-state">
+        <div><strong>${ui.stateTitle}:</strong></div>
+        <div><strong>${ui.fieldSize}:</strong> ${state.fieldWidth}x${state.fieldHeight}</div>
+        <div><strong>${ui.pos}:</strong> (${state.x}, ${state.y})</div>
+        <div><strong>${ui.dir}:</strong> ${state.direction}</div>
+        <div><strong>${ui.bones}:</strong> ${state.bones}</div>
+        <div><strong>${ui.runs}:</strong> ${state.howManyRun}</div>
+      </div>
+    `;
+    }
+    appendConsoleLine(text, className = '') {
+        const line = document.createElement('div');
+        line.className = className ? `console-line ${className}` : 'console-line';
+        line.textContent = text;
+        this.consoleEl.appendChild(line);
+        this.consoleEl.scrollTop = this.consoleEl.scrollHeight;
+    }
+    async loadHelpSections(language) {
+        const documentation = await Promise.all(documentationFiles.map(async (doc) => {
+            const localizedDoc = await this.fetchLocalizedDocumentation(doc, language);
+            if (!localizedDoc) {
+                return null;
+            }
+            return {
+                kind: 'documentation',
+                title: doc.titles.de,
+                localizedTitles: doc.titles,
+                sourcePath: localizedDoc.sourcePath,
+                content: localizedDoc.content,
+            };
+        }));
+        const examples = await Promise.all(exampleFileNames.map(async (fileName) => {
+            const content = await this.fetchTextFile(`./examples/${fileName}`);
+            if (content === null) {
+                return null;
+            }
+            return {
+                kind: 'example',
+                title: fileName,
+                sourcePath: `examples/${fileName}`,
+                content,
+            };
+        }));
+        const sections = [];
+        documentation.forEach((section) => {
+            if (section) {
+                sections.push(section);
+            }
+        });
+        examples.forEach((section) => {
+            if (section) {
+                sections.push(section);
+            }
+        });
+        return sections;
+    }
+    async fetchLocalizedDocumentation(documentationFile, language) {
+        const fileName = documentationFile.sourcePath.split('/').pop() ?? documentationFile.sourcePath;
+        const candidates = [
+            {
+                fetchPath: documentationFile.fetchPath,
+                sourcePath: documentationFile.sourcePath,
+            },
+        ];
+        if (language !== 'de') {
+            const localizedSourcePath = `docs/i18n/${language}/${fileName}`;
+            candidates.unshift({
+                fetchPath: `./${localizedSourcePath}`,
+                sourcePath: localizedSourcePath,
+            });
+        }
+        return this.fetchFirstAvailableText(candidates);
+    }
+    async fetchFirstAvailableText(candidates) {
+        for (const candidate of candidates) {
+            const content = await this.fetchTextFile(candidate.fetchPath);
+            if (content !== null) {
+                return {
+                    content,
+                    sourcePath: candidate.sourcePath,
+                };
+            }
+        }
+        return null;
+    }
+    async fetchTextFile(path) {
+        try {
+            const response = await fetch(path, { cache: 'no-store' });
+            if (!response.ok) {
+                return null;
+            }
+            return (await response.text()).replace(/^\uFEFF/, '').trimEnd();
+        }
+        catch {
+            return null;
+        }
+    }
+    renderHelpSections(sections) {
+        const labels = helpLabels[this.language];
+        if (sections.length === 0) {
+            return `<p class="help-status">${this.escapeHtml(labels.empty)}</p>`;
+        }
+        const docs = sections.filter((section) => section.kind === 'documentation');
+        const examples = sections.filter((section) => section.kind === 'example');
+        const htmlParts = [];
+        if (docs.length > 0) {
+            htmlParts.push(`<h3 class="help-group-title">${this.escapeHtml(labels.docsSection)}</h3>`);
+            docs.forEach((section, index) => {
+                htmlParts.push(this.renderHelpSection(section, index === 0));
+            });
+        }
+        if (examples.length > 0) {
+            htmlParts.push(`<h3 class="help-group-title">${this.escapeHtml(labels.examplesSection)}</h3>`);
+            examples.forEach((section) => {
+                htmlParts.push(this.renderHelpSection(section, false));
+            });
+        }
+        return htmlParts.join('');
+    }
+    renderHelpSection(section, openByDefault) {
+        const localizedContent = section.kind === 'example'
+            ? this.localizeExampleScript(section.content, this.language)
+            : this.localizeHelpDocumentation(section.content, this.language);
+        const bodyHtml = section.kind === 'example'
+            ? this.renderCodeBlockHtml(localizedContent, 'lny')
+            : this.renderMarkdownDocument(localizedContent);
+        const sectionTitle = this.getLocalizedHelpSectionTitle(section);
+        return `
+      <details class="help-doc-section"${openByDefault ? ' open' : ''}>
+        <summary>
+          <span>${this.escapeHtml(sectionTitle)}</span>
+          <span class="help-doc-source">${this.escapeHtml(section.sourcePath)}</span>
+        </summary>
+        <div class="help-markdown">${bodyHtml}</div>
+      </details>
+    `;
+    }
+    renderMarkdownDocument(markdown) {
+        const lines = markdown.replace(/\r\n/g, '\n').split('\n');
+        const blocks = [];
+        let index = 0;
+        while (index < lines.length) {
+            const line = lines[index];
+            const trimmed = line.trim();
+            if (!trimmed) {
+                index += 1;
+                continue;
+            }
+            const fenceMatch = trimmed.match(/^```([a-zA-Z0-9_-]+)?\s*$/);
+            if (fenceMatch) {
+                const language = fenceMatch[1] ?? '';
+                const codeLines = [];
+                index += 1;
+                while (index < lines.length && !lines[index].trim().match(/^```\s*$/)) {
+                    codeLines.push(lines[index]);
+                    index += 1;
+                }
+                if (index < lines.length) {
+                    index += 1;
+                }
+                blocks.push(this.renderCodeBlockHtml(codeLines.join('\n'), language));
+                continue;
+            }
+            const headingMatch = line.match(/^(#{1,6})\s+(.+)$/);
+            if (headingMatch) {
+                const level = headingMatch[1].length;
+                const content = this.renderInlineMarkdown(headingMatch[2].trim());
+                blocks.push(`<h${level}>${content}</h${level}>`);
+                index += 1;
+                continue;
+            }
+            if (/^\s*([-*_]\s*){3,}\s*$/.test(trimmed)) {
+                blocks.push('<hr />');
+                index += 1;
+                continue;
+            }
+            if (this.isTableStart(lines, index)) {
+                const tableRender = this.renderTableHtml(lines, index);
+                blocks.push(tableRender.html);
+                index = tableRender.nextIndex;
+                continue;
+            }
+            if (this.isUnorderedListLine(line)) {
+                const items = [];
+                while (index < lines.length && this.isUnorderedListLine(lines[index])) {
+                    const listMatch = lines[index].match(/^\s*[-*]\s+(.+)$/);
+                    if (listMatch) {
+                        items.push(`<li>${this.renderInlineMarkdown(listMatch[1].trim())}</li>`);
+                    }
+                    index += 1;
+                }
+                blocks.push(`<ul>${items.join('')}</ul>`);
+                continue;
+            }
+            if (this.isOrderedListLine(line)) {
+                const items = [];
+                while (index < lines.length && this.isOrderedListLine(lines[index])) {
+                    const listMatch = lines[index].match(/^\s*\d+\.\s+(.+)$/);
+                    if (listMatch) {
+                        items.push(`<li>${this.renderInlineMarkdown(listMatch[1].trim())}</li>`);
+                    }
+                    index += 1;
+                }
+                blocks.push(`<ol>${items.join('')}</ol>`);
+                continue;
+            }
+            const paragraphLines = [];
+            while (index < lines.length &&
+                lines[index].trim() &&
+                !this.isMarkdownBlockStart(lines, index)) {
+                paragraphLines.push(lines[index].trim());
+                index += 1;
+            }
+            if (paragraphLines.length > 0) {
+                const paragraphHtml = paragraphLines
+                    .map((paragraphLine) => this.renderInlineMarkdown(paragraphLine))
+                    .join(' ');
+                blocks.push(`<p>${paragraphHtml}</p>`);
+                continue;
+            }
+            // Fallback to avoid an infinite loop when an unsupported pattern appears.
+            blocks.push(`<p>${this.renderInlineMarkdown(trimmed)}</p>`);
+            index += 1;
+        }
+        return blocks.join('');
+    }
+    isMarkdownBlockStart(lines, index) {
+        const line = lines[index] ?? '';
+        const trimmed = line.trim();
+        if (!trimmed) {
+            return true;
+        }
+        if (/^```/.test(trimmed)) {
+            return true;
+        }
+        if (/^(#{1,6})\s+/.test(line)) {
+            return true;
+        }
+        if (/^\s*([-*_]\s*){3,}\s*$/.test(trimmed)) {
+            return true;
+        }
+        if (this.isUnorderedListLine(line) || this.isOrderedListLine(line)) {
+            return true;
+        }
+        return this.isTableStart(lines, index);
+    }
+    isUnorderedListLine(line) {
+        return /^\s*[-*]\s+.+$/.test(line);
+    }
+    isOrderedListLine(line) {
+        return /^\s*\d+\.\s+.+$/.test(line);
+    }
+    isTableStart(lines, index) {
+        if (index + 1 >= lines.length) {
+            return false;
+        }
+        const headerLine = lines[index];
+        const dividerLine = lines[index + 1];
+        if (!headerLine.includes('|') || !dividerLine.includes('|')) {
+            return false;
+        }
+        const headerCells = this.parseTableRow(headerLine);
+        const dividerCells = this.parseTableRow(dividerLine);
+        if (headerCells.length < 2 || headerCells.length !== dividerCells.length) {
+            return false;
+        }
+        return dividerCells.every((cell) => this.isTableDividerCell(cell));
+    }
+    renderTableHtml(lines, startIndex) {
+        const headerCells = this.parseTableRow(lines[startIndex]);
+        const bodyRows = [];
+        let index = startIndex + 2;
+        while (index < lines.length) {
+            const line = lines[index];
+            if (!line.trim() || !line.includes('|')) {
+                break;
+            }
+            const rowCells = this.parseTableRow(line);
+            if (rowCells.length < 2) {
+                break;
+            }
+            bodyRows.push(this.normalizeTableCells(rowCells, headerCells.length));
+            index += 1;
+        }
+        const headHtml = `<thead><tr>${headerCells
+            .map((cell) => `<th>${this.renderInlineMarkdown(cell)}</th>`)
+            .join('')}</tr></thead>`;
+        const bodyHtml = bodyRows.length > 0
+            ? `<tbody>${bodyRows
+                .map((rowCells) => `<tr>${rowCells
+                .map((cell) => `<td>${this.renderInlineMarkdown(cell)}</td>`)
+                .join('')}</tr>`)
+                .join('')}</tbody>`
+            : '';
+        return {
+            html: `<table>${headHtml}${bodyHtml}</table>`,
+            nextIndex: index,
+        };
+    }
+    parseTableRow(row) {
+        const normalized = row.trim().replace(/^\|/, '').replace(/\|$/, '');
+        return normalized.split('|').map((cell) => cell.trim());
+    }
+    normalizeTableCells(cells, targetLength) {
+        if (cells.length === targetLength) {
+            return cells;
+        }
+        if (cells.length > targetLength) {
+            return [
+                ...cells.slice(0, targetLength - 1),
+                cells.slice(targetLength - 1).join(' | '),
+            ];
+        }
+        return [
+            ...cells,
+            ...Array.from({ length: targetLength - cells.length }, () => ''),
+        ];
+    }
+    isTableDividerCell(cell) {
+        return /^:?-{3,}:?$/.test(cell.trim());
+    }
+    renderCodeBlockHtml(code, language) {
+        const normalizedLanguage = language.toLowerCase().replace(/[^a-z0-9_-]/g, '');
+        const classAttribute = normalizedLanguage ? ` class="language-${normalizedLanguage}"` : '';
+        return `<pre><code${classAttribute}>${this.escapeHtml(code)}</code></pre>`;
+    }
+    renderInlineMarkdown(text) {
+        const codeTokens = [];
+        let html = text.replace(/`([^`]+)`/g, (_match, code) => {
+            const token = `@@CODE_TOKEN_${codeTokens.length}@@`;
+            codeTokens.push(`<code>${this.escapeHtml(code)}</code>`);
+            return token;
+        });
+        html = this.escapeHtml(html);
+        html = html.replace(/\[([^\]]+)\]\((https?:\/\/[^\s)]+)\)/g, (_match, label, url) => `<a href="${url}" target="_blank" rel="noreferrer">${label}</a>`);
+        html = html.replace(/\*\*([^*]+)\*\*/g, '<strong>$1</strong>');
+        html = html.replace(/\*([^*\n]+)\*/g, '<em>$1</em>');
+        html = html.replace(/~~([^~]+)~~/g, '<del>$1</del>');
+        codeTokens.forEach((tokenHtml, tokenIndex) => {
+            const token = `@@CODE_TOKEN_${tokenIndex}@@`;
+            html = html.split(token).join(tokenHtml);
+        });
+        return html;
+    }
+    escapeHtml(value) {
+        return value
+            .replace(/&/g, '&amp;')
+            .replace(/</g, '&lt;')
+            .replace(/>/g, '&gt;');
+    }
+    openHelpModal() {
+        this.helpModal.classList.add('open');
+        this.helpModal.setAttribute('aria-hidden', 'false');
+        document.body.classList.add('help-open');
+    }
+    hideHelp() {
+        this.helpModal.classList.remove('open');
+        this.helpModal.setAttribute('aria-hidden', 'true');
+        document.body.classList.remove('help-open');
+    }
+}
+window.addEventListener('DOMContentLoaded', () => {
+    const app = new BrowserRunner();
+    void app.init();
+});
+//# sourceMappingURL=browser.js.map