更新数据截止日2026.01.08

static/js/markdown-parser.js

@@ -0,0 +1,311 @@
+/**
+ * 基础Markdown解析器
+ * 支持标题、粗体、斜体、列表、链接、图片、代码、引用等基础语法
+ */
+class MarkdownParser {
+    constructor() {
+        this.patterns = {
+            heading: /^(#{1,6})\s+(.+)$/gm,
+            bold: /\*\*(.*?)\*\*/g,
+            italic: /\*(.*?)\*/g,
+            inlineCode: /`(.*?)`/g,
+            image: /!\[(.*?)]\((.*?)\)/g,
+            base64Image: /!\[(.*?)]\((data:image\/[^;]+;base64,[^\)]+)\)/gi,
+            imageLink: /\[(.*?)]\((.*?\.(?:jpg|jpeg|png|gif|bmp|webp|svg))\s*(?:"(.*?)")?\)/gi,
+            link: /\[(.*?)]\((?!.*\.(?:jpg|jpeg|png|gif|bmp|webp|svg))(.*?)\)/g,
+            blockquote: /^>\s+(.+)$/gm,
+            unorderedList: /^\s*[-*+]\s+(.+)$/gm,
+            orderedList: /^\d+\.\s+(.+)$/gm,
+            codeBlock: /```.*?\n([\s\S]*?)```/g,
+            horizontalRule: /^---$/gm,
+            comment: /<!--([\s\S]*?)-->/g
+        };
+    }
+
+    /**
+     * 解析Markdown文本为HTML
+     * @param {string} markdown - Markdown文本
+     * @returns {string} - HTML文本
+     */
+    parse(markdown) {
+        let html = markdown;
+
+        // 处理代码块（先处理，避免其他语法干扰）
+        html = html.replace(this.patterns.codeBlock, (match, code) => {
+            // 保留代码内部的换行符，只去除首尾空白
+            let codeLines = code.split('\n');
+            let result = '<pre>';
+            for (let i in codeLines) {
+                if (codeLines[i].trim() === '') {
+                    continue;
+                } else {
+                    result += `<code>${codeLines[i]}</code><br>`;
+                }
+
+            }
+            result += '</pre>';
+            return result;
+        });
+
+
+        // 处理块引用
+        html = html.replace(this.patterns.blockquote, (match, text) => {
+            return `<blockquote>${this.parseInline(text)}</blockquote>`;
+        });
+
+        // 处理水平分割线
+        html = html.replace(this.patterns.horizontalRule, '<hr>');
+
+        // 处理注释（保留HTML注释）
+        html = html.replace(this.patterns.comment, '<!--$1-->');
+
+        // 处理列表（先处理有序列表，再处理无序列表，避免冲突）
+        html = this.processLists(html);
+
+        // 处理段落（将连续文本包装为段落）
+        html = this.wrapParagraphs(html);
+
+        return html;
+    }
+
+    /**
+     * 解析行内元素
+     * @param {string} text - 文本内容
+     * @returns {string} - 解析后的HTML
+     */
+    parseInline(text) {
+        let html = text;
+
+        // 处理粗体
+        html = html.replace(this.patterns.bold, '<strong>$1</strong>');
+
+        // 处理斜体
+        html = html.replace(this.patterns.italic, '<em>$1</em>');
+
+        // 处理行内代码
+        html = html.replace(this.patterns.inlineCode, '<code>$1</code>');
+
+        // 处理普通图片格式 ![alt](url)
+        html = html.replace(this.patterns.image, '<img width="100%" src="$2" alt="$1">');
+
+        // 处理base64图片格式 ![alt](data:image/...)
+        html = html.replace(this.patterns.base64Image, '<img width="100%" src="$2" alt="$1">');
+
+        // 处理图片链接格式 [alt](image.jpg "title")
+        html = html.replace(this.patterns.imageLink, (match, alt, src, title) => {
+            const titleAttr = title ? ` title="${title}"` : '';
+            return `<img width="100%" src="${src}" alt="${alt}"${titleAttr}>`;
+        });
+
+        // 处理链接
+        html = html.replace(this.patterns.link, '<a href="$2">$1</a>');
+
+        return html;
+    }
+
+    /**
+     * 处理所有列表，先识别列表类型再处理列表项
+     * @param {string} html - HTML文本
+     * @returns {string} - 处理后的HTML
+     */
+    processLists(html) {
+        // 先识别并标记列表类型
+        const lines = html.split('\n');
+        let result = '';
+        let currentListType = '';
+        let listItems = [];
+
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i].trim();
+            
+            if (line.match(/^\d+\.\s/)) {
+                // 有序列表项
+                if (currentListType !== 'ol') {
+                    // 结束前一个列表
+                    if (listItems.length > 0) {
+                        result += this.wrapListItems(listItems, currentListType);
+                        listItems = [];
+                    }
+                    currentListType = 'ol';
+                }
+                const content = line.replace(/^\d+\.\s+/, '');
+                listItems.push(`<li>${this.parseInline(content)}</li>`);
+            } else if (line.match(/^[-*+]\s/)) {
+                // 无序列表项
+                if (currentListType !== 'ul') {
+                    // 结束前一个列表
+                    if (listItems.length > 0) {
+                        result += this.wrapListItems(listItems, currentListType);
+                        listItems = [];
+                    }
+                    currentListType = 'ul';
+                }
+                const content = line.replace(/^[-*+]\s+/, '');
+                listItems.push(`<li>${this.parseInline(content)}</li>`);
+            } else {
+                // 非列表项
+                if (listItems.length > 0) {
+                    result += this.wrapListItems(listItems, currentListType);
+                    listItems = [];
+                    currentListType = '';
+                }
+                result += lines[i] + '\n';
+            }
+        }
+
+        // 处理最后一个列表
+        if (listItems.length > 0) {
+            result += this.wrapListItems(listItems, currentListType);
+        }
+
+        return result;
+    }
+
+    /**
+     * 包装列表项
+     * @param {Array} listItems - 列表项数组
+     * @param {string} listType - 列表类型（ul或ol）
+     * @returns {string} - 包装后的HTML列表
+     */
+    wrapListItems(listItems, listType) {
+        if (listItems.length === 0) return '';
+        
+        const listTag = listType === 'ol' ? 'ol' : 'ul';
+        return `<${listTag}>\n${listItems.join('\n')}\n</${listTag}>\n`;
+    }
+
+
+
+    /**
+     * 包装段落，保留Markdown原有换行
+     * @param {string} html - HTML文本
+     * @returns {string} - 包装后的HTML
+     */
+    wrapParagraphs(html) {
+        const lines = html.split('\n');
+        let result = '';
+        let currentParagraph = '';
+
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            const trimmedLine = line.trim();
+
+            if (!trimmedLine) {
+                // 空行，结束当前段落
+                if (currentParagraph) {
+                    // 检查当前段落是否已经是块级元素
+                    if (!currentParagraph.match(/^<(h[1-6]|blockquote|ul|ol|li|pre|hr)/)) {
+                        result += `<p>${this.parseInline(currentParagraph)}</p>`;
+                    } else {
+                        result += currentParagraph;
+                    }
+                    currentParagraph = '';
+                }
+                result += '\n';
+            } else if (trimmedLine.match(/^<(h[1-6]|blockquote|ul|ol|li|pre|hr)/)) {
+                // 已经是块级元素，直接添加
+                if (currentParagraph) {
+                    if (!currentParagraph.match(/^<(h[1-6]|blockquote|ul|ol|li|pre|hr)/)) {
+                        result += `<p>${this.parseInline(currentParagraph)}</p>`;
+                    } else {
+                        result += currentParagraph;
+                    }
+                    currentParagraph = '';
+                }
+                result += line + '\n';
+            } else {
+                // 保留原有换行，不合并为一行
+                if (currentParagraph) {
+                    currentParagraph += '\n' + line;
+                } else {
+                    currentParagraph = line;
+                }
+            }
+        }
+
+        // 处理最后一个段落
+        if (currentParagraph) {
+            if (!currentParagraph.match(/^<(h[1-6]|blockquote|ul|ol|li|pre|hr)/)) {
+                result += `<p>${this.parseInline(currentParagraph)}</p>`;
+            } else {
+                result += currentParagraph;
+            }
+        }
+
+        return result;
+    }
+
+    /**
+     * HTML转义，支持保留<br>标签
+     * @param {string} text - 原始文本
+     * @returns {string} - 转义后的文本
+     */
+    escapeHTML(text) {
+        // 首先转义所有HTML特殊字符
+        const escapedText = text
+            .replace(/&/g, '&amp;')
+            .replace(/</g, '&lt;')
+            .replace(/>/g, '&gt;')
+            .replace(/"/g, '&quot;')
+            .replace(/'/g, '&#39;');
+        
+        // 然后恢复<br>标签的功能
+        return escapedText
+            .replace(/&lt;br\s*\/?&gt;/gi, '<br>')
+            .replace(/&lt;br\s*\/?&gt;/gi, '<br>')
+            .replace(/\\n/g, '<br>'); // 也支持\n换行符
+    }
+
+    /**
+     * 专门解析表格（与MergeTableParser配合使用）
+     * @param {string} markdown - Markdown表格文本
+     * @returns {string} - HTML表格
+     */
+    parseTable(markdown) {
+        // 使用MergeTableParser处理表格
+        if (typeof MergeTableParser !== 'undefined') {
+            const tableParser = new MergeTableParser();
+            return tableParser.parseMarkdownTable(markdown);
+        }
+        return markdown;
+    }
+
+    /**
+     * 完整解析Markdown，包含表格处理
+     * @param {string} markdown - 完整Markdown文本
+     * @returns {string} - 完整HTML
+     */
+    parseFull(markdown) {
+        let html = markdown;
+
+        // 先处理标题，避免表格干扰
+        html = html.replace(this.patterns.heading, (match, hashes, text) => {
+            const level = hashes.length;
+            return `<h${level}>${this.parseInline(text)}</h${level}>`;
+        });
+
+        // 再提取并处理表格
+        const tableRegex = /(\|.*?\|\s*\n)+/g;
+        html = html.replace(tableRegex, (match) => {
+            // 检查是否是有效的表格格式
+            const lines = match.trim().split('\n');
+            if (lines.length >= 2 && lines.every(line => line.trim().startsWith('|') && line.trim().endsWith('|'))) {
+                return this.parseTable(match);
+            }
+            return match;
+        });
+
+        // 然后处理其他Markdown语法
+        return this.parse(html);
+    }
+}
+
+// 导出为全局变量
+if (typeof window !== 'undefined') {
+    window.MarkdownParser = MarkdownParser;
+}
+
+// 使用示例
+if (typeof module !== 'undefined' && module.exports) {
+    module.exports = MarkdownParser;
+}