testomatio-editor-blocks 0.1.0

package/package/editor/customMarkdownConverter.js

@@ -0,0 +1,1038 @@
+import { isLinkInlineContent, isStyledTextInlineContent, } from "@blocknote/core";
+const BASE_BLOCK_PROPS = {
+    textAlignment: "left",
+    textColor: "default",
+    backgroundColor: "default",
+};
+const BASE_CELL_PROPS = {
+    backgroundColor: "default",
+    textColor: "default",
+    textAlignment: "left",
+};
+const TABLE_BLOCK_PROPS = {
+    textColor: "default",
+};
+const headingPrefixes = {
+    1: "#",
+    2: "##",
+    3: "###",
+    4: "####",
+    5: "#####",
+    6: "######",
+};
+const STEP_STATUSES = new Set(["draft", "ready", "blocked"]);
+function normalizeStatus(value) {
+    if (value && STEP_STATUSES.has(value)) {
+        return value;
+    }
+    return "draft";
+}
+const SPECIAL_CHAR_REGEX = /([*_`~\[\]()<>\\])/g;
+const HTML_SPAN_REGEX = /<\/?span[^>]*>/g;
+const HTML_UNDERLINE_REGEX = /<\/?u>/g;
+const EXPECTED_LABEL_REGEX = /^(?:[*_`]*\s*)?(expected(?:\s+result)?)\s*(?:[*_`]*\s*)?(?:\s*[:\-–—]?\s*)/i;
+// Matches any non-empty line that falls between the step title and the expected result line.
+const STEP_DATA_LINE_REGEX = /^(?!\s*(?:[*_`]*\s*)?(?:expected(?:\s+result)?)\b).+/i;
+const NUMBERED_STEP_REGEX = /^\d+[.)]\s+/;
+function escapeMarkdown(text) {
+    return text.replace(SPECIAL_CHAR_REGEX, "\\$1");
+}
+function stripHtmlWrappers(text) {
+    return text
+        .replace(HTML_SPAN_REGEX, "")
+        .replace(HTML_UNDERLINE_REGEX, "");
+}
+function stripExpectedPrefix(text) {
+    const match = text.match(EXPECTED_LABEL_REGEX);
+    if (!match) {
+        return text;
+    }
+    const label = match[0];
+    let remainder = text.slice(label.length).trimStart();
+    const cleanupLeading = (value) => {
+        let result = value.trimStart();
+        result = result.replace(/^\\+(?=[*_`~:[\]])/, "");
+        result = result.replace(/^(?:[*_`~]+)(?=\s|$)/, "");
+        return result.trimStart();
+    };
+    remainder = cleanupLeading(remainder);
+    remainder = stripLeadingFormatting(remainder);
+    return remainder.trimStart();
+}
+function stripLeadingFormatting(text) {
+    let result = text.trimStart();
+    let changed = true;
+    while (changed) {
+        changed = false;
+        // Remove escaped markers like \* or \_ at the start
+        if (/^\\+[*_`~]/.test(result)) {
+            result = result.replace(/^\\+/, "");
+            changed = true;
+            result = result.trimStart();
+            continue;
+        }
+        // Remove leading sequences of markdown emphasis markers
+        const leadingMarkers = result.match(/^([*_`~]{1,3})(\s+|$)/);
+        if (leadingMarkers) {
+            result = result.slice(leadingMarkers[1].length).trimStart();
+            changed = true;
+            continue;
+        }
+    }
+    return result;
+}
+function unescapeMarkdown(text) {
+    return stripHtmlWrappers(text).replace(/\\([*_`~\[\]()<>\\])/g, "$1");
+}
+function applyTextStyles(text, styles) {
+    var _a;
+    if (!styles) {
+        return text;
+    }
+    const hasCode = styles.code === true;
+    let result = text;
+    if (hasCode) {
+        result = "`" + result.replace(/`/g, "\\`") + "`";
+        // Code style supersedes other styles in Markdown.
+        return result;
+    }
+    const wrappers = [];
+    if (styles.bold) {
+        wrappers.push({ prefix: "**", suffix: "**" });
+    }
+    if (styles.italic) {
+        wrappers.push({ prefix: "*", suffix: "*" });
+    }
+    if (styles.strike) {
+        wrappers.push({ prefix: "~~", suffix: "~~" });
+    }
+    if (styles.underline) {
+        wrappers.push({ prefix: "<u>", suffix: "</u>" });
+    }
+    if (styles.textColor && styles.textColor !== "default") {
+        wrappers.push({
+            prefix: `<span style="color: ${styles.textColor}">`,
+            suffix: "</span>",
+        });
+    }
+    if (styles.backgroundColor && styles.backgroundColor !== "default") {
+        wrappers.push({
+            prefix: `<span style="background-color: ${styles.backgroundColor}">`,
+            suffix: "</span>",
+        });
+    }
+    for (const wrapper of wrappers) {
+        const suffix = (_a = wrapper.suffix) !== null && _a !== void 0 ? _a : wrapper.prefix;
+        result = `${wrapper.prefix}${result}${suffix}`;
+    }
+    return result;
+}
+function inlineToMarkdown(content) {
+    if (!content || !Array.isArray(content)) {
+        return "";
+    }
+    return content
+        .map((item) => {
+        if (isStyledTextInlineContent(item)) {
+            return applyTextStyles(escapeMarkdown(item.text), item.styles);
+        }
+        if (isLinkInlineContent(item)) {
+            const inner = inlineToMarkdown(item.content);
+            const safeHref = escapeMarkdown(item.href);
+            return `[${inner}](${safeHref})`;
+        }
+        if (Array.isArray(item.content)) {
+            return inlineToMarkdown(item.content);
+        }
+        return "";
+    })
+        .join("");
+}
+function serializeChildren(block, ctx) {
+    var _a;
+    if (!((_a = block.children) === null || _a === void 0 ? void 0 : _a.length)) {
+        return [];
+    }
+    const childCtx = { ...ctx, listDepth: ctx.listDepth + 1 };
+    return serializeBlocks(block.children, childCtx);
+}
+function flattenWithBlankLine(lines, appendBlank = false) {
+    if (appendBlank && (lines.length === 0 || lines.at(-1) !== "")) {
+        return [...lines, ""];
+    }
+    return lines;
+}
+function serializeBlock(block, ctx, orderedIndex) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+    const lines = [];
+    const indent = ctx.listDepth > 0 ? "  ".repeat(ctx.listDepth) : "";
+    switch (block.type) {
+        case "paragraph": {
+            const text = inlineToMarkdown(block.content);
+            if (text.length > 0) {
+                lines.push(ctx.insideQuote ? `> ${text}` : text);
+            }
+            return flattenWithBlankLine(lines, !ctx.insideQuote);
+        }
+        case "heading": {
+            const level = (_a = block.props.level) !== null && _a !== void 0 ? _a : 1;
+            const prefix = (_b = headingPrefixes[level]) !== null && _b !== void 0 ? _b : headingPrefixes[3];
+            const text = inlineToMarkdown(block.content);
+            lines.push(`${prefix} ${text}`.trimEnd());
+            return flattenWithBlankLine(lines, true);
+        }
+        case "quote": {
+            const quoteContent = serializeBlocks((_c = block.children) !== null && _c !== void 0 ? _c : [], {
+                ...ctx,
+                listDepth: ctx.listDepth,
+                insideQuote: true,
+            });
+            if ((_d = block.content) === null || _d === void 0 ? void 0 : _d.length) {
+                const quoteText = inlineToMarkdown(block.content)
+                    .split(/\n/)
+                    .map((fragment) => `> ${fragment}`);
+                lines.push(...quoteText);
+            }
+            lines.push(...quoteContent.map((line) => (line ? `> ${line}` : ">")));
+            return flattenWithBlankLine(lines, true);
+        }
+        case "codeBlock": {
+            const language = block.props.language || "";
+            const fence = "```" + language;
+            const body = inlineToMarkdown(block.content);
+            lines.push(fence);
+            if (body.length > 0) {
+                lines.push(body);
+            }
+            lines.push("```");
+            return flattenWithBlankLine(lines, true);
+        }
+        case "bulletListItem": {
+            const text = inlineToMarkdown(block.content);
+            lines.push(`${indent}- ${text}`.trimEnd());
+            lines.push(...serializeChildren(block, ctx));
+            return lines;
+        }
+        case "numberedListItem": {
+            const number = orderedIndex !== null && orderedIndex !== void 0 ? orderedIndex : (typeof block.props.start === "number"
+                ? block.props.start
+                : 1);
+            const text = inlineToMarkdown(block.content);
+            lines.push(`${indent}${number}. ${text}`.trimEnd());
+            lines.push(...serializeChildren(block, ctx));
+            return lines;
+        }
+        case "checkListItem": {
+            const checked = block.props.checked ? "x" : " ";
+            const text = inlineToMarkdown(block.content);
+            lines.push(`${indent}- [${checked}] ${text}`.trimEnd());
+            lines.push(...serializeChildren(block, ctx));
+            return lines;
+        }
+        case "testCase": {
+            const status = (_e = block.props.status) !== null && _e !== void 0 ? _e : "draft";
+            const reference = block.props.reference;
+            const attrs = [`status="${status}"`];
+            if (reference) {
+                attrs.push(`reference="${escapeMarkdown(reference)}"`);
+            }
+            lines.push(`:::test-case ${attrs.join(" ")}`.trimEnd());
+            const body = inlineToMarkdown(block.content);
+            if (body.length > 0) {
+                lines.push(body);
+            }
+            lines.push(":::");
+            return flattenWithBlankLine(lines, true);
+        }
+        case "testStep": {
+            const stepTitle = ((_f = block.props.stepTitle) !== null && _f !== void 0 ? _f : "").trim();
+            const stepData = ((_g = block.props.stepData) !== null && _g !== void 0 ? _g : "").trim();
+            const expectedResult = ((_h = block.props.expectedResult) !== null && _h !== void 0 ? _h : "").trim();
+            if (stepTitle.length > 0) {
+                const normalizedTitle = stepTitle
+                    .split(/\r?\n/)
+                    .map((segment) => segment.trim())
+                    .filter((segment) => segment.length > 0)
+                    .join(" ");
+                if (normalizedTitle.length > 0) {
+                    lines.push(`* ${normalizedTitle}`);
+                }
+            }
+            if (stepData.length > 0) {
+                const dataLines = stepData.split(/\r?\n/);
+                dataLines.forEach((dataLine) => {
+                    const trimmedLine = dataLine.trim();
+                    if (trimmedLine.length > 0) {
+                        lines.push(`  ${trimmedLine}`);
+                    }
+                    else {
+                        lines.push("  ");
+                    }
+                });
+            }
+            const normalizedExpected = stripExpectedPrefix(expectedResult).trim();
+            if (normalizedExpected.length > 0) {
+                const expectedLines = normalizedExpected.split(/\r?\n/);
+                const label = "*Expected Result*";
+                expectedLines.forEach((expectedLine, index) => {
+                    const trimmedLine = expectedLine.trim();
+                    if (trimmedLine.length === 0) {
+                        return;
+                    }
+                    if (index === 0) {
+                        lines.push(`  ${label}: ${trimmedLine}`);
+                    }
+                    else {
+                        lines.push(`  ${trimmedLine}`);
+                    }
+                });
+            }
+            if (lines.length === 0) {
+                return lines;
+            }
+            return flattenWithBlankLine(lines, false);
+        }
+        case "table": {
+            const tableContent = block.content;
+            if (!tableContent || tableContent.type !== "tableContent") {
+                return flattenWithBlankLine(lines, true);
+            }
+            const rows = Array.isArray(tableContent.rows)
+                ? tableContent.rows
+                : [];
+            if (rows.length === 0) {
+                return flattenWithBlankLine(lines, true);
+            }
+            const columnCount = rows.reduce((max, row) => {
+                const length = Array.isArray(row.cells) ? row.cells.length : 0;
+                return Math.max(max, length);
+            }, 0);
+            if (columnCount === 0) {
+                return flattenWithBlankLine(lines, true);
+            }
+            const headerRowCount = rows.length
+                ? Math.min(rows.length, Math.max((_j = tableContent.headerRows) !== null && _j !== void 0 ? _j : 1, 1))
+                : 0;
+            const columnAlignments = new Array(columnCount).fill("left");
+            const getCellAlignment = (cell) => {
+                var _a;
+                if (cell && typeof cell === "object" && ((_a = cell.props) === null || _a === void 0 ? void 0 : _a.textAlignment)) {
+                    return cell.props.textAlignment;
+                }
+                return "left";
+            };
+            const getCellText = (cell) => {
+                if (Array.isArray(cell)) {
+                    return inlineToMarkdown(cell);
+                }
+                if (cell && typeof cell === "object" && Array.isArray(cell.content)) {
+                    return inlineToMarkdown(cell.content);
+                }
+                return "";
+            };
+            rows.forEach((row) => {
+                if (!Array.isArray(row.cells)) {
+                    return;
+                }
+                row.cells.forEach((cell, index) => {
+                    const alignment = getCellAlignment(cell);
+                    if (alignment !== "left") {
+                        columnAlignments[index] = alignment;
+                    }
+                });
+            });
+            const normalizeRow = (row) => {
+                const cells = Array.isArray(row.cells) ? row.cells : [];
+                const cellTexts = cells.map(getCellText);
+                while (cellTexts.length < columnCount) {
+                    cellTexts.push("");
+                }
+                return cellTexts;
+            };
+            const formattedRows = rows.map(normalizeRow);
+            const formatCell = (value) => (value.length ? value : " ");
+            const toAlignmentToken = (alignment) => {
+                switch (alignment) {
+                    case "center":
+                        return ":---:";
+                    case "right":
+                        return "---:";
+                    case "justify":
+                        return ":---:";
+                    default:
+                        return "---";
+                }
+            };
+            const headerRow = formattedRows[0];
+            lines.push(`| ${headerRow.map((cell) => formatCell(cell)).join(" | ")} |`);
+            lines.push(`| ${columnAlignments
+                .map((alignment) => toAlignmentToken(alignment))
+                .join(" | ")} |`);
+            const bodyStartIndex = headerRowCount > 0 ? headerRowCount : 1;
+            formattedRows.slice(bodyStartIndex).forEach((row) => {
+                lines.push(`| ${row.map((cell) => formatCell(cell)).join(" | ")} |`);
+            });
+            return flattenWithBlankLine(lines, true);
+        }
+    }
+    const fallbackBlock = block;
+    if (fallbackBlock.content) {
+        const text = inlineToMarkdown(fallbackBlock.content);
+        if (text.length > 0) {
+            lines.push(text);
+        }
+    }
+    lines.push(...serializeChildren(fallbackBlock, ctx));
+    return flattenWithBlankLine(lines, false);
+}
+function serializeBlocks(blocks, ctx) {
+    const lines = [];
+    let orderedIndex = null;
+    for (const block of blocks) {
+        if (block.type === "numberedListItem") {
+            if (typeof block.props.start === "number") {
+                orderedIndex = block.props.start;
+            }
+            else if (orderedIndex === null) {
+                orderedIndex = 1;
+            }
+            lines.push(...serializeBlock(block, ctx, orderedIndex));
+            orderedIndex += 1;
+            continue;
+        }
+        orderedIndex = null;
+        lines.push(...serializeBlock(block, ctx));
+    }
+    return lines;
+}
+export function blocksToMarkdown(blocks) {
+    const lines = serializeBlocks(blocks, { listDepth: 0, insideQuote: false });
+    const cleaned = lines
+        // Collapse more than two blank lines into just two for readability.
+        .join("\n")
+        .replace(/\n{3,}/g, "\n\n")
+        .trimEnd();
+    return cleaned;
+}
+function parseInlineMarkdown(text) {
+    const cleaned = stripHtmlWrappers(text);
+    const result = [];
+    let buffer = "";
+    const pushPlain = () => {
+        if (buffer.length === 0) {
+            return;
+        }
+        result.push({ type: "text", text: unescapeMarkdown(buffer), styles: {} });
+        buffer = "";
+    };
+    let i = 0;
+    while (i < cleaned.length) {
+        if (cleaned.startsWith("**", i)) {
+            const end = cleaned.indexOf("**", i + 2);
+            if (end !== -1) {
+                pushPlain();
+                const inner = cleaned.slice(i + 2, end);
+                result.push({
+                    type: "text",
+                    text: unescapeMarkdown(inner),
+                    styles: { bold: true },
+                });
+                i = end + 2;
+                continue;
+            }
+        }
+        if (cleaned.startsWith("~~", i)) {
+            const end = cleaned.indexOf("~~", i + 2);
+            if (end !== -1) {
+                pushPlain();
+                const inner = cleaned.slice(i + 2, end);
+                result.push({
+                    type: "text",
+                    text: unescapeMarkdown(inner),
+                    styles: { strike: true },
+                });
+                i = end + 2;
+                continue;
+            }
+        }
+        if (cleaned.startsWith("`", i)) {
+            const end = cleaned.indexOf("`", i + 1);
+            if (end !== -1) {
+                pushPlain();
+                const inner = cleaned.slice(i + 1, end);
+                result.push({
+                    type: "text",
+                    text: unescapeMarkdown(inner),
+                    styles: { code: true },
+                });
+                i = end + 1;
+                continue;
+            }
+        }
+        if (cleaned[i] === "[") {
+            const endLabel = cleaned.indexOf("]", i + 1);
+            const startLink = cleaned.indexOf("(", endLabel + 1);
+            const endLink = cleaned.indexOf(")", startLink + 1);
+            if (endLabel !== -1 && startLink === endLabel + 1 && endLink !== -1) {
+                pushPlain();
+                const label = cleaned.slice(i + 1, endLabel);
+                const href = cleaned.slice(startLink + 1, endLink);
+                result.push({
+                    type: "link",
+                    href: unescapeMarkdown(href),
+                    content: parseInlineMarkdown(label),
+                });
+                i = endLink + 1;
+                continue;
+            }
+        }
+        if (cleaned.startsWith("*", i)) {
+            const end = cleaned.indexOf("*", i + 1);
+            if (end !== -1) {
+                pushPlain();
+                const inner = cleaned.slice(i + 1, end);
+                result.push({
+                    type: "text",
+                    text: unescapeMarkdown(inner),
+                    styles: { italic: true },
+                });
+                i = end + 1;
+                continue;
+            }
+        }
+        buffer += cleaned[i];
+        i += 1;
+    }
+    pushPlain();
+    return result;
+}
+function createTextContent(text) {
+    const inline = parseInlineMarkdown(text.trim());
+    return inline.length === 0 ? undefined : inline;
+}
+function cloneBaseProps() {
+    return { ...BASE_BLOCK_PROPS };
+}
+function cloneCellProps() {
+    return { ...BASE_CELL_PROPS };
+}
+function detectListType(trimmed) {
+    if (/^[-*+]\s+\[[xX\s]\]\s+/.test(trimmed)) {
+        return "check";
+    }
+    if (/^\d+[.)]\s+/.test(trimmed)) {
+        return "numbered";
+    }
+    if (/^[-*+]\s+/.test(trimmed)) {
+        return "bullet";
+    }
+    return null;
+}
+function countIndent(line) {
+    const match = line.match(/^ */);
+    return match ? match[0].length : 0;
+}
+function parseList(lines, startIndex, listType, indentLevel) {
+    var _a, _b, _c, _d;
+    const items = [];
+    let index = startIndex;
+    while (index < lines.length) {
+        const rawLine = lines[index];
+        const trimmed = rawLine.trim();
+        if (!trimmed) {
+            index += 1;
+            continue;
+        }
+        let indent = countIndent(rawLine);
+        const baseIndent = indentLevel * 2;
+        if (indent > baseIndent && indent <= baseIndent + 1) {
+            indent = baseIndent;
+        }
+        if (indent < indentLevel * 2) {
+            break;
+        }
+        if (indent > indentLevel * 2) {
+            const lastItem = items.at(-1);
+            if (!lastItem) {
+                break;
+            }
+            const nestedType = detectListType(trimmed);
+            if (!nestedType) {
+                break;
+            }
+            const nested = parseList(lines, index, nestedType, indentLevel + 1);
+            lastItem.children = [...((_a = lastItem.children) !== null && _a !== void 0 ? _a : []), ...nested.items];
+            index = nested.nextIndex;
+            continue;
+        }
+        const detectedType = detectListType(trimmed);
+        if (detectedType !== listType) {
+            break;
+        }
+        if (listType === "check") {
+            const checkMatch = trimmed.match(/^[-*+]\s+\[([xX\s])\]\s+(.*)$/);
+            const checked = ((_b = checkMatch === null || checkMatch === void 0 ? void 0 : checkMatch[1]) !== null && _b !== void 0 ? _b : "").toLowerCase() === "x";
+            const text = (_c = checkMatch === null || checkMatch === void 0 ? void 0 : checkMatch[2]) !== null && _c !== void 0 ? _c : trimmed.slice(6);
+            items.push({
+                type: "checkListItem",
+                props: { ...cloneBaseProps(), checked },
+                content: createTextContent(unescapeMarkdown(text)),
+                children: [],
+            });
+        }
+        else if (listType === "numbered") {
+            const match = trimmed.match(/^(\d+)[.)]\s+(.*)$/);
+            const start = match ? Number(match[1]) : 1;
+            const text = match ? match[2] : trimmed;
+            items.push({
+                type: "numberedListItem",
+                props: { ...cloneBaseProps(), start },
+                content: createTextContent(unescapeMarkdown(text)),
+                children: [],
+            });
+        }
+        else {
+            const bulletMatch = trimmed.match(/^[-*+]\s+(.*)$/);
+            const text = (_d = bulletMatch === null || bulletMatch === void 0 ? void 0 : bulletMatch[1]) !== null && _d !== void 0 ? _d : trimmed.slice(2);
+            items.push({
+                type: "bulletListItem",
+                props: cloneBaseProps(),
+                content: createTextContent(unescapeMarkdown(text)),
+                children: [],
+            });
+        }
+        index += 1;
+    }
+    return { items, nextIndex: index };
+}
+function parseTestStep(lines, index) {
+    const current = lines[index];
+    const trimmed = current.trim();
+    if (!trimmed.startsWith("* ") && !trimmed.startsWith("- ")) {
+        return null;
+    }
+    const stepTitle = unescapeMarkdown(trimmed.slice(2)).trim();
+    const stepDataLines = [];
+    let expectedResult = "";
+    let next = index + 1;
+    let inExpectedResult = false;
+    while (next < lines.length) {
+        const line = lines[next];
+        const hasIndent = /^\s{2,}/.test(line);
+        const rawTrimmed = line.trim();
+        if (!rawTrimmed) {
+            if (stepDataLines.length > 0) {
+                stepDataLines.push("");
+            }
+            next += 1;
+            continue;
+        }
+        const isNumberedStep = NUMBERED_STEP_REGEX.test(rawTrimmed);
+        const isNewStep = (!hasIndent && (rawTrimmed.startsWith("* ") || rawTrimmed.startsWith("- "))) ||
+            (!hasIndent && isNumberedStep);
+        if (isNewStep) {
+            break;
+        }
+        if (rawTrimmed.startsWith("#") ||
+            rawTrimmed.startsWith(":::") ||
+            rawTrimmed.startsWith(">") ||
+            rawTrimmed.startsWith("|")) {
+            break;
+        }
+        if (rawTrimmed.match(EXPECTED_LABEL_REGEX)) {
+            inExpectedResult = true;
+            const withoutLabel = stripExpectedPrefix(rawTrimmed);
+            expectedResult = unescapeMarkdown(withoutLabel);
+            next += 1;
+            continue;
+        }
+        if (rawTrimmed.startsWith("```")) {
+            stepDataLines.push(unescapeMarkdown(rawTrimmed));
+            next += 1;
+            while (next < lines.length) {
+                const fenceLine = lines[next];
+                const fenceTrimmed = fenceLine.trim();
+                stepDataLines.push(unescapeMarkdown(fenceTrimmed));
+                next += 1;
+                if (fenceTrimmed.startsWith("```")) {
+                    break;
+                }
+            }
+            continue;
+        }
+        if (inExpectedResult) {
+            const withoutLabel = stripExpectedPrefix(rawTrimmed);
+            expectedResult += "\n" + unescapeMarkdown(withoutLabel);
+            next += 1;
+            continue;
+        }
+        if (STEP_DATA_LINE_REGEX.test(rawTrimmed)) {
+            const content = unescapeMarkdown(rawTrimmed);
+            stepDataLines.push(content);
+            next += 1;
+            continue;
+        }
+        break;
+    }
+    const stepData = stepDataLines
+        .map((line) => line.trimEnd())
+        .join("\n")
+        .trim();
+    // Only parse as test step if there's expected result or data content
+    if (expectedResult || stepData) {
+        return {
+            block: {
+                type: "testStep",
+                props: {
+                    stepTitle,
+                    stepData,
+                    expectedResult,
+                },
+                children: [],
+            },
+            nextIndex: next,
+        };
+    }
+    return null;
+}
+function parseTestCase(lines, index) {
+    var _a;
+    const trimmed = lines[index].trim();
+    if (!trimmed.startsWith(":::test-case")) {
+        return null;
+    }
+    const statusMatch = trimmed.match(/status="([^"]*)"/);
+    const referenceMatch = trimmed.match(/reference="([^"]*)"/);
+    let bodyLines = [];
+    let next = index + 1;
+    while (next < lines.length && lines[next].trim() !== ":::") {
+        bodyLines.push(lines[next]);
+        next += 1;
+    }
+    if (next < lines.length && lines[next].trim() === ":::") {
+        next += 1;
+    }
+    const contentText = bodyLines.join("\n").trim();
+    return {
+        block: {
+            type: "testCase",
+            props: {
+                ...cloneBaseProps(),
+                status: normalizeStatus(statusMatch === null || statusMatch === void 0 ? void 0 : statusMatch[1]),
+                reference: (_a = referenceMatch === null || referenceMatch === void 0 ? void 0 : referenceMatch[1]) !== null && _a !== void 0 ? _a : "",
+            },
+            content: contentText
+                ? [{ type: "text", text: unescapeMarkdown(contentText), styles: {} }]
+                : undefined,
+            children: [],
+        },
+        nextIndex: next,
+    };
+}
+function parseHeading(lines, index) {
+    const trimmed = lines[index].trim();
+    if (!trimmed.startsWith("#")) {
+        return null;
+    }
+    const match = trimmed.match(/^(#+)\s+(.*)$/);
+    if (!match) {
+        return null;
+    }
+    const rawLevel = Math.min(match[1].length, 3);
+    const level = (rawLevel === 1 || rawLevel === 2 ? rawLevel : 3);
+    const text = match[2];
+    return {
+        block: {
+            type: "heading",
+            props: { ...cloneBaseProps(), level },
+            content: createTextContent(unescapeMarkdown(text)),
+            children: [],
+        },
+        nextIndex: index + 1,
+    };
+}
+function parseCodeBlock(lines, index) {
+    const trimmed = lines[index].trim();
+    if (!trimmed.startsWith("```")) {
+        return null;
+    }
+    const language = trimmed.slice(3).trim();
+    const body = [];
+    let next = index + 1;
+    while (next < lines.length && !lines[next].startsWith("```")) {
+        body.push(lines[next]);
+        next += 1;
+    }
+    if (next < lines.length && lines[next].startsWith("```")) {
+        next += 1;
+    }
+    return {
+        block: {
+            type: "codeBlock",
+            props: { language },
+            content: body.length
+                ? [{ type: "text", text: body.join("\n"), styles: {} }]
+                : undefined,
+            children: [],
+        },
+        nextIndex: next,
+    };
+}
+function parseQuote(lines, index) {
+    if (!lines[index].trim().startsWith(">")) {
+        return null;
+    }
+    const collected = [];
+    let next = index;
+    while (next < lines.length) {
+        const trimmed = lines[next].trim();
+        if (!trimmed.startsWith(">")) {
+            break;
+        }
+        collected.push(trimmed.replace(/^>\s?/, ""));
+        next += 1;
+    }
+    return {
+        block: {
+            type: "quote",
+            props: cloneBaseProps(),
+            content: createTextContent(unescapeMarkdown(collected.join("\n"))),
+            children: [],
+        },
+        nextIndex: next,
+    };
+}
+function parseParagraph(lines, index) {
+    const buffer = [];
+    let next = index;
+    const isTermination = (line) => {
+        const trimmed = line.trim();
+        if (!trimmed) {
+            return true;
+        }
+        if (trimmed.startsWith(":::test-case")) {
+            return true;
+        }
+        if (trimmed.startsWith("* ")) {
+            return true;
+        }
+        if (trimmed.startsWith("#")) {
+            return true;
+        }
+        if (trimmed.startsWith(">")) {
+            return true;
+        }
+        if (trimmed.startsWith("```")) {
+            return true;
+        }
+        if (detectListType(trimmed)) {
+            return true;
+        }
+        return false;
+    };
+    while (next < lines.length) {
+        const line = lines[next];
+        if (isTableRowLine(line) &&
+            next + 1 < lines.length &&
+            isSeparatorRow(lines[next + 1])) {
+            break;
+        }
+        if (isTermination(line) && buffer.length > 0) {
+            break;
+        }
+        if (!line.trim()) {
+            next += 1;
+            break;
+        }
+        buffer.push(line.trim());
+        next += 1;
+    }
+    return {
+        block: {
+            type: "paragraph",
+            props: cloneBaseProps(),
+            content: createTextContent(unescapeMarkdown(buffer.join(" "))),
+            children: [],
+        },
+        nextIndex: next,
+    };
+}
+export function markdownToBlocks(markdown) {
+    const normalized = markdown.replace(/\r\n/g, "\n");
+    const lines = normalized.split("\n");
+    const blocks = [];
+    let index = 0;
+    while (index < lines.length) {
+        const line = lines[index];
+        if (!line.trim()) {
+            index += 1;
+            continue;
+        }
+        const testCase = parseTestCase(lines, index);
+        if (testCase) {
+            blocks.push(testCase.block);
+            index = testCase.nextIndex;
+            continue;
+        }
+        const testStep = parseTestStep(lines, index);
+        if (testStep) {
+            blocks.push(testStep.block);
+            index = testStep.nextIndex;
+            continue;
+        }
+        const table = parseTable(lines, index);
+        if (table) {
+            blocks.push(table.block);
+            index = table.nextIndex;
+            continue;
+        }
+        const heading = parseHeading(lines, index);
+        if (heading) {
+            blocks.push(heading.block);
+            index = heading.nextIndex;
+            continue;
+        }
+        const code = parseCodeBlock(lines, index);
+        if (code) {
+            blocks.push(code.block);
+            index = code.nextIndex;
+            continue;
+        }
+        const quote = parseQuote(lines, index);
+        if (quote) {
+            blocks.push(quote.block);
+            index = quote.nextIndex;
+            continue;
+        }
+        const listType = detectListType(line.trim());
+        if (listType) {
+            const { items, nextIndex } = parseList(lines, index, listType, 0);
+            blocks.push(...items);
+            index = nextIndex;
+            continue;
+        }
+        const paragraph = parseParagraph(lines, index);
+        blocks.push(paragraph.block);
+        index = paragraph.nextIndex;
+    }
+    return blocks;
+}
+function splitTableRow(line) {
+    let value = line.trim();
+    if (value.startsWith("|")) {
+        value = value.slice(1);
+    }
+    if (value.endsWith("|")) {
+        value = value.slice(0, -1);
+    }
+    const cells = [];
+    let current = "";
+    let i = 0;
+    while (i < value.length) {
+        const char = value[i];
+        if (char === "\\" && i + 1 < value.length) {
+            current += value[i + 1];
+            i += 2;
+            continue;
+        }
+        if (char === "|") {
+            cells.push(current.trim());
+            current = "";
+            i += 1;
+            continue;
+        }
+        current += char;
+        i += 1;
+    }
+    cells.push(current.trim());
+    return cells;
+}
+function isTableRowLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("|")) {
+        return false;
+    }
+    const cells = splitTableRow(trimmed);
+    return cells.length >= 2;
+}
+function isSeparatorRow(line) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("|")) {
+        return false;
+    }
+    const cells = splitTableRow(trimmed);
+    if (!cells.length) {
+        return false;
+    }
+    return cells.every((cell) => /^:?[-]{3,}:?$/.test(cell.replace(/\s+/g, "")));
+}
+function alignmentFromToken(token) {
+    const trimmed = token.trim();
+    if (trimmed.startsWith(":") && trimmed.endsWith(":")) {
+        return "center";
+    }
+    if (trimmed.endsWith(":")) {
+        return "right";
+    }
+    if (trimmed.startsWith(":")) {
+        return "left";
+    }
+    return "left";
+}
+function parseTable(lines, index) {
+    if (!isTableRowLine(lines[index])) {
+        return null;
+    }
+    if (index + 1 >= lines.length || !isSeparatorRow(lines[index + 1])) {
+        return null;
+    }
+    const headerCells = splitTableRow(lines[index]);
+    const alignmentCells = splitTableRow(lines[index + 1]);
+    const columnCount = Math.max(headerCells.length, alignmentCells.length);
+    const columnAlignments = new Array(columnCount).fill("left");
+    alignmentCells.forEach((token, idx) => {
+        columnAlignments[idx] = alignmentFromToken(token);
+    });
+    const allRows = [headerCells];
+    let next = index + 2;
+    while (next < lines.length && isTableRowLine(lines[next])) {
+        allRows.push(splitTableRow(lines[next]));
+        next += 1;
+    }
+    const normalizedRows = allRows.map((row) => {
+        const cells = [...row];
+        while (cells.length < columnCount) {
+            cells.push("");
+        }
+        return cells;
+    });
+    const tableRows = normalizedRows.map((row) => {
+        const cells = row.map((cellText, columnIndex) => {
+            var _a, _b;
+            return ({
+                type: "tableCell",
+                props: {
+                    ...cloneCellProps(),
+                    textAlignment: (_a = columnAlignments[columnIndex]) !== null && _a !== void 0 ? _a : "left",
+                },
+                content: (_b = createTextContent(cellText)) !== null && _b !== void 0 ? _b : [],
+            });
+        });
+        return { cells };
+    });
+    const tableBlock = {
+        type: "table",
+        props: { ...TABLE_BLOCK_PROPS },
+        content: {
+            type: "tableContent",
+            columnWidths: new Array(columnCount).fill(undefined),
+            headerRows: 1,
+            rows: tableRows,
+        },
+        children: [],
+    };
+    return {
+        block: tableBlock,
+        nextIndex: next,
+    };
+}