@plusplusoneplusplus/coc 1.0.1 → 1.0.3

package/node_modules/@plusplusoneplusplus/forge/dist/editor/parsing/markdown-parser.d.ts

@@ -0,0 +1,203 @@
+/**
+ * Markdown parsing utilities
+ *
+ * Pure TypeScript structural parsing functions for markdown content.
+ * Every function takes strings/arrays and returns parsed structures —
+ * no side effects, no state, no DOM or VS Code dependencies.
+ */
+/**
+ * Interface for a parsed code block
+ */
+export interface CodeBlock {
+    /** Programming language identifier */
+    language: string;
+    /** Starting line number (1-based) */
+    startLine: number;
+    /** Ending line number (1-based) */
+    endLine: number;
+    /** Code content without the fence markers */
+    code: string;
+    /** Unique identifier for the block */
+    id: string;
+    /** Whether this is a mermaid diagram */
+    isMermaid: boolean;
+}
+/**
+ * Interface for markdown line highlighting result
+ */
+export interface MarkdownHighlightResult {
+    /** The HTML-formatted line */
+    html: string;
+    /** Whether we're inside a code block after this line */
+    inCodeBlock: boolean;
+    /** Current code block language if inside a block */
+    codeBlockLang: string | null;
+    /** Whether this line is a code fence start */
+    isCodeFenceStart?: boolean;
+    /** Whether this line is a code fence end */
+    isCodeFenceEnd?: boolean;
+}
+/**
+ * Parsed table structure
+ */
+export interface ParsedTable {
+    /** Starting line number (1-based, inclusive) */
+    startLine: number;
+    /** Ending line number (1-based, exclusive) */
+    endLine: number;
+    /** Header cell values */
+    headers: string[];
+    /** Column alignments */
+    alignments: Array<'left' | 'center' | 'right'>;
+    /** Body row cell values */
+    rows: string[][];
+    /** Unique identifier for the table */
+    id: string;
+}
+/**
+ * Parse code blocks from markdown content
+ */
+export declare function parseCodeBlocks(content: string): CodeBlock[];
+/**
+ * Check if content contains mermaid blocks
+ */
+export declare function hasMermaidBlocks(content: string): boolean;
+/**
+ * Parse mermaid blocks from content
+ */
+export declare function parseMermaidBlocks(content: string): CodeBlock[];
+/**
+ * Detect markdown heading level from a line
+ * Returns 0 if not a heading, 1-6 for heading levels
+ */
+export declare function detectHeadingLevel(line: string): number;
+/**
+ * Check if a line is a blockquote
+ */
+export declare function isBlockquote(line: string): boolean;
+/**
+ * Check if a line is an unordered list item
+ */
+export declare function isUnorderedListItem(line: string): boolean;
+/**
+ * Check if a line is an ordered list item
+ */
+export declare function isOrderedListItem(line: string): boolean;
+/**
+ * Check if a line is a horizontal rule
+ */
+export declare function isHorizontalRule(line: string): boolean;
+/**
+ * Check if a line is a task list item (checkbox)
+ */
+export declare function isTaskListItem(line: string): {
+    isTask: boolean;
+    checked: boolean;
+};
+/**
+ * Extract link information from markdown link syntax
+ */
+export declare function extractLinks(text: string): Array<{
+    text: string;
+    url: string;
+    start: number;
+    end: number;
+}>;
+/**
+ * Extract inline code spans from text
+ */
+export declare function extractInlineCode(text: string): Array<{
+    code: string;
+    start: number;
+    end: number;
+}>;
+/**
+ * Check if a line starts a code fence
+ */
+export declare function isCodeFenceStart(line: string): {
+    isFence: boolean;
+    language: string;
+};
+/**
+ * Check if a line ends a code fence
+ */
+export declare function isCodeFenceEnd(line: string): boolean;
+/**
+ * Detect emphasis markers in text (bold, italic, strikethrough)
+ */
+export declare function detectEmphasis(text: string): {
+    bold: Array<{
+        text: string;
+        start: number;
+        end: number;
+    }>;
+    italic: Array<{
+        text: string;
+        start: number;
+        end: number;
+    }>;
+    strikethrough: Array<{
+        text: string;
+        start: number;
+        end: number;
+    }>;
+};
+/**
+ * Parse a table row into cells
+ */
+export declare function parseTableRow(line: string): string[];
+/**
+ * Parse table alignments from a separator line
+ */
+export declare function parseTableAlignments(line: string): Array<'left' | 'center' | 'right'>;
+/**
+ * Check if a line could be a table separator
+ */
+export declare function isTableSeparator(line: string): boolean;
+/**
+ * Check if a line could be a table row
+ */
+export declare function isTableRow(line: string): boolean;
+/**
+ * Parse a markdown table starting at a specific line and return structured data
+ */
+export declare function parseTable(lines: string[], startIndex: number): {
+    headers: string[];
+    rows: string[][];
+    alignments: Array<'left' | 'center' | 'right'>;
+    endIndex: number;
+} | null;
+/**
+ * Parse all markdown tables from content.
+ * Scans through the content and returns a `ParsedTable` for every table found.
+ */
+export declare function parseTables(content: string): ParsedTable[];
+/**
+ * Extract image information from markdown image syntax
+ */
+export declare function extractImages(text: string): Array<{
+    alt: string;
+    url: string;
+    start: number;
+    end: number;
+}>;
+/**
+ * Check if an image URL is an external URL (http/https)
+ */
+export declare function isExternalImageUrl(url: string): boolean;
+/**
+ * Check if an image URL is a data URL
+ */
+export declare function isDataUrl(url: string): boolean;
+/**
+ * Detect the type of markdown element a line represents
+ */
+export type MarkdownLineType = 'heading' | 'blockquote' | 'unordered-list' | 'ordered-list' | 'task-list' | 'horizontal-rule' | 'code-fence-start' | 'code-fence-end' | 'table-row' | 'paragraph' | 'empty';
+export declare function detectLineType(line: string, inCodeBlock: boolean): MarkdownLineType;
+/**
+ * Get the language display name for a code block
+ */
+export declare function getLanguageDisplayName(language: string): string;
+import { generateAnchorId } from '../rendering/markdown-renderer';
+export { generateAnchorId };
+//# sourceMappingURL=markdown-parser.d.ts.map

package/node_modules/@plusplusoneplusplus/forge/dist/editor/parsing/markdown-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown-parser.d.ts","sourceRoot":"","sources":["../../../src/editor/parsing/markdown-parser.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;GAEG;AACH,MAAM,WAAW,SAAS;IACtB,sCAAsC;IACtC,QAAQ,EAAE,MAAM,CAAC;IACjB,qCAAqC;IACrC,SAAS,EAAE,MAAM,CAAC;IAClB,mCAAmC;IACnC,OAAO,EAAE,MAAM,CAAC;IAChB,6CAA6C;IAC7C,IAAI,EAAE,MAAM,CAAC;IACb,sCAAsC;IACtC,EAAE,EAAE,MAAM,CAAC;IACX,wCAAwC;IACxC,SAAS,EAAE,OAAO,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACpC,8BAA8B;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,wDAAwD;IACxD,WAAW,EAAE,OAAO,CAAC;IACrB,oDAAoD;IACpD,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,8CAA8C;IAC9C,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,4CAA4C;IAC5C,cAAc,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IACxB,gDAAgD;IAChD,SAAS,EAAE,MAAM,CAAC;IAClB,8CAA8C;IAC9C,OAAO,EAAE,MAAM,CAAC;IAChB,yBAAyB;IACzB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,wBAAwB;IACxB,UAAU,EAAE,KAAK,CAAC,MAAM,GAAG,QAAQ,GAAG,OAAO,CAAC,CAAC;IAC/C,2BAA2B;IAC3B,IAAI,EAAE,MAAM,EAAE,EAAE,CAAC;IACjB,sCAAsC;IACtC,EAAE,EAAE,MAAM,CAAC;CACd;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,EAAE,CAwD5D;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEzD;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,EAAE,CAE/D;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAGvD;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAElD;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEzD;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEtD;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE,CASlF;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC,CAe3G;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC,CAcnG;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAYrF;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAKpD;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG;IAC1C,IAAI,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC1D,MAAM,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC5D,aAAa,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACtE,CAuCA;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAIpD;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,KAAK,CAAC,MAAM,GAAG,QAAQ,GAAG,OAAO,CAAC,CASrF;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEtD;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEhD;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,UAAU,EAAE,MAAM,GAAG;IAC7D,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,IAAI,EAAE,MAAM,EAAE,EAAE,CAAC;IACjB,UAAU,EAAE,KAAK,CAAC,MAAM,GAAG,QAAQ,GAAG,OAAO,CAAC,CAAC;IAC/C,QAAQ,EAAE,MAAM,CAAC;CACpB,GAAG,IAAI,CAyBP;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW,EAAE,CA6B1D;AAkCD;;GAEG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,KAAK,CAAC;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC,CAe3G;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAE9C;AAED;;GAEG;AACH,MAAM,MAAM,gBAAgB,GACtB,SAAS,GACT,YAAY,GACZ,gBAAgB,GAChB,cAAc,GACd,WAAW,GACX,iBAAiB,GACjB,kBAAkB,GAClB,gBAAgB,GAChB,WAAW,GACX,WAAW,GACX,OAAO,CAAC;AAEd,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,OAAO,GAAG,gBAAgB,CA0BnF;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CA+C/D;AAED,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAClE,OAAO,EAAE,gBAAgB,EAAE,CAAC"}

package/node_modules/@plusplusoneplusplus/forge/dist/editor/parsing/markdown-parser.js

@@ -0,0 +1,474 @@
+"use strict";
+/**
+ * Markdown parsing utilities
+ *
+ * Pure TypeScript structural parsing functions for markdown content.
+ * Every function takes strings/arrays and returns parsed structures —
+ * no side effects, no state, no DOM or VS Code dependencies.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateAnchorId = void 0;
+exports.parseCodeBlocks = parseCodeBlocks;
+exports.hasMermaidBlocks = hasMermaidBlocks;
+exports.parseMermaidBlocks = parseMermaidBlocks;
+exports.detectHeadingLevel = detectHeadingLevel;
+exports.isBlockquote = isBlockquote;
+exports.isUnorderedListItem = isUnorderedListItem;
+exports.isOrderedListItem = isOrderedListItem;
+exports.isHorizontalRule = isHorizontalRule;
+exports.isTaskListItem = isTaskListItem;
+exports.extractLinks = extractLinks;
+exports.extractInlineCode = extractInlineCode;
+exports.isCodeFenceStart = isCodeFenceStart;
+exports.isCodeFenceEnd = isCodeFenceEnd;
+exports.detectEmphasis = detectEmphasis;
+exports.parseTableRow = parseTableRow;
+exports.parseTableAlignments = parseTableAlignments;
+exports.isTableSeparator = isTableSeparator;
+exports.isTableRow = isTableRow;
+exports.parseTable = parseTable;
+exports.parseTables = parseTables;
+exports.extractImages = extractImages;
+exports.isExternalImageUrl = isExternalImageUrl;
+exports.isDataUrl = isDataUrl;
+exports.detectLineType = detectLineType;
+exports.getLanguageDisplayName = getLanguageDisplayName;
+/**
+ * Parse code blocks from markdown content
+ */
+function parseCodeBlocks(content) {
+    // Normalize line endings for robust parsing across LF/CRLF/CR.
+    const normalized = content.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+    const lines = normalized.split('\n');
+    const blocks = [];
+    let inBlock = false;
+    let openingFenceLength = 0;
+    let currentBlock = {};
+    let codeLines = [];
+    lines.forEach((line, index) => {
+        // Allow any amount of leading whitespace before fences.
+        // CommonMark spec only allows 0-3 spaces, but we're lenient here to handle
+        // non-standard markdown (e.g., deeply indented code blocks in documents).
+        //
+        // Opening fence:
+        // - 3+ backticks
+        // - optional info string (no backticks)
+        // - optional trailing whitespace
+        const openingFenceMatch = line.match(/^[ \t]*(`{3,})([^\s`]*)?\s*$/);
+        if (!inBlock && openingFenceMatch) {
+            inBlock = true;
+            openingFenceLength = openingFenceMatch[1].length;
+            const language = openingFenceMatch[2] || 'plaintext';
+            currentBlock = {
+                language,
+                startLine: index + 1,
+                isMermaid: language === 'mermaid'
+            };
+            codeLines = [];
+            return;
+        }
+        if (inBlock) {
+            // Closing fence:
+            // - 3+ backticks
+            // - optional trailing whitespace only (no info string)
+            // - fence length must be >= opening fence length
+            const closingFenceMatch = line.match(/^[ \t]*(`{3,})\s*$/);
+            if (closingFenceMatch && closingFenceMatch[1].length >= openingFenceLength) {
+                inBlock = false;
+                openingFenceLength = 0;
+                currentBlock.endLine = index + 1;
+                currentBlock.code = codeLines.join('\n');
+                currentBlock.id = `codeblock-${currentBlock.startLine}`;
+                blocks.push(currentBlock);
+                currentBlock = {};
+                return;
+            }
+            codeLines.push(line);
+        }
+    });
+    return blocks;
+}
+/**
+ * Check if content contains mermaid blocks
+ */
+function hasMermaidBlocks(content) {
+    return /```mermaid[\s\S]*?```/.test(content);
+}
+/**
+ * Parse mermaid blocks from content
+ */
+function parseMermaidBlocks(content) {
+    return parseCodeBlocks(content).filter(block => block.isMermaid);
+}
+/**
+ * Detect markdown heading level from a line
+ * Returns 0 if not a heading, 1-6 for heading levels
+ */
+function detectHeadingLevel(line) {
+    const match = line.match(/^(#{1,6})\s+/);
+    return match ? match[1].length : 0;
+}
+/**
+ * Check if a line is a blockquote
+ */
+function isBlockquote(line) {
+    return /^>\s*/.test(line);
+}
+/**
+ * Check if a line is an unordered list item
+ */
+function isUnorderedListItem(line) {
+    return /^\s*[-*+]\s+/.test(line);
+}
+/**
+ * Check if a line is an ordered list item
+ */
+function isOrderedListItem(line) {
+    return /^\s*\d+\.\s+/.test(line);
+}
+/**
+ * Check if a line is a horizontal rule
+ */
+function isHorizontalRule(line) {
+    return /^(---+|\*\*\*+|___+)\s*$/.test(line);
+}
+/**
+ * Check if a line is a task list item (checkbox)
+ */
+function isTaskListItem(line) {
+    const match = line.match(/^\s*[-*+]\s+\[([ xX])\]/);
+    if (match) {
+        return {
+            isTask: true,
+            checked: match[1].toLowerCase() === 'x'
+        };
+    }
+    return { isTask: false, checked: false };
+}
+/**
+ * Extract link information from markdown link syntax
+ */
+function extractLinks(text) {
+    const links = [];
+    const regex = /\[([^\]]+)\]\(([^)]+)\)/g;
+    let match;
+    while ((match = regex.exec(text)) !== null) {
+        links.push({
+            text: match[1],
+            url: match[2],
+            start: match.index,
+            end: match.index + match[0].length
+        });
+    }
+    return links;
+}
+/**
+ * Extract inline code spans from text
+ */
+function extractInlineCode(text) {
+    const codeSpans = [];
+    const regex = /`([^`]+)`/g;
+    let match;
+    while ((match = regex.exec(text)) !== null) {
+        codeSpans.push({
+            code: match[1],
+            start: match.index,
+            end: match.index + match[0].length
+        });
+    }
+    return codeSpans;
+}
+/**
+ * Check if a line starts a code fence
+ */
+function isCodeFenceStart(line) {
+    // Allow any amount of leading whitespace before the fence.
+    // CommonMark spec only allows 0-3 spaces, but we're lenient here to handle
+    // non-standard markdown (e.g., deeply indented code blocks in documents).
+    const match = line.match(/^[ \t]*```(\w*)\s*$/);
+    if (match) {
+        return {
+            isFence: true,
+            language: match[1] || 'plaintext'
+        };
+    }
+    return { isFence: false, language: '' };
+}
+/**
+ * Check if a line ends a code fence
+ */
+function isCodeFenceEnd(line) {
+    // Allow any amount of leading whitespace before the fence.
+    // CommonMark spec only allows 0-3 spaces, but we're lenient here to handle
+    // non-standard markdown (e.g., deeply indented code blocks in documents).
+    return /^[ \t]*```\s*$/.test(line);
+}
+/**
+ * Detect emphasis markers in text (bold, italic, strikethrough)
+ */
+function detectEmphasis(text) {
+    const result = {
+        bold: [],
+        italic: [],
+        strikethrough: []
+    };
+    // Bold (**text** or __text__)
+    const boldRegex = /(\*\*|__)([^*_]+)\1/g;
+    let match;
+    while ((match = boldRegex.exec(text)) !== null) {
+        result.bold.push({
+            text: match[2],
+            start: match.index,
+            end: match.index + match[0].length
+        });
+    }
+    // Italic (*text* or _text_) - need to avoid bold markers
+    const italicRegex = /(?<!\*)\*([^*]+)\*(?!\*)|(?<!_)_([^_]+)_(?!_)/g;
+    while ((match = italicRegex.exec(text)) !== null) {
+        result.italic.push({
+            text: match[1] || match[2],
+            start: match.index,
+            end: match.index + match[0].length
+        });
+    }
+    // Strikethrough ~~text~~
+    const strikeRegex = /~~([^~]+)~~/g;
+    while ((match = strikeRegex.exec(text)) !== null) {
+        result.strikethrough.push({
+            text: match[1],
+            start: match.index,
+            end: match.index + match[0].length
+        });
+    }
+    return result;
+}
+/**
+ * Parse a table row into cells
+ */
+function parseTableRow(line) {
+    // Remove leading/trailing pipes and split
+    const trimmed = line.replace(/^\|/, '').replace(/\|$/, '');
+    return trimmed.split('|').map(cell => cell.trim());
+}
+/**
+ * Parse table alignments from a separator line
+ */
+function parseTableAlignments(line) {
+    const cells = parseTableRow(line);
+    return cells.map(cell => {
+        const left = cell.startsWith(':');
+        const right = cell.endsWith(':');
+        if (left && right)
+            return 'center';
+        if (right)
+            return 'right';
+        return 'left';
+    });
+}
+/**
+ * Check if a line could be a table separator
+ */
+function isTableSeparator(line) {
+    return /^\|?[\s\-:|]+\|[\s\-:|]*$/.test(line);
+}
+/**
+ * Check if a line could be a table row
+ */
+function isTableRow(line) {
+    return line.includes('|');
+}
+/**
+ * Parse a markdown table starting at a specific line and return structured data
+ */
+function parseTable(lines, startIndex) {
+    if (startIndex >= lines.length)
+        return null;
+    const headerLine = lines[startIndex];
+    if (!headerLine.includes('|'))
+        return null;
+    const separatorLine = lines[startIndex + 1];
+    if (!separatorLine || !isTableSeparator(separatorLine))
+        return null;
+    const headers = parseTableRow(headerLine);
+    const alignments = parseTableAlignments(separatorLine);
+    const rows = [];
+    let i = startIndex + 2;
+    while (i < lines.length && lines[i].includes('|')) {
+        rows.push(parseTableRow(lines[i]));
+        i++;
+    }
+    return {
+        headers,
+        rows,
+        alignments,
+        endIndex: i - 1
+    };
+}
+/**
+ * Parse all markdown tables from content.
+ * Scans through the content and returns a `ParsedTable` for every table found.
+ */
+function parseTables(content) {
+    // Normalize line endings for consistent parsing across LF/CRLF/CR.
+    const normalized = content.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+    const lines = normalized.split('\n');
+    const tables = [];
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        // Check if this line could be a table header (contains |)
+        if (line.includes('|') && i + 1 < lines.length) {
+            const separatorLine = lines[i + 1];
+            // Check if next line is a table separator (contains | and - or :)
+            if (/^\|?[\s\-:|]+\|/.test(separatorLine)) {
+                const table = parseTableAt(lines, i);
+                if (table) {
+                    tables.push(table);
+                    // table.endLine is 1-based exclusive, convert back to 0-based for loop
+                    i = table.endLine - 1;
+                    continue;
+                }
+            }
+        }
+        i++;
+    }
+    return tables;
+}
+/**
+ * Parse a table starting at a specific 0-based line index
+ */
+function parseTableAt(lines, startIndex) {
+    const headerLine = lines[startIndex];
+    const separatorLine = lines[startIndex + 1];
+    const headers = parseTableRow(headerLine);
+    if (headers.length === 0)
+        return null;
+    const alignments = parseTableAlignments(separatorLine);
+    const rows = [];
+    let i = startIndex + 2;
+    while (i < lines.length && lines[i].includes('|')) {
+        const row = parseTableRow(lines[i]);
+        if (row.length > 0) {
+            rows.push(row);
+        }
+        i++;
+    }
+    return {
+        startLine: startIndex + 1, // 1-based (inclusive)
+        endLine: i + 1, // 1-based (exclusive)
+        headers,
+        alignments,
+        rows,
+        id: 'table-' + (startIndex + 1)
+    };
+}
+/**
+ * Extract image information from markdown image syntax
+ */
+function extractImages(text) {
+    const images = [];
+    const regex = /!\[([^\]]*)\]\(([^)]+)\)/g;
+    let match;
+    while ((match = regex.exec(text)) !== null) {
+        images.push({
+            alt: match[1],
+            url: match[2],
+            start: match.index,
+            end: match.index + match[0].length
+        });
+    }
+    return images;
+}
+/**
+ * Check if an image URL is an external URL (http/https)
+ */
+function isExternalImageUrl(url) {
+    return /^https?:\/\//i.test(url);
+}
+/**
+ * Check if an image URL is a data URL
+ */
+function isDataUrl(url) {
+    return /^data:/i.test(url);
+}
+function detectLineType(line, inCodeBlock) {
+    if (inCodeBlock) {
+        if (isCodeFenceEnd(line))
+            return 'code-fence-end';
+        return 'paragraph'; // Inside code block, treat as plain text
+    }
+    if (line.trim() === '')
+        return 'empty';
+    const fenceCheck = isCodeFenceStart(line);
+    if (fenceCheck.isFence)
+        return 'code-fence-start';
+    if (isHorizontalRule(line))
+        return 'horizontal-rule';
+    if (detectHeadingLevel(line) > 0)
+        return 'heading';
+    if (isBlockquote(line))
+        return 'blockquote';
+    const taskCheck = isTaskListItem(line);
+    if (taskCheck.isTask)
+        return 'task-list';
+    if (isUnorderedListItem(line))
+        return 'unordered-list';
+    if (isOrderedListItem(line))
+        return 'ordered-list';
+    if (line.includes('|'))
+        return 'table-row';
+    return 'paragraph';
+}
+/**
+ * Get the language display name for a code block
+ */
+function getLanguageDisplayName(language) {
+    const displayNames = {
+        'js': 'JavaScript',
+        'javascript': 'JavaScript',
+        'ts': 'TypeScript',
+        'typescript': 'TypeScript',
+        'py': 'Python',
+        'python': 'Python',
+        'rb': 'Ruby',
+        'ruby': 'Ruby',
+        'java': 'Java',
+        'cs': 'C#',
+        'csharp': 'C#',
+        'cpp': 'C++',
+        'c': 'C',
+        'go': 'Go',
+        'rust': 'Rust',
+        'rs': 'Rust',
+        'swift': 'Swift',
+        'kotlin': 'Kotlin',
+        'kt': 'Kotlin',
+        'php': 'PHP',
+        'sql': 'SQL',
+        'html': 'HTML',
+        'css': 'CSS',
+        'scss': 'SCSS',
+        'sass': 'Sass',
+        'less': 'Less',
+        'json': 'JSON',
+        'yaml': 'YAML',
+        'yml': 'YAML',
+        'xml': 'XML',
+        'md': 'Markdown',
+        'markdown': 'Markdown',
+        'bash': 'Bash',
+        'sh': 'Shell',
+        'shell': 'Shell',
+        'powershell': 'PowerShell',
+        'ps1': 'PowerShell',
+        'dockerfile': 'Dockerfile',
+        'docker': 'Dockerfile',
+        'plaintext': 'Plain Text',
+        'text': 'Plain Text',
+        'mermaid': 'Mermaid Diagram'
+    };
+    return displayNames[language.toLowerCase()] || language.toUpperCase();
+}
+const markdown_renderer_1 = require("../rendering/markdown-renderer");
+Object.defineProperty(exports, "generateAnchorId", { enumerable: true, get: function () { return markdown_renderer_1.generateAnchorId; } });
+//# sourceMappingURL=markdown-parser.js.map