@yozora/tokenizer-admonition/lib/cjs/index.cjs

Tokenizer for processing admonitions

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var FencedBlockTokenizer = require('@yozora/tokenizer-fenced-block');
var ast = require('@yozora/ast');
var character = require('@yozora/character');
var coreTokenizer = require('@yozora/core-tokenizer');

function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }

var FencedBlockTokenizer__default = /*#__PURE__*/_interopDefault(FencedBlockTokenizer);

const match = function (api) {
    const hook = FencedBlockTokenizer.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 (character.isUnicodeWhitespaceCharacter(p.codePoint))
                    break;
                keywordNodePoints.push(p);
            }
            i = coreTokenizer.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 = coreTokenizer.mergeAndStripContentLines(titleLines);
                return api.processInlines(contents);
            })();
            const keyword = character.calcEscapedStringFromNodePoints(keywordNodePoints, 0, keywordNodePoints.length, true);
            const children = api.parseBlockTokens(token.children);
            const node = api.shouldReservePosition
                ? { type: ast.AdmonitionType, position: token.position, keyword, title, children }
                : { type: ast.AdmonitionType, keyword, title, children };
            return node;
        }),
    };
};

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

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

exports.AdmonitionTokenizer = AdmonitionTokenizer;
exports.AdmonitionTokenizerName = uniqueName;
exports.admonitionMatch = match;
exports.admonitionParse = parse;
exports.default = AdmonitionTokenizer;