quikdown 1.1.1 → 1.2.3

package/dist/quikdown_yaml.umd.js

@@ -0,0 +1,723 @@
+/**
+ * quikdown_yaml - YAML Markdown Parser
+ * @version 1.2.3
+ * @license BSD-2-Clause
+ * @copyright DeftIO 2025
+ */
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
+    typeof define === 'function' && define.amd ? define(factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.quikdown_yaml = factory());
+})(this, (function () { 'use strict';
+
+    /**
+     * quikdown_ast - Forgiving markdown to AST parser
+     * Converts markdown to a structured Abstract Syntax Tree
+     * @param {string} markdown - The markdown source text
+     * @param {Object} options - Optional configuration object
+     * @returns {Object} - The AST object
+     */
+
+    // Version will be injected at build time
+    const quikdownVersion$1 = '1.2.3';
+
+    // Safety limit to prevent infinite loops in list parsing
+    const MAX_LOOP_ITERATIONS = 1000;
+
+    /**
+     * Parse markdown into an AST
+     * @param {string} markdown - The markdown source text
+     * @param {Object} options - Optional configuration object
+     * @returns {Object} - The AST object
+     */
+    function quikdown_ast(markdown, options = {}) {
+        if (!markdown || typeof markdown !== 'string') {
+            return { type: 'document', children: [] };
+        }
+
+        // Normalize line endings (handle CRLF, CR, LF uniformly)
+        const text = markdown.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+
+        const children = parseBlocks(text);
+
+        return {
+            type: 'document',
+            children
+        };
+    }
+
+    /**
+     * Parse block-level elements
+     */
+    function parseBlocks(text, options) {
+        const blocks = [];
+        const lines = text.split('\n');
+        let i = 0;
+
+        while (i < lines.length) {
+            const line = lines[i];
+
+            // Empty line - skip
+            if (line.trim() === '') {
+                i++;
+                continue;
+            }
+
+            // Fenced code block (``` or ~~~)
+            const fenceMatch = line.match(/^(```|~~~)(.*)$/);
+            if (fenceMatch) {
+                const [, openFence, langPart] = fenceMatch;
+                const lang = langPart.trim();
+                const codeLines = [];
+                i++;
+
+                // Find closing fence (forgiving: accept mismatched fences or EOF)
+                while (i < lines.length) {
+                    const closingMatch = lines[i].match(/^(```|~~~)\s*$/);
+                    if (closingMatch) {
+                        i++;
+                        break;
+                    }
+                    codeLines.push(lines[i]);
+                    i++;
+                }
+
+                blocks.push({
+                    type: 'code_block',
+                    lang: lang || null,
+                    content: codeLines.join('\n'),
+                    fence: openFence
+                });
+                continue;
+            }
+
+            // Horizontal rule
+            if (/^---+\s*$/.test(line) || /^\*\*\*+\s*$/.test(line) || /^___+\s*$/.test(line)) {
+                blocks.push({ type: 'hr' });
+                i++;
+                continue;
+            }
+
+            // Heading (forgiving: accept #heading without space)
+            const headingMatch = line.match(/^(#{1,6})\s*(.+?)\s*#*$/);
+            if (headingMatch) {
+                const [, hashes, content] = headingMatch;
+                blocks.push({
+                    type: 'heading',
+                    level: hashes.length,
+                    children: parseInline(content)
+                });
+                i++;
+                continue;
+            }
+
+            // Table (look for separator line)
+            if (line.includes('|')) {
+                const tableResult = tryParseTable(lines, i);
+                if (tableResult) {
+                    blocks.push(tableResult.node);
+                    i = tableResult.nextIndex;
+                    continue;
+                }
+            }
+
+            // Blockquote
+            if (line.match(/^>\s*/)) {
+                const quoteLines = [];
+                while (i < lines.length && lines[i].match(/^>\s*/)) {
+                    quoteLines.push(lines[i].replace(/^>\s*/, ''));
+                    i++;
+                }
+                blocks.push({
+                    type: 'blockquote',
+                    children: parseBlocks(quoteLines.join('\n'))
+                });
+                continue;
+            }
+
+            // List (ordered or unordered)
+            const listMatch = line.match(/^(\s*)([*\-+]|\d+\.)\s+(.*)$/);
+            if (listMatch) {
+                const listResult = parseList(lines, i);
+                blocks.push(listResult.node);
+                i = listResult.nextIndex;
+                continue;
+            }
+
+            // Paragraph - collect lines until empty line or block element
+            const paragraphLines = [];
+            while (i < lines.length) {
+                const pLine = lines[i];
+
+                // Stop on empty line
+                if (pLine.trim() === '') break;
+
+                // Stop on block elements
+                if (/^(```|~~~)/.test(pLine)) break;
+                if (/^#{1,6}\s/.test(pLine)) break;
+                if (/^---+\s*$/.test(pLine) || /^\*\*\*+\s*$/.test(pLine) || /^___+\s*$/.test(pLine)) break;
+                if (/^>\s*/.test(pLine)) break;
+                if (/^(\s*)([*\-+]|\d+\.)\s+/.test(pLine)) break;
+                if (pLine.includes('|') && i + 1 < lines.length && /^\|?[\s\-:|]+\|?$/.test(lines[i + 1])) break;
+
+                paragraphLines.push(pLine);
+                i++;
+            }
+
+            if (paragraphLines.length > 0) {
+                blocks.push({
+                    type: 'paragraph',
+                    children: parseInline(paragraphLines.join('\n'))
+                });
+            }
+        }
+
+        return blocks;
+    }
+
+    /**
+     * Try to parse a table starting at the given line
+     */
+    function tryParseTable(lines, startIndex, options) {
+        // Need at least 2 lines (header + separator)
+        if (startIndex + 1 >= lines.length) return null;
+
+        const headerLine = lines[startIndex];
+        const separatorLine = lines[startIndex + 1];
+
+        // Check if separator line is valid
+        if (!/^\|?[\s\-:|]+\|?$/.test(separatorLine) || !separatorLine.includes('-')) {
+            return null;
+        }
+
+        // Parse header
+        const headerCells = parseTableRow(headerLine);
+        if (headerCells.length === 0) return null;
+
+        // Parse alignments from separator
+        const separatorCells = parseTableRow(separatorLine);
+        const alignments = separatorCells.map(cell => {
+            const trimmed = cell.trim();
+            if (trimmed.startsWith(':') && trimmed.endsWith(':')) return 'center';
+            if (trimmed.endsWith(':')) return 'right';
+            return 'left';
+        });
+
+        // Parse headers with inline formatting
+        const headers = headerCells.map(cell => parseInline(cell.trim()));
+
+        // Parse body rows
+        const rows = [];
+        let i = startIndex + 2;
+        while (i < lines.length) {
+            const rowLine = lines[i];
+            if (!rowLine.includes('|') || rowLine.trim() === '') break;
+
+            const cells = parseTableRow(rowLine);
+            rows.push(cells.map(cell => parseInline(cell.trim())));
+            i++;
+        }
+
+        return {
+            node: {
+                type: 'table',
+                headers,
+                rows,
+                alignments
+            },
+            nextIndex: i
+        };
+    }
+
+    /**
+     * Parse a table row into cells
+     */
+    function parseTableRow(line) {
+        // Handle pipes at start/end or not
+        let trimmed = line.trim();
+        if (trimmed.startsWith('|')) trimmed = trimmed.slice(1);
+        if (trimmed.endsWith('|')) trimmed = trimmed.slice(0, -1);
+        return trimmed.split('|');
+    }
+
+    /**
+     * Parse a list starting at the given line
+     */
+    function parseList(lines, startIndex, options) {
+        const items = [];
+        let i = startIndex;
+        let loopCount = 0;
+
+        // Determine initial list type
+        const firstMatch = lines[i].match(/^(\s*)([*\-+]|\d+\.)\s+(.*)$/);
+        const isOrdered = /^\d+\./.test(firstMatch[2]);
+        const baseIndent = firstMatch[1].length;
+
+        while (i < lines.length && loopCount < MAX_LOOP_ITERATIONS) {
+            loopCount++;
+            const line = lines[i];
+            const match = line.match(/^(\s*)([*\-+]|\d+\.)\s+(.*)$/);
+
+            if (!match) break;
+
+            const [, indent, marker, content] = match;
+            const indentLevel = indent.length;
+
+            // If less indented than base, stop
+            if (indentLevel < baseIndent) break;
+
+            // If same indentation but different list type, stop
+            const itemIsOrdered = /^\d+\./.test(marker);
+            if (indentLevel === baseIndent && itemIsOrdered !== isOrdered) break;
+
+            // If more indented, it's a nested list - handle by collecting sub-lines
+            if (indentLevel > baseIndent) {
+                // This is a nested list item, collect and parse as sublist
+                const subLines = [];
+                let subLoopCount = 0;
+                while (i < lines.length && subLoopCount < MAX_LOOP_ITERATIONS) {
+                    subLoopCount++;
+                    const subLine = lines[i];
+                    const subMatch = subLine.match(/^(\s*)([*\-+]|\d+\.)\s+/);
+                    if (!subMatch) break;
+                    if (subMatch[1].length < baseIndent) break;
+                    if (subMatch[1].length === baseIndent) break;
+                    subLines.push(subLine);
+                    i++;
+                }
+
+                if (subLines.length > 0 && items.length > 0) {
+                    // Add nested list to last item
+                    const nestedResult = parseList(subLines, 0);
+                    const lastItem = items[items.length - 1];
+                    if (!lastItem.children) {
+                        lastItem.children = [];
+                    } else if (!Array.isArray(lastItem.children)) {
+                        lastItem.children = [{ type: 'paragraph', children: lastItem.children }];
+                    }
+                    lastItem.children.push(nestedResult.node);
+                }
+                continue;
+            }
+
+            // Parse list item
+            const itemNode = {
+                type: 'list_item',
+                checked: null,
+                children: null
+            };
+
+            // Check for task list syntax
+            const taskMatch = content.match(/^\[([x ])\]\s*(.*)$/i);
+            if (taskMatch && !isOrdered) {
+                itemNode.checked = taskMatch[1].toLowerCase() === 'x';
+                itemNode.children = parseInline(taskMatch[2]);
+            } else {
+                itemNode.children = parseInline(content);
+            }
+
+            items.push(itemNode);
+            i++;
+        }
+
+        return {
+            node: {
+                type: 'list',
+                ordered: isOrdered,
+                items
+            },
+            nextIndex: i
+        };
+    }
+
+    /**
+     * Parse inline elements
+     */
+    function parseInline(text, options) {
+        if (!text) return [];
+
+        const nodes = [];
+        let remaining = text;
+
+        while (remaining.length > 0) {
+            let matched = false;
+
+            // Line break (1+ trailing spaces or explicit \n after processing)
+            // Handle inline line breaks (two spaces at end of line or backslash before newline)
+            const brMatch = remaining.match(/^(.+?)(?: {2}|\\\n|\n)/);
+            if (brMatch && remaining.includes('\n')) {
+                const beforeBr = remaining.indexOf('\n');
+                const beforeText = remaining.slice(0, beforeBr);
+                const afterText = remaining.slice(beforeBr + 1);
+
+                // Check if line break is significant (2+ trailing spaces or backslash)
+                if (beforeText.endsWith('  ') || beforeText.endsWith('\\')) {
+                    const cleanText = beforeText.replace(/\\$/, '').replace(/  +$/, '');
+                    if (cleanText) {
+                        nodes.push(...parseInlineContent(cleanText));
+                    }
+                    nodes.push({ type: 'br' });
+                    remaining = afterText;
+                    matched = true;
+                    continue;
+                }
+            }
+
+            // Images: ![alt](url)
+            const imgMatch = remaining.match(/^!\[([^\]]*)\]\(\s*([^)\s]+)\s*\)/);
+            if (imgMatch) {
+                nodes.push({
+                    type: 'image',
+                    alt: imgMatch[1],
+                    url: imgMatch[2].trim()  // Forgiving: trim whitespace in URL
+                });
+                remaining = remaining.slice(imgMatch[0].length);
+                matched = true;
+                continue;
+            }
+
+            // Links: [text](url)
+            const linkMatch = remaining.match(/^\[([^\]]+)\]\(\s*([^)\s]+)\s*\)/);
+            if (linkMatch) {
+                nodes.push({
+                    type: 'link',
+                    url: linkMatch[2].trim(),  // Forgiving: trim whitespace in URL
+                    children: parseInlineContent(linkMatch[1])
+                });
+                remaining = remaining.slice(linkMatch[0].length);
+                matched = true;
+                continue;
+            }
+
+            // Inline code: `code`
+            const codeMatch = remaining.match(/^`([^`]+)`/);
+            if (codeMatch) {
+                nodes.push({
+                    type: 'code',
+                    value: codeMatch[1]
+                });
+                remaining = remaining.slice(codeMatch[0].length);
+                matched = true;
+                continue;
+            }
+
+            // Bold: **text** or __text__
+            const boldMatch = remaining.match(/^(\*\*|__)(.+?)\1/);
+            if (boldMatch) {
+                nodes.push({
+                    type: 'strong',
+                    children: parseInlineContent(boldMatch[2])
+                });
+                remaining = remaining.slice(boldMatch[0].length);
+                matched = true;
+                continue;
+            }
+
+            // Strikethrough: ~~text~~
+            const strikeMatch = remaining.match(/^~~(.+?)~~/);
+            if (strikeMatch) {
+                nodes.push({
+                    type: 'del',
+                    children: parseInlineContent(strikeMatch[1])
+                });
+                remaining = remaining.slice(strikeMatch[0].length);
+                matched = true;
+                continue;
+            }
+
+            // Italic: *text* or _text_ (not at word boundary for underscores)
+            const emMatch = remaining.match(/^(\*|_)(?!\1)(.+?)(?<!\1)\1(?!\1)/);
+            if (emMatch) {
+                nodes.push({
+                    type: 'em',
+                    children: parseInlineContent(emMatch[2])
+                });
+                remaining = remaining.slice(emMatch[0].length);
+                matched = true;
+                continue;
+            }
+
+            // Autolinks: URLs starting with http:// or https://
+            const urlMatch = remaining.match(/^(https?:\/\/[^\s<>[\]]+)/);
+            if (urlMatch) {
+                nodes.push({
+                    type: 'link',
+                    url: urlMatch[1],
+                    children: [{ type: 'text', value: urlMatch[1] }]
+                });
+                remaining = remaining.slice(urlMatch[0].length);
+                matched = true;
+                continue;
+            }
+
+            // Plain text - consume until next potential inline element or end
+            if (!matched) {
+                // Find next potential inline marker
+                const nextMarker = remaining.search(/[`*_~![\\n]|https?:\/\//);
+                if (nextMarker === -1) {
+                    // No more markers, consume rest as text
+                    nodes.push({ type: 'text', value: remaining });
+                    break;
+                } else if (nextMarker === 0) {
+                    // Current char is a marker but didn't match - consume it as text
+                    nodes.push({ type: 'text', value: remaining[0] });
+                    remaining = remaining.slice(1);
+                } else {
+                    // Consume text up to next marker
+                    nodes.push({ type: 'text', value: remaining.slice(0, nextMarker) });
+                    remaining = remaining.slice(nextMarker);
+                }
+            }
+        }
+
+        // Merge adjacent text nodes
+        return mergeTextNodes(nodes);
+    }
+
+    /**
+     * Parse inline content (recursive helper for nested inline elements)
+     */
+    function parseInlineContent(text, options) {
+        // For simple nested content, use parseInline
+        // But handle newlines as spaces for inline content
+        const normalized = text.replace(/\n/g, ' ');
+        return parseInline(normalized);
+    }
+
+    /**
+     * Merge adjacent text nodes
+     */
+    function mergeTextNodes(nodes) {
+        const merged = [];
+        for (const node of nodes) {
+            if (node.type === 'text' && merged.length > 0 && merged[merged.length - 1].type === 'text') {
+                merged[merged.length - 1].value += node.value;
+            } else {
+                merged.push(node);
+            }
+        }
+        return merged;
+    }
+
+    // Attach version
+    quikdown_ast.version = quikdownVersion$1;
+
+    // Export for both CommonJS and ES6
+    /* istanbul ignore next */
+    if (typeof module !== 'undefined' && module.exports) {
+        module.exports = quikdown_ast;
+    }
+
+    // For browser global
+    /* istanbul ignore next */
+    if (typeof window !== 'undefined') {
+        window.quikdown_ast = quikdown_ast;
+    }
+
+    /**
+     * quikdown_yaml - Markdown to YAML converter
+     * Converts markdown to YAML via AST
+     * @param {string} markdown - The markdown source text
+     * @param {Object} options - Optional configuration object
+     * @returns {string} - YAML string representation of the AST
+     */
+
+
+    // Version will be injected at build time
+    const quikdownVersion = '1.2.3';
+
+    /**
+     * Convert markdown to YAML
+     * @param {string} markdown - The markdown source text
+     * @param {Object} options - Optional configuration object
+     * @returns {string} - YAML string
+     */
+    function quikdown_yaml(markdown, options = {}) {
+        const ast = quikdown_ast(markdown, options);
+        return astToYaml(ast, 0);
+    }
+
+    /**
+     * Convert an AST node to YAML string
+     * Minimal YAML serializer - no external dependencies
+     * @param {Object|Array|string|number|boolean|null} node - The value to serialize
+     * @param {number} indent - Current indentation level
+     * @returns {string} - YAML string
+     */
+    function astToYaml(node, indent) {
+        const spaces = '  '.repeat(indent);
+
+        if (node === null || node === undefined) {
+            return 'null';
+        }
+
+        if (typeof node === 'boolean') {
+            return node ? 'true' : 'false';
+        }
+
+        if (typeof node === 'number') {
+            return String(node);
+        }
+
+        if (typeof node === 'string') {
+            return formatYamlString(node);
+        }
+
+        if (Array.isArray(node)) {
+            if (node.length === 0) {
+                return '[]';
+            }
+
+            const lines = [];
+            for (const item of node) {
+                if (typeof item === 'object' && item !== null && !Array.isArray(item)) {
+                    // Object item - inline the first property on the same line as dash
+                    const props = Object.entries(item);
+                    if (props.length > 0) {
+                        const [firstKey, firstValue] = props[0];
+                        const firstValueStr = formatValue(firstValue, indent + 1);
+                        lines.push(`${spaces}- ${firstKey}: ${firstValueStr}`);
+
+                        // Remaining properties
+                        for (let i = 1; i < props.length; i++) {
+                            const [key, value] = props[i];
+                            const valueStr = formatValue(value, indent + 1);
+                            lines.push(`${spaces}  ${key}: ${valueStr}`);
+                        }
+                    } else {
+                        lines.push(`${spaces}- {}`);
+                    }
+                } else {
+                    // Simple value
+                    const valueStr = astToYaml(item, indent + 1);
+                    lines.push(`${spaces}- ${valueStr}`);
+                }
+            }
+            return '\n' + lines.join('\n');
+        }
+
+        if (typeof node === 'object') {
+            const entries = Object.entries(node);
+            if (entries.length === 0) {
+                return '{}';
+            }
+
+            const lines = [];
+            for (const [key, value] of entries) {
+                const valueStr = formatValue(value, indent);
+                lines.push(`${spaces}${key}: ${valueStr}`);
+            }
+            return lines.join('\n');
+        }
+
+        return String(node);
+    }
+
+    /**
+     * Format a value for YAML (handles nested objects/arrays)
+     */
+    function formatValue(value, indent) {
+        if (value === null || value === undefined) {
+            return 'null';
+        }
+
+        if (typeof value === 'boolean') {
+            return value ? 'true' : 'false';
+        }
+
+        if (typeof value === 'number') {
+            return String(value);
+        }
+
+        if (typeof value === 'string') {
+            return formatYamlString(value);
+        }
+
+        if (Array.isArray(value)) {
+            if (value.length === 0) {
+                return '[]';
+            }
+            return astToYaml(value, indent + 1);
+        }
+
+        if (typeof value === 'object') {
+            // Nested object - format on new lines with increased indent
+            const entries = Object.entries(value);
+            if (entries.length === 0) {
+                return '{}';
+            }
+            return '\n' + astToYaml(value, indent + 1);
+        }
+
+        return String(value);
+    }
+
+    /**
+     * Format a string for YAML (handle quoting and escaping)
+     */
+    function formatYamlString(str) {
+        // Check if string needs quoting
+        const needsQuoting = (
+            str === '' ||
+            str.includes('\n') ||
+            str.includes(':') ||
+            str.includes('#') ||
+            str.includes("'") ||
+            str.includes('"') ||
+            str.startsWith(' ') ||
+            str.endsWith(' ') ||
+            str.startsWith('-') ||
+            str.startsWith('[') ||
+            str.startsWith('{') ||
+            str === 'true' ||
+            str === 'false' ||
+            str === 'null' ||
+            str === 'yes' ||
+            str === 'no' ||
+            str === 'on' ||
+            str === 'off' ||
+            /^\d+$/.test(str) ||
+            /^\d+\.\d+$/.test(str)
+        );
+
+        if (!needsQuoting) {
+            return str;
+        }
+
+        // Use double quotes and escape special characters
+        if (str.includes('\n')) {
+            // For multiline strings, use literal block style
+            const escaped = str.replace(/\n/g, '\\n');
+            return `"${escaped.replace(/"/g, '\\"')}"`;
+        }
+
+        // Simple string quoting
+        return `"${str.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+    }
+
+    // Expose the AST parser for direct access
+    quikdown_yaml.parse = quikdown_ast;
+
+    // Expose the YAML serializer for direct AST-to-YAML conversion
+    quikdown_yaml.stringify = function(ast) {
+        return astToYaml(ast, 0);
+    };
+
+    // Attach version
+    quikdown_yaml.version = quikdownVersion;
+
+    // Export for both CommonJS and ES6
+    /* istanbul ignore next */
+    if (typeof module !== 'undefined' && module.exports) {
+        module.exports = quikdown_yaml;
+    }
+
+    // For browser global
+    /* istanbul ignore next */
+    if (typeof window !== 'undefined') {
+        window.quikdown_yaml = quikdown_yaml;
+    }
+
+    return quikdown_yaml;
+
+}));