Marked 库使用指引

import { readFileSync } from "fs";
import { join } from "path";

// 需要安装 marked 依赖
import { parse } from "marked"; 

const markdown = readFileSync(join(__dirname, "test.md"), "utf-8");
const html = parse(markdown); 
console.log(html);

import { Marked } from "./Instance.ts";

const markedInstance = new Marked(); 

/**
 * 当 opt 中的 async 属性为 true 时，返回值类型将为 Promise<string>，
 * 否则为 string
 */
export function marked(
    src: string,
    opt?: MarkedOptions
): string | Promise<string> {
    return markedInstance.parse(src, opt); 
}

export const parse = marked; 

import { _Lexer } from "./Lexer.ts";
import { _Parser } from "./Parser.ts";

export class Marked {
    parse = this.#parseMarkdown(_Lexer.lex, _Parser.parse); 
    parseInline = this.#parseMarkdown(_Lexer.lexInline, _Parser.parseInline);

    Parser = _Parser;
    Lexer = _Lexer;

    /**
     * 省略 lexer 和 parser 的类型，
     * 因为它们既冗长，又不重要
     */
    #parseMarkdown(lexer, parser) {
        // 此处为了方便观察 Marked 工作流程，仅摘录异步工作流程
        if (opt.async) {
            return Promise.resolve(opt.hooks ? opt.hooks.preprocess(src) : src)
                .then((src) => lexer(src, opt)) 
                .then((tokens) =>
                    opt.hooks ? opt.hooks.processAllTokens(tokens) : tokens
                )
                .then((tokens) =>
                    opt.walkTokens
                        ? Promise.all(
                              this.walkTokens(tokens, opt.walkTokens)
                          ).then(() => tokens)
                        : tokens
                )
                .then((tokens) => parser(tokens, opt)) 
                .then((html) =>
                    opt.hooks ? opt.hooks.postprocess(html) : html
                )
                .catch(throwError);
        }
    }
}

import { _Tokenizer } from "./Tokenizer.ts";
import { _defaults } from "./defaults.ts";
import { block, inline } from "./rules.ts";

import type { Token, TokensList, Tokens } from "./Tokens.ts";
import type { MarkedOptions, TokenizerExtension } from "./MarkedOptions.ts";

export class _Lexer {
    tokens: TokensList;

    private tokenizer: _Tokenizer; 
    private inlineQueue: { src: string; tokens: Token[] }[];

    constructor(options?: MarkedOptions) {
        this.tokens = [] as unknown as TokensList;

        this.options = options || _defaults;
        this.options.tokenizer = this.options.tokenizer || new _Tokenizer(); 

        this.tokenizer = this.options.tokenizer; 
        this.tokenizer.options = this.options;
        this.tokenizer.lexer = this;
        this.inlineQueue = [];

        const rules = {
            block: block.normal,
            inline: inline.normal
        };

        this.tokenizer.rules = rules;
    }

    // 静态方法
    static lex(src: string, options?: MarkedOptions) {
        const lexer = new _Lexer(options);
        return lexer.lex(src);
    }

    // 成员方法
    lex(src: string) {
        src = src.replace(/\r\n|\r/g, "\n");

        this.blockTokens(src, this.tokens); 

        for (let i = 0; i <CodeGroup this.inlineQueue.length; i++) {
            const next = this.inlineQueue[i];
            this.inlineTokens(next.src, next.tokens); 
        }
        this.inlineQueue = [];

        return this.tokens;
    }

    blockTokens(src: string, tokens: Token[] = []) {
        /**
         * 先在自定义扩展内寻找可以匹配当前字符串开头的
         * this.options.extensions.block 是块级自定义扩展的 tokenizer() 函数的数组
         */
        while (src) {
            if (
                this.options.extensions &&
                this.options.extensions.block &&
                this.options.extensions.block.some(
                    (extTokenizer: TokenizerExtension["tokenizer"]) => {
                        if (
                            (token = extTokenizer.call(
                                { lexer: this },
                                src,
                                tokens
                            ))
                        ) {
                            // 删除已被匹配的字符串，这也是为什么 raw 属性是必需的
                            src = src.substring(token.raw.length); 
                            tokens.push(token); 
                            return true; 
                        }
                        return false;
                    }
                )
            ) {
                continue;
            }
        }

        /**
         * 若字符串开头不符合任何自定义扩展的规则，则使用默认解析
         * 此处仅摘录一例，默认标题解析
         */
        if ((token = this.tokenizer.heading(src))) {
            src = src.substring(token.raw.length);
            tokens.push(token);
            continue;
        }
    }
}

import type { Rules } from "./rules.ts";

export class _Tokenizer {
    options: MarkedOptions;
    rules!: Rules; // set by the lexer
    lexer!: _Lexer; // set by the lexer

    /** 此处仅摘录一例，默认标题解析器的定义 */
    heading(src: string): Tokens.Heading | undefined {
        const cap = this.rules.block.heading.exec(src);
        if (cap) {
            let text = cap[2].trim();

            // remove trailing #s
            if (/#$/.test(text)) {
                const trimmed = rtrim(text, "#");
                if (this.options.pedantic) {
                    text = trimmed.trim();
                } else if (!trimmed || / $/.test(trimmed)) {
                    text = trimmed.trim();
                }
            }

            return {
                type: "heading",
                raw: cap[0],
                depth: cap[1].length,
                text,
                /** 调用 lexer 对象的 inline() 方法 ，解析其中的行内元素 */
                tokens: this.lexer.inline(text), 
            };
        }
    }
}

import { _Renderer } from "./Renderer.ts";

export class _Parser {
    options: MarkedOptions;
    renderer: _Renderer;
    constructor(options?: MarkedOptions) {
        this.options = options || _defaults;
        this.options.renderer = this.options.renderer || new _Renderer(); 

        this.renderer = this.options.renderer; 
        this.renderer.options = this.options;
    }

    // 静态方法
    static parse(tokens: Token[], options?: MarkedOptions) {
        const parser = new _Parser(options);
        return parser.parse(tokens);
    }

    // 成员方法
    parse(tokens: Token[], top = true): string {
        let out = ""; // 最终输出的文本

        for (let i = 0; i <CodeGroup tokens.length; i++) {
            const token = tokens[i];

            // 首先判定 token 类型是否由自定义扩展定义
            if (
                this.options.extensions &&
                this.options.extensions.renderers &&
                this.options.extensions.renderers[token.type]
            ) {
                const genericToken = token as Tokens.Generic;
                // 使用自定义扩展中的渲染
                const ret = this.options.extensions.renderers[
                    genericToken.type
                ].call({ parser: this }, genericToken);
                if (
                    ret !== false ||
                    ![
                        "space",
                        "hr",
                        "heading",
                        "code",
                        "table",
                        "blockquote",
                        "list",
                        "html",
                        "paragraph",
                        "text"
                    ].includes(genericToken.type)
                ) {
                    out += ret || "";
                    continue;
                }
            }

            // 默认渲染
            switch (token.type) {
                // 此处省略了其他 case
                case "heading": {
                    const headingToken = token as Tokens.Heading;
                    // 渲染
                    out += this.renderer.heading(
                        this.parseInline(headingToken.tokens), 
                        headingToken.depth, 
                        unescape(
                            this.parseInline(
                                headingToken.tokens,
                                this.textRenderer
                            )
                        )
                    );
                    continue;
                }
            }
        }

        return out;
    }
}