emdp 1.0.0

package/dist/parser/utils.js

@@ -0,0 +1,277 @@
+"use strict";
+/**
+ * Shared text-processing utilities for the parser, including entity decoding, escaping,
+ * whitespace handling, and URI normalization.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ASCII_PUNCTUATION_CHARS = exports.ASCII_PUNCTUATION_REGEX = void 0;
+exports.decodeHtmlEntities = decodeHtmlEntities;
+exports.escapeXml = escapeXml;
+exports.escapeHtml = escapeHtml;
+exports.isAsciiPunctuation = isAsciiPunctuation;
+exports.isWhitespace = isWhitespace;
+exports.isUnicodeWhitespace = isUnicodeWhitespace;
+exports.isUnicodePunctuation = isUnicodePunctuation;
+exports.normalizeLineEndings = normalizeLineEndings;
+exports.expandTabs = expandTabs;
+exports.expandTabsPartial = expandTabsPartial;
+exports.trimLeadingSpaces = trimLeadingSpaces;
+exports.countLeadingSpaces = countLeadingSpaces;
+exports.countLeadingChars = countLeadingChars;
+exports.removeIndent = removeIndent;
+exports.extractContentAfterMarker = extractContentAfterMarker;
+exports.normalizeUri = normalizeUri;
+exports.unescapeString = unescapeString;
+exports.normalizeLabel = normalizeLabel;
+exports.isTagFilterTag = isTagFilterTag;
+exports.applyTagFilter = applyTagFilter;
+const entities_js_1 = require("./entities.js");
+function decodeHtmlEntities(str) {
+    return str.replace(/&(#[xX]?[0-9a-fA-F]+|[a-zA-Z][a-zA-Z0-9]*);/g, (match, capture) => {
+        if (capture.startsWith('#x') || capture.startsWith('#X')) {
+            const code = parseInt(capture.slice(2), 16);
+            if (!isNaN(code) && code >= 0 && code <= 0x10ffff) {
+                if (code === 0)
+                    return '\uFFFD';
+                return String.fromCodePoint(code);
+            }
+        }
+        else if (capture.startsWith('#')) {
+            const code = parseInt(capture.slice(1), 10);
+            if (!isNaN(code) && code >= 0 && code <= 0x10ffff) {
+                if (code === 0)
+                    return '\uFFFD';
+                return String.fromCodePoint(code);
+            }
+        }
+        else if (entities_js_1.HTML_ENTITIES[capture]) {
+            return entities_js_1.HTML_ENTITIES[capture];
+        }
+        return match;
+    });
+}
+function escapeXml(str) {
+    return str
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;');
+}
+function escapeHtml(str, preserveEntities = false) {
+    if (preserveEntities) {
+        return str
+            .replace(/&(?![#a-zA-Z0-9]+;)/g, '&amp;')
+            .replace(/</g, '&lt;')
+            .replace(/>/g, '&gt;')
+            .replace(/"/g, '&quot;');
+    }
+    return escapeXml(str);
+}
+exports.ASCII_PUNCTUATION_REGEX = /[!"#$%&'()*+,\-./:;<=>?@\[\\\]^_`{|}~]/;
+exports.ASCII_PUNCTUATION_CHARS = '!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~';
+function isAsciiPunctuation(char) {
+    return exports.ASCII_PUNCTUATION_REGEX.test(char);
+}
+function isWhitespace(char) {
+    return char === ' ' || char === '\t' || char === '\n' || char === '\r' || char === '\f';
+}
+function isUnicodeWhitespace(char) {
+    return /\s/.test(char);
+}
+function isUnicodePunctuation(char) {
+    return /[\p{P}\p{S}]/u.test(char);
+}
+function normalizeLineEndings(str) {
+    return str.replace(/\r\n?/g, '\n');
+}
+function expandTabs(line, tabStop = 4) {
+    let result = '';
+    let column = 0;
+    for (const char of line) {
+        if (char === '\t') {
+            const spaces = tabStop - (column % tabStop);
+            result += ' '.repeat(spaces);
+            column += spaces;
+        }
+        else {
+            result += char;
+            column++;
+        }
+    }
+    return result;
+}
+function expandTabsPartial(line, startColumn, tabStop = 4) {
+    let result = '';
+    let column = startColumn;
+    for (const char of line) {
+        if (char === '\t') {
+            const spaces = tabStop - (column % tabStop);
+            result += ' '.repeat(spaces);
+            column += spaces;
+        }
+        else {
+            result += char;
+            column++;
+        }
+    }
+    return result;
+}
+function trimLeadingSpaces(line, max = 3) {
+    let count = 0;
+    let i = 0;
+    while (i < line.length && line[i] === ' ' && count < max) {
+        count++;
+        i++;
+    }
+    return { trimmed: line.slice(i), count };
+}
+function countLeadingSpaces(line) {
+    let count = 0;
+    for (const char of line) {
+        if (char === ' ')
+            count++;
+        else if (char === '\t')
+            count += 4 - (count % 4);
+        else
+            break;
+    }
+    return count;
+}
+function countLeadingChars(line) {
+    let spaces = 0;
+    let chars = 0;
+    for (const char of line) {
+        if (char === ' ') {
+            spaces++;
+            chars++;
+        }
+        else if (char === '\t') {
+            const tabWidth = 4 - (spaces % 4);
+            spaces += tabWidth;
+            chars++;
+        }
+        else {
+            break;
+        }
+    }
+    return { spaces, chars };
+}
+function removeIndent(line, indent) {
+    let removed = 0;
+    let i = 0;
+    while (i < line.length && removed < indent) {
+        if (line[i] === ' ') {
+            removed++;
+            i++;
+        }
+        else if (line[i] === '\t') {
+            const tabWidth = 4 - (removed % 4);
+            if (removed + tabWidth <= indent) {
+                removed += tabWidth;
+                i++;
+            }
+            else {
+                const remaining = indent - removed;
+                const spacesFromTab = tabWidth - remaining;
+                const originalColumn = removed + tabWidth;
+                return ' '.repeat(spacesFromTab) + expandRestOfLine(line, i + 1, originalColumn);
+            }
+        }
+        else {
+            break;
+        }
+    }
+    return line.slice(i);
+}
+function expandRestOfLine(line, startIdx, startColumn) {
+    let result = '';
+    let column = startColumn;
+    for (let i = startIdx; i < line.length; i++) {
+        const char = line[i];
+        if (char === '\t') {
+            const tabWidth = 4 - (column % 4);
+            result += ' '.repeat(tabWidth);
+            column += tabWidth;
+        }
+        else {
+            result += char;
+            column++;
+        }
+    }
+    return result;
+}
+function extractContentAfterMarker(line, startColumn, charIndex) {
+    if (charIndex > 0 && line[charIndex - 1] === '\t') {
+        let col = 0;
+        let idx = 0;
+        while (idx < charIndex - 1) {
+            if (line[idx] === '\t') {
+                col = col + (4 - (col % 4));
+            }
+            else {
+                col++;
+            }
+            idx++;
+        }
+        const tabEndColumn = col + (4 - (col % 4));
+        if (startColumn > col && startColumn < tabEndColumn) {
+            const remainingSpaces = tabEndColumn - startColumn;
+            return ' '.repeat(remainingSpaces) + line.slice(charIndex);
+        }
+    }
+    return line.slice(charIndex);
+}
+function normalizeUri(uri) {
+    try {
+        let result = '';
+        let i = 0;
+        while (i < uri.length) {
+            const char = uri[i];
+            if (char === '%' && i + 2 < uri.length && /^[0-9a-fA-F]{2}$/.test(uri.slice(i + 1, i + 3))) {
+                result += uri.slice(i, i + 3).toUpperCase();
+                i += 3;
+            }
+            else {
+                const code = char.charCodeAt(0);
+                if (code > 0x7f || char === ' ') {
+                    result += encodeURIComponent(char);
+                }
+                else {
+                    result += char;
+                }
+                i++;
+            }
+        }
+        return result;
+    }
+    catch {
+        return uri;
+    }
+}
+function unescapeString(str) {
+    return str.replace(/\\([!"#$%&'()*+,\-./:;<=>?@\[\\\]^_`{|}~])/g, '$1');
+}
+function normalizeLabel(label) {
+    return label
+        .trim()
+        .replace(/[ \t\r\n]+/g, ' ')
+        .replace(/\u1e9e/g, 'ss')
+        .toLowerCase();
+}
+const TAG_FILTER = new Set([
+    'title',
+    'textarea',
+    'style',
+    'xmp',
+    'iframe',
+    'noembed',
+    'noframes',
+    'script',
+    'plaintext',
+]);
+function isTagFilterTag(tagName) {
+    return TAG_FILTER.has(tagName.toLowerCase());
+}
+function applyTagFilter(html) {
+    return html.replace(/<(?=[ \t\n\r]*\/?[ \t\n\r]*(?:title|textarea|style|xmp|iframe|noembed|noframes|script|plaintext)\b)/gi, '&lt;');
+}

package/dist/types/cli.d.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+/**
+ * Command-line interface for the Markdown parser that reads Markdown from stdin and writes rendered
+ * HTML to stdout with optional GFM flags.
+ */
+export {};

package/dist/types/gfm.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Entry point for GitHub Flavored Markdown that re-exports GFM helpers, renderer, and AST types.
+ */
+export * from './parser/gfm/index.js';
+export { default } from './parser/gfm/index.js';
+export type { DocumentNode, BlockNode, InlineNode, ParagraphNode, HeadingNode, ThematicBreakNode, CodeBlockNode, BlockquoteNode, ListNode, ListItemNode, HtmlBlockNode, TableNode, TableRowNode, TableCellNode, TableAlignment, TextNode, SoftbreakNode, HardbreakNode, CodeSpanNode, EmphasisNode, StrongNode, StrikethroughNode, LinkNode, ImageNode, HtmlInlineNode, ParseOptions, RenderOptions, } from './parser/types.js';

package/dist/types/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Main entry point for the CommonMark parser that re-exports public APIs.
+ */
+export * from './parser/index.js';
+export { default } from './parser/index.js';

package/dist/types/parser/block-parser.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Block parsing phase that builds block nodes like paragraphs, headings, lists, code blocks,
+ * blockquotes, and HTML blocks while collecting link reference definitions.
+ */
+import type { DocumentNode, LinkReferenceDefinition } from './types.js';
+export declare class BlockParser {
+    private lines;
+    private lineIndex;
+    private linkReferences;
+    private static readonly LAZY_PREFIX;
+    parse(input: string): {
+        document: DocumentNode;
+        linkReferences: Map<string, LinkReferenceDefinition>;
+    };
+    private currentLine;
+    private advance;
+    private parseBlocks;
+    private parseList;
+    private parseListItem;
+    private lastNonBlankLine;
+    private getBlockquotePrefix;
+    private allowsLazyAfterListMarker;
+    private extractBlockquoteContent;
+    private extractListItemContent;
+}

package/dist/types/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/types/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;

package/dist/types/parser/blocks/code-block-indented.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Parser for indented code blocks.
+ */
+import type { CodeBlockNode } from '../types.js';
+export declare function isIndentedCodeLine(line: string): boolean;
+export declare function removeIndentation(line: string, amount?: number): string;
+export declare function createIndentedCodeBlock(lines: string[]): CodeBlockNode;

package/dist/types/parser/blocks/heading-atx.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Parser for ATX headings using leading # markers.
+ */
+import type { HeadingNode } from '../types.js';
+export declare function parseAtxHeading(line: string): {
+    level: 1 | 2 | 3 | 4 | 5 | 6;
+    content: string;
+} | null;
+export declare function isAtxHeading(line: string): boolean;
+export declare function createHeadingNode(level: 1 | 2 | 3 | 4 | 5 | 6): HeadingNode;

package/dist/types/parser/blocks/heading-setext.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Parser for setext headings underlined with = or -.
+ */
+export declare function parseSetextHeading(line: string): {
+    level: 1 | 2;
+} | null;
+export declare function isSetextHeadingUnderline(line: string): boolean;
+export declare function getSetextLevel(line: string): 1 | 2 | null;

package/dist/types/parser/blocks/html-block.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Parser for raw HTML blocks defined by the CommonMark spec.
+ */
+import type { HtmlBlockNode } from '../types.js';
+export type HtmlBlockType = 1 | 2 | 3 | 4 | 5 | 6 | 7 | null;
+export declare function getHtmlBlockType(line: string, canInterruptParagraph: boolean): HtmlBlockType;
+export declare function isHtmlBlockClose(line: string, type: HtmlBlockType): boolean;
+export declare function isHtmlBlockStart(line: string, canInterruptParagraph?: boolean): boolean;
+export declare function createHtmlBlockNode(content: string): HtmlBlockNode;

package/dist/types/parser/blocks/link-reference.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Parser for link reference definitions used by reference-style links.
+ */
+import type { LinkReferenceDefinition } from '../types.js';
+export interface LinkRefResult {
+    label: string;
+    definition: LinkReferenceDefinition;
+    consumed: number;
+}
+export declare function parseLinkReferenceDefinition(text: string): LinkRefResult | null;
+export declare function isLinkReferenceStart(line: string): boolean;

package/dist/types/parser/blocks/list.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Parser for ordered and unordered lists with nesting and tight/loose detection.
+ */
+import type { ListNode, ListItemNode } from '../types.js';
+export interface ListMarker {
+    type: 'bullet' | 'ordered';
+    indent: number;
+    indentChars: number;
+    marker: string;
+    bulletChar?: '-' | '+' | '*';
+    start?: number;
+    delimiter?: '.' | ')';
+    padding: number;
+    paddingChars: number;
+    contentIndent: number;
+    contentCharIndex: number;
+}
+export declare function parseListMarker(line: string): ListMarker | null;
+export declare function isListItemStart(line: string): boolean;
+export declare function isBulletListStart(line: string): boolean;
+export declare function isOrderedListStart(line: string): boolean;
+export declare function canStartList(line: string, interruptingParagraph: boolean): boolean;
+export declare function createListNode(marker: ListMarker): ListNode;
+export declare function createListItemNode(): ListItemNode;
+export declare function listsMatch(a: ListMarker, b: ListMarker): boolean;

package/dist/types/parser/blocks/paragraph.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Parser for paragraph blocks as the default block type.
+ */
+import type { ParagraphNode } from '../types.js';
+export declare function createParagraphNode(): ParagraphNode;
+export declare function isParagraphContinuation(line: string): boolean;
+export declare function trimParagraphLine(line: string): string;

package/dist/types/parser/blocks/table.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Parser for GFM tables built from pipe-delimited rows.
+ */
+import type { TableNode, TableRowNode, TableCellNode, TableAlignment, InlineNode } from '../types.js';
+export declare function parseDelimiterRow(line: string): TableAlignment[] | null;
+export declare function splitTableRow(line: string): string[];
+export declare function isTableRow(line: string): boolean;
+export declare function couldBeTableHeader(line: string): boolean;
+export declare function isTableStart(headerLine: string, delimiterLine: string): TableAlignment[] | null;
+export declare function createTableCellNode(align: TableAlignment, isHeader: boolean, children?: InlineNode[]): TableCellNode;
+export declare function createTableRowNode(isHeader: boolean, cells?: TableCellNode[]): TableRowNode;
+export declare function createTableNode(alignments: TableAlignment[]): TableNode;
+export declare function parseTableRowCells(line: string, alignments: TableAlignment[], isHeader: boolean): TableCellNode[];

package/dist/types/parser/blocks/task-list.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Parser for GFM task list items that recognize [ ] and [x] markers.
+ */
+import type { ListItemNode } from '../types.js';
+export declare function parseTaskListMarker(text: string): {
+    checked: boolean;
+    length: number;
+} | null;
+export declare function processTaskListItem(item: ListItemNode): void;
+export declare function processTaskLists(blocks: any[]): void;

package/dist/types/parser/blocks/thematic-break.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Parser for thematic breaks (horizontal rules).
+ */
+import type { ThematicBreakNode } from '../types.js';
+export declare function parseThematicBreak(line: string): ThematicBreakNode | null;
+export declare function isThematicBreak(line: string): boolean;

package/dist/types/parser/entities.d.ts

@@ -0,0 +1,4 @@
+/**
+ * HTML named character reference map used to decode entities in Markdown content.
+ */
+export declare const HTML_ENTITIES: Record<string, string>;

package/dist/types/parser/gfm/block-parser.d.ts

@@ -0,0 +1,32 @@
+/**
+ * GFM block parser that extends CommonMark with table support.
+ */
+import type { DocumentNode, LinkReferenceDefinition, FootnoteDefinition } from '../types.js';
+export declare class GFMBlockParser {
+    private lines;
+    private lineIndex;
+    private linkReferences;
+    private footnoteDefinitions;
+    private static readonly LAZY_PREFIX;
+    private enableTables;
+    private enableTaskLists;
+    private enableFootnotes;
+    constructor(extensions?: Set<string>);
+    parse(input: string): {
+        document: DocumentNode;
+        linkReferences: Map<string, LinkReferenceDefinition>;
+        footnoteDefinitions: Map<string, FootnoteDefinition>;
+    };
+    private currentLine;
+    private advance;
+    private parseBlocks;
+    private parseTable;
+    private parseFootnoteDefinition;
+    private parseList;
+    private parseListItem;
+    private lastNonBlankLine;
+    private getBlockquotePrefix;
+    private allowsLazyAfterListMarker;
+    private extractBlockquoteContent;
+    private extractListItemContent;
+}

package/dist/types/parser/gfm/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * GFM parser entry point that exposes the CommonMark superset with GFM extensions.
+ */
+import type { DocumentNode, ParseOptions, RenderOptions } from '../types.js';
+import { GFMBlockParser } from './block-parser.js';
+import { GFMInlineParser } from './inline-parser.js';
+import { GFMHtmlRenderer } from './renderer.js';
+export { GFMBlockParser } from './block-parser.js';
+export { GFMInlineParser } from './inline-parser.js';
+export { GFMHtmlRenderer } from './renderer.js';
+export declare class GFMParser {
+    private blockParser;
+    private inlineParser;
+    private options;
+    constructor(options?: ParseOptions);
+    parse(input: string): DocumentNode;
+    private processInlines;
+}
+export declare function parse(input: string, options?: ParseOptions): DocumentNode;
+export declare function render(document: DocumentNode, options?: RenderOptions): string;
+export declare function gfm(input: string, options?: ParseOptions & RenderOptions): string;
+declare const _default: {
+    parse: typeof parse;
+    render: typeof render;
+    gfm: typeof gfm;
+    GFMParser: typeof GFMParser;
+    GFMBlockParser: typeof GFMBlockParser;
+    GFMInlineParser: typeof GFMInlineParser;
+    GFMHtmlRenderer: typeof GFMHtmlRenderer;
+};
+export default _default;

package/dist/types/parser/gfm/inline-parser.d.ts

@@ -0,0 +1,25 @@
+/**
+ * GFM inline parser that extends CommonMark with strikethrough and extended autolinks.
+ */
+import type { InlineNode, LinkReferenceDefinition, FootnoteDefinition } from '../types.js';
+export declare class GFMInlineParser {
+    private linkReferences;
+    private footnoteDefinitions;
+    private enableAutolink;
+    private enableStrikethrough;
+    private enableFootnotes;
+    private enableTagfilter;
+    constructor(extensions?: Set<string>);
+    setLinkReferences(refs: Map<string, LinkReferenceDefinition>): void;
+    setFootnoteDefinitions(defs: Map<string, FootnoteDefinition>): void;
+    parse(text: string): InlineNode[];
+    private extractTextFromNodes;
+    private normalizeLabelForMatching;
+    private processEmphasisAndStrikethrough;
+    private processStrikethrough;
+    private processEmphasis;
+    private flattenNestedEmphasis;
+    private computeDelimiterRun;
+    private getFirstChar;
+    private getLastChar;
+}

package/dist/types/parser/gfm/renderer.d.ts

@@ -0,0 +1,43 @@
+/**
+ * GFM HTML renderer that adds tables, strikethrough, and task list rendering on top of CommonMark.
+ */
+import type { DocumentNode, RenderOptions } from '../types.js';
+export declare class GFMHtmlRenderer {
+    private options;
+    private footnoteDefinitions;
+    private footnoteOrder;
+    private footnoteRefCounts;
+    private footnoteRefIds;
+    constructor(options?: RenderOptions);
+    render(document: DocumentNode): string;
+    private renderBlocks;
+    private renderBlock;
+    private renderParagraph;
+    private renderHeading;
+    private renderThematicBreak;
+    private renderCodeBlock;
+    private renderBlockquote;
+    private renderList;
+    private renderListItem;
+    private renderHtmlBlock;
+    private renderTable;
+    private renderTableRow;
+    private renderTableCell;
+    private renderInlines;
+    private renderInline;
+    private renderText;
+    private renderSoftbreak;
+    private renderHardbreak;
+    private renderCodeSpan;
+    private renderEmphasis;
+    private renderStrong;
+    private renderStrikethrough;
+    private renderFootnoteRef;
+    private renderLink;
+    private renderImage;
+    private renderHtmlInline;
+    private renderInlinesSmart;
+    private applyDashesAndEllipses;
+    private renderFootnotes;
+    private renderFootnoteBackrefs;
+}

package/dist/types/parser/index.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Core parser module that coordinates block and inline parsing and exposes the main parser
+ * class and convenience helpers.
+ */
+import type { DocumentNode, ParseOptions, RenderOptions } from './types.js';
+import { BlockParser } from './block-parser.js';
+import { InlineParser } from './inline-parser.js';
+import { HtmlRenderer } from './renderer.js';
+export * from './types.js';
+export { BlockParser } from './block-parser.js';
+export { InlineParser } from './inline-parser.js';
+export { HtmlRenderer } from './renderer.js';
+export declare class MarkdownParser {
+    private blockParser;
+    private inlineParser;
+    private options;
+    constructor(options?: ParseOptions);
+    parse(input: string): DocumentNode;
+    private processInlines;
+}
+export declare function parse(input: string, options?: ParseOptions): DocumentNode;
+export declare function render(document: DocumentNode, options?: RenderOptions): string;
+export declare function markdown(input: string, options?: ParseOptions & RenderOptions): string;
+declare const _default: {
+    parse: typeof parse;
+    render: typeof render;
+    markdown: typeof markdown;
+    MarkdownParser: typeof MarkdownParser;
+    BlockParser: typeof BlockParser;
+    InlineParser: typeof InlineParser;
+    HtmlRenderer: typeof HtmlRenderer;
+};
+export default _default;

package/dist/types/parser/inline-parser.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Inline parsing phase that builds inline nodes such as emphasis, links, images, code spans,
+ * autolinks, and HTML.
+ */
+import type { InlineNode, LinkReferenceDefinition } from './types.js';
+export declare class InlineParser {
+    private linkReferences;
+    setLinkReferences(refs: Map<string, LinkReferenceDefinition>): void;
+    parse(text: string): InlineNode[];
+    private extractTextFromNodes;
+    private normalizeLabelForMatching;
+    private processEmphasis;
+    private computeDelimiterRun;
+    private getFirstChar;
+    private getLastChar;
+}