markdown-parser 0.0.8 → 0.1.0

package/dist/index.js

@@ -0,0 +1,2699 @@
+import { decodeHTMLStrict } from 'entities';
+
+function parseInline(input, options) {
+    const nodes = [];
+    const brackets = [];
+    let characterCursor = 0;
+    while(characterCursor < input.length){
+        const marker = input.charAt(characterCursor);
+        if (marker === "\n") {
+            const startIndex = characterCursor;
+            let numOfPrecedingSpaces = 0;
+            while(true){
+                const currentIndex = startIndex - numOfPrecedingSpaces - 1;
+                if (currentIndex < 0) break;
+                if (input.charAt(currentIndex) !== " ") break;
+                numOfPrecedingSpaces++;
+            }
+            const lastNode = nodes[nodes.length - 1];
+            if (lastNode?.type === "text") {
+                const content = lastNode.text;
+                lastNode.text = content.slice(0, content.length - numOfPrecedingSpaces);
+            }
+            if (numOfPrecedingSpaces >= 2) {
+                nodes.push({
+                    type: "hardbreak"
+                });
+            } else {
+                nodes.push({
+                    type: "softbreak"
+                });
+            }
+            // Skip any leading spaces or tabs in the next line.
+            const numOfSpaces = getNumOfConsecutiveCharacters(input, {
+                characters: [
+                    " "
+                ],
+                startIndex: startIndex + 1
+            });
+            characterCursor += 1 /* Skip the newline character */  + numOfSpaces;
+        } else if (marker === "\\") {
+            // If "\" is followed by a newline, it is a forced hard line break.
+            const nextCharacter = input.charAt(characterCursor + 1);
+            if (nextCharacter === "\n") {
+                nodes.push({
+                    type: "hardbreak"
+                });
+                characterCursor += 2; // Skip the "\" and the following newline character
+                // Skip any leading spaces or tabs in the next line.
+                const numOfSpaces = getNumOfConsecutiveCharacters(input, {
+                    characters: [
+                        " ",
+                        "\t"
+                    ],
+                    startIndex: characterCursor
+                });
+                characterCursor += numOfSpaces;
+                continue;
+            }
+            if (isAsciiPunctuationCharacter(nextCharacter)) {
+                nodes.push({
+                    type: "text",
+                    text: nextCharacter
+                });
+                characterCursor += 2;
+                continue;
+            }
+            nodes.push({
+                type: "text",
+                text: marker
+            });
+            characterCursor += 1;
+        } else if (marker === "`") {
+            const numOfOpeningBackticks = getNumOfConsecutiveCharacters(input, {
+                characters: [
+                    "`"
+                ],
+                startIndex: characterCursor
+            });
+            let hasClosingBackticks = false;
+            const openerIndex = characterCursor + numOfOpeningBackticks;
+            let closerIndex = openerIndex;
+            while(closerIndex < input.length){
+                closerIndex = input.indexOf("`", closerIndex);
+                if (closerIndex === -1) break;
+                const numOfClosingBackticks = getNumOfConsecutiveCharacters(input, {
+                    characters: [
+                        "`"
+                    ],
+                    startIndex: closerIndex
+                });
+                // If the number of consecutive backticks in the closing backticks is the same as the number of consecutive backticks at the start of the code span, it is a valid code span.
+                if (numOfClosingBackticks === numOfOpeningBackticks) {
+                    hasClosingBackticks = true;
+                    break;
+                }
+                // Move the closer index to the next backtick.
+                closerIndex += numOfClosingBackticks;
+            }
+            if (hasClosingBackticks) {
+                let content = input.slice(openerIndex, closerIndex).replace(/\n/g, " "); // Replace newlines inside the captured text with a space as per CommonMark spec.
+                if (content[0] === " " && content[content.length - 1] === " ") {
+                    if (content.trim().length > 0) {
+                        content = content.slice(1, content.length - 1);
+                    }
+                }
+                nodes.push({
+                    type: "code-span",
+                    text: content
+                });
+                characterCursor = closerIndex + numOfOpeningBackticks;
+            } else {
+                nodes.push({
+                    type: "text",
+                    text: marker.repeat(numOfOpeningBackticks)
+                });
+                characterCursor += numOfOpeningBackticks;
+            }
+        } else if (marker === "*" || marker === "_") {
+            const numOfMarkers = getNumOfConsecutiveCharacters(input, {
+                characters: [
+                    marker
+                ],
+                startIndex: characterCursor
+            });
+            const previousCharacter = input[characterCursor - 1] ?? " ";
+            const nextCharacter = input[characterCursor + numOfMarkers] ?? " ";
+            const isPreviousCharacterPunctuation = isAsciiPunctuationCharacter(previousCharacter) || isUnicodePunctuationCharacter(previousCharacter);
+            const isNextCharacterPunctuation = isAsciiPunctuationCharacter(nextCharacter) || isUnicodePunctuationCharacter(nextCharacter);
+            const isPreviousCharacterWhitespace = isWhiteSpaceCharacter(previousCharacter);
+            const isNextCharacterWhitespace = isWhiteSpaceCharacter(nextCharacter);
+            /**
+			 * A left-flanking delimiter run is a delimiter run that is:
+			 * (1) not followed by Unicode whitespace, and either
+			 * (2a) not followed by a Unicode punctuation character, or (2b) followed by a Unicode punctuation character and preceded by Unicode whitespace or a Unicode punctuation character.
+			 * Read more: https://spec.commonmark.org/0.31.2/#left-flanking-delimiter-run
+			 */ const isLeftFlanking = !isNextCharacterWhitespace && (!isNextCharacterPunctuation || isPreviousCharacterWhitespace || isPreviousCharacterPunctuation);
+            /**
+			 * A right-flanking delimiter run is a delimiter run that is
+			 * (1) not preceded by Unicode whitespace, and either
+			 * (2a) not preceded by a Unicode punctuation character, or (2b) preceded by a Unicode punctuation character and followed by Unicode whitespace or a Unicode punctuation character.
+			 * Read more: https://spec.commonmark.org/0.31.2/#right-flanking-delimiter-run
+			 */ const isRightFlanking = !isPreviousCharacterWhitespace && (!isPreviousCharacterPunctuation || isNextCharacterWhitespace || isNextCharacterPunctuation);
+            // For emphasis characters, we create a special node that could evolve to emphasis nodes or become simple text nodes, depending on whether they have a matching opener/closer.
+            if (marker === "*") {
+                nodes.push({
+                    type: "emphasis-delimiter",
+                    marker,
+                    canOpen: isLeftFlanking,
+                    canClose: isRightFlanking,
+                    count: numOfMarkers,
+                    content: marker.repeat(numOfMarkers)
+                });
+            } else {
+                nodes.push({
+                    type: "emphasis-delimiter",
+                    marker,
+                    canOpen: isLeftFlanking && (!isRightFlanking || isPreviousCharacterPunctuation),
+                    canClose: isRightFlanking && (!isLeftFlanking || isNextCharacterPunctuation),
+                    count: numOfMarkers,
+                    content: marker.repeat(numOfMarkers)
+                });
+            }
+            characterCursor += numOfMarkers;
+        } else if (marker === "[") {
+            const node = {
+                type: "text",
+                text: marker
+            };
+            nodes.push(node);
+            brackets.push({
+                marker: "[",
+                node,
+                startIndex: characterCursor,
+                isActive: true
+            });
+            characterCursor += 1;
+        } else if (marker === "!" && input.charAt(characterCursor + 1) === "[") {
+            const node = {
+                type: "text",
+                text: "!["
+            };
+            nodes.push(node);
+            brackets.push({
+                marker: "![",
+                node,
+                startIndex: characterCursor,
+                isActive: true
+            });
+            characterCursor += 2;
+        } else if (marker === "]") {
+            const startIndex = characterCursor;
+            // Pop the last bracket from the bracket stack.
+            const openerBracket = brackets.pop();
+            // If the last bracket doesn't exist or is inactive, we render the closing bracket as text.
+            if (openerBracket === undefined || !openerBracket.isActive) {
+                nodes.push({
+                    type: "text",
+                    text: marker
+                });
+                characterCursor += 1;
+                continue;
+            }
+            const target = parseLinkTarget(input, {
+                startIndex: characterCursor + 1
+            });
+            let href;
+            let title;
+            if (target !== null) {
+                href = target.href;
+                title = target.title;
+                characterCursor = target.endIndex + 1;
+            } else {
+                let label;
+                const referenceLabel = parseReferenceLinkLabel(input, {
+                    startIndex: characterCursor + 1
+                });
+                if (referenceLabel !== null) {
+                    // If the reference label is a full label (e.g. [label]), we use the explicit label.
+                    if (referenceLabel.label.length > 0) {
+                        label = referenceLabel.label;
+                    } else {
+                        label = extractLinkLabel(input, {
+                            startIndex: openerBracket.marker === "[" ? openerBracket.startIndex + 1 : openerBracket.startIndex + 2,
+                            endIndex: startIndex
+                        });
+                    }
+                    characterCursor = referenceLabel.endIndex + 1;
+                } else {
+                    label = extractLinkLabel(input, {
+                        startIndex: openerBracket.marker === "[" ? openerBracket.startIndex + 1 : openerBracket.startIndex + 2,
+                        endIndex: startIndex
+                    });
+                    // Advance the character cursor by 1 to skip the closing bracket
+                    characterCursor = startIndex + 1;
+                }
+                const definition = label !== null ? options.referenceDefinitions.get(normalizeReference(label)) : undefined;
+                if (definition === undefined) {
+                    nodes.push({
+                        type: "text",
+                        text: marker
+                    });
+                    characterCursor = startIndex + 1;
+                    continue;
+                }
+                href = definition.href;
+                title = definition.title;
+            }
+            const openerNodeIndex = nodes.indexOf(openerBracket.node);
+            const children = parseEmphasisDelimiterNodes(nodes.splice(openerNodeIndex + 1));
+            nodes[openerNodeIndex] = {
+                type: openerBracket.marker === "[" ? "link" : "image",
+                href: encodeUnsafeChars(href),
+                title,
+                children
+            };
+            // As per CommonMark specification, links cannot contain other links. When we form a link, we mark all the '[' brackets as inactive so that if a closing bracket ']' is encountered, it will be rendered as text instead of forming a link.
+            if (openerBracket.marker === "[") {
+                for (const bracket of brackets){
+                    if (bracket.marker === "[") {
+                        bracket.isActive = false; // This bracket's '[' now requires its ']' to be rendered as text.
+                    }
+                }
+            }
+        } else if (marker === "<") {
+            // Attempt to parse the content as an autolink.
+            const emailMatch = input.slice(characterCursor).match(EMAIL_REGEX);
+            if (emailMatch !== null) {
+                const email = emailMatch[0].slice(1, emailMatch[0].length - 1);
+                let destination;
+                try {
+                    destination = encodeUnsafeChars("mailto:" + email);
+                } catch  {
+                    destination = "mailto:" + email;
+                }
+                nodes.push({
+                    type: "link",
+                    href: destination,
+                    children: [
+                        {
+                            type: "text",
+                            text: email
+                        }
+                    ]
+                });
+                characterCursor += emailMatch[0].length;
+                continue;
+            }
+            const uriMatch = input.slice(characterCursor).match(AUTOLINK_REGEX);
+            if (uriMatch !== null) {
+                const uri = uriMatch[0].slice(1, uriMatch[0].length - 1);
+                let destination;
+                try {
+                    destination = encodeUnsafeChars(uri);
+                } catch  {
+                    destination = uri;
+                }
+                nodes.push({
+                    type: "link",
+                    href: destination,
+                    children: [
+                        {
+                            type: "text",
+                            text: uri
+                        }
+                    ]
+                });
+                characterCursor += uriMatch[0].length;
+                continue;
+            }
+            // If we failed to parse the content as an autolink, attempt to parse it as a raw HTML tag.
+            const htmlTagMatch = input.slice(characterCursor).match(HTML_TAG_REGEX);
+            if (htmlTagMatch !== null) {
+                nodes.push({
+                    type: "html",
+                    content: htmlTagMatch[0]
+                });
+                characterCursor += htmlTagMatch[0].length;
+                continue;
+            }
+            nodes.push({
+                type: "text",
+                text: marker
+            });
+            characterCursor += 1;
+        } else if (marker === "&") {
+            const match = input.slice(characterCursor).match(ENTITY_REGEX);
+            if (match !== null) {
+                const entity = match[0];
+                nodes.push({
+                    type: "text",
+                    text: decodeHTMLStrict(entity)
+                });
+                characterCursor += entity.length;
+                continue;
+            }
+            nodes.push({
+                type: "text",
+                text: marker
+            });
+            characterCursor += 1;
+        } else {
+            let endIndex = characterCursor;
+            while(endIndex < input.length){
+                const character = input.charAt(endIndex);
+                if (character === "\n") break;
+                if (character === "\\") break;
+                if (character === "`") break;
+                if (character === "*") break;
+                if (character === "_") break;
+                if (character === "[") break;
+                if (character === "]") break;
+                if (character === "!") break;
+                if (character === "<") break;
+                if (character === "&") break;
+                endIndex++;
+            }
+            // If no characters were consumed, consume at least one character. This handles standalone "!" character not followed by "[" (which falls through from the above checks since it's not an image opener)
+            if (endIndex === characterCursor) {
+                endIndex++;
+            }
+            nodes.push({
+                type: "text",
+                text: input.slice(characterCursor, endIndex)
+            });
+            characterCursor = endIndex;
+        }
+    }
+    return mergeAdjacentTextNodes(parseEmphasisDelimiterNodes(nodes));
+}
+function parseEmphasisDelimiterNodes(nodes) {
+    const result = nodes;
+    let closerIndex = 0;
+    while(closerIndex < result.length){
+        const node = result[closerIndex];
+        if (node === undefined) break;
+        // Skip delimiters that cannot close an emphasis. E.g., in '*foo bar', the '*' is left-flanking only, so we skip it as it cannot close an emphasis.
+        if (node.type !== "emphasis-delimiter" || !node.canClose) {
+            closerIndex++;
+            continue;
+        }
+        const closer = node;
+        // Search backward from the closer to find the nearest matching opener.
+        const openerInfo = findMatchingOpenerForCloser(result, {
+            node: closer,
+            index: closerIndex
+        });
+        // If no matching opener is found, we continue to the next delimiter after handling the case where the closer cannot open emphasis either.
+        if (openerInfo === null) {
+            // If a matching opener isn't found for the closer and if the closer cannot open emphasis either, we replace the delimiter with a text node containing the delimiter's content.
+            if (!closer.canOpen) {
+                result[closerIndex] = {
+                    type: "text",
+                    text: closer.content
+                };
+            }
+            closerIndex++;
+            continue;
+        }
+        const opener = openerInfo.node;
+        const openerIndex = openerInfo.index;
+        // If the opener and closer both have at least two marker characters, it is a strong emphasis.
+        const isStrong = opener.content.length >= 2 && closer.content.length >= 2;
+        // Depending on whether it is a strong emphasis or not, we remove the last two or one characters from the opener node text and the first two or one characters from the closer node text.
+        opener.content = opener.content.slice(0, isStrong ? -2 : -1);
+        closer.content = closer.content.slice(isStrong ? 2 : 1);
+        // Collect the nodes between opener and closer to be wrapped in the emphasis node.
+        // Any emphasis-delimiter nodes are replaced with text nodes containing the delimiter's content as they can't participate in future matches at this level.
+        const children = result.slice(openerIndex + 1, closerIndex).map((node)=>{
+            if (node.type === "emphasis-delimiter") {
+                return {
+                    type: "text",
+                    text: node.content
+                };
+            }
+            return node;
+        });
+        result.splice(openerIndex + 1, closerIndex - openerIndex - 1, {
+            type: isStrong ? "strong" : "emphasis",
+            children
+        });
+        // If the opener is fully consumed (i.e., no remaining characters), we remove it from the result array.
+        if (opener.content.length === 0) {
+            result.splice(openerIndex, 1);
+        }
+        // If the closer is fully consumed (i.e., no remaining characters), we remove it from the result array.
+        if (closer.content.length === 0) {
+            result.splice(result.indexOf(closer), 1);
+        }
+        // Move the closer index to the node after the opener as we've collapsed the nodes between opener and closer into a single emphasis node.
+        closerIndex = openerIndex + 1;
+    }
+    return result.map((node)=>{
+        if (node.type === "emphasis-delimiter") {
+            return {
+                type: "text",
+                text: node.content
+            };
+        }
+        return node;
+    });
+}
+function findMatchingOpenerForCloser(nodes, closer) {
+    for(let i = closer.index - 1; i >= 0; i--){
+        const node = nodes[i];
+        if (node?.type !== "emphasis-delimiter") continue;
+        // Skip delimiters that cannot open an emphasis or are not the same marker as the closer.
+        if (!node.canOpen) continue;
+        if (node.marker !== closer.node.marker) continue;
+        /**
+		 * Check if the delimiter pair violates the rule of three.
+		 * In the CommonMark emphasis rules, when a delimiter run can both open and close, a special constraint applies to decide whether a pair of runs should match:
+		 * If the sum of the run lengths of the opener and closer is a multiple of 3, then they do not match unless both run lengths are themselves multiples of 3.
+		 */ if ((node.canClose || closer.node.canOpen) && (node.count + closer.node.count) % 3 === 0 && (node.count % 3 !== 0 || closer.node.count % 3 !== 0)) {
+            continue;
+        }
+        return {
+            node,
+            index: i
+        };
+    }
+    return null;
+}
+/**
+ * Counts the number of consecutive characters from a set starting at a given position.
+ *
+ * @param input - The string to search within.
+ * @param options.characters - Array of characters to match (any character in the array counts).
+ * @param options.startIndex - The position in the input to start counting from.
+ * @returns The count of consecutive matching characters (0 if none match).
+ *
+ * @example
+ * getNumOfConsecutiveCharacters("```ts", { characters: ["`"], startIndex: 0 })  // 3
+ * getNumOfConsecutiveCharacters("  \thello", { characters: [" ", "\t"], startIndex: 0 })  // 3
+ */ function getNumOfConsecutiveCharacters(input, { characters, startIndex }) {
+    let numOfConsecutiveCharacters = 0;
+    while(true){
+        if (startIndex + numOfConsecutiveCharacters >= input.length) break;
+        if (!characters.includes(input.charAt(startIndex + numOfConsecutiveCharacters))) {
+            break;
+        }
+        numOfConsecutiveCharacters++;
+    }
+    return numOfConsecutiveCharacters;
+}
+/**
+ * Merges adjacent text nodes in an array of LeafNodes into a single text node, recursively processing any children arrays found in nodes with a "children" property.
+ *
+ * For example, the input:
+ *   [
+ *     { type: "text", text: "foo" },
+ *     { type: "text", text: "bar" },
+ *     { type: "emphasis", children: [
+ *        { type: "text", text: "baz" },
+ *        { type: "text", text: "qux" }
+ *     ]}
+ *   ]
+ * will be transformed to:
+ *   [
+ *     { type: "text", text: "foobar" },
+ *     { type: "emphasis", children: [
+ *        { type: "text", text: "bazqux" }
+ *     ]}
+ *   ]
+ *
+ * @param nodes An array of LeafNode objects (e.g. text, link, emphasis, etc.).
+ * @returns A new array of LeafNodes where no two adjacent nodes have type "text", including recursively merged children arrays.
+ */ function mergeAdjacentTextNodes(nodes) {
+    const result = [];
+    for (const node of nodes){
+        if (node.type === "text") {
+            const lastNode = result[result.length - 1];
+            if (lastNode?.type === "text") {
+                lastNode.text += node.text;
+            } else {
+                result.push(node);
+            }
+        } else {
+            // Recursively merge text nodes for any children.
+            if ("children" in node) {
+                node.children = mergeAdjacentTextNodes(node.children);
+            }
+            result.push(node);
+        }
+    }
+    return result;
+}
+/**
+ * Checks if the character is an ASCII punctuation character.
+ * An ASCII punctuation character is !, ", #, $, %, &, ', (, ), *, +, ,, -, ., / (U+0021–2F), :, ;, <, =, >, ?, @ (U+003A–0040), [, \, ], ^, _, ` (U+005B–0060), {, |, }, or ~ (U+007B–007E).
+ * @param character - The character to check.
+ * @returns true if the character is an ASCII punctuation character, false otherwise.
+ *
+ * The following characters are considered ASCII punctuation characters:
+ * - ! (U+0021)
+ * - " (U+0022)
+ * - # (U+0023)
+ * - $ (U+0024)
+ * - % (U+0025)
+ * - & (U+0026)
+ * - ' (U+0027)
+ * - ( (U+0028)
+ * - ) (U+0029)
+ * - * (U+002A)
+ * - + (U+002B)
+ * - , (U+002C)
+ * - - (U+002D)
+ * - . (U+002E)
+ * - / (U+002F)
+ * - : (U+003A)
+ * - ; (U+003B)
+ * - < (U+003C)
+ * - = (U+003D)
+ * - > (U+003E)
+ * - ? (U+003F)
+ * - @ (U+0040)
+ * - [ (U+005B)
+ * - \ (U+005C)
+ * - ] (U+005D)
+ * - ^ (U+005E)
+ * - _ (U+005F)
+ * - ` (U+0060)
+ * - { (U+007B)
+ * - | (U+007C)
+ * - } (U+007D)
+ * - ~ (U+007E)
+ *
+ * https://spec.commonmark.org/0.31.2/#ascii-punctuation-character
+ */ function isAsciiPunctuationCharacter(character) {
+    switch(character){
+        case "!":
+        case '"':
+        case "#":
+        case "$":
+        case "%":
+        case "&":
+        case "'":
+        case "(":
+        case ")":
+        case "*":
+        case "+":
+        case ",":
+        case "-":
+        case ".":
+        case "/":
+        case ":":
+        case ";":
+        case "<":
+        case "=":
+        case ">":
+        case "?":
+        case "@":
+        case "[":
+        case "\\":
+        case "]":
+        case "^":
+        case "_":
+        case "`":
+        case "{":
+        case "|":
+        case "}":
+        case "~":
+            return true;
+        default:
+            return false;
+    }
+}
+const UNICODE_P_REGEX = /[!-#%-*,-/:;?@[-\]_{}\xA1\xA7\xAB\xB6\xB7\xBB\xBF\u037E\u0387\u055A-\u055F\u0589\u058A\u05BE\u05C0\u05C3\u05C6\u05F3\u05F4\u0609\u060A\u060C\u060D\u061B\u061D-\u061F\u066A-\u066D\u06D4\u0700-\u070D\u07F7-\u07F9\u0830-\u083E\u085E\u0964\u0965\u0970\u09FD\u0A76\u0AF0\u0C77\u0C84\u0DF4\u0E4F\u0E5A\u0E5B\u0F04-\u0F12\u0F14\u0F3A-\u0F3D\u0F85\u0FD0-\u0FD4\u0FD9\u0FDA\u104A-\u104F\u10FB\u1360-\u1368\u1400\u166E\u169B\u169C\u16EB-\u16ED\u1735\u1736\u17D4-\u17D6\u17D8-\u17DA\u1800-\u180A\u1944\u1945\u1A1E\u1A1F\u1AA0-\u1AA6\u1AA8-\u1AAD\u1B5A-\u1B60\u1B7D\u1B7E\u1BFC-\u1BFF\u1C3B-\u1C3F\u1C7E\u1C7F\u1CC0-\u1CC7\u1CD3\u2010-\u2027\u2030-\u2043\u2045-\u2051\u2053-\u205E\u207D\u207E\u208D\u208E\u2308-\u230B\u2329\u232A\u2768-\u2775\u27C5\u27C6\u27E6-\u27EF\u2983-\u2998\u29D8-\u29DB\u29FC\u29FD\u2CF9-\u2CFC\u2CFE\u2CFF\u2D70\u2E00-\u2E2E\u2E30-\u2E4F\u2E52-\u2E5D\u3001-\u3003\u3008-\u3011\u3014-\u301F\u3030\u303D\u30A0\u30FB\uA4FE\uA4FF\uA60D-\uA60F\uA673\uA67E\uA6F2-\uA6F7\uA874-\uA877\uA8CE\uA8CF\uA8F8-\uA8FA\uA8FC\uA92E\uA92F\uA95F\uA9C1-\uA9CD\uA9DE\uA9DF\uAA5C-\uAA5F\uAADE\uAADF\uAAF0\uAAF1\uABEB\uFD3E\uFD3F\uFE10-\uFE19\uFE30-\uFE52\uFE54-\uFE61\uFE63\uFE68\uFE6A\uFE6B\uFF01-\uFF03\uFF05-\uFF0A\uFF0C-\uFF0F\uFF1A\uFF1B\uFF1F\uFF20\uFF3B-\uFF3D\uFF3F\uFF5B\uFF5D\uFF5F-\uFF65]|\uD800[\uDD00-\uDD02\uDF9F\uDFD0]|\uD801\uDD6F|\uD802[\uDC57\uDD1F\uDD3F\uDE50-\uDE58\uDE7F\uDEF0-\uDEF6\uDF39-\uDF3F\uDF99-\uDF9C]|\uD803[\uDEAD\uDF55-\uDF59\uDF86-\uDF89]|\uD804[\uDC47-\uDC4D\uDCBB\uDCBC\uDCBE-\uDCC1\uDD40-\uDD43\uDD74\uDD75\uDDC5-\uDDC8\uDDCD\uDDDB\uDDDD-\uDDDF\uDE38-\uDE3D\uDEA9]|\uD805[\uDC4B-\uDC4F\uDC5A\uDC5B\uDC5D\uDCC6\uDDC1-\uDDD7\uDE41-\uDE43\uDE60-\uDE6C\uDEB9\uDF3C-\uDF3E]|\uD806[\uDC3B\uDD44-\uDD46\uDDE2\uDE3F-\uDE46\uDE9A-\uDE9C\uDE9E-\uDEA2\uDF00-\uDF09]|\uD807[\uDC41-\uDC45\uDC70\uDC71\uDEF7\uDEF8\uDF43-\uDF4F\uDFFF]|\uD809[\uDC70-\uDC74]|\uD80B[\uDFF1\uDFF2]|\uD81A[\uDE6E\uDE6F\uDEF5\uDF37-\uDF3B\uDF44]|\uD81B[\uDE97-\uDE9A\uDFE2]|\uD82F\uDC9F|\uD836[\uDE87-\uDE8B]|\uD83A[\uDD5E\uDD5F]/;
+const UNICODE_S_REGEX = /[$+<->^`|~\xA2-\xA6\xA8\xA9\xAC\xAE-\xB1\xB4\xB8\xD7\xF7\u02C2-\u02C5\u02D2-\u02DF\u02E5-\u02EB\u02ED\u02EF-\u02FF\u0375\u0384\u0385\u03F6\u0482\u058D-\u058F\u0606-\u0608\u060B\u060E\u060F\u06DE\u06E9\u06FD\u06FE\u07F6\u07FE\u07FF\u0888\u09F2\u09F3\u09FA\u09FB\u0AF1\u0B70\u0BF3-\u0BFA\u0C7F\u0D4F\u0D79\u0E3F\u0F01-\u0F03\u0F13\u0F15-\u0F17\u0F1A-\u0F1F\u0F34\u0F36\u0F38\u0FBE-\u0FC5\u0FC7-\u0FCC\u0FCE\u0FCF\u0FD5-\u0FD8\u109E\u109F\u1390-\u1399\u166D\u17DB\u1940\u19DE-\u19FF\u1B61-\u1B6A\u1B74-\u1B7C\u1FBD\u1FBF-\u1FC1\u1FCD-\u1FCF\u1FDD-\u1FDF\u1FED-\u1FEF\u1FFD\u1FFE\u2044\u2052\u207A-\u207C\u208A-\u208C\u20A0-\u20C0\u2100\u2101\u2103-\u2106\u2108\u2109\u2114\u2116-\u2118\u211E-\u2123\u2125\u2127\u2129\u212E\u213A\u213B\u2140-\u2144\u214A-\u214D\u214F\u218A\u218B\u2190-\u2307\u230C-\u2328\u232B-\u2426\u2440-\u244A\u249C-\u24E9\u2500-\u2767\u2794-\u27C4\u27C7-\u27E5\u27F0-\u2982\u2999-\u29D7\u29DC-\u29FB\u29FE-\u2B73\u2B76-\u2B95\u2B97-\u2BFF\u2CE5-\u2CEA\u2E50\u2E51\u2E80-\u2E99\u2E9B-\u2EF3\u2F00-\u2FD5\u2FF0-\u2FFF\u3004\u3012\u3013\u3020\u3036\u3037\u303E\u303F\u309B\u309C\u3190\u3191\u3196-\u319F\u31C0-\u31E3\u31EF\u3200-\u321E\u322A-\u3247\u3250\u3260-\u327F\u328A-\u32B0\u32C0-\u33FF\u4DC0-\u4DFF\uA490-\uA4C6\uA700-\uA716\uA720\uA721\uA789\uA78A\uA828-\uA82B\uA836-\uA839\uAA77-\uAA79\uAB5B\uAB6A\uAB6B\uFB29\uFBB2-\uFBC2\uFD40-\uFD4F\uFDCF\uFDFC-\uFDFF\uFE62\uFE64-\uFE66\uFE69\uFF04\uFF0B\uFF1C-\uFF1E\uFF3E\uFF40\uFF5C\uFF5E\uFFE0-\uFFE6\uFFE8-\uFFEE\uFFFC\uFFFD]|\uD800[\uDD37-\uDD3F\uDD79-\uDD89\uDD8C-\uDD8E\uDD90-\uDD9C\uDDA0\uDDD0-\uDDFC]|\uD802[\uDC77\uDC78\uDEC8]|\uD805\uDF3F|\uD807[\uDFD5-\uDFF1]|\uD81A[\uDF3C-\uDF3F\uDF45]|\uD82F\uDC9C|\uD833[\uDF50-\uDFC3]|\uD834[\uDC00-\uDCF5\uDD00-\uDD26\uDD29-\uDD64\uDD6A-\uDD6C\uDD83\uDD84\uDD8C-\uDDA9\uDDAE-\uDDEA\uDE00-\uDE41\uDE45\uDF00-\uDF56]|\uD835[\uDEC1\uDEDB\uDEFB\uDF15\uDF35\uDF4F\uDF6F\uDF89\uDFA9\uDFC3]|\uD836[\uDC00-\uDDFF\uDE37-\uDE3A\uDE6D-\uDE74\uDE76-\uDE83\uDE85\uDE86]|\uD838[\uDD4F\uDEFF]|\uD83B[\uDCAC\uDCB0\uDD2E\uDEF0\uDEF1]|\uD83C[\uDC00-\uDC2B\uDC30-\uDC93\uDCA0-\uDCAE\uDCB1-\uDCBF\uDCC1-\uDCCF\uDCD1-\uDCF5\uDD0D-\uDDAD\uDDE6-\uDE02\uDE10-\uDE3B\uDE40-\uDE48\uDE50\uDE51\uDE60-\uDE65\uDF00-\uDFFF]|\uD83D[\uDC00-\uDED7\uDEDC-\uDEEC\uDEF0-\uDEFC\uDF00-\uDF76\uDF7B-\uDFD9\uDFE0-\uDFEB\uDFF0]|\uD83E[\uDC00-\uDC0B\uDC10-\uDC47\uDC50-\uDC59\uDC60-\uDC87\uDC90-\uDCAD\uDCB0\uDCB1\uDD00-\uDE53\uDE60-\uDE6D\uDE70-\uDE7C\uDE80-\uDE88\uDE90-\uDEBD\uDEBF-\uDEC5\uDECE-\uDEDB\uDEE0-\uDEE8\uDEF0-\uDEF8\uDF00-\uDF92\uDF94-\uDFCA]/;
+/**
+ * Checks if the character is a unicode punctuation character.
+ * A Unicode punctuation character is a character in the Unicode P (puncuation) or S (symbol) general categories.
+ * @param character - The character to check.
+ * @returns true if the character is a punctuation character, false otherwise.
+ *
+ * https://spec.commonmark.org/0.31.2/#unicode-punctuation-character
+ */ function isUnicodePunctuationCharacter(character) {
+    return UNICODE_P_REGEX.test(character) || UNICODE_S_REGEX.test(character);
+}
+function isWhiteSpaceCharacter(character) {
+    const code = character.charCodeAt(0);
+    if (code >= 0x2000 && code <= 0x200a) {
+        return true;
+    }
+    switch(code){
+        case 0x09:
+        /* \t */ case 0x0a:
+        /* \n */ case 0x0b:
+        /* \v */ case 0x0c:
+        /* \f */ case 0x0d:
+        /* \r */ case 0x20:
+        case 0xa0:
+        case 0x1680:
+        case 0x202f:
+        case 0x205f:
+        case 0x3000:
+            return true;
+    }
+    return false;
+}
+function parseLinkTarget(input, options) {
+    const startIndex = options.startIndex;
+    if (input.charAt(startIndex) !== "(") return null;
+    // Count the number of whitespaces and newlines after the left parenthesis.
+    const numOfWhitespacesAfterLeftParenthesis = getNumOfConsecutiveCharacters(input, {
+        characters: [
+            " ",
+            "\t",
+            "\n"
+        ],
+        startIndex: startIndex + 1
+    });
+    const destinationStartIndex = startIndex + numOfWhitespacesAfterLeftParenthesis + 1; // Skip whitespaces and newlines after the left parenthesis
+    const destination = parseLinkDestination(input, {
+        startIndex: destinationStartIndex
+    });
+    if (destination === null || destination.endIndex === destinationStartIndex) {
+        return null;
+    }
+    const destinationEndIndex = destination.endIndex;
+    const numOfWhitespacesAfterHref = getNumOfConsecutiveCharacters(input, {
+        characters: [
+            " ",
+            "\t",
+            "\n"
+        ],
+        startIndex: destinationEndIndex + 1
+    });
+    const titleStartIndex = destinationEndIndex + numOfWhitespacesAfterHref + 1;
+    const title = parseLinkTitle(input, {
+        startIndex: titleStartIndex
+    });
+    let targetEndIndex = destination.endIndex;
+    if (title !== null) {
+        targetEndIndex = title.endIndex;
+    }
+    const numOfWhitespaces = getNumOfConsecutiveCharacters(input, {
+        characters: [
+            " ",
+            "\t",
+            "\n"
+        ],
+        startIndex: targetEndIndex + 1
+    });
+    targetEndIndex += numOfWhitespaces + 1;
+    // Link target must end with a right parenthesis.
+    if (input.charAt(targetEndIndex) !== ")") {
+        return null;
+    }
+    return {
+        href: destination.href,
+        title: title?.title,
+        raw: input.slice(startIndex, targetEndIndex + 1),
+        endIndex: targetEndIndex
+    };
+}
+function parseLinkDestination(input, options) {
+    const startIndex = options.startIndex;
+    // If the destination start index is out of bounds, the link target is invalid.
+    if (startIndex >= input.length) return null;
+    if (input.charAt(startIndex) === "<") {
+        const destinationStartIndex = startIndex + 1;
+        let destinationEndIndex = destinationStartIndex;
+        while(destinationEndIndex < input.length){
+            const character = input.charAt(destinationEndIndex);
+            if (character === "\n") return null;
+            if (character === "<") return null;
+            if (character === ">") {
+                return {
+                    href: unescapeString(input.slice(destinationStartIndex, destinationEndIndex)),
+                    raw: input.slice(destinationStartIndex, destinationEndIndex + 1),
+                    endIndex: destinationEndIndex
+                };
+            }
+            // If the current character is a backslash and it is not the last character, it is an escaped character, so we skip the current character and the next character.
+            if (character === "\\" && destinationEndIndex + 1 < input.length) {
+                destinationEndIndex += 2;
+                continue;
+            }
+            destinationEndIndex++;
+        }
+        return null;
+    } else {
+        const destinationStartIndex = startIndex;
+        let destinationEndIndex = destinationStartIndex;
+        let numOfLeftParentheses = 0;
+        while(destinationEndIndex < input.length){
+            const characterCode = input.charCodeAt(destinationEndIndex);
+            if (input.charCodeAt(destinationEndIndex) === 0x20 /* SPACE */ ) break;
+            // Handle ASCII control characters
+            if (characterCode < 0x20 || characterCode === 0x7f) {
+                break;
+            }
+            if (characterCode === 0x5c /* BACKSLASH */  && destinationEndIndex + 1 < input.length) {
+                if (input.charCodeAt(destinationEndIndex + 1) === 0x20 /* SPACE */ ) {
+                    break;
+                }
+                destinationEndIndex += 2;
+                continue;
+            }
+            if (characterCode === 0x28 /* LEFT_PARENTHESIS */ ) {
+                numOfLeftParentheses++;
+                if (numOfLeftParentheses > 32) return null;
+            }
+            if (characterCode === 0x29 /* RIGHT_PARENTHESIS */ ) {
+                if (numOfLeftParentheses === 0) break;
+                numOfLeftParentheses--;
+            }
+            destinationEndIndex++;
+        }
+        // Unbalanced parentheses make the destination invalid
+        if (numOfLeftParentheses !== 0) return null;
+        const raw = input.slice(destinationStartIndex, destinationEndIndex);
+        return {
+            href: unescapeString(raw),
+            raw,
+            endIndex: destinationEndIndex - 1
+        };
+    }
+}
+function parseLinkTitle(input, options) {
+    const startIndex = options.startIndex;
+    // If the title start index is out of bounds, the link title is invalid.
+    if (startIndex >= input.length) return null;
+    const openingQuoteCharacter = input.charAt(startIndex);
+    // Link title must start with ", ', or (
+    if (![
+        '"',
+        "'",
+        "("
+    ].includes(openingQuoteCharacter)) {
+        return null;
+    }
+    const closingQuoteCharacter = openingQuoteCharacter === "(" ? ")" : openingQuoteCharacter;
+    let endIndex = startIndex + 1;
+    while(endIndex < input.length){
+        const character = input.charAt(endIndex);
+        if (character === closingQuoteCharacter) {
+            return {
+                raw: input.slice(startIndex, endIndex + 1),
+                title: unescapeString(input.slice(startIndex + 1, endIndex)),
+                endIndex: endIndex
+            };
+        }
+        // For parenthesis-delimited titles, unescaped `(` is not allowed; this prevents ambiguity in parsing.
+        if (character === "(" && openingQuoteCharacter === "(") {
+            return null;
+        }
+        // If the current character is a backslash and it is not the last character, it is an escaped character, so we skip the current character and the next character.
+        if (character === "\\" && endIndex + 1 < input.length) {
+            endIndex += 2;
+            continue;
+        }
+        // Regular characters (including newlines) are allowed in the title.
+        endIndex++;
+    }
+    return null;
+}
+function parseReferenceLinkLabel(input, options) {
+    const startIndex = options.startIndex;
+    if (startIndex >= input.length) return null;
+    if (input.charAt(startIndex) !== "[") return null;
+    // Handle the special case of a collapsed reference '[]'. We return an empty label in this case.
+    if (input.charAt(startIndex + 1) === "]") {
+        return {
+            label: "",
+            raw: input.slice(startIndex, startIndex + 2),
+            endIndex: startIndex + 1
+        };
+    }
+    let label = "";
+    let endIndex = startIndex + 1;
+    while(endIndex < input.length){
+        const character = input.charAt(endIndex);
+        // A reference label that is too long is invalid.
+        if (label.length > 999) return null;
+        if (character === "\\") {
+            const nextCharacter = input.charAt(endIndex + 1);
+            // Only ']', '[' and '\' need to be escaped within labels. Other backslashes are preserved literally for label matching.
+            if ([
+                "]",
+                "[",
+                "\\"
+            ].includes(nextCharacter)) {
+                label += nextCharacter;
+                endIndex += 2;
+            } else {
+                label += character;
+                endIndex++;
+            }
+            continue;
+        }
+        // Unescaped `[` characters are not allowed in reference link labels. This prevents ambiguous nested bracket parsing.
+        if (character === "[") return null;
+        // If the current character is a closing bracket, we return the reference label.
+        if (character === "]") {
+            // An empty reference label is invalid.
+            if (label.trim().length === 0) return null;
+            return {
+                label,
+                raw: input.slice(startIndex, endIndex + 1),
+                endIndex: endIndex
+            };
+        }
+        label += character;
+        endIndex++;
+    }
+    // Reached the end of text without finding a closing bracket, so the reference label is invalid.
+    return null;
+}
+function extractLinkLabel(input, options) {
+    let label = "";
+    let index = options.startIndex;
+    while(index < options.endIndex){
+        if (index >= input.length) break;
+        // A label that is too long is invalid.
+        if (label.length > 999) return null;
+        const character = input.charAt(index);
+        if (character === "\\") {
+            // Only ']', '[' and '\' can be escaped within labels. Other backslashes are preserved literally for label matching.
+            if ([
+                "]",
+                "[",
+                "\\"
+            ].includes(input.charAt(index + 1))) {
+                label += input.charAt(index + 1);
+                index += 2;
+            } else {
+                label += character;
+                index++;
+            }
+            continue;
+        }
+        label += character;
+        index++;
+    }
+    // An empty label is invalid.
+    if (label.trim().length === 0) return null;
+    return label;
+}
+function normalizeReference(reference) {
+    return reference.trim().replace(/\s+/g, " ").toLowerCase().toUpperCase();
+}
+const UNESCAPE_MD_RE = /\\([!"#$%&'()*+,\-./:;<=>?@[\\\]^_`{|}~])/g;
+const ENTITY_RE = /&([a-z#][a-z0-9]{1,31});/gi;
+const UNESCAPE_ALL_RE = new RegExp(UNESCAPE_MD_RE.source + "|" + ENTITY_RE.source, "gi");
+const DIGITAL_ENTITY_TEST_RE = /^#((?:x[a-f0-9]{1,8}|[0-9]{1,8}))$/i;
+function unescapeString(text) {
+    if (text.indexOf("\\") < 0 && text.indexOf("&") < 0) return text;
+    return text.replace(UNESCAPE_ALL_RE, (match, escaped, entity)=>{
+        if (escaped) return escaped;
+        if (entity.charAt(0) === "#" && DIGITAL_ENTITY_TEST_RE.test(entity)) {
+            const code = entity.charAt(1).toLowerCase() === "x" ? parseInt(entity.slice(2), 16) : parseInt(entity.slice(1), 10);
+            if (isValidEntityCode(code)) {
+                return fromCodePoint(code);
+            }
+            return match;
+        }
+        const decoded = decodeHTMLStrict(match);
+        if (decoded !== match) {
+            return decoded;
+        }
+        return match;
+    });
+}
+function isValidEntityCode(code) {
+    // Broken sequence
+    if (code >= 0xd800 && code <= 0xdfff) return false;
+    // Never used
+    if (code >= 0xfdd0 && code <= 0xfdef) return false;
+    if ((code & 0xffff) === 0xffff || (code & 0xffff) === 0xfffe) return false;
+    // Control codes
+    if (code >= 0x00 && code <= 0x08) return false;
+    if (code === 0x0b) return false;
+    if (code >= 0x0e && code <= 0x1f) return false;
+    if (code >= 0x7f && code <= 0x9f) return false;
+    // Out of range
+    if (code > 0x10ffff) return false;
+    return true;
+}
+function fromCodePoint(code) {
+    if (code > 0xffff) {
+        code -= 0x10000;
+        const surrogate1 = 0xd800 + (code >> 10);
+        const surrogate2 = 0xdc00 + (code & 0x3ff);
+        return String.fromCharCode(surrogate1, surrogate2);
+    }
+    return String.fromCharCode(code);
+}
+/**
+ * A cached lookup table used to quickly percent-encode ASCII characters (0–127).
+ *
+ * Key: a string of "allowed" (unencoded) characters besides alphanumerics.
+ * Value: an array of length 128 where:
+ *   - table[code] is the literal character if it is allowed as-is
+ *   - otherwise table[code] is the percent-encoded form (e.g., "%2F")
+ */ const asciiEncodeTableCache = Object.create(null);
+/**
+ * Builds (or retrieves from cache) a lookup table for ASCII characters.
+ *
+ * Rules:
+ * - Alphanumerics [0-9A-Za-z] are always left unencoded.
+ * - Everything else is percent-encoded by default.
+ * - Characters present in `allowedChars` are left unencoded as well.
+ *
+ * This table is only for ASCII 0–127. Non-ASCII characters are handled with
+ * `encodeURIComponent` at runtime.
+ */ function getAsciiEncodeTable(allowedChars) {
+    const cachedTable = asciiEncodeTableCache[allowedChars];
+    if (cachedTable) return cachedTable;
+    const table = [];
+    asciiEncodeTableCache[allowedChars] = table;
+    // Pre-fill for all ASCII codes.
+    for(let code = 0; code < 128; code++){
+        const ch = String.fromCharCode(code);
+        // Always allow unencoded alphanumeric characters.
+        if (/^[0-9a-z]$/i.test(ch)) {
+            table.push(ch);
+            continue;
+        }
+        // Percent-encode any other ASCII character by default.
+        const hex = code.toString(16).toUpperCase();
+        table.push(`%${hex.padStart(2, "0")}`);
+    }
+    // Override: allow any characters provided in `allowedChars` to pass through.
+    for(let i = 0; i < allowedChars.length; i++){
+        const allowedChar = allowedChars[i];
+        if (allowedChar === undefined) continue;
+        const code = allowedChars.charCodeAt(i);
+        // Only affects ASCII entries; non-ASCII isn't in the table anyway.
+        if (code < 128) {
+            table[code] = allowedChar;
+        }
+    }
+    return table;
+}
+/**
+ * Characters allowed unencoded by default (in addition to alphanumerics).
+ */ const DEFAULT_ALLOWED_CHARS = ";/?:@&=+$,-_.!~*'()#";
+/**
+ * Encodes "unsafe" characters using percent-encoding while optionally preserving
+ * already-escaped sequences (e.g., "%2F").
+ */ function encodeUnsafeChars(input, allowedChars, keepExistingEscapes) {
+    // If the second argument isn't a string, treat it as `keepExistingEscapes`.
+    // This preserves the original API shape:
+    //   encodeUnsafeChars(input, keepExistingEscapes)
+    if (typeof allowedChars !== "string") {
+        keepExistingEscapes = allowedChars;
+        allowedChars = DEFAULT_ALLOWED_CHARS;
+    }
+    // Default behavior: preserve valid "%HH" sequences.
+    if (typeof keepExistingEscapes === "undefined") {
+        keepExistingEscapes = true;
+    }
+    const asciiTable = getAsciiEncodeTable(allowedChars);
+    let encoded = "";
+    for(let i = 0; i < input.length; i++){
+        const currentCharacter = input[i];
+        if (currentCharacter === undefined) continue;
+        const codeUnit = input.charCodeAt(i);
+        // If requested, preserve correct percent-escape sequences: "%[0-9A-Fa-f]{2}"
+        if (keepExistingEscapes && codeUnit === 0x25 /* '%' */  && i + 2 < input.length) {
+            const maybeHex = input.slice(i + 1, i + 3);
+            if (/^[0-9a-f]{2}$/i.test(maybeHex)) {
+                encoded += input.slice(i, i + 3);
+                i += 2; // skip the two hex digits as well
+                continue;
+            }
+        }
+        // Fast path: ASCII characters use our lookup table.
+        if (codeUnit < 128) {
+            encoded += asciiTable[codeUnit];
+            continue;
+        }
+        // Handle UTF-16 surrogate pairs and invalid surrogate code units.
+        // Surrogates range: 0xD800–0xDFFF
+        if (codeUnit >= 0xd800 && codeUnit <= 0xdfff) {
+            const isHighSurrogate = codeUnit >= 0xd800 && codeUnit <= 0xdbff;
+            if (isHighSurrogate && i + 1 < input.length) {
+                const nextCodeUnit = input.charCodeAt(i + 1);
+                const isLowSurrogate = nextCodeUnit >= 0xdc00 && nextCodeUnit <= 0xdfff;
+                // Valid surrogate pair: encode the combined code point.
+                if (isLowSurrogate) {
+                    encoded += encodeURIComponent(currentCharacter + input[i + 1]);
+                    i++; // consume the low surrogate
+                    continue;
+                }
+            }
+            // Invalid surrogate (unpaired): emit UTF-8 for U+FFFD replacement char.
+            encoded += "%EF%BF%BD";
+            continue;
+        }
+        // Non-ASCII, non-surrogate: rely on encodeURIComponent for correct UTF-8 encoding.
+        encoded += encodeURIComponent(currentCharacter);
+    }
+    return encoded;
+}
+const ENTITY_REGEX = /^&(?:#x[a-f0-9]{1,6}|#[0-9]{1,7}|[a-z][a-z0-9]{1,31});/i;
+// Pattern for valid HTML attribute names (starts with letter/underscore/colon).
+const ATTRIBUTE_NAME = "[a-zA-Z_:][a-zA-Z0-9:._-]*";
+// Pattern for unquoted attribute values (no quotes, spaces, or special chars).
+const UNQUOTED = "[^\"'=<>`\\x00-\\x20]+";
+// Pattern for single-quoted attribute values.
+const SINGLE_QUOTED = "'[^']*'";
+// Pattern for double-quoted attribute values.
+const DOUBLE_QUOTED = '"[^"]*"';
+// Combined pattern for any valid attribute value format.
+const ATTRIBUTE_VALUE = "(?:" + UNQUOTED + "|" + SINGLE_QUOTED + "|" + DOUBLE_QUOTED + ")";
+// Pattern for a complete HTML attribute (name with optional value).
+const ATTRIBUTE = "(?:\\s+" + ATTRIBUTE_NAME + "(?:\\s*=\\s*" + ATTRIBUTE_VALUE + ")?)";
+// Pattern for an opening HTML tag (e.g., `<div>`, `<img />`).
+const OPEN_TAG = "<[A-Za-z][A-Za-z0-9\\-]*" + ATTRIBUTE + "*\\s*\\/?>";
+// Pattern for a closing HTML tag (e.g., `</div>`).
+const CLOSE_TAG = "<\\/[A-Za-z][A-Za-z0-9\\-]*\\s*>";
+// Pattern for HTML comments (e.g., `<!-- comment -->`).
+const COMMENT = "<!---?>|<!--(?:[^-]|-[^-]|--[^>])*-->";
+// Pattern for processing instructions (e.g., `<?xml ... ?>`).
+const PROCESSING = "<[?][\\s\\S]*?[?]>";
+// Pattern for DOCTYPE and other declarations (e.g., `<!DOCTYPE html>`).
+const DECLARATION = "<![A-Za-z][^>]*>";
+// Pattern for CDATA sections (e.g., `<![CDATA[ ... ]]>`).
+const CDATA = "<!\\[CDATA\\[[\\s\\S]*?\\]\\]>";
+// Regex to match any inline HTML construct at the start of a string. Used for detecting HTML tags within inline content.
+const HTML_TAG_REGEX = new RegExp("^(?:" + OPEN_TAG + "|" + CLOSE_TAG + "|" + COMMENT + "|" + PROCESSING + "|" + DECLARATION + "|" + CDATA + ")");
+const EMAIL_REGEX = /^<([a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*)>/;
+const AUTOLINK_REGEX = /^<[A-Za-z][A-Za-z0-9.+-]{1,31}:[^<>\x00-\x20]*>/i;
+
+/**
+ * Splits a chunk of text into lines.
+ *
+ * Supported line endings:
+ *   - LF      -> "\n"   (line feed)
+ *   - CRLF    -> "\r\n" (carriage return + line feed)
+ *   - CR      -> "\r"   (carriage return)
+ *
+ * @example
+ * ```ts
+ * const lines = new LineSplitter().split("Hello\nWorld\r\nTest\r");
+ * console.log(lines); // ["Hello", "World", "Test"]
+ * ```
+ */ class LineSplitter {
+    #partialLine;
+    #hasPendingCR;
+    /**
+	 * Splits the given chunk of text passed as parameter into lines. By default, the last partial line is not returned.
+	 * @param chunk - The chunk of text to split into lines.
+	 * @param options.stream - A boolean flag indicating whether the last partial line is included in the returned lines. Defaults to false.
+	 * @returns An array of lines after splitting the given chunk of text.
+	 */ split(chunk = "", options) {
+        const stream = options?.stream ?? false;
+        const lines = [];
+        let lineStartIndex = 0; // Start index of the current candidate line within this chunk.
+        // If the last chunk ended with "\r" (CR), ignore a leading "\n" (LF) here (CRLF boundary).
+        if (this.#hasPendingCR) {
+            if (chunk[0] === "\n") lineStartIndex = 1;
+            this.#hasPendingCR = false;
+        }
+        for(let i = lineStartIndex; i < chunk.length; i++){
+            const currentChar = chunk[i];
+            // Check if the current character is newline (\n), which indicates the end of a line.
+            if (currentChar === "\n") {
+                // Prepend the partial line to the text from the current line and add it to the lines array.
+                lines.push(this.#partialLine + chunk.slice(lineStartIndex, i));
+                // Reset the partial line to an empty string.
+                this.#partialLine = "";
+                lineStartIndex = i + 1; // Set the next start index to the next character after the newline.
+            } else if (currentChar === "\r") {
+                // (1) CRLF is fully contained within this chunk. Emit the line up to the CR, skip the following LF, and continue.
+                if (i + 1 < chunk.length && chunk[i + 1] === "\n") {
+                    lines.push(this.#partialLine + chunk.slice(lineStartIndex, i));
+                    this.#partialLine = "";
+                    i += 1; // Skip the next character ("\n") since it's part of the CRLF sequence.
+                    lineStartIndex = i + 1; // Set the next start index to the next character after the CRLF sequence.
+                } else if (i === chunk.length - 1) {
+                    lines.push(this.#partialLine + chunk.slice(lineStartIndex, i));
+                    this.#partialLine = "";
+                    lineStartIndex = i + 1;
+                    this.#hasPendingCR = true; // Set the flag to true to indicate that the current chunk ended with a carriage return (\r) and we may ignore a leading "\n" next time.
+                } else {
+                    lines.push(this.#partialLine + chunk.slice(lineStartIndex, i));
+                    this.#partialLine = "";
+                    lineStartIndex = i + 1;
+                }
+            }
+        }
+        // Append any remaining text to the buffer to ensure that any text after the last newline is included in the next chunk.
+        this.#partialLine += chunk.slice(lineStartIndex);
+        // If not streaming and there is a partial line, add it to the lines array and reset the partial line.
+        if (!stream && this.#partialLine.length > 0) {
+            lines.push(this.#partialLine);
+            this.#partialLine = "";
+        }
+        return lines;
+    }
+    constructor(){
+        this.#partialLine = ""; // Holds any text from the previous chunks that didn't end with a newline.
+        this.#hasPendingCR = false; // Indicates if the previous chunk ended with a carriage return (\r), so we may ignore a leading "\n" next.
+    }
+}
+
+class MarkdownParser {
+    parse(input, options) {
+        const stream = options?.stream ?? false;
+        const lines = this.splitter.split(input, {
+            stream
+        });
+        for (const line of lines){
+            this.parseLine(line.replace(/\0/g, "\uFFFD"));
+            this.nextLineIndex++;
+        }
+        // If stream is false, we need to finalize all remaining open blocks before returning the nodes.
+        if (!stream) {
+            // Close the latest spine of the root node; this finalizes all remaining open blocks before returning the nodes.
+            closeRightmostPath(this.root);
+        }
+        // Parse reference link definitions for finalized/closed blocks.
+        this.parseReferenceLinkDefinitions(this.root);
+        const nodes = [];
+        let i = this.nextNodeIndex;
+        for(; i < this.root.children.length; i++){
+            const node = this.root.children[i];
+            if (node === undefined || !node.isClosed) break;
+            nodes.push(this.convertInternalBlockToPublicBlock(node));
+        }
+        this.nextNodeIndex = i;
+        return nodes;
+    }
+    parseLine(line) {
+        const lineIndex = this.nextLineIndex;
+        // We start from the root node and descend through the rightmost path of the current node until we find the last open node that the current line continues.
+        let lastMatchedNode = this.root;
+        while(true){
+            if (!("children" in lastMatchedNode)) break;
+            // If there are no children in the current node or if the last/rightmost child of the current node is not open, we do not traverse any further, in which case the last matched node is the current node.
+            const child = lastMatchedNode.children.at(-1);
+            if (child === undefined || child.isClosed) break;
+            // We now match the current line against this child node and check if the line continues the child node or not.
+            // If the child node is a blockquote node, we check if the current line continues the blockquote or not.
+            if (child.type === "blockquote") {
+                const blockquote = parseBlockquoteLine(line);
+                // If the current line continues the blockquote, we update the line (by removing the blockquote marker and the optional space after it) and continue attempting to match the line with the rightmost child of the blockquote node and so on.
+                if (blockquote !== null) {
+                    line = blockquote.content;
+                    lastMatchedNode = child;
+                    child.endLineIndex = lineIndex;
+                    continue;
+                } else {
+                    break;
+                }
+            }
+            if (child.type === "list") {
+                const item = child.children.at(-1);
+                if (item === undefined || item.isClosed) break;
+                if (isLineEmpty(line)) {
+                    const lastItemChild = item.children.at(-1);
+                    // If the current line is empty and there are no children in the list item, we close the list item.
+                    if (lastItemChild === undefined) {
+                        closeRightmostPath(child);
+                        return;
+                    } else {
+                        lastMatchedNode = item;
+                        continue;
+                    }
+                }
+                // If the current line is not empty, we check if it's indented enough to continue the list item.
+                // If it is, we update the line (by removing the leading indent) and continue attempting to match the line with the rightmost child of the list item node and so on.
+                const numOfColumns = getLeadingNonspaceColumn(line);
+                if (numOfColumns >= child.numOfColumns) {
+                    line = sliceLeadingIndent(line, child.numOfColumns);
+                    lastMatchedNode = item;
+                    continue;
+                } else {
+                    break;
+                }
+            }
+            // If the child node is a fenced code block node, we check if the current line closes the fenced code block or continues it.
+            if (child.type === "fenced-code-block") {
+                const marker = child.marker;
+                const numOfMarkers = child.numOfMarkers;
+                // If the current line closes the fenced code block, we mark the fenced code block as closed and exit as the line has been fully processed and doesn't require any further processing.
+                if (isCodeFenceEnd(line, {
+                    marker,
+                    numOfMarkers
+                })) {
+                    child.endLineIndex = lineIndex;
+                    child.isClosed = true;
+                    return;
+                } else {
+                    child.endLineIndex = lineIndex;
+                    child.lines.push(sliceLeadingIndent(line, child.indentLevel));
+                    return;
+                }
+            }
+            // If the child node is an indented code block node, we check if the current line closes the indented code block or continues it.
+            if (child.type === "indented-code-block") {
+                // We continue the indented code block if the current line is indented enough or if it's empty.
+                if (isIndentedCodeLine(line)) {
+                    child.endLineIndex = lineIndex;
+                    child.lines.push(sliceLeadingIndent(line, 4));
+                    return;
+                } else if (isLineEmpty(line)) {
+                    child.endLineIndex = lineIndex;
+                    child.lines.push("");
+                    return;
+                } else {
+                    child.isClosed = true;
+                    break;
+                }
+            }
+            if (child.type === "html-block") {
+                // If the HTML block can be interrupted by a blank line and the current line is empty, we mark the HTML block as closed.
+                if (child.canBeInterruptedByBlankLine && isLineEmpty(line)) {
+                    child.isClosed = true;
+                    return;
+                }
+                child.endLineIndex = lineIndex;
+                child.lines.push(line);
+                // If the HTML block ends with the current line, we mark the HTML block as closed.
+                if (child.endPattern?.test(line.trim())) {
+                    child.isClosed = true;
+                    return;
+                }
+                return;
+            }
+            // If the child node is a paragraph or table node, we check if the current line is empty or not
+            if (child.type === "paragraph" || child.type === "table") {
+                // If the current line is empty, we mark the paragraph or table node as closed and exit as the line has been fully processed and doesn't require any further processing.
+                if (isLineEmpty(line)) {
+                    child.isClosed = true;
+                    return;
+                } else {
+                    break;
+                }
+            }
+        }
+        // Represents the node where newly matched nodes are expected to be added. This may not always be true for exceptional cases, like paragraph continuation.
+        let currentContainer = lastMatchedNode;
+        while(true){
+            // Blockquote
+            const blockquote = parseBlockquoteLine(line);
+            if (blockquote !== null) {
+                const node = {
+                    type: "blockquote",
+                    children: [],
+                    isClosed: false,
+                    parent: currentContainer,
+                    startLineIndex: lineIndex,
+                    endLineIndex: lineIndex
+                };
+                addNode(node);
+                currentContainer = node;
+                line = blockquote.content;
+                continue;
+            }
+            // ATX heading
+            const heading = parseATXHeading(line);
+            if (heading !== null) {
+                addNode({
+                    type: "heading",
+                    level: heading.level,
+                    content: heading.content,
+                    isClosed: true,
+                    parent: currentContainer,
+                    startLineIndex: lineIndex,
+                    endLineIndex: lineIndex
+                });
+                break;
+            }
+            // Fenced code block
+            const fencedCode = parseCodeFenceStart(line);
+            if (fencedCode !== null) {
+                addNode({
+                    type: "fenced-code-block",
+                    indentLevel: fencedCode.indentLevel,
+                    numOfMarkers: fencedCode.numOfMarkers,
+                    marker: fencedCode.marker,
+                    info: fencedCode.info,
+                    lines: [],
+                    isClosed: false,
+                    parent: currentContainer,
+                    startLineIndex: lineIndex,
+                    endLineIndex: lineIndex
+                });
+                break;
+            }
+            // HTML block
+            const htmlBlock = parseHTMLBlockStart(line);
+            if (htmlBlock !== null) {
+                const node = {
+                    type: "html-block",
+                    endPattern: htmlBlock.endPattern,
+                    canBeInterruptedByBlankLine: htmlBlock.canBeInterruptedByBlankLine,
+                    lines: [
+                        line
+                    ],
+                    isClosed: false,
+                    parent: currentContainer,
+                    startLineIndex: lineIndex,
+                    endLineIndex: lineIndex
+                };
+                if (htmlBlock.canInterruptParagraph) {
+                    addNode(node);
+                    // If the HTML block also ends with the current line, we mark the HTML block as closed.
+                    if (node.endPattern?.test(line.trim())) {
+                        node.isClosed = true;
+                    }
+                    break;
+                } else {
+                    const deepestOpenNode = getDeepestOpenNodeOnRightmostPath(currentContainer);
+                    if (deepestOpenNode === null || deepestOpenNode.type !== "paragraph") {
+                        addNode(node);
+                        // If the HTML block also ends with the current line, we mark the HTML block as closed.
+                        if (node.endPattern?.test(line.trim())) {
+                            node.isClosed = true;
+                        }
+                        break;
+                    }
+                }
+            }
+            const lastChild = currentContainer.children.at(-1);
+            if (lastChild?.type === "paragraph" && !lastChild.isClosed) {
+                // Table
+                const table = parseTableStartLine({
+                    firstLine: lastChild.lines.at(-1),
+                    secondLine: line
+                });
+                if (table !== null) {
+                    // Remove the last line from the paragraph node as it'll be replaced by the table node
+                    lastChild.lines.pop();
+                    // If the paragraph node has no lines left, we remove the paragraph node from the container node
+                    if (lastChild.lines.length === 0) {
+                        currentContainer.children.pop();
+                    }
+                    addNode({
+                        type: "table",
+                        alignments: table.alignments,
+                        head: {
+                            cells: table.head.cells
+                        },
+                        body: {
+                            rows: []
+                        },
+                        isClosed: false,
+                        parent: currentContainer,
+                        startLineIndex: lineIndex,
+                        endLineIndex: lineIndex
+                    });
+                    break;
+                }
+                // Setext heading
+                const heading = parseSetextHeading(line);
+                if (heading !== null) {
+                    let lines = lastChild.lines;
+                    const originalNumOfLines = lines.length;
+                    // Parse link reference definitions (if any) from the paragraph lines
+                    let definition = parseLinkReferenceDefinition(lines);
+                    while(definition !== null){
+                        const { label, href, title } = definition.definition;
+                        if (!this.referenceDefinitions.has(label)) {
+                            this.referenceDefinitions.set(label, {
+                                href,
+                                title
+                            });
+                        }
+                        lines = lines.slice(definition.nextLineIndex);
+                        definition = parseLinkReferenceDefinition(lines);
+                    }
+                    // If there are remaining lines after parsing link reference definitions, we create a new heading node with the remaining lines
+                    if (lines.length > 0) {
+                        // Remove the current paragraph node from the container node as it'll replaced by a heading node
+                        currentContainer.children.pop();
+                        addNode({
+                            type: "heading",
+                            level: heading.level,
+                            content: lines.join("\n").trim(),
+                            isClosed: true,
+                            parent: currentContainer,
+                            startLineIndex: lastChild.startLineIndex - (originalNumOfLines - lines.length),
+                            endLineIndex: lineIndex
+                        });
+                        break;
+                    } else {
+                        lastChild.lines.push(line);
+                        break;
+                    }
+                }
+            }
+            // Thematic break
+            if (isSeparator(line)) {
+                addNode({
+                    type: "thematic-break",
+                    isClosed: true,
+                    parent: currentContainer,
+                    startLineIndex: lineIndex,
+                    endLineIndex: lineIndex
+                });
+                break;
+            }
+            // List
+            const list = parseListItem(line);
+            if (list !== null) {
+                // If the last child of the current container is a paragraph node and it's not closed, we check if the list can interrupt the paragraph or not.
+                const lastChild = currentContainer.children.at(-1);
+                if (lastChild?.type === "paragraph" && !lastChild.isClosed) {
+                    if (isLineEmpty(list.content) || list.kind === "ordered" && list.value !== 1) {
+                        lastChild.endLineIndex = lineIndex;
+                        lastChild.lines.push(line);
+                        break;
+                    }
+                }
+                let parent;
+                if (list.kind === "ordered") {
+                    const lastChild = currentContainer.children.at(-1);
+                    if (lastChild?.type === "list" && !lastChild.isClosed && lastChild.kind === "ordered" && lastChild.delimiter === list.delimiter) {
+                        parent = lastChild;
+                    } else {
+                        parent = {
+                            type: "list",
+                            kind: "ordered",
+                            start: list.value,
+                            delimiter: list.delimiter,
+                            numOfColumns: list.numOfColumns,
+                            children: [],
+                            isClosed: false,
+                            parent: currentContainer,
+                            startLineIndex: lineIndex,
+                            endLineIndex: lineIndex,
+                            isTight: true
+                        };
+                        addNode(parent);
+                    }
+                } else {
+                    const lastChild = currentContainer.children.at(-1);
+                    if (lastChild?.type === "list" && !lastChild.isClosed && lastChild.kind === "unordered" && lastChild.marker === list.marker) {
+                        parent = lastChild;
+                    } else {
+                        parent = {
+                            type: "list",
+                            kind: "unordered",
+                            marker: list.marker,
+                            children: [],
+                            isClosed: false,
+                            parent: currentContainer,
+                            numOfColumns: list.numOfColumns,
+                            startLineIndex: lineIndex,
+                            endLineIndex: lineIndex,
+                            isTight: true
+                        };
+                        addNode(parent);
+                    }
+                }
+                parent.numOfColumns = list.numOfColumns;
+                const item = {
+                    type: "list-item",
+                    children: [],
+                    isClosed: false,
+                    parent: parent,
+                    startLineIndex: lineIndex,
+                    endLineIndex: lineIndex
+                };
+                addNode(item);
+                currentContainer = item;
+                line = list.content;
+                continue;
+            }
+            const latestOpenNode = getDeepestOpenNodeOnRightmostPath(currentContainer);
+            // If the latest open node is not a paragraph and the current line is indented, we create a new indented code block node
+            if (isIndentedCodeLine(line) && (latestOpenNode === null || latestOpenNode.type !== "paragraph")) {
+                addNode({
+                    type: "indented-code-block",
+                    lines: [
+                        sliceLeadingIndent(line, 4)
+                    ],
+                    isClosed: false,
+                    parent: currentContainer,
+                    startLineIndex: lineIndex,
+                    endLineIndex: lineIndex
+                });
+                break;
+            }
+            if (isLineEmpty(line)) {
+                closeRightmostPath(currentContainer);
+                break;
+            }
+            // Table continuation
+            if (lastChild?.type === "table" && !lastChild.isClosed) {
+                lastChild.endLineIndex = lineIndex;
+                const numOfColumns = lastChild.head.cells.length;
+                let cells = parseTableRow(line);
+                if (cells.length > numOfColumns) {
+                    // Trim to max allowed columns
+                    cells = cells.slice(0, numOfColumns);
+                } else if (cells.length < numOfColumns) {
+                    // Fill the remainder with empty strings
+                    cells = [
+                        ...cells,
+                        ...Array(numOfColumns - cells.length).fill("")
+                    ];
+                }
+                lastChild.body.rows.push({
+                    cells
+                });
+                break;
+            }
+            // Paragraph
+            if (latestOpenNode?.type === "paragraph") {
+                latestOpenNode.endLineIndex = lineIndex;
+                latestOpenNode.lines.push(line);
+                break;
+            } else {
+                addNode({
+                    type: "paragraph",
+                    lines: [
+                        line
+                    ],
+                    isClosed: false,
+                    parent: currentContainer,
+                    startLineIndex: lineIndex,
+                    endLineIndex: lineIndex
+                });
+                break;
+            }
+        }
+    }
+    parseReferenceLinkDefinitions(parent) {
+        for(let i = 0; i < parent.children.length; i++){
+            const block = parent.children[i];
+            if (block === undefined) break;
+            // If a block is not closed/finalized yet, we do not parse reference link definitions for it
+            if (!block.isClosed) break;
+            if (block.type === "paragraph") {
+                let lines = block.lines;
+                let definition = parseLinkReferenceDefinition(lines);
+                while(definition !== null){
+                    const { label, href, title } = definition.definition;
+                    if (!this.referenceDefinitions.has(label)) {
+                        this.referenceDefinitions.set(label, {
+                            href,
+                            title
+                        });
+                    }
+                    lines = lines.slice(definition.nextLineIndex);
+                    definition = parseLinkReferenceDefinition(lines);
+                }
+                if (lines.length > 0) {
+                    block.lines = lines;
+                } else {
+                    parent.children.splice(i, 1);
+                    i--;
+                }
+            } else if (block.type === "blockquote") {
+                this.parseReferenceLinkDefinitions(block);
+            } else if (block.type === "list") {
+                for (const item of block.children){
+                    this.parseReferenceLinkDefinitions(item);
+                }
+            }
+        }
+    }
+    convertInternalBlockToPublicBlock(block) {
+        switch(block.type){
+            case "blockquote":
+                return {
+                    type: "blockquote",
+                    children: block.children.map((child)=>this.convertInternalBlockToPublicBlock(child))
+                };
+            case "heading":
+                return {
+                    type: "heading",
+                    level: block.level,
+                    children: parseInline(block.content, {
+                        referenceDefinitions: this.referenceDefinitions
+                    })
+                };
+            case "paragraph":
+                {
+                    return {
+                        type: "paragraph",
+                        children: parseInline(block.lines.join("\n").trim(), {
+                            referenceDefinitions: this.referenceDefinitions
+                        })
+                    };
+                }
+            case "thematic-break":
+                return {
+                    type: "thematic-break"
+                };
+            case "fenced-code-block":
+                return {
+                    type: "code-block",
+                    content: block.lines.length > 0 ? block.lines.join("\n") + "\n" : "",
+                    info: block.info
+                };
+            case "indented-code-block":
+                {
+                    let startIndex = 0;
+                    let endIndex = block.lines.length - 1;
+                    while(startIndex < endIndex){
+                        const line = block.lines[startIndex];
+                        if (line === undefined) break;
+                        if (!isLineEmpty(line)) break;
+                        startIndex++;
+                    }
+                    while(endIndex > startIndex){
+                        const line = block.lines[endIndex];
+                        if (line === undefined) break;
+                        if (!isLineEmpty(line)) break;
+                        endIndex--;
+                    }
+                    return {
+                        type: "code-block",
+                        content: block.lines.slice(startIndex, endIndex + 1).join("\n") + "\n"
+                    };
+                }
+            case "html-block":
+                return {
+                    type: "html-block",
+                    content: block.lines.join("\n")
+                };
+            case "list":
+                {
+                    const items = block.children.map((item)=>({
+                            children: item.children.map((child)=>this.convertInternalBlockToPublicBlock(child))
+                        }));
+                    if (block.kind === "ordered") {
+                        return {
+                            type: "list",
+                            kind: "ordered",
+                            start: block.start,
+                            tight: block.isTight,
+                            items: items
+                        };
+                    } else {
+                        return {
+                            type: "list",
+                            kind: "unordered",
+                            marker: block.marker,
+                            tight: block.isTight,
+                            items: items
+                        };
+                    }
+                }
+            case "table":
+                {
+                    return {
+                        type: "table",
+                        head: {
+                            cells: block.head.cells.map((cell, index)=>({
+                                    align: block.alignments[index],
+                                    children: parseInline(cell, {
+                                        referenceDefinitions: this.referenceDefinitions
+                                    })
+                                }))
+                        },
+                        body: {
+                            rows: block.body.rows.map((row)=>({
+                                    cells: row.cells.map((cell, index)=>({
+                                            align: block.alignments[index],
+                                            children: parseInline(cell, {
+                                                referenceDefinitions: this.referenceDefinitions
+                                            })
+                                        }))
+                                }))
+                        }
+                    };
+                }
+        }
+    }
+    constructor(){
+        this.splitter = new LineSplitter();
+        this.root = {
+            type: "root",
+            children: [],
+            parent: null
+        };
+        this.nextLineIndex = 0;
+        this.nextNodeIndex = 0;
+        this.referenceDefinitions = new Map();
+    }
+}
+function addNode(node) {
+    // Ensure we don't have any dangling "open" nodes on the last-child chain before inserting a new sibling at this level.
+    closeRightmostPath(node.parent);
+    // Insert the new node as the next child of the parent.
+    if (node.type === "list-item") {
+        // This 'if' condition exists only for TypeScript's type narrowing purposes.
+        node.parent.children.push(node);
+    } else {
+        node.parent.children.push(node);
+    }
+}
+/**
+ * Closes any currently-open nodes along the parent's "rightmost path" (i.e., repeatedly following the last child) until it reaches:
+ * - a closed node, or
+ * - the end of the chain (no children).
+ *
+ * This is used to "seal" any unfinished blocks before adding a new sibling block to the parent node.
+ *
+ * @param parent The parent/container node whose last-child chain will be traversed and closed.
+ * @param options.endLineIndex The end line index to update the nodes with.
+ */ function closeRightmostPath(parent) {
+    // Find the deepest open node on the rightmost path of the parent container. Then, we close the node, traverse up the parent chain, closing the parent nodes until we reach the root node.
+    // You'll notice that this is not the most efficient way to do this, because we basically travel to the leaf from the parent and then back up to the parent. But, it is required for list tightness calculation.
+    // We could definitely optimize this by keeping track of the deepest open node from parsing the last line, but that would require a lot of additional state management, which is not worth the complexity for now.
+    let currentNode = getDeepestOpenNodeOnRightmostPath(parent);
+    while(currentNode !== parent){
+        if (currentNode === null) break;
+        currentNode.isClosed = true;
+        if (currentNode.type === "list") {
+            currentNode.isTight = isListTight(currentNode);
+        }
+        switch(currentNode.type){
+            case "blockquote":
+            case "list":
+            case "list-item":
+                {
+                    // When closing a container node, we update the start and end line indices based on their first and last child's start and end line indices.
+                    const firstChild = currentNode.children.at(0);
+                    const lastChild = currentNode.children.at(-1);
+                    if (firstChild !== undefined) {
+                        currentNode.startLineIndex = Math.min(currentNode.startLineIndex, firstChild.startLineIndex);
+                    }
+                    if (lastChild !== undefined) {
+                        currentNode.endLineIndex = Math.max(currentNode.endLineIndex, lastChild.endLineIndex);
+                    }
+                    break;
+                }
+        }
+        if (currentNode.parent?.type === "root") break;
+        currentNode = currentNode.parent;
+    }
+}
+function isListTight(list) {
+    // 1) Check if there are gaps between list items
+    const items = list.children;
+    for(let i = 0; i < items.length - 1; i++){
+        const a = items[i];
+        const b = items[i + 1];
+        if (a === undefined || b === undefined) break;
+        if (a.endLineIndex < b.startLineIndex - 1) {
+            return false;
+        }
+    }
+    // 2) Check if there are gaps between block children inside each item
+    for (const item of items){
+        const blocks = item.children;
+        for(let j = 0; j < blocks.length - 1; j++){
+            const a = blocks[j];
+            const b = blocks[j + 1];
+            if (a === undefined || b === undefined) break;
+            if (a.endLineIndex < b.startLineIndex - 1) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+function getDeepestOpenNodeOnRightmostPath(node) {
+    const child = node.children.at(-1);
+    // If the last child of the current node is undefined or closed, we return null to indicate that there is no latest open node.
+    if (child === undefined || child.isClosed) return null;
+    // At this point, the last child is guaranteed to be open, so depending on whether the node can contain more nodes, we traverse deeper into the spine or return the last child as is.
+    switch(child.type){
+        case "blockquote":
+        case "list":
+        case "list-item":
+            {
+                const deepestOpenNode = getDeepestOpenNodeOnRightmostPath(child);
+                if (deepestOpenNode !== null) return deepestOpenNode;
+                return child;
+            }
+        default:
+            return child;
+    }
+}
+/**
+ * Determines if a line qualifies as an indented code block line.
+ *
+ * Per CommonMark spec, a line with 4 or more spaces of indentation (after tab expansion)
+ * is considered part of an indented code block, unless it's within another block structure.
+ *
+ * @param line - The line to check.
+ * @returns True if the line has 4+ columns of indentation, false otherwise.
+ */ function isIndentedCodeLine(line) {
+    const column = getLeadingNonspaceColumn(line);
+    return column >= 4;
+}
+/**
+ * Attempts to parse a line as the opening of a fenced code block.
+ *
+ * Per CommonMark spec, a code fence opening consists of:
+ * - Optional indentation (0-3 spaces)
+ * - At least 3 consecutive backticks (`) or tildes (~)
+ * - Optional info string (language identifier and metadata)
+ *
+ * For backtick fences, the info string cannot contain backticks.
+ *
+ * @param line - The line to parse.
+ * @returns An object with fence details if valid, or null if not a fence opening.
+ *   - indentLevel: The number of leading spaces (for content de-indentation)
+ *   - numOfMarkers: The count of fence characters (must match or exceed for closing)
+ *   - marker: The fence character used ("~" or "`")
+ *   - info: The optional info string (language, etc.), or undefined if empty
+ */ function parseCodeFenceStart(line) {
+    const indentColumns = getLeadingNonspaceColumn(line);
+    if (indentColumns > 3) return null;
+    line = line.trim();
+    // Fences require at least 3 identical markers; if fewer than 3 characters remain in the line, it cannot be a fence.
+    if (line.length < 3) return null;
+    // Only ~ (tilde) or ` (backtick) can start a fence.
+    const marker = line.charAt(0);
+    if (marker !== "~" && marker !== "`") {
+        return null;
+    }
+    /**
+	 * Count the number of consecutive markers in the line. If the line does not contain at least 3 markers, it cannot be a fence.
+	 * ┌───┬───┬───┬───┬───┐
+	 * │ 0 | 1 | 2 | 3 | 4 |
+	 * ├───┼───┼───┼───┼───┼
+	 * │ ~ | ~ | ~ | t | s |
+	 * └───┴───┴───┴───┴───┘
+	 *   ▲       ▲
+	 *   │       │
+	 *   └───────┘
+	 */ let numOfMarkers = 1;
+    while(true){
+        if (numOfMarkers >= line.length) break;
+        if (line.charAt(numOfMarkers) !== marker) break;
+        numOfMarkers++;
+    }
+    if (numOfMarkers < 3) return null;
+    /**
+	 * 'info string' is the text between the opening fence and the end of the line. It typically includes the language name and optional meta.
+	 * ┌───┬───┬───┬───┬───┐
+	 * │ 0 | 1 | 2 | 3 | 4 |
+	 * ├───┼───┼───┼───┼───┼
+	 * │ ~ | ~ | ~ | t | s |
+	 * └───┴───┴───┴───┴───┘
+	 *               ▲   ▲
+	 *               │   │
+	 *               └───┘
+	 */ const info = line.slice(numOfMarkers).trim();
+    // For backtick fences only: if the info string itself contains a backtick, it is not a valid fence.
+    if (marker === "`" && info.indexOf("`") >= 0) {
+        return null;
+    }
+    return {
+        indentLevel: indentColumns,
+        numOfMarkers,
+        marker,
+        info: info === "" ? undefined : info
+    };
+}
+/**
+ * Determines if a line is a valid closing fence for a code block.
+ *
+ * A valid closing fence must satisfy these conditions (per CommonMark):
+ * 1. Indented by at most 3 spaces
+ * 2. Consists of the same character as the opening fence (` or ~)
+ * 3. Contains at least as many fence characters as the opening fence
+ * 4. Contains only the fence characters (no info string allowed)
+ *
+ * @param line - The line to check.
+ * @param options.marker - The fence character from the opening fence ('`' or '~').
+ * @param options.numOfMarkers - The number of fence characters in the opening fence.
+ * @returns `true` if the line is a valid closing fence, `false` otherwise.
+ *
+ * @example
+ * ```typescript
+ * // Opening fence was: ```
+ * isCodeFenceEnd("```", { marker: '`', numOfMarkers: 3 });    // true
+ * isCodeFenceEnd("````", { marker: '`', numOfMarkers: 3 });   // true (more markers OK)
+ * isCodeFenceEnd("``", { marker: '`', numOfMarkers: 3 });     // false (too few)
+ * isCodeFenceEnd("~~~", { marker: '`', numOfMarkers: 3 });    // false (wrong marker)
+ * isCodeFenceEnd("``` ", { marker: '`', numOfMarkers: 3 });   // true (trailing space trimmed)
+ * isCodeFenceEnd("```js", { marker: '`', numOfMarkers: 3 });  // false (has info string)
+ * ```
+ *
+ * @see https://spec.commonmark.org/0.31.2/#fenced-code-blocks
+ */ function isCodeFenceEnd(line, options) {
+    // The closing fence must be indented by at most 3 columns.
+    const indent = getLeadingNonspaceColumn(line);
+    if (indent > 3) return false;
+    line = line.trim();
+    // Line must start with the **same** marker character to qualify as a closing fence.
+    if (line.charAt(0) !== options.marker) return false;
+    // Count the number of consecutive markers in the line. If the line does not contain the same number of markers as the opening fence, it cannot be a closing fence.
+    let numOfMarkers = 1;
+    while(true){
+        if (numOfMarkers >= line.length) break;
+        if (line.charAt(numOfMarkers) !== options.marker) break;
+        numOfMarkers++;
+    }
+    if (numOfMarkers < options.numOfMarkers) return false;
+    // The closing fence cannot contain any other characters (except spaces and tabs) after the sequence of markers. Since we trimmed the line, we only need to check if there are any characters left.
+    if (line.length > numOfMarkers) return false;
+    return true;
+}
+/**
+ * Returns the index of the first non-whitespace character in the line. Tabs are not expanded and treated as a single space.
+ * @param line - The line to get the index of the first non-whitespace character of.
+ * @returns The index of the first non-whitespace character in the line.
+ *
+ * The index of the first non-whitespace character in the following example is 3.
+ * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┐
+ * │ 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |
+ * ├───┼───┼───┼───┼───┼───┼───┼───┼───┤
+ * │ ␣ | ␣ | ␣ | T | h | i | s | ␣ | ␣ |
+ * └───┴───┴───┴───┴───┴───┴───┴───┴───┘
+ *               ▲
+ *
+ * The index of the first non-whitespace character in the following example is 3.
+ * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┐
+ * │ 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |
+ * ├───┼───┼───┼───┼───┼───┼───┼───┼───┤
+ * │ ␣ | ␣ | ⇥ | T | h | i | s | ␣ | ␣ |
+ * └───┴───┴───┴───┴───┴───┴───┴───┴───┘
+ *               ▲
+ */ function getFirstNonspaceIndex(line) {
+    let index = 0; // The index of the first non-whitespace character in the line.
+    for(let i = 0; i < line.length; i++){
+        const character = line.charAt(i);
+        if (isSpaceOrTab(character)) {
+            index++;
+        } else {
+            break;
+        }
+    }
+    return index;
+}
+/**
+ * Returns the indentation columns/width of the line. Tabs are expanded to the next multiple of 4 spaces.
+ * The value is the effective cursor position before the first non-whitespace character. Spaces add one column each; tabs add a variable number to reach the next tab stop.
+ *
+ * @param line - The line to get the indentation columns/width of.
+ * @returns The indentation columns/width of the line.
+ *
+ * The indentation width of the line in the following example is 3. The line begins with three spaces.
+ * The three spaces move the cursor to column 3.
+ * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┐
+ * │ 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |
+ * ├───┼───┼───┼───┼───┼───┼───┼───┼───┤
+ * │ ␣ | ␣ | ␣ | T | h | i | s | ␣ | ␣ |
+ * └───┴───┴───┴───┴───┴───┴───┴───┴───┘
+ *
+ * The indentation width of the line in the following example is 4. The line begins with a tab.
+ * The tab advances to the next multiple of 4, which is column 4.
+ * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┐
+ * │ 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |
+ * ├───┼───┼───┼───┼───┼───┼───┼───┼───┤
+ * │ ⇥ | T | h | i | s | ␣ | ␣ | ␣ | ␣ |
+ * └───┴───┴───┴───┴───┴───┴───┴───┴───┘
+ *
+ * The indentation width of the line in the following example is 4. The line begins with two spaces, then a tab.
+ * The two spaces move the cursor to column 2. The tab then advances to the next multiple of 4, which is column 4.
+ * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┐
+ * │ 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |
+ * ├───┼───┼───┼───┼───┼───┼───┼───┼───┤
+ * │ ␣ | ␣ | ⇥ | T | h | i | s | ␣ | ␣ |
+ * └───┴───┴───┴───┴───┴───┴───┴───┴───┘
+ */ function getLeadingNonspaceColumn(line) {
+    let columns = 0;
+    for(let i = 0; i < line.length; i++){
+        const ch = line.charAt(i);
+        if (ch === " ") {
+            columns += 1;
+        } else if (ch === "\t") {
+            columns += 4 - columns % 4;
+        } else {
+            break;
+        }
+    }
+    return columns;
+}
+/**
+ * Removes up to the specified visual columns from the start of the line, expanding tabs at 4-space stops.
+ * If we cut through a tab, we add the remaining spaces back (partial tab expansion).
+ *
+ * @param line - The line to remove the leading indent from.
+ * @param width - The width of the leading indent to slice.
+ * @returns The line with the leading indent removed.
+ */ function sliceLeadingIndent(line, width) {
+    let indent = 0; // Indicates the indentation level of the line (tabs are expanded to the next multiple of 4 spaces)
+    let startIndex = 0;
+    while(startIndex < line.length){
+        if (line.charAt(startIndex) === " ") {
+            indent++;
+        } else if (line.charAt(startIndex) === "\t") {
+            indent += 4 - indent % 4;
+        } else {
+            break;
+        }
+        startIndex++;
+    }
+    /**
+	 * Fix any partial tab expanstion: if a tab pushed the indentation level past the required indent, we cannot "slice half a tab",
+	 * so we add the remaining spaces to the start of the line to preserve the intended remaining indentation.
+	 *
+	 * For example, if the line is indented by 2 spaces, and the width is 4, after consuming the 2 spaces, indent = 2 and startIndex = 0,
+	 * so we need to add 4 - 2 = 2 spaces to the start of the line to preserve the intended remaining indentation.
+	 */ if (indent > width) {
+        return " ".repeat(indent - width) + line.slice(startIndex);
+    } else {
+        return line.slice(startIndex);
+    }
+}
+/**
+ * Checks if the line is a separator. Must satisfy the following conditions:
+ * - The first non-space character in the line must be a -, _, or * character.
+ * - There must be at least 3 markers in the line. Spaces and tabs are allowed in the line. Any other character is not allowed.
+ * @param line - The line to check.
+ * @returns true if the line is a separator, false otherwise.
+ */ function isSeparator(line) {
+    if (isIndentedCodeLine(line)) return false;
+    line = line.trim();
+    const marker = line.charAt(0);
+    // Only -, _, and * can be used to create a separator.
+    if (marker !== "-" && marker !== "_" && marker !== "*") {
+        return false;
+    }
+    /**
+	 * Count the number of markers in the line. If the line does not contain at least 3 markers, it is not a separator.
+	 * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┐
+	 * │ 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |
+	 * ├───┼───┼───┼───┼───┼───┼───┼───┼───┤
+	 * │ ␣ | * | ␣ | * | ␣ | * | ␣ | ␣ | ␣ |
+	 * └───┴───┴───┴───┴───┴───┴───┴───┴───┘
+	 *       ▲       ▲       ▲
+	 */ let markerCount = 1;
+    for(let i = 1; i < line.length; i++){
+        const character = line.charAt(i);
+        // Markers can be mixed with spaces and tabs.
+        if (isSpaceOrTab(character)) {
+            continue;
+        }
+        if (character !== marker) {
+            return false;
+        }
+        markerCount++;
+    }
+    if (markerCount < 3) return false;
+    return true;
+}
+function parseBlockquoteLine(line) {
+    if (isIndentedCodeLine(line)) return null;
+    const firstNonspaceIndex = getFirstNonspaceIndex(line);
+    /**
+	 * The first non-whitespace character in the line must be a > character.
+	 * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┐
+	 * │ 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |
+	 * ├───┼───┼───┼───┼───┼───┼───┼───┼───┤
+	 * │ ␣ | ␣ | ␣ | > | ␣ | T | h | i | s |
+	 * └───┴───┴───┴───┴───┴───┴───┴───┴───┘
+	 *               ▲
+	 */ if (line.charAt(firstNonspaceIndex) !== ">") return null;
+    let characterIndex = firstNonspaceIndex + 1; // Skip the blockquote marker.
+    // Count the number of columns (tabs are expanded to the next multiple of 4 spaces) from the beginning of the line to the start of the content of the blockquote line.
+    let numOfColumns = characterIndex;
+    while(characterIndex < line.length){
+        if (line.charAt(characterIndex) === "\t") {
+            numOfColumns += 4 - numOfColumns % 4;
+            characterIndex++;
+        } else if (line.charAt(characterIndex) === " ") {
+            numOfColumns++;
+            characterIndex++;
+        } else {
+            break;
+        }
+    }
+    // Append the leading spaces to the content of the blockquote line.
+    const content = " ".repeat(numOfColumns - firstNonspaceIndex - 1) + line.slice(characterIndex);
+    // Consume the first space after the blockquote marker (if it exists)
+    if (content.charAt(0) === " ") {
+        return {
+            content: content.slice(1)
+        };
+    }
+    return {
+        content
+    };
+}
+/**
+ * Attempts to parse a line as an ATX-style heading.
+ *
+ * Per CommonMark spec, an ATX heading consists of:
+ * - Optional indentation (0-3 spaces)
+ * - 1-6 consecutive # characters
+ * - Optional space/tab followed by heading content
+ * - Optional closing sequence of # characters (preceded by space)
+ *
+ * Examples:
+ *   "# Heading 1"     -> { level: 1, content: "Heading 1" }
+ *   "## Title ##"     -> { level: 2, content: "Title" }
+ *   "### Empty"       -> { level: 3, content: "Empty" }
+ *   "#No space"       -> null (space required after #)
+ *   "####### Too many" -> null (max 6 levels)
+ *
+ * @param line - The line to parse.
+ * @returns An object with heading level and content if valid, or null if not a heading.
+ */ function parseATXHeading(line) {
+    if (isIndentedCodeLine(line)) return null;
+    line = line.trim();
+    // A heading must start with a # character.
+    if (line.charAt(0) !== "#") return null;
+    /**
+	 * Count the number of consecutive # characters in the line.
+	 * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┐
+	 * │ 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |
+	 * ├───┼───┼───┼───┼───┼───┼───┼───┼───┤
+	 * │ # | # | # | # | ␣ | T | h | i | s |
+	 * └───┴───┴───┴───┴───┴───┴───┴───┴───┘
+	 *   ▲           ▲
+	 *   │           │
+	 *   └───────────┘
+	 */ let numOfOpeningHashes = 1; // The number of consecutive # characters in the line; initialized to 1 because the first character is a #.
+    while(true){
+        if (numOfOpeningHashes >= line.length) break;
+        if (line.charAt(numOfOpeningHashes) !== "#") break;
+        numOfOpeningHashes++;
+    }
+    // A heading must have a level between 1 and 6. If the level is greater than 6, it is not a heading.
+    if (numOfOpeningHashes > 6) return null;
+    /**
+	 * If there are more characters after the # characters and the character immediately after the # characters is not a space or a tab, it is not a heading.
+	 *
+	 * The following example is not a heading because the character immediately after the # characters is not a space or a tab.
+	 * ┌───┬───┬───┬───┬───┬───┬───┬───┐
+	 * │ # | # | # | # | T | h | i | s |
+	 * └───┴───┴───┴───┴───┴───┴───┴───┘
+	 *                   ▲
+	 */ if (numOfOpeningHashes < line.length && line.charAt(numOfOpeningHashes) !== " " && line.charAt(numOfOpeningHashes) !== "\t") {
+        return null;
+    }
+    /**
+	 * Count the number of consecutive # characters at the end of the line.
+	 * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬────┬────┬────┐
+	 * │ 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 |
+	 * ├───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼────┼────┼────┤
+	 * │ # | # | # | # | ␣ | T | h | i | s | ␣ | #  | #  | #  |
+	 * └───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴────┴────┴────┘
+	 *                                           ▲         ▲
+	 *                                           │         │
+	 *                                           └─────────┘
+	 */ let numOfClosingHashes = 0; // The number of consecutive # characters at the end of the line.
+    while(true){
+        if (line.length - numOfClosingHashes - 1 <= numOfOpeningHashes) break;
+        if (line.charAt(line.length - numOfClosingHashes - 1) !== "#") break;
+        numOfClosingHashes++;
+    }
+    const contentEndIndex = isSpaceOrTab(line.charAt(line.length - numOfClosingHashes - 1)) ? line.length - numOfClosingHashes : line.length;
+    return {
+        level: numOfOpeningHashes,
+        content: line.slice(numOfOpeningHashes, contentEndIndex).trim()
+    };
+}
+/**
+ * Checks if the line is a setext heading. Must satisfy the following conditions:
+ * - The first non-whitespace character in the line must be a valid marker (minus or equals sign).
+ * - All characters in the line after stripping leading and trailing whitespace must be the same as the marker.
+ * @param line - The line to check.
+ * @returns true if the line is a setext heading, false otherwise.
+ */ function parseSetextHeading(line) {
+    if (isIndentedCodeLine(line)) return null;
+    line = line.trim(); // Trim the line to remove leading and trailing whitespace.
+    // A heading must start with a minus or equals sign.
+    const marker = line.charAt(0);
+    if (marker !== "=" && marker !== "-") return null;
+    // Ensure that all other characters in the line are the same as the marker.
+    for (const character of line){
+        if (character !== marker) return null;
+    }
+    if (marker === "=") return {
+        level: 1
+    };
+    return {
+        level: 2
+    };
+}
+function parseTableStartLine({ firstLine, secondLine }) {
+    if (firstLine === undefined || secondLine === undefined) return null;
+    if (isIndentedCodeLine(secondLine)) return null;
+    if (isLineEmpty(secondLine)) return null;
+    firstLine = firstLine.trim();
+    secondLine = secondLine.trim();
+    // The first character in the second line must be a pipe, colon, or dash.
+    if (secondLine.charAt(0) !== "|" && secondLine.charAt(0) !== ":" && secondLine.charAt(0) !== "-") {
+        return null;
+    }
+    // If the first character in the second line is a dash, it must not be followed by a space or tab.
+    if (secondLine.charAt(0) === "-" && isSpaceOrTab(secondLine.charAt(1))) {
+        return null;
+    }
+    // If the first line does not contain any pipe characters, it is not a table.
+    if (firstLine.indexOf("|") === -1) {
+        return null;
+    }
+    // The second line must not contain any other characters than pipes, colons, dashes, spaces, or tabs.
+    for(let i = 1; i < secondLine.length; i++){
+        if (secondLine.charAt(i) === "|" || secondLine.charAt(i) === ":" || secondLine.charAt(i) === "-" || isSpaceOrTab(secondLine.charAt(i))) {
+            continue;
+        }
+        return null;
+    }
+    /**
+	 * | foo  |  bar  |  baz  |      ← first line (header row)
+	 * | :--- | :---: |  ---: |      ← second line (delimiter row)
+	 *    ▲       ▲         ▲
+	 *    │       │         └────── right alignment
+	 *    │       │
+	 *    │       └──────────────── center alignment
+	 *    │
+	 *    └──────────────────────── left alignment
+	 */ const delimiterCells = secondLine.split("|");
+    const alignments = [];
+    for(let i = 0; i < delimiterCells.length; i++){
+        const cell = delimiterCells[i]?.trim();
+        // An empty cell is only allowed at the start or end of the line.
+        if (!cell) {
+            if (i === 0 || i === delimiterCells.length - 1) continue;
+            return null;
+        }
+        // A delimiter cell must contain only dashes and optional colons at the start and end.
+        if (!/^:?-+:?$/.test(cell)) return null;
+        if (cell.charAt(cell.length - 1) === ":") {
+            if (cell.charAt(0) === ":") {
+                alignments.push("center");
+            } else {
+                alignments.push("right");
+            }
+        } else if (cell.charAt(0) === ":") {
+            alignments.push("left");
+        } else {
+            alignments.push(undefined);
+        }
+    }
+    const headerCells = parseTableRow(firstLine);
+    if (headerCells.length === 0 || headerCells.length !== alignments.length) {
+        return null;
+    }
+    return {
+        head: {
+            cells: headerCells
+        },
+        alignments
+    };
+}
+function parseTableRow(line) {
+    /**
+	 * Cell contents in table rows can include escaped pipe characters. We need to split the line on "|" but not on escaped "|" characters.
+	 *
+	 * "a|b|c"         → ["a","b","c"]
+	 * "a\|b|c"        → ["a|b","c"]
+	 * "\|a\|b\|c"     → ["|a|b|c"]
+	 * "\\\|b"         → ["\|b"]   (only the "\" right before "|" is removed)
+	 *
+	 * foo \| bar | baz
+	 *      ▲     ▲
+	 *      │     └────── split here
+	 *      │
+	 *      └────── do not split here (escaped pipe character)
+	 */ const cells = line.trim().split(/(?<!\\)\|/) // Split on unescaped pipe characters (i.e., pipe characters not preceded by "\")
+    .map((cell)=>cell.replace(/\\\|/g, "|")) // Unescape the remaining "\|" (i.e., replace "\|" with "|")
+    .map((cell)=>cell.trim());
+    // Empty cells are only allowed at the start or end of the line. If there are any empty cells, we remove them.
+    if (cells.length > 0) {
+        if (cells[0] === "") cells.shift();
+        if (cells[cells.length - 1] === "") cells.pop();
+    }
+    return cells;
+}
+function parseLinkReferenceDefinition(lines) {
+    const firstLine = lines[0];
+    if (firstLine === undefined) return null;
+    let nextLineIndex = 1;
+    let content = firstLine.trim() + "\n";
+    // A link reference definition must start with a left bracket '['
+    if (content.charAt(0) !== "[") return null;
+    let label = "";
+    let characterCursor = 1; // Skip the opening bracket '['
+    while(characterCursor < content.length){
+        const character = content.charAt(characterCursor);
+        if (character === "\\") {
+            const nextCharacter = content.charAt(characterCursor + 1);
+            // Only ']', '[' and '\' need to be escaped within labels. Escaping them allows them to appear literally in the label
+            if ([
+                "]",
+                "[",
+                "\\"
+            ].includes(nextCharacter)) {
+                label += nextCharacter;
+                characterCursor += 2;
+            } else {
+                label += character;
+                characterCursor++;
+            }
+            continue;
+        }
+        // Unescaped `[` characters are not allowed in reference link labels. This prevents ambiguous nested bracket parsing.
+        if (character === "[") return null;
+        // If the current character is a closing bracket, we return the reference label.
+        if (character === "]") break;
+        if (character === "\n") {
+            const nextLine = lines[nextLineIndex];
+            if (nextLine === undefined) return null;
+            content += nextLine.trim() + "\n";
+            label += "\n";
+            characterCursor++;
+            nextLineIndex++;
+            continue;
+        }
+        label += character;
+        characterCursor++;
+    }
+    if (label.length === 0 || label.length > 999) return null;
+    if (label.trim().length === 0) return null;
+    characterCursor++; // Skip the closing bracket ']'
+    if (content.charAt(characterCursor) !== ":") return null;
+    characterCursor++; // Skip the colon ':'
+    // Skip optional whitespaces after the colon ':'
+    while(true){
+        const character = content.charAt(characterCursor);
+        if (character === " " || character === "\t") {
+            characterCursor++;
+            continue;
+        }
+        if (character === "\n") {
+            const nextLine = lines[nextLineIndex];
+            if (nextLine === undefined) return null;
+            content += nextLine.trim() + "\n";
+            characterCursor++;
+            nextLineIndex++;
+            continue;
+        }
+        break;
+    }
+    const destination = parseLinkDestination(content, {
+        startIndex: characterCursor
+    });
+    // If the destination is invalid, the link reference definition is invalid (for both stream and non-stream parsing)
+    if (destination === null) return null;
+    characterCursor = destination.endIndex + 1;
+    const characterCursorAfterDestination = characterCursor;
+    const nextLineIndexAfterDestination = nextLineIndex;
+    const destinationIsFollowedByNewline = content.charAt(characterCursor) === "\n";
+    if (!destinationIsFollowedByNewline && ![
+        " ",
+        "\t"
+    ].includes(content.charAt(characterCursor))) {
+        return null;
+    }
+    // Skip optional whitespaces after the destination
+    while(true){
+        const character = content.charAt(characterCursor);
+        if (character === " " || character === "\t") {
+            characterCursor++;
+            continue;
+        }
+        if (character === "\n") {
+            const nextLine = lines[nextLineIndex];
+            if (nextLine === undefined) break;
+            content += nextLine.trim() + "\n";
+            characterCursor++;
+            nextLineIndex++;
+            continue;
+        }
+        break;
+    }
+    let title;
+    const openingQuoteCharacter = content.charAt(characterCursor);
+    // Reference link title must start with ", ', or (
+    if ([
+        '"',
+        "'",
+        "("
+    ].includes(openingQuoteCharacter)) {
+        const closingQuoteCharacter = openingQuoteCharacter === "(" ? ")" : openingQuoteCharacter;
+        characterCursor++; // Skip the opening quote character
+        const titleStartIndex = characterCursor;
+        while(true){
+            const character = content.charAt(characterCursor);
+            if (character === closingQuoteCharacter) {
+                title = unescapeString(content.slice(titleStartIndex, characterCursor));
+                characterCursor++; // Skip the closing quote character
+                break;
+            }
+            // For parenthesis-delimited titles, unescaped `(` is not allowed; this prevents ambiguity in parsing.
+            if (character === "(" && openingQuoteCharacter === "(") {
+                break;
+            }
+            // If the current character is a backslash and it is not the last character, it is an escaped character, so we skip the current character and the next character.
+            if (character === "\\" && characterCursor + 1 < content.length) {
+                characterCursor += 2;
+                continue;
+            }
+            if (character === "\n") {
+                const nextLine = lines[nextLineIndex];
+                if (nextLine === undefined) break;
+                content += nextLine.trim() + "\n";
+                characterCursor++;
+                nextLineIndex++;
+                continue;
+            }
+            // Regular characters (including newlines) are allowed in the title.
+            characterCursor++;
+        }
+    }
+    // Title must noot be followed by any more content
+    if (content.charAt(characterCursor) !== "\n") {
+        title = undefined;
+    }
+    if (title === undefined) {
+        // If the destination is not followed by a newline and the title is invalid, the link reference definition is invalid
+        if (!destinationIsFollowedByNewline) {
+            return null;
+        } else {
+            characterCursor = characterCursorAfterDestination + 1;
+            nextLineIndex = nextLineIndexAfterDestination;
+        }
+    }
+    return {
+        definition: {
+            label: normalizeReference(label),
+            href: destination.href,
+            title
+        },
+        nextLineIndex
+    };
+}
+function parseListItem(line) {
+    let item;
+    const orderedListItem = parseOrderedListItem(line);
+    if (orderedListItem !== null) {
+        item = {
+            kind: "ordered",
+            ...orderedListItem
+        };
+    } else {
+        const unorderedListItem = parseUnorderedListItem(line);
+        if (unorderedListItem !== null) {
+            item = {
+                kind: "unordered",
+                ...unorderedListItem
+            };
+        } else {
+            return null;
+        }
+    }
+    let content = item.content;
+    let numOfColumns = item.numOfColumns;
+    if (item.numOfColumnsAfterMarker >= 5 || item.numOfColumnsAfterMarker <= 0 || isLineEmpty(item.content)) {
+        content = " ".repeat(item.numOfColumnsAfterMarker) + content;
+        if (content.charAt(0) === " ") {
+            content = content.slice(1);
+        }
+        // The baseline content indentation is one space past the marker
+        numOfColumns = numOfColumns - item.numOfColumnsAfterMarker + 1;
+    }
+    if (item.kind === "ordered") {
+        return {
+            kind: "ordered",
+            content,
+            numOfColumns,
+            value: item.value,
+            delimiter: item.delimiter
+        };
+    } else {
+        return {
+            kind: "unordered",
+            content,
+            numOfColumns,
+            marker: item.marker
+        };
+    }
+}
+/**
+ * Checks if the line represents the start of an ordered list item. Must satisfy the following conditions:
+ * - The first non-whitespace character in the line must be a digit (0-9). It can be followed by characters that are also digits (0-9).
+ * - There must be at most 9 digits in the line.
+ * - The character immediately after the digits must be a period '.' character or a closing parenthesis ')' character.
+ * - The character immediately after the digits must be a space or a tab (if it exists).
+ * @param line - The line to check.
+ * @returns The value of the ordered list item and the number of digits in the line if the line is an ordered list item, null otherwise.
+ */ function parseOrderedListItem(line) {
+    if (isIndentedCodeLine(line)) return null;
+    const firstNonspaceIndex = getFirstNonspaceIndex(line);
+    // The first character after whitespaces must be a digit.
+    if (line.charCodeAt(firstNonspaceIndex) < 0x30 /* 0 */  || line.charCodeAt(firstNonspaceIndex) > 0x39 /* 9 */ ) {
+        return null;
+    }
+    /**
+	 * Count the number of consecutive digits in the line (starting from the first non-whitespace character)
+	 *
+	 * In the following example, the number of digits is 1.
+	 * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┐
+	 * │ 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |
+	 * ├───┼───┼───┼───┼───┼───┼───┼───┼───┤
+	 * │ ␣ | 1 | ) | ␣ | T | h | i | s | ␣ |
+	 * └───┴───┴───┴───┴───┴───┴───┴───┴───┘
+	 *       ▲
+	 *
+	 * In the following example, the number of digits is 1.
+	 * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┐
+	 * │ 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |
+	 * ├───┼───┼───┼───┼───┼───┼───┼───┼───┤
+	 * │ ␣ | 1 | 2 | ) | ␣ | T | h | e | ␣ |
+	 * └───┴───┴───┴───┴───┴───┴───┴───┴───┘
+	 *       ▲   ▲
+	 *       │   │
+	 *       └───┘
+	 */ let numOfDigits = 1;
+    while(true){
+        if (firstNonspaceIndex + numOfDigits >= line.length) break;
+        if (line.charCodeAt(firstNonspaceIndex + numOfDigits) >= 0x30 /* 0 */  && line.charCodeAt(firstNonspaceIndex + numOfDigits) <= 0x39 /* 9 */ ) {
+            numOfDigits++;
+            // A valid ordered list item cannot have more than 9 digits.
+            if (numOfDigits > 9) return null;
+            continue;
+        }
+        break;
+    }
+    const delimiter = line.charAt(firstNonspaceIndex + numOfDigits);
+    // The character immediately after the digits (delimiter) must be a period '.' character or a closing parenthesis ')' character.
+    if (delimiter !== "." && delimiter !== ")") return null;
+    // The digits must be a valid number.
+    const value = parseInt(line.slice(firstNonspaceIndex, firstNonspaceIndex + numOfDigits), 10);
+    if (!Number.isFinite(value)) return null;
+    // Skip the digits and the period or closing parenthesis.
+    let characterIndex = firstNonspaceIndex + numOfDigits + 1;
+    // The character immediately after the digits must be a space or a tab if the content is not empty
+    if (characterIndex < line.length && line.charAt(characterIndex) !== " " && line.charAt(characterIndex) !== "\t") {
+        return null;
+    }
+    // Count the total number of columns (tabs are expanded to the next multiple of 4 spaces) from the beginning of the line to the start of the content of the ordered list item.
+    let numOfColumns = characterIndex;
+    while(characterIndex < line.length){
+        if (line.charAt(characterIndex) === "\t") {
+            numOfColumns += 4 - numOfColumns % 4;
+            characterIndex++;
+        } else if (line.charAt(characterIndex) === " ") {
+            numOfColumns++;
+            characterIndex++;
+        } else {
+            break;
+        }
+    }
+    const numOfColumnsAfterMarker = numOfColumns - (firstNonspaceIndex + numOfDigits + 1);
+    return {
+        content: line.slice(characterIndex),
+        numOfColumns,
+        numOfColumnsAfterMarker,
+        value,
+        delimiter
+    };
+}
+function parseUnorderedListItem(line) {
+    if (isIndentedCodeLine(line)) return null;
+    const firstNonspaceIndex = getFirstNonspaceIndex(line);
+    const marker = line.charAt(firstNonspaceIndex);
+    if (marker !== "*" && marker !== "+" && marker !== "-") {
+        return null;
+    }
+    let characterIndex = firstNonspaceIndex + 1;
+    // The character immediately after the marker must be a space or a tab if the content is not empty
+    if (characterIndex < line.length && line.charAt(characterIndex) !== " " && line.charAt(characterIndex) !== "\t") {
+        return null;
+    }
+    // Count the total number of columns (tabs are expanded to the next multiple of 4 spaces) from the beginning of the line to the start of the content of the ordered list item.
+    let numOfColumns = characterIndex;
+    while(characterIndex < line.length){
+        if (line.charAt(characterIndex) === "\t") {
+            numOfColumns += 4 - numOfColumns % 4;
+            characterIndex++;
+        } else if (line.charAt(characterIndex) === " ") {
+            numOfColumns++;
+            characterIndex++;
+        } else {
+            break;
+        }
+    }
+    const numOfColumnsAfterMarker = numOfColumns - (firstNonspaceIndex + 1);
+    return {
+        content: line.slice(characterIndex),
+        marker,
+        numOfColumns,
+        numOfColumnsAfterMarker
+    };
+}
+// List of HTML block detection sequences per CommonMark specification.
+const HTML_SEQUENCES = [
+    {
+        startPattern: /^<(?:script|pre|textarea|style)(?:\s|>|$)/i,
+        endPattern: /<\/(?:script|pre|textarea|style)>/i,
+        canInterruptParagraph: true,
+        canBeInterruptedByBlankLine: false
+    },
+    {
+        startPattern: /^<!--/,
+        endPattern: /-->/,
+        canInterruptParagraph: true,
+        canBeInterruptedByBlankLine: false
+    },
+    {
+        startPattern: /^<\?/,
+        endPattern: /\?>/,
+        canInterruptParagraph: true,
+        canBeInterruptedByBlankLine: false
+    },
+    {
+        startPattern: /^<![A-Za-z]/,
+        endPattern: />/,
+        canInterruptParagraph: true,
+        canBeInterruptedByBlankLine: false
+    },
+    {
+        startPattern: /^<!\[CDATA\[/,
+        endPattern: /\]\]>/,
+        canInterruptParagraph: true,
+        canBeInterruptedByBlankLine: false
+    },
+    {
+        startPattern: /^<[/]?(?:address|article|aside|base|basefont|blockquote|body|caption|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption|figure|footer|form|frame|frameset|h[123456]|head|header|hr|html|iframe|legend|li|link|main|menu|menuitem|nav|noframes|ol|optgroup|option|p|param|section|search|summary|table|tbody|td|tfoot|th|thead|title|tr|track|ul)(?:\s|[/]?[>]|$)/i,
+        canInterruptParagraph: true,
+        canBeInterruptedByBlankLine: true
+    },
+    {
+        startPattern: new RegExp("^(?:" + OPEN_TAG + "|" + CLOSE_TAG + ")\\s*$", "i"),
+        canInterruptParagraph: false,
+        canBeInterruptedByBlankLine: true
+    }
+];
+/**
+ * Attempts to parse a line as the opening of an HTML block.
+ *
+ * @param line - The line to parse.
+ * @returns An object with the end pattern of the HTML block and whether it can interrupt a paragraph.
+ */ function parseHTMLBlockStart(line) {
+    if (isIndentedCodeLine(line)) return null;
+    const firstNonspaceIndex = getFirstNonspaceIndex(line);
+    if (line.charAt(firstNonspaceIndex) !== "<") return null;
+    const sequence = HTML_SEQUENCES.find((sequence)=>sequence.startPattern.test(line.slice(firstNonspaceIndex)));
+    if (sequence === undefined) return null;
+    return {
+        endPattern: sequence.endPattern,
+        canInterruptParagraph: sequence.canInterruptParagraph,
+        canBeInterruptedByBlankLine: sequence.canBeInterruptedByBlankLine
+    };
+}
+/**
+ * Checks if a line is empty (contains only whitespace).
+ *
+ * @param line - The line to check.
+ * @returns True if the line contains only whitespace characters, false otherwise.
+ */ function isLineEmpty(line) {
+    return line.trim().length === 0;
+}
+function isSpaceOrTab(char) {
+    return char === " " || char === "\t";
+}
+
+export { MarkdownParser };