emdp 1.0.0

package/dist/parser/gfm/block-parser.js

@@ -0,0 +1,773 @@
+"use strict";
+/**
+ * GFM block parser that extends CommonMark with table support.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GFMBlockParser = void 0;
+const utils_js_1 = require("../utils.js");
+const thematic_break_js_1 = require("../blocks/thematic-break.js");
+const heading_atx_js_1 = require("../blocks/heading-atx.js");
+const heading_setext_js_1 = require("../blocks/heading-setext.js");
+const code_block_indented_js_1 = require("../blocks/code-block-indented.js");
+const code_block_fenced_js_1 = require("../blocks/code-block-fenced.js");
+const blockquote_js_1 = require("../blocks/blockquote.js");
+const list_js_1 = require("../blocks/list.js");
+const html_block_js_1 = require("../blocks/html-block.js");
+const html_block_js_2 = require("../blocks/html-block.js");
+const paragraph_js_1 = require("../blocks/paragraph.js");
+const link_reference_js_1 = require("../blocks/link-reference.js");
+const table_js_1 = require("../blocks/table.js");
+const task_list_js_1 = require("../blocks/task-list.js");
+const footnote_js_1 = require("../inlines/footnote.js");
+function getIndent(raw) {
+    let indent = 0;
+    for (const char of raw) {
+        if (char === ' ')
+            indent++;
+        else if (char === '\t')
+            indent += 4 - (indent % 4);
+        else
+            break;
+    }
+    return indent;
+}
+class GFMBlockParser {
+    lines = [];
+    lineIndex = 0;
+    linkReferences = new Map();
+    footnoteDefinitions = new Map();
+    static LAZY_PREFIX = '\u0000';
+    enableTables;
+    enableTaskLists;
+    enableFootnotes;
+    constructor(extensions) {
+        this.enableTables = !extensions || extensions.has('table');
+        this.enableTaskLists = !extensions || extensions.has('tasklist');
+        this.enableFootnotes = !extensions || extensions.has('footnotes');
+    }
+    parse(input) {
+        this.lines = (0, utils_js_1.normalizeLineEndings)(input).split('\n');
+        this.lineIndex = 0;
+        this.linkReferences = new Map();
+        this.footnoteDefinitions = new Map();
+        const document = {
+            type: 'document',
+            children: [],
+        };
+        this.parseBlocks(document, 0);
+        if (this.enableTaskLists) {
+            (0, task_list_js_1.processTaskLists)(document.children);
+        }
+        return {
+            document,
+            linkReferences: this.linkReferences,
+            footnoteDefinitions: this.footnoteDefinitions,
+        };
+    }
+    currentLine() {
+        return this.lines[this.lineIndex];
+    }
+    advance() {
+        this.lineIndex++;
+    }
+    parseBlocks(container, baseIndent) {
+        let paragraphLines = [];
+        const finishParagraph = () => {
+            if (paragraphLines.length > 0) {
+                let text = paragraphLines.join('\n');
+                let consumed = 0;
+                while (text.length > 0) {
+                    const result = (0, link_reference_js_1.parseLinkReferenceDefinition)(text);
+                    if (!result)
+                        break;
+                    if (!this.linkReferences.has(result.label)) {
+                        this.linkReferences.set(result.label, result.definition);
+                    }
+                    text = text.slice(result.consumed);
+                    consumed += result.consumed;
+                }
+                text = text.trim();
+                if (text.length > 0) {
+                    const para = (0, paragraph_js_1.createParagraphNode)();
+                    para.rawContent = text;
+                    container.children.push(para);
+                }
+                paragraphLines = [];
+                return consumed > 0 || text.length > 0;
+            }
+            return false;
+        };
+        while (this.lineIndex < this.lines.length) {
+            const line = this.currentLine();
+            if (line.startsWith(GFMBlockParser.LAZY_PREFIX)) {
+                const raw = line.slice(GFMBlockParser.LAZY_PREFIX.length);
+                const rawIndent = getIndent(raw);
+                paragraphLines.push((0, utils_js_1.removeIndent)(raw, Math.min(rawIndent, 3)));
+                this.advance();
+                continue;
+            }
+            const lineIndent = getIndent(line);
+            if (line.trim() === '') {
+                finishParagraph();
+                this.advance();
+                continue;
+            }
+            const dedented = (0, utils_js_1.removeIndent)(line, Math.min(3, lineIndent));
+            const trimmed = line.replace(/^ {0,3}/, '');
+            if (this.enableFootnotes) {
+                const footnoteLabel = (0, footnote_js_1.parseFootnoteLabel)(trimmed, 0);
+                if (footnoteLabel && trimmed[footnoteLabel.length] === ':') {
+                    finishParagraph();
+                    this.parseFootnoteDefinition(footnoteLabel.label, footnoteLabel.normalized, trimmed, footnoteLabel.length);
+                    continue;
+                }
+            }
+            if (this.enableTables && paragraphLines.length >= 1) {
+                const lastLine = paragraphLines[paragraphLines.length - 1];
+                if ((0, table_js_1.isTableRow)(lastLine)) {
+                    const alignments = (0, table_js_1.isTableStart)(lastLine, line);
+                    if (alignments) {
+                        if (paragraphLines.length > 1) {
+                            const precedingLines = paragraphLines.slice(0, -1);
+                            let text = precedingLines.join('\n');
+                            while (text.length > 0) {
+                                const result = (0, link_reference_js_1.parseLinkReferenceDefinition)(text);
+                                if (!result)
+                                    break;
+                                if (!this.linkReferences.has(result.label)) {
+                                    this.linkReferences.set(result.label, result.definition);
+                                }
+                                text = text.slice(result.consumed);
+                            }
+                            text = text.trim();
+                            if (text.length > 0) {
+                                const para = (0, paragraph_js_1.createParagraphNode)();
+                                para.rawContent = text;
+                                container.children.push(para);
+                            }
+                        }
+                        const table = this.parseTable(lastLine, alignments);
+                        paragraphLines = [];
+                        container.children.push(table);
+                        continue;
+                    }
+                }
+            }
+            if (paragraphLines.length > 0) {
+                const setextLevel = (0, heading_setext_js_1.getSetextLevel)(line);
+                if (setextLevel) {
+                    let content = paragraphLines.join('\n');
+                    while (content.length > 0) {
+                        const result = (0, link_reference_js_1.parseLinkReferenceDefinition)(content);
+                        if (!result)
+                            break;
+                        if (!this.linkReferences.has(result.label)) {
+                            this.linkReferences.set(result.label, result.definition);
+                        }
+                        content = content.slice(result.consumed);
+                    }
+                    content = content.trim();
+                    paragraphLines = [];
+                    if (content.length > 0) {
+                        const heading = (0, heading_atx_js_1.createHeadingNode)(setextLevel);
+                        heading.rawContent = content;
+                        container.children.push(heading);
+                    }
+                    else if ((0, thematic_break_js_1.isThematicBreak)(line)) {
+                        container.children.push((0, thematic_break_js_1.parseThematicBreak)(line));
+                    }
+                    else {
+                        paragraphLines.push(line);
+                    }
+                    this.advance();
+                    continue;
+                }
+            }
+            if ((0, thematic_break_js_1.isThematicBreak)(line)) {
+                finishParagraph();
+                container.children.push((0, thematic_break_js_1.parseThematicBreak)(line));
+                this.advance();
+                continue;
+            }
+            const atxResult = (0, heading_atx_js_1.parseAtxHeading)(line);
+            if (atxResult) {
+                finishParagraph();
+                const heading = (0, heading_atx_js_1.createHeadingNode)(atxResult.level);
+                heading.rawContent = atxResult.content;
+                container.children.push(heading);
+                this.advance();
+                continue;
+            }
+            if (paragraphLines.length > 0 && /^ {0,3}=+[ \t]*$/.test(line)) {
+                let content = paragraphLines.join('\n');
+                while (content.length > 0) {
+                    const result = (0, link_reference_js_1.parseLinkReferenceDefinition)(content);
+                    if (!result)
+                        break;
+                    if (!this.linkReferences.has(result.label)) {
+                        this.linkReferences.set(result.label, result.definition);
+                    }
+                    content = content.slice(result.consumed);
+                }
+                content = content.trim();
+                paragraphLines = [];
+                if (content.length > 0) {
+                    const heading = (0, heading_atx_js_1.createHeadingNode)(1);
+                    heading.rawContent = content;
+                    container.children.push(heading);
+                }
+                else {
+                    paragraphLines.push(line);
+                }
+                this.advance();
+                continue;
+            }
+            const fenceInfo = (0, code_block_fenced_js_1.parseFenceOpen)(line);
+            if (fenceInfo) {
+                finishParagraph();
+                const codeLines = [];
+                this.advance();
+                let closedProperly = false;
+                while (this.lineIndex < this.lines.length) {
+                    const codeLine = this.currentLine();
+                    if ((0, code_block_fenced_js_1.isFenceClose)(codeLine, fenceInfo)) {
+                        this.advance();
+                        closedProperly = true;
+                        break;
+                    }
+                    codeLines.push(codeLine);
+                    this.advance();
+                }
+                if (!closedProperly) {
+                    while (codeLines.length > 0 && codeLines[codeLines.length - 1] === '') {
+                        codeLines.pop();
+                    }
+                }
+                const info = (0, utils_js_1.unescapeString)((0, utils_js_1.decodeHtmlEntities)(fenceInfo.info));
+                container.children.push((0, code_block_fenced_js_1.createFencedCodeBlock)(info, codeLines, fenceInfo.indent));
+                continue;
+            }
+            if (paragraphLines.length === 0 && lineIndent >= 4) {
+                const codeLines = [(0, utils_js_1.removeIndent)(line, 4)];
+                this.advance();
+                while (this.lineIndex < this.lines.length) {
+                    const codeLine = this.currentLine();
+                    const codeIndent = getIndent(codeLine);
+                    if (codeIndent >= 4) {
+                        codeLines.push((0, utils_js_1.removeIndent)(codeLine, 4));
+                        this.advance();
+                    }
+                    else if (codeLine.trim() === '') {
+                        codeLines.push('');
+                        this.advance();
+                    }
+                    else {
+                        break;
+                    }
+                }
+                while (codeLines.length > 0 && codeLines[codeLines.length - 1] === '') {
+                    codeLines.pop();
+                }
+                container.children.push((0, code_block_indented_js_1.createIndentedCodeBlock)(codeLines));
+                continue;
+            }
+            const bqMatch = line.match(/^ {0,3}>([ \t]?)/);
+            if (bqMatch) {
+                finishParagraph();
+                const blockquote = (0, blockquote_js_1.createBlockquoteNode)();
+                const quoteLines = [];
+                let inFence = null;
+                while (this.lineIndex < this.lines.length) {
+                    const quoteLine = this.currentLine();
+                    const qMatch = quoteLine.match(/^ {0,3}>([ \t]?)/);
+                    if (qMatch) {
+                        const content = this.extractBlockquoteContent(quoteLine, qMatch);
+                        quoteLines.push(content);
+                        if (inFence) {
+                            if ((0, code_block_fenced_js_1.isFenceClose)(content, inFence)) {
+                                inFence = null;
+                            }
+                        }
+                        else {
+                            const fenceInfo = (0, code_block_fenced_js_1.parseFenceOpen)(content);
+                            if (fenceInfo) {
+                                inFence = fenceInfo;
+                            }
+                        }
+                        this.advance();
+                    }
+                    else if (quoteLine.trim() === '') {
+                        break;
+                    }
+                    else if (quoteLines.length > 0) {
+                        if (inFence) {
+                            break;
+                        }
+                        if ((0, thematic_break_js_1.isThematicBreak)(quoteLine) || (0, code_block_fenced_js_1.parseFenceOpen)(quoteLine)) {
+                            break;
+                        }
+                        if (quoteLines[quoteLines.length - 1].trim() === '') {
+                            break;
+                        }
+                        const lastContent = this.lastNonBlankLine(quoteLines);
+                        if (lastContent &&
+                            !(0, code_block_fenced_js_1.parseFenceOpen)(lastContent) &&
+                            getIndent(lastContent) < 4 &&
+                            this.allowsLazyAfterListMarker(lastContent)) {
+                            const nestedPrefix = this.getBlockquotePrefix(lastContent);
+                            quoteLines.push(nestedPrefix + GFMBlockParser.LAZY_PREFIX + quoteLine);
+                            this.advance();
+                        }
+                        else {
+                            break;
+                        }
+                    }
+                    else {
+                        break;
+                    }
+                }
+                const subParser = new GFMBlockParser();
+                const result = subParser.parse(quoteLines.join('\n'));
+                blockquote.children = result.document.children;
+                result.linkReferences.forEach((def, label) => {
+                    if (!this.linkReferences.has(label)) {
+                        this.linkReferences.set(label, def);
+                    }
+                });
+                result.footnoteDefinitions.forEach((def, label) => {
+                    if (!this.footnoteDefinitions.has(label)) {
+                        this.footnoteDefinitions.set(label, def);
+                    }
+                });
+                container.children.push(blockquote);
+                continue;
+            }
+            const listMarker = (0, list_js_1.parseListMarker)(line);
+            if (listMarker) {
+                const canInterrupt = paragraphLines.length === 0 ||
+                    (listMarker.type === 'bullet' || listMarker.start === 1) &&
+                        line.slice(listMarker.indent + listMarker.marker.length + listMarker.padding).trim() !== '';
+                if (canInterrupt) {
+                    finishParagraph();
+                    const list = (0, list_js_1.createListNode)(listMarker);
+                    this.parseList(list, listMarker);
+                    container.children.push(list);
+                    continue;
+                }
+            }
+            const htmlType = (0, html_block_js_1.getHtmlBlockType)(line, paragraphLines.length === 0);
+            if (htmlType !== null) {
+                finishParagraph();
+                const htmlLines = [line];
+                const closeOnSameLine = htmlType >= 1 && htmlType <= 5 && (0, html_block_js_1.isHtmlBlockClose)(line, htmlType);
+                this.advance();
+                if (!closeOnSameLine) {
+                    while (this.lineIndex < this.lines.length) {
+                        const htmlLine = this.currentLine();
+                        if (htmlType === 6 || htmlType === 7) {
+                            if (htmlLine.trim() === '') {
+                                break;
+                            }
+                            htmlLines.push(htmlLine);
+                            this.advance();
+                        }
+                        else {
+                            htmlLines.push(htmlLine);
+                            this.advance();
+                            if ((0, html_block_js_1.isHtmlBlockClose)(htmlLine, htmlType)) {
+                                break;
+                            }
+                        }
+                    }
+                }
+                container.children.push((0, html_block_js_2.createHtmlBlockNode)(htmlLines.join('\n') + '\n'));
+                continue;
+            }
+            paragraphLines.push((0, utils_js_1.removeIndent)(line, Math.min(lineIndent, 3)));
+            this.advance();
+        }
+        finishParagraph();
+    }
+    parseTable(headerLine, alignments) {
+        const table = (0, table_js_1.createTableNode)(alignments);
+        const headerCells = (0, table_js_1.parseTableRowCells)(headerLine, alignments, true);
+        const headerRow = (0, table_js_1.createTableRowNode)(true, headerCells);
+        table.children.push(headerRow);
+        this.advance();
+        while (this.lineIndex < this.lines.length) {
+            const line = this.currentLine();
+            if (line.trim() === '') {
+                break;
+            }
+            if (line.match(/^ {0,3}>/)) {
+                break;
+            }
+            if ((0, thematic_break_js_1.isThematicBreak)(line)) {
+                break;
+            }
+            if ((0, heading_atx_js_1.parseAtxHeading)(line)) {
+                break;
+            }
+            if ((0, code_block_fenced_js_1.parseFenceOpen)(line)) {
+                break;
+            }
+            if ((0, html_block_js_1.getHtmlBlockType)(line, true) !== null) {
+                break;
+            }
+            const cells = (0, table_js_1.parseTableRowCells)(line, alignments, false);
+            const row = (0, table_js_1.createTableRowNode)(false, cells);
+            table.children.push(row);
+            this.advance();
+        }
+        return table;
+    }
+    parseFootnoteDefinition(label, key, trimmedLine, labelLength) {
+        if (!key) {
+            this.advance();
+            return;
+        }
+        const contentLines = [];
+        const afterColon = trimmedLine.slice(labelLength + 1);
+        const firstContent = afterColon.replace(/^[ \t]+/, '');
+        if (firstContent.length > 0) {
+            contentLines.push(firstContent);
+        }
+        this.advance();
+        while (this.lineIndex < this.lines.length) {
+            const line = this.currentLine();
+            if (line.trim() === '') {
+                let lookahead = this.lineIndex + 1;
+                while (lookahead < this.lines.length && this.lines[lookahead].trim() === '') {
+                    lookahead++;
+                }
+                if (lookahead < this.lines.length && getIndent(this.lines[lookahead]) >= 4) {
+                    contentLines.push('');
+                    this.advance();
+                    continue;
+                }
+                break;
+            }
+            if (getIndent(line) >= 4) {
+                contentLines.push((0, utils_js_1.removeIndent)(line, 4));
+                this.advance();
+                continue;
+            }
+            break;
+        }
+        const subParser = new GFMBlockParser();
+        const result = subParser.parse(contentLines.join('\n'));
+        result.linkReferences.forEach((def, refLabel) => {
+            if (!this.linkReferences.has(refLabel)) {
+                this.linkReferences.set(refLabel, def);
+            }
+        });
+        if (!this.footnoteDefinitions.has(key)) {
+            this.footnoteDefinitions.set(key, { label, blocks: result.document.children });
+        }
+    }
+    parseList(list, firstMarker) {
+        let sawBlankLine = false;
+        let sawBlankLineInItem = false;
+        let sawBlankBetweenItems = false;
+        while (this.lineIndex < this.lines.length) {
+            const line = this.currentLine();
+            if ((0, thematic_break_js_1.isThematicBreak)(line)) {
+                break;
+            }
+            const marker = (0, list_js_1.parseListMarker)(line);
+            if (marker && (0, list_js_1.listsMatch)(firstMarker, marker)) {
+                if (sawBlankLine) {
+                    sawBlankBetweenItems = true;
+                }
+                sawBlankLine = false;
+                const item = (0, list_js_1.createListItemNode)();
+                const itemResult = this.parseListItem(item, marker);
+                if (itemResult.blankInItem) {
+                    sawBlankLineInItem = true;
+                }
+                if (itemResult.endsWithBlank) {
+                    sawBlankLine = true;
+                }
+                list.children.push(item);
+            }
+            else if (line.trim() === '') {
+                sawBlankLine = true;
+                this.advance();
+                let nextIdx = this.lineIndex;
+                while (nextIdx < this.lines.length && this.lines[nextIdx].trim() === '') {
+                    nextIdx++;
+                }
+                if (nextIdx < this.lines.length) {
+                    const nextLine = this.lines[nextIdx];
+                    const nextMarker = (0, list_js_1.parseListMarker)(nextLine);
+                    if (!nextMarker || !(0, list_js_1.listsMatch)(firstMarker, nextMarker)) {
+                        if (getIndent(nextLine) < firstMarker.contentIndent) {
+                            break;
+                        }
+                    }
+                }
+                else {
+                    break;
+                }
+            }
+            else {
+                break;
+            }
+        }
+        if (sawBlankLineInItem || sawBlankBetweenItems) {
+            list.tight = false;
+        }
+    }
+    parseListItem(item, marker) {
+        const itemLines = [];
+        let firstLine = this.currentLine();
+        if (firstLine.startsWith(GFMBlockParser.LAZY_PREFIX)) {
+            firstLine = firstLine.slice(GFMBlockParser.LAZY_PREFIX.length);
+        }
+        let firstContent = this.extractListItemContent(firstLine, marker);
+        if (firstContent.trim() === '' && firstLine.slice(marker.indentChars + marker.marker.length).match(/^[ \t]/)) {
+            itemLines.push('');
+        }
+        else {
+            itemLines.push(firstContent);
+        }
+        this.advance();
+        let sawBlankLine = false;
+        let blankLineInItem = false;
+        let trailingBlanks = 0;
+        const contentIndent = marker.contentIndent;
+        const baseThreshold = contentIndent + 1;
+        let lastNonBlankIndent = firstContent.trim() === '' ? null : contentIndent;
+        let lastNonBlankWasListMarker = false;
+        let sawNonBlankContent = firstContent.trim() !== '';
+        let inFence = null;
+        if (firstContent.trim() !== '') {
+            const firstFence = (0, code_block_fenced_js_1.parseFenceOpen)(firstContent);
+            if (firstFence) {
+                inFence = firstFence;
+            }
+            lastNonBlankWasListMarker = (0, list_js_1.parseListMarker)(firstContent) !== null;
+        }
+        while (this.lineIndex < this.lines.length) {
+            let line = this.currentLine();
+            let lazyLine = false;
+            if (line.startsWith(GFMBlockParser.LAZY_PREFIX)) {
+                line = line.slice(GFMBlockParser.LAZY_PREFIX.length);
+                lazyLine = true;
+            }
+            const lineIndent = getIndent(line);
+            if (inFence) {
+                const contentLine = lineIndent >= contentIndent ? (0, utils_js_1.removeIndent)(line, contentIndent) : line;
+                itemLines.push(contentLine);
+                if ((0, code_block_fenced_js_1.isFenceClose)(contentLine, inFence)) {
+                    inFence = null;
+                }
+                this.advance();
+                continue;
+            }
+            if (line.trim() === '') {
+                sawBlankLine = true;
+                trailingBlanks++;
+                itemLines.push('');
+                this.advance();
+                continue;
+            }
+            const newMarker = lazyLine ? null : (0, list_js_1.parseListMarker)(line);
+            if (newMarker && (0, list_js_1.listsMatch)(marker, newMarker) && newMarker.indent < contentIndent) {
+                break;
+            }
+            if (!sawNonBlankContent && sawBlankLine && lineIndent >= contentIndent) {
+                break;
+            }
+            if (lineIndent >= contentIndent) {
+                const contentLine = (0, utils_js_1.removeIndent)(line, contentIndent);
+                const isListMarker = (0, list_js_1.parseListMarker)(contentLine) !== null;
+                if (sawBlankLine && (lineIndent <= baseThreshold ||
+                    (lastNonBlankIndent !== null && lastNonBlankIndent <= baseThreshold && !lastNonBlankWasListMarker))) {
+                    blankLineInItem = true;
+                }
+                sawBlankLine = false;
+                trailingBlanks = 0;
+                itemLines.push(contentLine);
+                lastNonBlankIndent = lineIndent;
+                lastNonBlankWasListMarker = isListMarker;
+                sawNonBlankContent = true;
+                if (!inFence) {
+                    const fenceInfo = (0, code_block_fenced_js_1.parseFenceOpen)(contentLine);
+                    if (fenceInfo) {
+                        inFence = fenceInfo;
+                    }
+                }
+                this.advance();
+            }
+            else if (sawBlankLine) {
+                break;
+            }
+            else {
+                if (!(0, thematic_break_js_1.isThematicBreak)(line) && !(0, heading_atx_js_1.parseAtxHeading)(line) &&
+                    !(0, code_block_fenced_js_1.parseFenceOpen)(line) && !line.match(/^ {0,3}>/) &&
+                    !newMarker) {
+                    trailingBlanks = 0;
+                    itemLines.push(line);
+                    lastNonBlankIndent = lineIndent;
+                    lastNonBlankWasListMarker = false;
+                    sawNonBlankContent = true;
+                    this.advance();
+                }
+                else {
+                    break;
+                }
+            }
+        }
+        const endsWithBlank = trailingBlanks > 0;
+        while (itemLines.length > 0 && itemLines[itemLines.length - 1] === '') {
+            itemLines.pop();
+        }
+        const subParser = new GFMBlockParser();
+        const result = subParser.parse(itemLines.join('\n'));
+        item.children = result.document.children;
+        result.linkReferences.forEach((def, label) => {
+            if (!this.linkReferences.has(label)) {
+                this.linkReferences.set(label, def);
+            }
+        });
+        result.footnoteDefinitions.forEach((def, label) => {
+            if (!this.footnoteDefinitions.has(label)) {
+                this.footnoteDefinitions.set(label, def);
+            }
+        });
+        const paragraphCount = item.children.filter((child) => child.type === 'paragraph').length;
+        if (paragraphCount >= 2) {
+            blankLineInItem = true;
+        }
+        return { blankInItem: blankLineInItem, endsWithBlank };
+    }
+    lastNonBlankLine(lines) {
+        for (let i = lines.length - 1; i >= 0; i--) {
+            const line = lines[i];
+            if (line.trim() !== '') {
+                return line;
+            }
+        }
+        return null;
+    }
+    getBlockquotePrefix(line) {
+        let i = 0;
+        let prefix = '';
+        while (i < line.length) {
+            let spaces = 0;
+            const start = i;
+            while (i < line.length && line[i] === ' ' && spaces < 3) {
+                spaces++;
+                i++;
+            }
+            if (i < line.length && line[i] === '>') {
+                i++;
+                if (i < line.length && (line[i] === ' ' || line[i] === '\t')) {
+                    i++;
+                }
+                prefix += line.slice(start, i);
+            }
+            else {
+                break;
+            }
+        }
+        return prefix;
+    }
+    allowsLazyAfterListMarker(line) {
+        const marker = (0, list_js_1.parseListMarker)(line);
+        if (!marker) {
+            return true;
+        }
+        const afterMarker = line.slice(marker.contentCharIndex);
+        return /^[ \t]*>/.test(afterMarker);
+    }
+    extractBlockquoteContent(line, match) {
+        const optionalSpace = match[1];
+        let column = 0;
+        let charIndex = 0;
+        while (charIndex < line.length && line[charIndex] === ' ' && charIndex < 3) {
+            column++;
+            charIndex++;
+        }
+        charIndex++;
+        column++;
+        let result = '';
+        if (optionalSpace === '\t') {
+            const tabWidth = 4 - (column % 4);
+            const remaining = tabWidth - 1;
+            if (remaining > 0) {
+                result = ' '.repeat(remaining);
+            }
+            charIndex++;
+            column += tabWidth;
+        }
+        else if (optionalSpace === ' ') {
+            charIndex++;
+            column++;
+        }
+        while (charIndex < line.length) {
+            const char = line[charIndex];
+            if (char === '\t') {
+                const tabWidth = 4 - (column % 4);
+                result += ' '.repeat(tabWidth);
+                column += tabWidth;
+            }
+            else {
+                result += char;
+                column++;
+            }
+            charIndex++;
+        }
+        return result;
+    }
+    extractListItemContent(line, marker) {
+        let column = 0;
+        let charIndex = 0;
+        let result = '';
+        while (charIndex < line.length && charIndex < marker.indentChars) {
+            if (line[charIndex] === '\t') {
+                column = column + (4 - (column % 4));
+            }
+            else {
+                column++;
+            }
+            charIndex++;
+        }
+        charIndex += marker.marker.length;
+        column += marker.marker.length;
+        if (charIndex < line.length && marker.paddingChars > 0) {
+            const paddingChar = line[charIndex];
+            if (paddingChar === '\t') {
+                const tabWidth = 4 - (column % 4);
+                const consumed = Math.min(tabWidth, marker.padding);
+                column += consumed;
+                charIndex += marker.paddingChars;
+                const remaining = tabWidth - consumed;
+                if (remaining > 0) {
+                    result += ' '.repeat(remaining);
+                    column += remaining;
+                }
+            }
+            else {
+                column += marker.padding;
+                charIndex += marker.paddingChars;
+            }
+        }
+        while (charIndex < line.length) {
+            const char = line[charIndex];
+            if (char === '\t') {
+                const tabWidth = 4 - (column % 4);
+                result += ' '.repeat(tabWidth);
+                column += tabWidth;
+            }
+            else {
+                result += char;
+                column++;
+            }
+            charIndex++;
+        }
+        return result;
+    }
+}
+exports.GFMBlockParser = GFMBlockParser;