diff --git a/Core.js b/Core.js
index 16c3bc3..9ec77cc 100644
--- a/Core.js
+++ b/Core.js
@@ -363,49 +363,384 @@ class SimonUp {
 
         return html.replace('', tocListHtml);
     }
+/**
+ * SimonUp Core Compiler (Core.js) - Version 1.2
+ * Eine moderne, fluss- und blockorientierte Auszeichnungssprache.
+ */
+
+// Globale Hilfsfunktionen außerhalb der Klasse, um Parsing-Verschachtelungen zu verhindern
+function _suSlugify(text) {
+    if (!text) return '';
+    return text.toLowerCase().replace(/[^a-z0-9\s-]/g, '').replace(/\s+/g, '-');
+}
+
+class SimonUp {
+    constructor() {
+        this.plugins = [];
+        this.headings = [];
+        this.counters = [0, 0, 0, 0, 0, 0];
+    }
+
+    use(plugin) {
+        this.plugins.push(plugin);
+        return this;
+    }
+
+    parse(text) {
+        this.headings = [];
+        this.counters = [0, 0, 0, 0, 0, 0];
+        var html = text;
+
+        if (this.plugins && this.plugins.length > 0) {
+            for (var 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 (var j = 0; j < this.plugins.length; j++) {
+                if (this.plugins[j].after) {
+                    html = this.plugins[j].after(html);
+                }
+            }
+        }
+
+        return html;
+    }
+
+    _parseBlocks(text) {
+        var lines = text.replace(/\r\n/g, '\n').split('\n');
+        var result = [];
+        var inBlock = false;
+        var blockType = null;
+        var blockMeta = ""; 
+        var blockBuffer = [];
+
+        for (var i = 0; i < lines.length; i++) {
+            var line = lines[i];
+
+            if (!inBlock && line.startsWith('&') && line.trim().length > 1) {
+                inBlock = true;
+                var fullHeader = line.substring(1).trim();
+                var 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() === '&') {
+                result.push(this._renderBlock(blockType, blockMeta, blockBuffer));
+                inBlock = false;
+                blockType = null;
+                blockMeta = "";
+                continue;
+            }
+
+            if (inBlock) {
+                blockBuffer.push(line);
+            } else {
+                var trimmed = line.trim();
+                
+                if (trimmed === '___') {
+                    result.push('<hr>');
+                } else if (trimmed.startsWith('- ')) {
+                    var insideUl = this._parseInline(line.replace(/^\s*-\s+/, ''));
+                    result.push('<ul-item>' + insideUl + '</ul-item>');
+                } else if (/^\d+\.\s+/.test(trimmed)) {
+                    var cleanLine = line.replace(/^\s*\d+\.\s+/, '');
+                    var insideOl = this._parseInline(cleanLine);
+                    result.push('<ol-item>' + insideOl + '</ol-item>');
+                } else {
+                    result.push(this._parseInline(line));
+                }
+            }
+        }
+
+        return this._processParagraphsAndLists(result);
+    }
+
+    _renderBlock(type, meta, lines) {
+        var content = lines.join('\n');
+        var self = this;
+
+        switch (type) {
+            case 'toc':
+                var tocWrapper = '';
+                if (meta || content.trim()) {
+                    tocWrapper = '<div class="simonup-toc-wrapper">\n';
+                    if (meta) {
+                        tocWrapper += '<h2>' + meta + '</h2>\n';
+                    }
+                    if (content.trim()) {
+                        var 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': 
+                var langClass = meta ? ' class="language-' + meta + '"' : '';
+                var escapedCode = content.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+                return '<pre><code' + langClass + '>' + escapedCode + '</code></pre>';
+
+            case 'q': 
+                var qContent = lines.map(function(l) { return self._parseInline(l); }).join('<br>');
+                return '<blockquote>' + qContent + '</blockquote>';
+
+            case 'b': 
+                var bContent = lines.map(function(l) { return self._parseInline(l); }).join('<br>');
+                return '<div class="bible-block">' + bContent + '</div>';
+
+            case 'f': 
+                var fSummary = meta || 'Details';
+                var 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': 
+                var iColor = meta || '#ff6347';
+                var 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:
+                var defContent = lines.map(function(l) { return self._parseInline(l); }).join('<br>');
+                return '<div class="block-' + type + '">' + defContent + '</div>';
+        }
+    }
+
+    _renderTable(meta, lines) {
+        var tableHtml = '<table>\n';
+        var currentCells = [];
+        var cellBuffer = [];
+        var self = this;
+
+        for (var i = 0; i < lines.length; i++) {
+            var line = lines[i];
+            var parts = line.split('|');
+            for (var j = 0; j < parts.length; j++) {
+                var 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) {
+                var rowContent = currentCells.map(function(c) {
+                    var 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;
+    }
+
+    _parseInline(text) {
+        if (!text) return '';
+        var html = text;
+
+        var escapes = [];
+        html = html.replace(/\\(.)/g, function(match, char) {
+            escapes.push(char);
+            return '';
+        });
+
+        html = html.replace(/\/\/(\s|$)/g, '$1');
+
+        var self = this;
+        var processHeading = function(pattern, callback) {
+            var match;
+            while ((match = pattern.exec(html)) !== null) {
+                var fullMatch = match[0];
+                var level = parseInt(match[1]);
+                var titleAndRest = match[2];
+                
+                var title = titleAndRest;
+                var rest = "";
+                var closeIdx = titleAndRest.indexOf('/#');
+                if (closeIdx !== -1) {
+                    title = titleAndRest.substring(0, closeIdx);
+                    rest = titleAndRest.substring(closeIdx + 2);
+                }
+
+                var 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) {
+            var numStr = self._getAutoNumber(level);
+            var fullTitle = numStr + ' ' + title;
+            var id = _suSlugify(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) {
+            var id = _suSlugify(title);
+            self.headings.push({ level: level, text: title, id: id });
+            return '<h' + level + ' id="' + id + '">' + title + '</h' + level + '>' + rest;
+        });
+
+        var 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 (var k = 0; k < inlineRules.length; k++) {
+            var rule = inlineRules[k];
+            var tagSimple = rule.tag.split(' ')[0];
+            
+            var regex = new RegExp(rule.symbol + '(.+?)\\x2F' + rule.symbol, 'g');
+            html = html.replace(regex, '<' + rule.tag + '>$1</' + tagSimple + '>');
+
+            var resetRegex = new RegExp(rule.symbol + '(.+?)(?=)', 'g');
+            html = html.replace(resetRegex, '<' + rule.tag + '>$1</' + tagSimple + '>');
+        }
+        
+        html = html.replace(//g, '');
+
+        var 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"></a>');
+
+        html = html.replace(/\^x\[([^\]]+)\]\^/g, '<span class="footnote-auto" title="$1">[*]</span>'); 
+        html = html.replace(/\^(\d+)\[([^\]]+)\]\^/g, '<sup class="footnote-manual" title="$2">[$1]</sup>');
+
+        html = html.replace(//g, function(match, idx) {
+            return escapes[idx];
+        });
+
+        return html;
+    }
+
+    _getAutoNumber(level) {
+        var idx = level - 1;
+        this.counters[idx]++;
+        for (var i = idx + 1; i < 6; i++) {
+            this.counters[i] = 0;
+        }
+        var activeParts = this.counters.slice(0, level);
+        return activeParts.join('.') + '.';
+    }
+
+    _injectTOC(html) {
+        if (!html.includes('')) {
+            return html;
+        }
+        if (this.headings.length === 0) {
+            return html.replace('', '');
+        }
+
+        var tocListHtml = '<div class="simonup-toc">\n<ul>\n';
+        var currentLevel = 1;
+
+        for (var i = 0; i < this.headings.length; i++) {
+            var heading = this.headings[i];
+            if (heading.level > currentLevel) {
+                var diffUp = heading.level - currentLevel;
+                tocListHtml += '<ul>\n'.repeat(diffUp);
+            } else if (heading.level < currentLevel) {
+                var 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) {
+            var 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)
-     */
     _processParagraphsAndLists(elements) {
-        let processed = [];
-        let paragraphBuffer = [];
-        let listBuffer = [];
-        let currentListType = null; 
+        var processed = [];
+        var paragraphBuffer = [];
+        var listBuffer = [];
+        var currentListType = null; 
 
-        const flushList = function() {
+        var flushList = function() {
             if (listBuffer.length > 0) {
-                let items = listBuffer.map(function(item) { return `  <li>${item}</li>`; }).join('\n');
-                processed.push(`<${currentListType}>\n${items}\n</${currentListType}>`);
+                var items = listBuffer.map(function(item) { return '  <li>' + item + '</li>'; }).join('\n');
+                processed.push('<' + currentListType + '>\n' + items + '\n</' + currentListType + '>');
                 listBuffer = [];
                 currentListType = null;
             }
         };
 
-        const flushParagraph = function() {
+        var flushParagraph = function() {
             if (paragraphBuffer.length > 0) {
-                let pContent = paragraphBuffer.join('<br>');
-                processed.push(`<p>${pContent}</p>`);
+                var 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>');
+        for (var i = 0; i < elements.length; i++) {
+            var element = elements[i];
+            var isUlItem = element.startsWith('<ul-item>');
+            var 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, '');
+                var type = isUlItem ? 'ul' : 'ol';
+                var 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);
@@ -423,4 +758,4 @@ class SimonUp {
 
         return processed.join('\n');
     }
-}
\ No newline at end of file
+}