emdp 1.0.0

package/dist/parser/block-parser.js

@@ -0,0 +1,644 @@
+"use strict";
+/**
+ * Block parsing phase that builds block nodes like paragraphs, headings, lists, code blocks,
+ * blockquotes, and HTML blocks while collecting link reference definitions.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockParser = 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 paragraph_js_1 = require("./blocks/paragraph.js");
+const link_reference_js_1 = require("./blocks/link-reference.js");
+function parseLine(raw) {
+    let indent = 0;
+    let i = 0;
+    while (i < raw.length) {
+        if (raw[i] === ' ') {
+            indent++;
+            i++;
+        }
+        else if (raw[i] === '\t') {
+            indent += 4 - (indent % 4);
+            i++;
+        }
+        else {
+            break;
+        }
+    }
+    return { raw, content: raw.slice(i), indent };
+}
+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 BlockParser {
+    lines = [];
+    lineIndex = 0;
+    linkReferences = new Map();
+    static LAZY_PREFIX = '\u0000';
+    parse(input) {
+        this.lines = (0, utils_js_1.normalizeLineEndings)(input).split('\n');
+        this.lineIndex = 0;
+        this.linkReferences = new Map();
+        const document = {
+            type: 'document',
+            children: [],
+        };
+        this.parseBlocks(document, 0);
+        return { document, linkReferences: this.linkReferences };
+    }
+    currentLine() {
+        return this.lines[this.lineIndex];
+    }
+    advance() {
+        this.lineIndex++;
+    }
+    parseBlocks(container, baseIndent) {
+        let paragraphLines = [];
+        let paragraphCanBeInterrupted = true;
+        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 = [];
+                paragraphCanBeInterrupted = true;
+                return consumed > 0 || text.length > 0;
+            }
+            return false;
+        };
+        while (this.lineIndex < this.lines.length) {
+            const line = this.currentLine();
+            if (line.startsWith(BlockParser.LAZY_PREFIX)) {
+                const raw = line.slice(BlockParser.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 dedentedIndent = getIndent(dedented);
+            if ((0, thematic_break_js_1.isThematicBreak)(line)) {
+                if (paragraphLines.length > 0 && /^ {0,3}-+[ \t]*$/.test(line)) {
+                    const level = (0, heading_setext_js_1.getSetextLevel)(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)(level);
+                        heading.rawContent = content;
+                        container.children.push(heading);
+                    }
+                    else {
+                        container.children.push((0, thematic_break_js_1.parseThematicBreak)(line));
+                    }
+                    this.advance();
+                    continue;
+                }
+                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 + BlockParser.LAZY_PREFIX + quoteLine);
+                            this.advance();
+                        }
+                        else {
+                            break;
+                        }
+                    }
+                    else {
+                        break;
+                    }
+                }
+                const subParser = new BlockParser();
+                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);
+                    }
+                });
+                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_1.createHtmlBlockNode)(htmlLines.join('\n') + '\n'));
+                continue;
+            }
+            paragraphLines.push((0, utils_js_1.removeIndent)(line, Math.min(lineIndent, 3)));
+            this.advance();
+        }
+        finishParagraph();
+    }
+    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(BlockParser.LAZY_PREFIX)) {
+            firstLine = firstLine.slice(BlockParser.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(BlockParser.LAZY_PREFIX)) {
+                line = line.slice(BlockParser.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 BlockParser();
+        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);
+            }
+        });
+        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 fullMatch = match[0];
+        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) {
+        const contentStartColumn = marker.indent + marker.marker.length + marker.padding;
+        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.BlockParser = BlockParser;

package/dist/parser/blocks/blockquote.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Parser for blockquote elements prefixed with >.
+ */
+import type { BlockquoteNode } from '../types.js';
+export declare function isBlockquoteStart(line: string): boolean;
+export declare function removeBlockquotePrefix(line: string): string;
+export declare function createBlockquoteNode(): BlockquoteNode;
+export declare function getBlockquoteContent(line: string): string | null;

package/dist/parser/blocks/blockquote.js

@@ -0,0 +1,28 @@
+"use strict";
+/**
+ * Parser for blockquote elements prefixed with >.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBlockquoteStart = isBlockquoteStart;
+exports.removeBlockquotePrefix = removeBlockquotePrefix;
+exports.createBlockquoteNode = createBlockquoteNode;
+exports.getBlockquoteContent = getBlockquoteContent;
+const BLOCKQUOTE_REGEX = /^( {0,3})>( ?)/;
+function isBlockquoteStart(line) {
+    return BLOCKQUOTE_REGEX.test(line);
+}
+function removeBlockquotePrefix(line) {
+    return line.replace(BLOCKQUOTE_REGEX, '');
+}
+function createBlockquoteNode() {
+    return {
+        type: 'blockquote',
+        children: [],
+    };
+}
+function getBlockquoteContent(line) {
+    const match = line.match(BLOCKQUOTE_REGEX);
+    if (!match)
+        return null;
+    return line.slice(match[0].length);
+}

package/dist/parser/blocks/code-block-fenced.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Parser for fenced code blocks with optional info strings.
+ */
+import type { CodeBlockNode } from '../types.js';
+export interface FenceInfo {
+    indent: number;
+    char: '`' | '~';
+    length: number;
+    info: string;
+}
+export declare function parseFenceOpen(line: string): FenceInfo | null;
+export declare function isFenceClose(line: string, fence: FenceInfo): boolean;
+export declare function isFencedCodeStart(line: string): boolean;
+export declare function createFencedCodeBlock(info: string, lines: string[], indent: number): CodeBlockNode;