@lyhue1991/wxgzh 0.1.0

package/dist/core/converter.js

@@ -0,0 +1,656 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderMarkdownToHtml = renderMarkdownToHtml;
+exports.extractPublishableContent = extractPublishableContent;
+exports.readHtmlMetadata = readHtmlMetadata;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const cheerio = __importStar(require("cheerio"));
+const highlight_js_1 = __importDefault(require("highlight.js"));
+const juice_1 = __importDefault(require("juice"));
+const markdown_it_1 = __importDefault(require("markdown-it"));
+const markdown_it_mathjax3_1 = __importDefault(require("markdown-it-mathjax3"));
+const themes_1 = require("./themes");
+const HIGHLIGHT_INLINE_CSS = `
+.hljs-comment,
+.hljs-quote {
+  color: #6a9955;
+  font-style: italic;
+}
+
+.hljs-keyword,
+.hljs-selector-tag,
+.hljs-literal,
+.hljs-section,
+.hljs-link,
+.hljs-meta .hljs-keyword {
+  color: #c586c0;
+  font-weight: 600;
+}
+
+.hljs-string,
+.hljs-regexp,
+.hljs-symbol,
+.hljs-bullet,
+.hljs-addition,
+.hljs-template-tag,
+.hljs-template-variable {
+  color: #ce9178;
+}
+
+.hljs-number,
+.hljs-literal,
+.hljs-meta,
+.hljs-selector-attr,
+.hljs-selector-pseudo,
+.hljs-attr,
+.hljs-attribute {
+  color: #b5cea8;
+}
+
+.hljs-built_in,
+.hljs-type,
+.hljs-name,
+.hljs-selector-class,
+.hljs-selector-id {
+  color: #4ec9b0;
+}
+
+.hljs-title,
+.hljs-title.class_,
+.hljs-title.class_.inherited__,
+.hljs-title.function_,
+.hljs-function .hljs-title,
+.hljs-class .hljs-title {
+  color: #dcdcaa;
+}
+
+.hljs-variable,
+.hljs-params,
+.hljs-operator,
+.hljs-punctuation,
+.hljs-subst,
+.hljs-deletion,
+.hljs-property {
+  color: #d4d4d4;
+}
+
+.hljs-emphasis {
+  font-style: italic;
+}
+
+.hljs-strong {
+  font-weight: 700;
+}
+`;
+const WECHAT_BLOCKQUOTE_INLINE_CSS = `
+blockquote,
+q {
+  margin: 1.2em 3% !important;
+  padding: 0 0 0 1em !important;
+  border: 0 !important;
+  border-left: 4px solid #d9d9d9 !important;
+  border-radius: 0 !important;
+  background: transparent !important;
+  color: #8c8c8c !important;
+  quotes: none;
+}
+
+blockquote p,
+blockquote ul,
+blockquote ol,
+blockquote section,
+blockquote pre,
+blockquote table,
+q p,
+q ul,
+q ol,
+q section,
+q pre,
+q table {
+  margin: 0.45em 0 !important;
+  color: inherit !important;
+}
+
+blockquote p:first-child,
+blockquote ul:first-child,
+blockquote ol:first-child,
+blockquote section:first-child,
+blockquote pre:first-child,
+blockquote table:first-child,
+q p:first-child,
+q ul:first-child,
+q ol:first-child,
+q section:first-child,
+q pre:first-child,
+q table:first-child {
+  margin-top: 0 !important;
+}
+
+blockquote p:last-child,
+blockquote ul:last-child,
+blockquote ol:last-child,
+blockquote section:last-child,
+blockquote pre:last-child,
+blockquote table:last-child,
+q p:last-child,
+q ul:last-child,
+q ol:last-child,
+q section:last-child,
+q pre:last-child,
+q table:last-child {
+  margin-bottom: 0 !important;
+}
+`;
+const WECHAT_TABLE_INLINE_CSS = `
+section.tbl-wrapper {
+  margin: 1.4em 3% !important;
+  padding: 0 0 10px 0 !important;
+  overflow-x: auto !important;
+  overflow-y: hidden !important;
+  -webkit-overflow-scrolling: touch;
+  background: transparent !important;
+}
+
+section.tbl-wrapper table {
+  width: max-content !important;
+  min-width: 100% !important;
+  margin: 0 !important;
+  border-collapse: collapse !important;
+  border-spacing: 0 !important;
+  table-layout: auto !important;
+  background: #ffffff !important;
+  font-size: 15px !important;
+  line-height: 1.75 !important;
+}
+
+section.tbl-wrapper thead,
+section.tbl-wrapper tbody,
+section.tbl-wrapper tr {
+  background: #ffffff !important;
+}
+
+section.tbl-wrapper th,
+section.tbl-wrapper td {
+  min-width: 120px !important;
+  padding: 14px 16px !important;
+  border: 1px solid #d9d9d9 !important;
+  text-align: left !important;
+  vertical-align: middle !important;
+  white-space: nowrap !important;
+}
+
+section.tbl-wrapper th {
+  background: #fafafa !important;
+  color: #444444 !important;
+  font-weight: 700 !important;
+}
+
+section.tbl-wrapper td {
+  color: #4f638f !important;
+}
+
+section.tbl-wrapper a {
+  color: #4f638f !important;
+  text-decoration: none !important;
+}
+`;
+const WECHAT_MATH_INLINE_CSS = `
+span.math-inline {
+  display: inline-block !important;
+  max-width: 100% !important;
+  margin: 0 0.12em !important;
+  vertical-align: middle !important;
+}
+
+span.math-inline mjx-container {
+  display: inline-block !important;
+  max-width: 100% !important;
+  color: #111111 !important;
+  vertical-align: middle !important;
+}
+
+section.math-block {
+  margin: 1.4em 3% !important;
+  overflow-x: auto !important;
+  overflow-y: hidden !important;
+  text-align: center !important;
+  -webkit-overflow-scrolling: touch;
+}
+
+section.math-block mjx-container {
+  display: inline-block !important;
+  min-width: min-content !important;
+  color: #111111 !important;
+}
+
+section.math-block mjx-container > svg,
+span.math-inline mjx-container > svg {
+  display: block !important;
+}
+`;
+const LANGUAGE_ALIASES = {
+    'c#': 'csharp',
+    'c++': 'cpp',
+    bash: 'bash',
+    console: 'bash',
+    js: 'javascript',
+    jsx: 'javascript',
+    py: 'python',
+    py3: 'python',
+    python3: 'python',
+    rs: 'rust',
+    sh: 'bash',
+    shell: 'bash',
+    text: null,
+    plaintext: null,
+    txt: null,
+    ts: 'typescript',
+    tsx: 'typescript',
+    yml: 'yaml',
+    zsh: 'bash'
+};
+function resolveHighlightLanguage(language) {
+    const raw = language.trim().toLowerCase();
+    if (!raw) {
+        return '';
+    }
+    const token = raw
+        .replace(/^[{\[]|[}\]]$/g, '')
+        .replace(/^language-/, '')
+        .replace(/^lang-/, '')
+        .split(/[\s,{]/, 1)[0]
+        ?.trim();
+    if (!token) {
+        return '';
+    }
+    if (Object.prototype.hasOwnProperty.call(LANGUAGE_ALIASES, token)) {
+        return LANGUAGE_ALIASES[token];
+    }
+    return token;
+}
+function renderHighlightedCode(code, language) {
+    const normalizedLanguage = resolveHighlightLanguage(language);
+    if (normalizedLanguage === null) {
+        return escapeHtml(code);
+    }
+    if (normalizedLanguage && highlight_js_1.default.getLanguage(normalizedLanguage)) {
+        return highlight_js_1.default.highlight(code, { language: normalizedLanguage }).value;
+    }
+    return highlight_js_1.default.highlightAuto(code).value;
+}
+const markdown = new markdown_it_1.default({
+    html: true,
+    linkify: true,
+    breaks: false,
+    highlight(code, language) {
+        const normalizedLanguage = resolveHighlightLanguage(language);
+        const highlighted = renderHighlightedCode(code, language);
+        const languageClass = normalizedLanguage ? ` language-${normalizedLanguage}` : '';
+        return `<pre><code class="hljs${languageClass}">${highlighted}</code></pre>`;
+    }
+});
+markdown.use(markdown_it_mathjax3_1.default);
+const DEFAULT_THEME = (0, themes_1.getDefaultThemeName)();
+const VOID_HTML_TAGS = new Set(['area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'param', 'source', 'track', 'wbr']);
+function escapeHtml(value) {
+    return value
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;');
+}
+function escapeHtmlAttribute(value) {
+    return escapeHtml(value);
+}
+function isTextNodeEmpty(node) {
+    return node.type === 'text' && !node.data.trim();
+}
+function isStandaloneImageParagraph($paragraph) {
+    const nodes = $paragraph.contents().toArray().filter((node) => !isTextNodeEmpty(node));
+    return nodes.every((node) => node.type === 'tag' && ['img', 'br'].includes(node.tagName.toLowerCase()));
+}
+function getStylesRoot() {
+    return node_path_1.default.resolve(__dirname, '../../styles');
+}
+function getThemeCssPath(theme) {
+    return node_path_1.default.join(getStylesRoot(), `${theme}.css`);
+}
+async function pathExists(filePath) {
+    try {
+        await (0, promises_1.access)(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function getCustomCssPath() {
+    return node_path_1.default.join(getStylesRoot(), 'custom.css');
+}
+async function loadThemeCss(theme) {
+    const resolvedTheme = (theme ?? DEFAULT_THEME).trim() || DEFAULT_THEME;
+    if (resolvedTheme === DEFAULT_THEME || !(0, themes_1.isValidTheme)(resolvedTheme)) {
+        return (0, promises_1.readFile)(getThemeCssPath(DEFAULT_THEME), 'utf8');
+    }
+    return (0, promises_1.readFile)(getThemeCssPath(resolvedTheme), 'utf8');
+}
+async function loadCustomCss() {
+    const customCssPath = getCustomCssPath();
+    if (!(await pathExists(customCssPath))) {
+        return '';
+    }
+    return (0, promises_1.readFile)(customCssPath, 'utf8');
+}
+function normalizeListItems($) {
+    $('li').each((_, element) => {
+        const $item = $(element);
+        const childElements = $item
+            .contents()
+            .toArray()
+            .filter((node) => !isTextNodeEmpty(node));
+        if (childElements.length === 0) {
+            return;
+        }
+        const hasBlockChild = childElements.some((node) => {
+            if (node.type !== 'tag') {
+                return false;
+            }
+            const tagName = node.tagName.toLowerCase();
+            return ['p', 'ul', 'ol', 'section', 'blockquote', 'pre', 'table'].includes(tagName);
+        });
+        const firstChild = childElements[0];
+        if (!hasBlockChild && firstChild?.type === 'tag' && firstChild.tagName.toLowerCase() === 'span' && childElements.length === 1) {
+            return;
+        }
+        if (hasBlockChild) {
+            return;
+        }
+        $item.html(`<span>${$item.html() ?? ''}</span>`);
+    });
+}
+function normalizeImages($) {
+    $('img').each((_, element) => {
+        const $image = $(element);
+        const parent = $image.parent();
+        const parentTag = parent.get(0)?.type === 'tag' ? parent.get(0).tagName.toLowerCase() : undefined;
+        if (parentTag === 'section' && parent.attr('data-wxgzh') === 'image') {
+            parent.addClass('img-wrapper');
+            return;
+        }
+        if (parentTag === 'p') {
+            if (isStandaloneImageParagraph(parent)) {
+                parent.replaceWith(`<section class="img-wrapper" data-wxgzh="image">${$.html($image)}</section>`);
+            }
+            else {
+                $image.wrap('<section class="img-wrapper" data-wxgzh="image"></section>');
+            }
+            return;
+        }
+        $image.wrap('<section class="img-wrapper" data-wxgzh="image"></section>');
+    });
+}
+function normalizeTables($) {
+    $('table').each((_, element) => {
+        const $table = $(element);
+        const parent = $table.parent();
+        const parentTag = parent.get(0)?.type === 'tag' ? parent.get(0).tagName.toLowerCase() : undefined;
+        if (parentTag === 'section' && parent.attr('data-wxgzh') === 'table') {
+            parent.addClass('tbl-wrapper');
+            return;
+        }
+        $table.wrap('<section class="tbl-wrapper" data-wxgzh="table"></section>');
+    });
+}
+function renderSoftBreakFriendlyHtml(nodes, preserveSoftBreak = true) {
+    return nodes.map((node) => renderSoftBreakFriendlyNode(node, preserveSoftBreak)).join('');
+}
+function renderSoftBreakFriendlyNode(node, preserveSoftBreak) {
+    if (node.type === 'text') {
+        return renderSoftBreakFriendlyText(node, preserveSoftBreak);
+    }
+    if (node.type !== 'tag') {
+        return '';
+    }
+    const element = node;
+    const tagName = element.tagName.toLowerCase();
+    const attributes = Object.entries(element.attribs ?? {})
+        .map(([key, value]) => ` ${key}="${escapeHtmlAttribute(String(value))}"`)
+        .join('');
+    if (VOID_HTML_TAGS.has(tagName)) {
+        return `<${tagName}${attributes}>`;
+    }
+    const nextPreserveSoftBreak = preserveSoftBreak && !['code', 'pre'].includes(tagName);
+    const children = renderSoftBreakFriendlyHtml(element.children ?? [], nextPreserveSoftBreak);
+    return `<${tagName}${attributes}>${children}</${tagName}>`;
+}
+function renderSoftBreakFriendlyText(node, preserveSoftBreak) {
+    const normalized = node.data.replace(/\r\n?/g, '\n');
+    if (!preserveSoftBreak || !normalized.includes('\n')) {
+        return escapeHtml(normalized);
+    }
+    return normalized.split('\n').map((segment) => escapeHtml(segment)).join('<br>');
+}
+function normalizeBlockquoteSoftBreaks($) {
+    $('blockquote p, q p').each((_, element) => {
+        const paragraph = element;
+        $(paragraph).html(renderSoftBreakFriendlyHtml(paragraph.children ?? []));
+    });
+}
+function normalizeMathFormulas($) {
+    $('span[id^="mjx-"]').each((_, element) => {
+        const $wrapper = $(element);
+        const $container = $wrapper.find('mjx-container').first();
+        if ($container.length === 0) {
+            return;
+        }
+        $wrapper.find('style, mjx-assistive-mml').remove();
+        const isDisplay = $container.attr('display') === 'true';
+        $container.removeAttr('style');
+        if (isDisplay) {
+            $wrapper.replaceWith(`<section class="math-block" data-wxgzh="math-block">${$.html($container)}</section>`);
+            return;
+        }
+        $wrapper.replaceWith(`<span class="math-inline" data-wxgzh="math-inline">${$.html($container)}</span>`);
+    });
+    $('section > eqn').each((_, element) => {
+        const $eqn = $(element);
+        const $container = $eqn.find('mjx-container').first();
+        if ($container.length === 0) {
+            return;
+        }
+        $eqn.find('style, mjx-assistive-mml').remove();
+        $container.removeAttr('style');
+        $eqn.replaceWith(`<section class="math-block" data-wxgzh="math-block">${$.html($container)}</section>`);
+    });
+    $('eq').each((_, element) => {
+        const $eq = $(element);
+        const $container = $eq.find('mjx-container').first();
+        if ($container.length === 0) {
+            return;
+        }
+        $eq.find('style, mjx-assistive-mml').remove();
+        $container.removeAttr('style');
+        $eq.replaceWith(`<span class="math-inline" data-wxgzh="math-inline">${$.html($container)}</span>`);
+    });
+}
+function createMetadataTags(metadata) {
+    const entries = Object.entries(metadata).filter(([, value]) => value !== undefined);
+    return entries
+        .map(([key, value]) => `<meta name="wxgzh:${key}" content="${escapeHtmlAttribute(String(value))}">`)
+        .join('\n');
+}
+function createDocumentHtml(content, metadata) {
+    return [
+        '<!DOCTYPE html>',
+        '<html lang="zh-CN">',
+        '<head>',
+        '  <meta charset="UTF-8">',
+        `  <title>${escapeHtmlAttribute(metadata.title ?? 'wxgzh article')}</title>`,
+        `  ${createMetadataTags(metadata)}`,
+        '</head>',
+        '<body>',
+        `  <div id="write" class="wrapper"><article>${content}</article></div>`,
+        '</body>',
+        '</html>'
+    ].join('\n');
+}
+function setInlineStyleProperty(existingStyle, property, value) {
+    const entries = new Map();
+    if (existingStyle) {
+        for (const declaration of existingStyle.split(';')) {
+            const trimmed = declaration.trim();
+            if (!trimmed) {
+                continue;
+            }
+            const separatorIndex = trimmed.indexOf(':');
+            if (separatorIndex === -1) {
+                continue;
+            }
+            const name = trimmed.slice(0, separatorIndex).trim();
+            const declarationValue = trimmed.slice(separatorIndex + 1).trim();
+            if (!name || !declarationValue) {
+                continue;
+            }
+            entries.set(name, declarationValue);
+        }
+    }
+    entries.set(property, value);
+    return Array.from(entries.entries())
+        .map(([name, declarationValue]) => `${name}: ${declarationValue}`)
+        .join('; ');
+}
+function cleanInlinedHtml(html) {
+    const $ = cheerio.load(html);
+    $('pre > code').each((_, element) => {
+        const $element = $(element);
+        $element.html(renderWechatFriendlyCodeHtml($element.contents().toArray()));
+    });
+    const $article = $('body > #write > article').first();
+    const $firstChild = $article.children().first();
+    if ($firstChild.length > 0) {
+        $firstChild.attr('style', setInlineStyleProperty($firstChild.attr('style'), 'margin-top', '0 !important'));
+    }
+    $('style').remove();
+    return $.html();
+}
+function renderWechatFriendlyCodeHtml(nodes) {
+    return nodes.map((node) => renderWechatFriendlyCodeNode(node)).join('');
+}
+function renderWechatFriendlyCodeNode(node) {
+    if (node.type === 'text') {
+        return renderWechatFriendlyCodeText(node);
+    }
+    if (node.type !== 'tag') {
+        return '';
+    }
+    const element = node;
+    const attributes = Object.entries(element.attribs ?? {})
+        .map(([key, value]) => ` ${key}="${escapeHtmlAttribute(String(value))}"`)
+        .join('');
+    const children = renderWechatFriendlyCodeHtml(element.children ?? []);
+    return `<${element.tagName}${attributes}>${children}</${element.tagName}>`;
+}
+function renderWechatFriendlyCodeText(node) {
+    const normalized = node.data.replace(/\r\n?/g, '\n').replace(/\t/g, '    ');
+    let result = '';
+    for (const char of normalized) {
+        if (char === '\n') {
+            result += '<br>';
+            continue;
+        }
+        if (char === ' ') {
+            result += '&nbsp;';
+            continue;
+        }
+        result += escapeHtml(char);
+    }
+    return result;
+}
+async function renderMarkdownToHtml(body, metadata) {
+    const content = markdown.render(body);
+    const $ = cheerio.load(`<article>${content}</article>`);
+    normalizeListItems($);
+    normalizeImages($);
+    normalizeTables($);
+    normalizeBlockquoteSoftBreaks($);
+    normalizeMathFormulas($);
+    const themeCss = await loadThemeCss(metadata.theme);
+    const customCss = await loadCustomCss();
+    const articleHtml = $('article').html() ?? '';
+    const baseHtml = createDocumentHtml(articleHtml, metadata);
+    const inlinedHtml = juice_1.default.inlineContent(baseHtml, `${themeCss}\n${HIGHLIGHT_INLINE_CSS}\n${WECHAT_BLOCKQUOTE_INLINE_CSS}\n${WECHAT_TABLE_INLINE_CSS}\n${WECHAT_MATH_INLINE_CSS}\n${customCss}`, {
+        removeStyleTags: true,
+        preserveMediaQueries: true,
+        preserveFontFaces: true,
+        applyWidthAttributes: false,
+        applyHeightAttributes: false,
+        applyAttributesTableElements: true
+    });
+    return cleanInlinedHtml(inlinedHtml);
+}
+function extractPublishableContent(html) {
+    const $ = cheerio.load(html);
+    const articleHtml = $('body > #write > article').first().html();
+    if (typeof articleHtml === 'string' && articleHtml.trim()) {
+        return articleHtml.trim();
+    }
+    const bodyHtml = $('body').html();
+    if (typeof bodyHtml === 'string' && bodyHtml.trim()) {
+        return bodyHtml.trim();
+    }
+    return html.trim();
+}
+function readHtmlMetadata(html) {
+    const $ = cheerio.load(html);
+    const metadata = {};
+    $('meta[name^="wxgzh:"]').each((_, element) => {
+        const name = $(element).attr('name')?.replace('wxgzh:', '');
+        const value = $(element).attr('content');
+        if (!name || value === undefined) {
+            return;
+        }
+        if (name === 'enableComment') {
+            metadata.enableComment = value === 'true';
+            return;
+        }
+        metadata[name] = value;
+    });
+    return metadata;
+}