@yozora/tokenizer-admonition/lib/esm/index.mjs

Tokenizer for processing admonitions

import FencedBlockTokenizer, { fencedBlockMatch } from '@yozora/tokenizer-fenced-block';
import { AdmonitionType } from '@yozora/ast';
import { isUnicodeWhitespaceCharacter, calcEscapedStringFromNodePoints, AsciiCodePoint } from '@yozora/character';
import { eatOptionalWhitespaces, mergeAndStripContentLines, TokenizerPriority } from '@yozora/core-tokenizer';

const match = function (api) {
    const hook = fencedBlockMatch.call(this, api);
    return {
        ...hook,
        isContainingBlock: true,
        onClose,
    };
    function onClose(token) {
        const children = api.rollbackPhrasingLines(token.lines);
        token.children = children;
    }
};

const parse = function (api) {
    return {
        parse: tokens => tokens.map(token => {
            const infoString = token.infoString;
            let i = 0;
            const keywordNodePoints = [];
            for (; i < infoString.length; ++i) {
                const p = infoString[i];
                if (isUnicodeWhitespaceCharacter(p.codePoint))
                    break;
                keywordNodePoints.push(p);
            }
            i = eatOptionalWhitespaces(infoString, i, infoString.length);
            const title = (() => {
                if (i >= infoString.length)
                    return [];
                const titleLines = [
                    {
                        nodePoints: infoString,
                        startIndex: i,
                        endIndex: infoString.length,
                        firstNonWhitespaceIndex: i,
                        countOfPrecedeSpaces: 0,
                    },
                ];
                const contents = mergeAndStripContentLines(titleLines);
                return api.processInlines(contents);
            })();
            const keyword = calcEscapedStringFromNodePoints(keywordNodePoints, 0, keywordNodePoints.length, true);
            const children = api.parseBlockTokens(token.children);
            const node = api.shouldReservePosition
                ? { type: AdmonitionType, position: token.position, keyword, title, children }
                : { type: AdmonitionType, keyword, title, children };
            return node;
        }),
    };
};

const uniqueName = '@yozora/tokenizer-admonition';

class AdmonitionTokenizer extends FencedBlockTokenizer {
    constructor(props = {}) {
        super({
            name: props.name ?? uniqueName,
            priority: props.priority ?? TokenizerPriority.FENCED_BLOCK,
            nodeType: AdmonitionType,
            markers: [AsciiCodePoint.COLON],
            markersRequired: 3,
        });
    }
    match = match;
    parse = parse;
}

export { AdmonitionTokenizer, uniqueName as AdmonitionTokenizerName, match as admonitionMatch, parse as admonitionParse, AdmonitionTokenizer as default };