diff --git a/Core.js b/Core.js
index 7f06c75..e50ad96 100644
--- a/Core.js
+++ b/Core.js
@@ -364,372 +364,6 @@ class SimonUp {
         return html.replace('', tocListHtml);
     }
 
-/**
- * SimonUp Core Compiler (Core.js) - Version 1.2
- * Eine moderne, fluss- und blockorientierte Auszeichnungssprache.
- */
-class SimonUp {
-    constructor() {
-        this.plugins = [];
-        this.headings = [];
-        this.counters = [0, 0, 0, 0, 0, 0];
-    }
-
-    /**
-     * Registriert eine Erweiterung (Plugin)
-     */
-    use(plugin) {
-        this.plugins.push(plugin);
-        return this;
-    }
-
-    /**
-     * Hauptfunktion: Wandelt SimonUp-Text (.up) in valides HTML um
-     */
-    parse(text) {
-        this.headings = [];
-        this.counters = [0, 0, 0, 0, 0, 0];
-
-        let html = text;
-
-        if (this.plugins && this.plugins.length > 0) {
-            for (let i = 0; i < this.plugins.length; i++) {
-                if (this.plugins[i].before) {
-                    html = this.plugins[i].before(html);
-                }
-            }
-        }
-
-        html = this._parseBlocks(html);
-        html = this._injectTOC(html);
-
-        if (this.plugins && this.plugins.length > 0) {
-            for (let i = 0; i < this.plugins.length; i++) {
-                if (this.plugins[i].after) {
-                    html = this.plugins[i].after(html);
-                }
-            }
-        }
-
-        return html;
-    }
-
-    /**
-     * INTERN: Verarbeitet strukturelle Blöcke und freie Strukturen zeilenweise
-     */
-    _parseBlocks(text) {
-        const lines = text.replace(/\r\n/g, '\n').split('\n');
-        let result = [];
-        let inBlock = false;
-        let blockType = null;
-        let blockMeta = ""; 
-        let blockBuffer = [];
-
-        for (let i = 0; i < lines.length; i++) {
-            let line = lines[i];
-
-            if (!inBlock && line.startsWith('&') && line.trim().length > 1) {
-                inBlock = true;
-                const fullHeader = line.substring(1).trim();
-                const spaceIndex = fullHeader.indexOf(' ');
-
-                if (spaceIndex !== -1) {
-                    blockType = fullHeader.substring(0, spaceIndex).toLowerCase();
-                    blockMeta = fullHeader.substring(spaceIndex).trim();
-                } else {
-                    blockType = fullHeader.toLowerCase();
-                    blockMeta = "";
-                }
-                blockBuffer = [];
-                continue;
-            }
-
-            if (inBlock && line.trim().replace(/\u00A0/g, ' ') === '&') {
-                result.push(this._renderBlock(blockType, blockMeta, blockBuffer));
-                inBlock = false;
-                blockType = null;
-                blockMeta = "";
-                continue;
-            }
-
-            if (inBlock) {
-                blockBuffer.push(line);
-            } else {
-                let trimmed = line.trim();
-                
-                if (trimmed === '___') {
-                    result.push('<hr>');
-                } else if (trimmed.startsWith('- ')) {
-                    let insideUl = this._parseInline(line.replace(/^\s*-\s+/, ''));
-                    result.push(`<ul-item>${insideUl}</ul-item>`);
-                } else if (/^\d+\.\s+/.test(trimmed)) {
-                    let cleanLine = line.replace(/^\s*\d+\.\s+/, '');
-                    let insideOl = this._parseInline(cleanLine);
-                    result.push(`<ol-item>${insideOl}</ol-item>`);
-                } else {
-                    result.push(this._parseInline(line));
-                }
-            }
-        }
-
-        return this._processParagraphsAndLists(result);
-    }
-
-    /**
-     * INTERN: Erzeugt das HTML für einen geschlossenen Block
-     */
-    _renderBlock(type, meta, lines) {
-        const content = lines.join('\n');
-        let self = this;
-
-        switch (type) {
-            case 'toc':
-                let tocWrapper = '';
-                if (meta || content.trim()) {
-                    tocWrapper = '<div class="simonup-toc-wrapper">\n';
-                    if (meta) {
-                        tocWrapper += `<h2>${meta}</h2>\n`;
-                    }
-                    if (content.trim()) {
-                        const intro = lines.map(function(l) { return self._parseInline(l); }).join('<br>');
-                        tocWrapper += `<p class="toc-intro">${intro}</p>\n`;
-                    }
-                    tocWrapper += '\n</div>';
-                }
-                return tocWrapper;
-
-            case 'c': 
-                const langClass = meta ? ` class="language-${meta}"` : '';
-                const escapedCode = content.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
-                return `<pre><code${langClass}>${escapedCode}</code></pre>`;
-
-            case 'q': 
-                const qContent = lines.map(function(l) { return self._parseInline(l); }).join('<br>');
-                return `<blockquote>${qContent}</blockquote>`;
-
-            case 'b': 
-                const bContent = lines.map(function(l) { return self._parseInline(l); }).join('<br>');
-                return `<div class="bible-block">${bContent}</div>`;
-
-            case 'f': 
-                const fSummary = meta || 'Details';
-                const fContent = lines.map(function(l) { return self._parseInline(l); }).join('<br>');
-                return `<details>\n<summary>${fSummary}</summary>\n<p>${fContent}</p>\n</details>`;
-
-            case 'i': 
-                const iColor = meta || '#ff6347';
-                const iContent = lines.map(function(l) { return self._parseInline(l); }).join('<br>');
-                return `<div class="infobox" style="border-left: 4px solid ${iColor}; padding: 10px; margin: 10px 0; background: #f8f9fa;">\n${iContent}\n</div>`;
-
-            case 't': 
-                return this._renderTable(meta, lines);
-
-            default:
-                const defContent = lines.map(function(l) { return self._parseInline(l); }).join('<br>');
-                return `<div class="block-${type}">${defContent}</div>`;
-        }
-    }
-
-    /**
-     * INTERN: Hilfsfunktion zum Rendern von Multi-line-Tabellen und Galerien
-     */
-    _renderTable(meta, lines) {
-        let tableHtml = '<table>\n';
-        let currentCells = [];
-        let cellBuffer = [];
-        let self = this;
-
-        for (let i = 0; i < lines.length; i++) {
-            let line = lines[i];
-            let parts = line.split('|');
-            for (let j = 0; j < parts.length; j++) {
-                let part = parts[j];
-                
-                if (j === parts.length - 1) {
-                    if (part.trim() !== '') {
-                        cellBuffer.push(part);
-                    }
-                    if (line.endsWith('|') && cellBuffer.length > 0) {
-                        currentCells.push(cellBuffer.join('\n'));
-                        cellBuffer = [];
-                    }
-                } else {
-                    cellBuffer.push(part);
-                    currentCells.push(cellBuffer.join('\n'));
-                    cellBuffer = [];
-                }
-            }
-
-            if (line.endsWith('|') && currentCells.length > 0) {
-                let rowContent = currentCells.map(function(c) {
-                    let parsedCell = self._parseInline(c.trim()).replace(/\n/g, '<br>');
-                    return `<td>${parsedCell}</td>`;
-                }).join('\n');
-                tableHtml += `<tr>\n${rowContent}\n</tr>\n`;
-                currentCells = [];
-            }
-        }
-        tableHtml += '</table>';
-        return tableHtml;
-    }
-
-    /**
-     * INTERN: Verarbeitet Fluss-Formatierungen (Inline) mittels V1.2-RegEx
-     */
-    _parseInline(text) {
-        if (!text) return '';
-        let html = text;
-
-        const escapes = [];
-        html = html.replace(/\\(.)/g, function(match, char) {
-            escapes.push(char);
-            return '';
-        });
-
-        html = html.replace(/\/\/(( \s|$))/g, '$1');
-
-        let self = this;
-        const processHeading = function(pattern, callback) {
-            let match;
-            while ((match = pattern.exec(html)) !== null) {
-                const fullMatch = match[0];
-                const level = parseInt(match[1]);
-                const titleAndRest = match[2];
-                
-                let title = titleAndRest;
-                let rest = "";
-                const closeIdx = titleAndRest.indexOf('/#');
-                if (closeIdx !== -1) {
-                    title = titleAndRest.substring(0, closeIdx);
-                    rest = titleAndRest.substring(closeIdx + 2);
-                }
-
-                const result = callback(level, title.trim(), rest);
-                html = html.substring(0, match.index) + result + html.substring(match.index + fullMatch.length);
-            }
-        };
-
-        processHeading(/^([1-6])x#\s*(.*)/g, function(level, title, rest) {
-            const numStr = self._getAutoNumber(level);
-            const fullTitle = `${numStr} ${title}`;
-            const id = self._slugify(fullTitle);
-            self.headings.push({ level: level, text: fullTitle, id: id });
-            return `<h${level} id="${id}">${fullTitle}</h${level}>${rest}`;
-        });
-
-        processHeading(/^([1-6])-#\s*(.*)/g, function(level, title, rest) {
-            return `<h${level}>${title}</h${level}>${rest}`;
-        });
-
-        processHeading(/^([1-6])#\s*(.*)/g, function(level, title, rest) {
-            const id = self._slugify(title);
-            self.headings.push({ level: level, text: title, id: id });
-            return `<h${level} id="${id}">${title}</h${level}>${rest}`;
-        });
-
-        const inlineRules = [
-            { tag: 'strong', symbol: '\\*\\*' },
-            { tag: 'span style="font-weight: 500;"', symbol: '\\*' },
-            { tag: 'em', symbol: '%' },
-            { tag: 'u', symbol: '_' },
-            { tag: 'del', symbol: '~' },
-            { tag: 'mark', symbol: '=' },
-            { tag: 'sup', symbol: '\\^' },
-            { tag: 'sub', symbol: '°' },
-            { tag: 'code', symbol: '`' }
-        ];
-
-        for (let k = 0; k < inlineRules.length; k++) {
-            let rule = inlineRules[k];
-            let tagSimple = rule.tag.split(' ')[0];
-            
-            let regex = new RegExp(rule.symbol + '(.+?)\\\\' + rule.symbol, 'g');
-            html = html.replace(regex, `<${rule.tag}>$1</${tagSimple}>`);
-
-            let resetRegex = new RegExp(rule.symbol + '(.+?)(?=)', 'g');
-            html = html.replace(resetRegex, `<${rule.tag}>$1</${tagSimple}>`);
-        }
-        
-        html = html.replace(//g, '');
-
-        const alignMap = { 'l': 'left', 'r': 'right', 'c': 'center', 'j': 'justify' };
-        html = html.replace(/>([lrcj])\s+(.+?)\s*\/>/g, function(m, dir, content) {
-            return `<div style="text-align: ${alignMap[dir]};">${content}</div>`;
-        });
-
-        html = html.replace(/!\[([^\]]+)\s+w:(\d+)\]\(([^)]+)\)/g, '<img src="$3" alt="$1" style="width: $2px; height: auto;">');
-        html = html.replace(/!\[([^\]]+)\]\(([^)]+)\)/g, '<img src="$2" alt="$1">');
-        html = html.replace(/\[([^\]]+)\]\{([^}]+)\}/g, '<a href="$2" target="_blank" rel="noopener noreferrer">$1</a>');
-        html = html.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2">$1</a>');
-
-        html = html.replace(/\^x\[([^\]]+)\]\^x/g, '<span class="footnote-auto" title="$1">[*]</span>'); 
-        html = html.replace(/\^(\d+)\[([^\]]+)\]\^x/g, '<sup class="footnote-manual" title="$2">[$1]</sup>');
-
-        html = html.replace(//g, function(match, idx) {
-            return escapes[idx];
-        });
-
-        return html;
-    }
-
-    /**
-     * INTERN: Errechnet die nächste fortlaufende Kapitelnummer
-     */
-    _getAutoNumber(level) {
-        let idx = level - 1;
-        this.counters[idx]++;
-        for (let i = idx + 1; i < 6; i++) {
-            this.counters[i] = 0;
-        }
-        let activeParts = this.counters.slice(0, level);
-        return activeParts.join('.') + '.';
-    }
-
-    /**
-     * INTERN: Macht aus Text eine URL-konforme ID
-     */
-    _slugify(text) {
-        return text.toLowerCase()
-            .replace(/[^a-z0-9\s-]/g, '') 
-            .replace(/\s+/g, '-');        
-    }
-
-    /**
-     * INTERN: Erzeugt die fertige HTML-Liste des TOC und injiziert sie in den Block
-     */
-    _injectTOC(html) {
-        if (!html.includes('')) {
-            return html;
-        }
-        if (this.headings.length === 0) {
-            return html.replace('', '');
-        }
-
-        let tocListHtml = '<div class="simonup-toc">\n<ul>\n';
-        let currentLevel = 1;
-
-        for (let i = 0; i < this.headings.length; i++) {
-            let heading = this.headings[i];
-            if (heading.level > currentLevel) {
-                let diffUp = heading.level - currentLevel;
-                tocListHtml += '<ul>\n'.repeat(diffUp);
-            } else if (heading.level < currentLevel) {
-                let diffDown = currentLevel - heading.level;
-                tocListHtml += '</ul>\n'.repeat(diffDown);
-            }
-            currentLevel = heading.level;
-            tocListHtml += `<li><a href="#${heading.id}">${heading.text}</a></li>\n`;
-        }
-        
-        if (currentLevel > 1) {
-            let diffFinal = currentLevel - 1;
-            tocListHtml += '</ul>\n'.repeat(diffFinal);
-        }
-        tocListHtml += '</ul>\n</div>';
-
-        return html.replace('', tocListHtml);
-    }
-
     /**
      * INTERN: Fasst freie Listen-Elemente zusammen und generiert Absätze (p)
      */
@@ -739,54 +373,40 @@ class SimonUp {
         let listBuffer = [];
         let currentListType = null; 
 
-        const flushList = function() {
+        function flushList() {
             if (listBuffer.length > 0) {
-                let items = listBuffer.map(function(item) { return `  <li>${item}</li>`; }).join('\n');
-                processed.push(`<${currentListType}>\n${items}\n</${currentListType}>`);
+                let items = listBuffer.map(function(item) { return "  <li>" + item + "</li>"; }).join("\n");
+                processed.push("<" + currentListType + ">\n" + items + "\n</" + currentListType + ">");
                 listBuffer = [];
                 currentListType = null;
             }
-        };
+        }
 
-        const flushParagraph = function() {
+        function flushParagraph() {
             if (paragraphBuffer.length > 0) {
-                let pContent = paragraphBuffer.join('<br>');
-                processed.push(`<p>${pContent}</p>`);
+                let pContent = paragraphBuffer.join("<br>");
+                processed.push("<p>" + pContent + "</p>");
                 paragraphBuffer = [];
             }
-        };
+        }
 
         for (let i = 0; i < elements.length; i++) {
             let element = elements[i];
-            let isUlItem = element.startsWith('<ul-item>');
-            let isOlItem = element.startsWith('<ol-item>');
+            let isUlItem = element.startsWith("<ul-item>");
+            let isOlItem = element.startsWith("<ol-item>");
 
             if (isUlItem || isOlItem) {
                 flushParagraph();
-                let type = isUlItem ? 'ul' : 'ol';
-                let content = isUlItem ? element.replace(/<\/?ul-item>/g, '') : element.replace(/<\/?ol-item>/g, '');
+                let type = isUlItem ? "ul" : "ol";
+                let content = isUlItem ? element.replace(/<\/?ul-item>/g, "") : element.replace(/<\/?ol-item>/g, "");
                 
                 if (currentListType && currentListType !== type) {
                     flushList();
                 }
                 currentListType = type;
                 listBuffer.push(content);
-            } else if (element.startsWith('<') && !/^(<a>|<strong>|<em>|<u>|<del>|<mark>|<sup>|<sub>|<span>|<code>|<img>|<h\d)/i.test(element)) {
+            } else if (element.startsWith("<") && !/^(<a>|<strong>|<em>|<u>|<del>|<mark>|<sup>|<sub>|<span>|<code>|<img>|<h\d)/i.test(element)) {
                 flushList();
                 flushParagraph();
                 processed.push(element);
-            } else if (element.trim() === '') {
-                flushList();
-                flushParagraph();
-            } else {
-                flushList();
-                paragraphBuffer.push(element);
-            }
-        }
-
-        flushList();
-        flushParagraph();
-
-        return processed.join('\n');
-    }
-}
\ No newline at end of file
+            } else if (element.trim
\ No newline at end of file