460 lines
No EOL
17 KiB
JavaScript
460 lines
No EOL
17 KiB
JavaScript
/**
|
|
* SimonUp Core Compiler (Core.js) - Version 1.2.3
|
|
* 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);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Phase 1: Blöcke und Inline-Strukturen parsen
|
|
html = this._parseBlocks(html);
|
|
|
|
// Phase 2: Das Inhaltsverzeichnis nachträglich in die vorbereitete Box einsetzen
|
|
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];
|
|
|
|
// Block-Start erkennen (&typ meta)
|
|
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;
|
|
}
|
|
|
|
// Block-Ende erkennen mit /&
|
|
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));
|
|
}
|
|
}
|
|
}
|
|
|
|
// Automatischer Schutz: Falls am Dateiende ein Block nicht geschlossen wurde
|
|
if (inBlock && blockBuffer.length > 0) {
|
|
result.push(this._renderBlock(blockType, blockMeta, blockBuffer));
|
|
}
|
|
|
|
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 = '<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 += 'STRENG_GEHEIMER_TOC_PLATZHALTER\n';
|
|
tocWrapper += '</div>';
|
|
return tocWrapper;
|
|
|
|
case 'c':
|
|
const langClass = meta ? ` class="language-${meta}"` : '';
|
|
const escapedCode = content.replace(/&/g, '&').replace(/</g, '<').replace(/>/g, '>');
|
|
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: Robustes Rendern von Multi-line-Tabellen und Galerien
|
|
*/
|
|
_renderTable(meta, lines) {
|
|
let tableHtml = '<table>\n';
|
|
|
|
let colCount = 0;
|
|
if (meta) {
|
|
let metaParts = meta.trim().split(/\s+/);
|
|
if (metaParts.length === 1 && metaParts[0].endsWith('x')) {
|
|
colCount = parseInt(metaParts[0]);
|
|
} else {
|
|
colCount = metaParts.length;
|
|
}
|
|
}
|
|
|
|
let fullContent = lines.join('\n');
|
|
let rawCells = fullContent.split('|');
|
|
|
|
if (rawCells.length > 1 && rawCells[rawCells.length - 1].trim() === '') {
|
|
rawCells.pop();
|
|
}
|
|
|
|
let currentConfiguredCols = colCount || 1;
|
|
let cellIndex = 0;
|
|
|
|
tableHtml += '<tr>\n';
|
|
|
|
for (let i = 0; i < rawCells.length; i++) {
|
|
let cellText = rawCells[i].trim();
|
|
let parsedCell = this._parseInline(cellText).replace(/\n/g, '<br>');
|
|
tableHtml += ` <td>${parsedCell}</td>\n`;
|
|
|
|
cellIndex++;
|
|
|
|
if (cellIndex === currentConfiguredCols && i < rawCells.length - 1) {
|
|
tableHtml += '</tr>\n<tr>\n';
|
|
cellIndex = 0;
|
|
}
|
|
}
|
|
|
|
tableHtml += '</tr>\n</table>';
|
|
return tableHtml;
|
|
}
|
|
|
|
/**
|
|
* INTERN: Verarbeitet Fluss-Formatierungen (Inline) ohne HTML-Zerstörung
|
|
*/
|
|
_parseInline(text) {
|
|
if (!text) return '';
|
|
let html = text;
|
|
|
|
const escapes = [];
|
|
html = html.replace(/\\(.)/g, function(match, char) {
|
|
escapes.push(char);
|
|
return `__ESCAPED_CHAR_${escapes.length - 1}__`;
|
|
});
|
|
|
|
// 1. Überschriften ERST parsen (bevor HTML-Tags im Fluss entstehen)
|
|
html = html.replace(/^([1-6])x#\s*(.*)/gm, (match, level, titleAndRest) => {
|
|
let { title, rest } = this._extractHeadingRest(titleAndRest);
|
|
const numStr = this._getAutoNumber(parseInt(level));
|
|
const fullTitle = `${numStr} ${title}`;
|
|
const id = this._slugify(fullTitle);
|
|
this.headings.push({ level: parseInt(level), text: title, id: id });
|
|
return `<h${level} id="${id}">${fullTitle}</h${level}>${rest}`;
|
|
});
|
|
|
|
html = html.replace(/^([1-6])-#\s*(.*)/gm, (match, level, titleAndRest) => {
|
|
let { title, rest } = this._extractHeadingRest(titleAndRest);
|
|
return `<h${level}>${title}</h${level}>${rest}`;
|
|
});
|
|
|
|
html = html.replace(/^([1-6])#\s*(.*)/gm, (match, level, titleAndRest) => {
|
|
let { title, rest } = this._extractHeadingRest(titleAndRest);
|
|
const id = this._slugify(title);
|
|
this.headings.push({ level: parseInt(level), text: title, id: id });
|
|
return `<h${level} id="${id}">${title}</h${level}>${rest}`;
|
|
});
|
|
|
|
// Medien & Links verarbeiten
|
|
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>');
|
|
|
|
// Hilfsfunktion: Führt Ersetzungen nur AUSSERHALB von HTML-Tags <...> aus
|
|
const replaceOutsideTags = (regex, replacement) => {
|
|
const masterRegex = new RegExp(/(<[^>]+>)/g.source + '|' + regex.source, 'g');
|
|
html = html.replace(masterRegex, (match, p1) => {
|
|
if (p1) return p1; // HTML-Tags überspringen
|
|
|
|
const innerMatch = regex.exec(match);
|
|
if (innerMatch) {
|
|
if (typeof replacement === 'function') {
|
|
return replacement(...innerMatch);
|
|
}
|
|
let res = replacement;
|
|
for (let idx = 1; idx < innerMatch.length; idx++) {
|
|
res = res.replace(new RegExp('\\$' + idx, 'g'), innerMatch[idx]);
|
|
}
|
|
return res;
|
|
}
|
|
return match;
|
|
});
|
|
};
|
|
|
|
// 2. Formatierung für FETT (**text/** oder **text/)
|
|
replaceOutsideTags(/\*\*(.+?)(?:\/\*\*|\/|\*\*|$)/, '<strong>$1</strong>');
|
|
|
|
// 3. Formatierung für MEDIUM (*text/* oder *text/)
|
|
replaceOutsideTags(/\*(.+?)(?:\/\*|\/|\*|$)/, '<span style="font-weight: 500;">$1</span>');
|
|
|
|
// 4. Standard Text-Inline-Rules via Symbol-Paar/Slash-Abschluss
|
|
const inlineRules = [
|
|
{ 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];
|
|
|
|
// Unterstützt %text/% sowie das Fallback %text am Zeilenende
|
|
replaceOutsideTags(new RegExp(rule.symbol + '(.+?)(?:\\/' + rule.symbol + '|\\/|' + rule.symbol + '|$)'), `<${rule.tag}>$1</${tagSimple}>`);
|
|
}
|
|
|
|
// Ausrichtungen & Fußnoten
|
|
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(/\^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(/__ESCAPED_CHAR_(\d+)__/g, function(match, idx) {
|
|
return escapes[idx];
|
|
});
|
|
|
|
return html;
|
|
}
|
|
|
|
/**
|
|
* INTERN: Hilfsmethode zur Extraktion des optionalen /# Abschlusses bei Überschriften
|
|
*/
|
|
_extractHeadingRest(text) {
|
|
let title = text;
|
|
let rest = "";
|
|
const closeIdx = text.indexOf('/#');
|
|
if (closeIdx !== -1) {
|
|
title = text.substring(0, closeIdx);
|
|
rest = text.substring(closeIdx + 2);
|
|
}
|
|
return { title: title.trim(), rest: rest };
|
|
}
|
|
|
|
/**
|
|
* 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) {
|
|
const placeholder = 'STRENG_GEHEIMER_TOC_PLATZHALTER';
|
|
|
|
if (!html.includes(placeholder)) {
|
|
return html;
|
|
}
|
|
|
|
if (this.headings.length === 0) {
|
|
return html.replace(placeholder, '');
|
|
}
|
|
|
|
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(placeholder, tocListHtml);
|
|
}
|
|
|
|
/**
|
|
* INTERN: Fasst freie Listen-Elemente zusammen und generiert Absätze (p)
|
|
*/
|
|
_processParagraphsAndLists(elements) {
|
|
let processed = [];
|
|
let paragraphBuffer = [];
|
|
let listBuffer = [];
|
|
let currentListType = null;
|
|
|
|
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 + ">");
|
|
listBuffer = [];
|
|
currentListType = null;
|
|
}
|
|
}
|
|
|
|
function flushParagraph() {
|
|
if (paragraphBuffer.length > 0) {
|
|
let pContent = paragraphBuffer.join("<br>");
|
|
processed.push("<p>" + pContent + "</p>");
|
|
paragraphBuffer = [];
|
|
}
|
|
}
|
|
|
|
for (let i = 0; i < elements.length; i++) {
|
|
let element = elements[i];
|
|
if (!element) continue;
|
|
|
|
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, "");
|
|
|
|
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[1-6])/i.test(element)) {
|
|
flushList();
|
|
flushParagraph();
|
|
processed.push(element);
|
|
} else {
|
|
flushList();
|
|
if (element.trim() === "") {
|
|
flushParagraph();
|
|
} else {
|
|
paragraphBuffer.push(element);
|
|
}
|
|
}
|
|
}
|
|
|
|
flushList();
|
|
flushParagraph();
|
|
|
|
return processed.join("\n");
|
|
}
|
|
} |