math_cms/scripts/katex-render.mjs

#!/usr/bin/env node
/**
 * KaTeX 服务端渲染脚本
 * 用法: echo "HTML内容" | node katex-render.js
 * 或:   node katex-render.js < input.html > output.html
 *
 * 将 HTML 中的 LaTeX 公式渲染为 KaTeX HTML
 */

import { createRequire } from 'module';
const require = createRequire(import.meta.url);

// 尝试多个路径加载 KaTeX
let katex;
const possiblePaths = [
    '/usr/local/lib/node_modules/katex',        // npm -g 全局安装路径
    '/usr/lib/node_modules/katex',              // Alpine 系统路径
    'katex',                                    // 本地 node_modules
];

let loadError = null;
for (const modulePath of possiblePaths) {
    try {
        katex = require(modulePath);
        break;
    } catch (e) {
        loadError = e;
    }
}

if (!katex) {
    console.error('Error: KaTeX module not found.');
    console.error('Tried paths:', possiblePaths.join(', '));
    if (loadError) console.error('Last error:', loadError.message);
    process.exit(1);
}

// 读取标准输入
let input = '';

process.stdin.setEncoding('utf8');

process.stdin.on('readable', () => {
    let chunk;
    while ((chunk = process.stdin.read()) !== null) {
        input += chunk;
    }
});

process.stdin.on('end', () => {
    try {
        const output = renderMathInHtml(input);
        process.stdout.write(output);
    } catch (error) {
        console.error('KaTeX render error:', error.message);
        process.exit(1);
    }
});

/**
 * 解码 HTML 实体
 */
function decodeHtmlEntities(text) {
    return text
        .replace(/&lt;/g, '<')
        .replace(/&gt;/g, '>')
        .replace(/&amp;/g, '&')
        .replace(/&quot;/g, '"')
        .replace(/&#39;/g, "'")
        .replace(/&apos;/g, "'")
        .replace(/&nbsp;/g, ' ');
}

/**
 * 编码 HTML 实体（用于安全输出）
 */
function encodeHtmlEntities(text) {
    return text
        .replace(/&/g, '&amp;')
        .replace(/</g, '&lt;')
        .replace(/>/g, '&gt;');
}

/**
 * 渲染 HTML 中的所有数学公式
 */
function renderMathInHtml(html) {
    // 保护 script/style/pre/textarea，避免把JS/CSS代码里的 $...$ 误当成公式
    const protectedBlocks = [];
    const protectedHtml = html.replace(
        /<(script|style|textarea|pre)\b[\s\S]*?<\/\1>/gi,
        (block) => {
            const marker = `__KATEX_PROTECTED_BLOCK_${protectedBlocks.length}__`;
            protectedBlocks.push(block);
            return marker;
        }
    );

    // 定界符配置（按优先级排序）
    const delimiters = [
        { left: '$$', right: '$$', display: true },
        { left: '\\[', right: '\\]', display: true },
        { left: '\\(', right: '\\)', display: false },
        { left: '$', right: '$', display: false },
    ];

    let result = protectedHtml;

    // 按顺序处理每种定界符
    for (const delimiter of delimiters) {
        result = processDelimiter(result, delimiter.left, delimiter.right, delimiter.display);
    }

    // 恢复被保护的代码块
    return result.replace(/__KATEX_PROTECTED_BLOCK_(\d+)__/g, (_, idx) => {
        const i = Number(idx);
        return Number.isInteger(i) && protectedBlocks[i] ? protectedBlocks[i] : '';
    });
}

/**
 * 处理特定定界符的公式
 */
function processDelimiter(html, left, right, displayMode) {
    // 转义正则特殊字符
    const escapeRegex = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');

    const leftEscaped = escapeRegex(left);
    const rightEscaped = escapeRegex(right);

    // 构建正则表达式
    // 【修复】允许数学符号 < 和 >，只排除明确的 HTML 标签（如 <span>, </div>）
    let pattern;
    if (left === '$' && right === '$') {
        // 单个 $...$：不匹配 $$，允许 < > 但不匹配换行
        pattern = new RegExp(`(?<!\\$)\\$(?!\\$)([^$\\n]+?)(?<!\\$)\\$(?!\\$)`, 'g');
    } else if (left === '$$' && right === '$$') {
        // $$...$$：允许多行和 < >
        pattern = new RegExp(`\\$\\$([\\s\\S]*?)\\$\\$`, 'g');
    } else {
        // \(...\) 和 \[...\]：允许 < >
        pattern = new RegExp(`${leftEscaped}([\\s\\S]*?)${rightEscaped}`, 'g');
    }

    return html.replace(pattern, (match, latex) => {
        try {
            // 清理 LaTeX 内容 - 先解码 HTML 实体
            let cleanLatex = decodeHtmlEntities(latex.trim());

            // 跳过空内容
            if (!cleanLatex) {
                return match;
            }

            // 【新增】跳过包含 HTML 标签的内容（如 <span>, </div>, <br>）
            // 但允许数学符号 < 和 >（如 a > 0, x < y）
            if (/<\/?[a-zA-Z][^>]*>/.test(cleanLatex)) {
                return match;
            }

            // 【修复】处理公式内的换行符：将 \n 替换成空格，避免破坏公式
            // 使用负向前瞻 (?![a-zA-Z]) 避免误伤 LaTeX 命令如 \neq, \ne, \newline, \nu 等
            cleanLatex = cleanLatex.replace(/\\n(?![a-zA-Z])/g, ' ').replace(/\n/g, ' ');

            // 渲染 KaTeX
            const rendered = katex.renderToString(cleanLatex, {
                displayMode: displayMode,
                throwOnError: false,
                strict: false,
                trust: true,
                output: 'html',
            });

            return rendered;
        } catch (error) {
            // 渲染失败时保留原始内容
            // console.error(`KaTeX error for "${latex.substring(0, 50)}...":`, error.message);
            return match;
        }
    });
}