emdp 1.0.0

package/dist/esm/parser/gfm/inline-parser.js

@@ -0,0 +1,809 @@
+/**
+ * GFM inline parser that extends CommonMark with strikethrough and extended autolinks.
+ */
+import { parseEscape } from '../inlines/escape.js';
+import { parseEntity } from '../inlines/entity.js';
+import { parseCodeSpan } from '../inlines/code-span.js';
+import { parseDelimiterRun, canDelimitersMatch } from '../inlines/emphasis.js';
+import { parseAutolink } from '../inlines/autolink.js';
+import { parseInlineLink, parseLinkLabel, createLinkNode, createImageNode } from '../inlines/link.js';
+import { createTextNode } from '../inlines/text.js';
+import { normalizeLabel } from '../utils.js';
+import { isTagFilterTag } from '../utils.js';
+import { parseStrikethroughDelimiter, canStrikethroughDelimitersMatch, createStrikethroughNode, } from '../inlines/strikethrough.js';
+import { parseExtendedAutolink } from '../inlines/autolink-extended.js';
+import { parseFootnoteLabel } from '../inlines/footnote.js';
+export class GFMInlineParser {
+    linkReferences = new Map();
+    footnoteDefinitions = new Map();
+    enableAutolink;
+    enableStrikethrough;
+    enableFootnotes;
+    enableTagfilter;
+    constructor(extensions) {
+        this.enableAutolink = !extensions || extensions.has('autolink');
+        this.enableStrikethrough = !extensions || extensions.has('strikethrough');
+        this.enableFootnotes = !extensions || extensions.has('footnotes');
+        this.enableTagfilter = !extensions || extensions.has('tagfilter');
+    }
+    setLinkReferences(refs) {
+        this.linkReferences = refs;
+    }
+    setFootnoteDefinitions(defs) {
+        this.footnoteDefinitions = defs;
+    }
+    parse(text) {
+        const nodes = [];
+        let delimiterStack = null;
+        let bracketStack = null;
+        let pos = 0;
+        let textBuffer = '';
+        const flushText = () => {
+            if (textBuffer.length > 0) {
+                nodes.push(createTextNode(textBuffer));
+                textBuffer = '';
+            }
+        };
+        const pushDelimiter = (run, node) => {
+            const d = {
+                run,
+                node,
+                active: true,
+                prev: delimiterStack,
+                next: null,
+            };
+            if (delimiterStack) {
+                delimiterStack.next = d;
+            }
+            delimiterStack = d;
+        };
+        while (pos < text.length) {
+            const char = text[pos];
+            const charBefore = pos > 0 ? text[pos - 1] : undefined;
+            if (this.enableAutolink) {
+                const extendedAutolink = parseExtendedAutolink(text, pos, charBefore);
+                if (extendedAutolink) {
+                    flushText();
+                    nodes.push(extendedAutolink.node);
+                    pos += extendedAutolink.length;
+                    continue;
+                }
+            }
+            const escapeResult = parseEscape(text, pos);
+            if (escapeResult) {
+                if (escapeResult.char === '\n') {
+                    textBuffer = textBuffer.replace(/ *$/, '');
+                    flushText();
+                    nodes.push({ type: 'hardbreak' });
+                    pos += escapeResult.length;
+                    while (pos < text.length && text[pos] === ' ') {
+                        pos++;
+                    }
+                }
+                else if (escapeResult.char === '*' || escapeResult.char === '_' || escapeResult.char === '~') {
+                    flushText();
+                    nodes.push(createTextNode(escapeResult.char, true));
+                    pos += escapeResult.length;
+                }
+                else if (escapeResult.char === '"' || escapeResult.char === "'" ||
+                    escapeResult.char === '-' || escapeResult.char === '.') {
+                    flushText();
+                    const node = createTextNode(escapeResult.char);
+                    node.noSmart = true;
+                    nodes.push(node);
+                    pos += escapeResult.length;
+                }
+                else {
+                    textBuffer += escapeResult.char;
+                    pos += escapeResult.length;
+                }
+                continue;
+            }
+            const entityResult = parseEntity(text, pos);
+            if (entityResult) {
+                textBuffer += entityResult.char;
+                pos += entityResult.length;
+                continue;
+            }
+            if (char === '`') {
+                const codeSpanResult = parseCodeSpan(text, pos);
+                if (codeSpanResult) {
+                    flushText();
+                    nodes.push(codeSpanResult.node);
+                    pos += codeSpanResult.length;
+                    continue;
+                }
+                else {
+                    textBuffer += char;
+                    pos++;
+                    while (pos < text.length && text[pos] === '`') {
+                        textBuffer += text[pos];
+                        pos++;
+                    }
+                    continue;
+                }
+            }
+            if (char === '<') {
+                const autolinkResult = parseAutolink(text, pos);
+                if (autolinkResult) {
+                    flushText();
+                    nodes.push(autolinkResult.node);
+                    pos += autolinkResult.length;
+                    continue;
+                }
+                const openingTagMatch = text.slice(pos).match(/^<[a-zA-Z][a-zA-Z0-9-]*(?:\s+[a-zA-Z_:][a-zA-Z0-9_.:-]*(?:\s*=\s*(?:[^\s"'=<>`]+|'[^']*'|"[^"]*"))?)*\s*\/?>/);
+                if (openingTagMatch) {
+                    const tagNameMatch = openingTagMatch[0].match(/^<\s*([a-zA-Z][a-zA-Z0-9-]*)/);
+                    if (this.enableTagfilter && tagNameMatch && isTagFilterTag(tagNameMatch[1])) {
+                        flushText();
+                        nodes.push({
+                            type: 'html_inline',
+                            literal: openingTagMatch[0].replace(/^</, '&lt;'),
+                        });
+                        pos += openingTagMatch[0].length;
+                        continue;
+                    }
+                    flushText();
+                    nodes.push({ type: 'html_inline', literal: openingTagMatch[0] });
+                    pos += openingTagMatch[0].length;
+                    continue;
+                }
+                const closingTagMatch = text.slice(pos).match(/^<\/[a-zA-Z][a-zA-Z0-9-]*\s*>/);
+                if (closingTagMatch) {
+                    const tagNameMatch = closingTagMatch[0].match(/^<\/\s*([a-zA-Z][a-zA-Z0-9-]*)/);
+                    if (this.enableTagfilter && tagNameMatch && isTagFilterTag(tagNameMatch[1])) {
+                        flushText();
+                        nodes.push({
+                            type: 'html_inline',
+                            literal: closingTagMatch[0].replace(/^</, '&lt;'),
+                        });
+                        pos += closingTagMatch[0].length;
+                        continue;
+                    }
+                    flushText();
+                    nodes.push({ type: 'html_inline', literal: closingTagMatch[0] });
+                    pos += closingTagMatch[0].length;
+                    continue;
+                }
+                const shortCommentMatch = text.slice(pos).match(/^<!---?>/);
+                if (shortCommentMatch) {
+                    flushText();
+                    nodes.push({ type: 'html_inline', literal: '<!---->' });
+                    pos += shortCommentMatch[0].length;
+                    continue;
+                }
+                const commentMatch = text.slice(pos).match(/^<!--(?!>)(?!-?>)[\s\S]*?-->/);
+                if (commentMatch) {
+                    flushText();
+                    nodes.push({ type: 'html_inline', literal: commentMatch[0] });
+                    pos += commentMatch[0].length;
+                    continue;
+                }
+                const piMatch = text.slice(pos).match(/^<\?[\s\S]*?\?>/);
+                if (piMatch) {
+                    flushText();
+                    nodes.push({ type: 'html_inline', literal: piMatch[0] });
+                    pos += piMatch[0].length;
+                    continue;
+                }
+                const cdataMatch = text.slice(pos).match(/^<!\[CDATA\[[\s\S]*?\]\]>/);
+                if (cdataMatch) {
+                    flushText();
+                    nodes.push({ type: 'html_inline', literal: cdataMatch[0] });
+                    pos += cdataMatch[0].length;
+                    continue;
+                }
+                const declMatch = text.slice(pos).match(/^<![a-zA-Z][\s\S]*?>/);
+                if (declMatch) {
+                    flushText();
+                    nodes.push({ type: 'html_inline', literal: declMatch[0] });
+                    pos += declMatch[0].length;
+                    continue;
+                }
+            }
+            if (char === ' ') {
+                let spaceCount = 0;
+                let j = pos;
+                while (j < text.length && text[j] === ' ') {
+                    spaceCount++;
+                    j++;
+                }
+                if (text[j] === '\n' && spaceCount >= 2) {
+                    textBuffer = textBuffer.replace(/ *$/, '');
+                    flushText();
+                    nodes.push({ type: 'hardbreak' });
+                    pos = j + 1;
+                    while (pos < text.length && text[pos] === ' ') {
+                        pos++;
+                    }
+                    continue;
+                }
+            }
+            if (char === '\n') {
+                textBuffer = textBuffer.replace(/ *$/, '');
+                flushText();
+                nodes.push({ type: 'softbreak' });
+                pos++;
+                while (pos < text.length && text[pos] === ' ') {
+                    pos++;
+                }
+                continue;
+            }
+            if (char === '~' && this.enableStrikethrough) {
+                let tildeCount = 0;
+                let j = pos;
+                while (j < text.length && text[j] === '~') {
+                    tildeCount++;
+                    j++;
+                }
+                if (tildeCount <= 2) {
+                    const strikeRun = parseStrikethroughDelimiter(text, pos);
+                    if (strikeRun && (strikeRun.canOpen || strikeRun.canClose)) {
+                        flushText();
+                        const node = createTextNode(text.slice(pos, pos + strikeRun.length));
+                        nodes.push(node);
+                        pos += strikeRun.length;
+                        continue;
+                    }
+                }
+                else {
+                    textBuffer += text.slice(pos, j);
+                    pos = j;
+                    continue;
+                }
+            }
+            if (char === '!' && text[pos + 1] === '[' && text[pos + 2] === '^') {
+                textBuffer += '!';
+                pos++;
+                continue;
+            }
+            if (this.enableFootnotes && char === '[' && text[pos + 1] === '^') {
+                const footnoteLabel = parseFootnoteLabel(text, pos);
+                if (footnoteLabel) {
+                    const def = this.footnoteDefinitions.get(footnoteLabel.normalized);
+                    flushText();
+                    if (def) {
+                        nodes.push({
+                            type: 'footnote_ref',
+                            label: def.label,
+                            key: footnoteLabel.normalized,
+                        });
+                    }
+                    else {
+                        nodes.push(createTextNode(text.slice(pos, pos + footnoteLabel.length), true));
+                    }
+                    pos += footnoteLabel.length;
+                    continue;
+                }
+            }
+            if (char === '*' || char === '_') {
+                flushText();
+                const run = parseDelimiterRun(text, pos);
+                if (run) {
+                    const node = createTextNode(text.slice(pos, pos + run.length));
+                    node.delimiterOrigLength = run.length;
+                    nodes.push(node);
+                    if (run.canOpen || run.canClose) {
+                        pushDelimiter(run, node);
+                    }
+                    pos += run.length;
+                    continue;
+                }
+            }
+            if (char === '!' && text[pos + 1] === '[') {
+                flushText();
+                const node = createTextNode('![');
+                nodes.push(node);
+                const bracket = {
+                    type: 'image',
+                    node,
+                    nodeIndex: nodes.length - 1,
+                    active: true,
+                    prev: bracketStack,
+                    bracketAfter: false,
+                    delimiterBefore: delimiterStack,
+                    textPos: pos + 2,
+                };
+                if (bracketStack)
+                    bracketStack.bracketAfter = true;
+                bracketStack = bracket;
+                pos += 2;
+                continue;
+            }
+            if (char === '[') {
+                flushText();
+                const node = createTextNode('[');
+                nodes.push(node);
+                const bracket = {
+                    type: 'link',
+                    node,
+                    nodeIndex: nodes.length - 1,
+                    active: true,
+                    prev: bracketStack,
+                    bracketAfter: false,
+                    delimiterBefore: delimiterStack,
+                    textPos: pos + 1,
+                };
+                if (bracketStack)
+                    bracketStack.bracketAfter = true;
+                bracketStack = bracket;
+                pos += 1;
+                continue;
+            }
+            if (char === ']' && bracketStack) {
+                flushText();
+                let opener = bracketStack;
+                if (!opener) {
+                    textBuffer += ']';
+                    pos++;
+                    continue;
+                }
+                if (!opener.active) {
+                    bracketStack = opener.prev;
+                    textBuffer += ']';
+                    pos++;
+                    continue;
+                }
+                let matched = false;
+                let destination = '';
+                let title = '';
+                let consumed = 1;
+                if (text[pos + 1] === '(') {
+                    const linkResult = parseInlineLink(text, pos + 1);
+                    if (linkResult) {
+                        matched = true;
+                        destination = linkResult.destination;
+                        title = linkResult.title;
+                        consumed = 1 + linkResult.length;
+                    }
+                }
+                if (!matched && text[pos + 1] === '[') {
+                    const labelResult = parseLinkLabel(text, pos + 1);
+                    if (labelResult && labelResult.label) {
+                        if (this.linkReferences.has(labelResult.label)) {
+                            matched = true;
+                            const ref = this.linkReferences.get(labelResult.label);
+                            destination = ref.destination;
+                            title = ref.title;
+                            consumed = 1 + labelResult.length;
+                        }
+                    }
+                    else if (labelResult && labelResult.label === '') {
+                        const innerText = this.extractTextFromNodes(nodes.slice(opener.nodeIndex + 1));
+                        const label = normalizeLabel(innerText);
+                        if (this.linkReferences.has(label)) {
+                            matched = true;
+                            const ref = this.linkReferences.get(label);
+                            destination = ref.destination;
+                            title = ref.title;
+                            consumed = 1 + labelResult.length;
+                        }
+                    }
+                }
+                if (!matched && text[pos + 1] !== '[') {
+                    const rawLabel = text.slice(opener.textPos, pos);
+                    const label = normalizeLabel(this.normalizeLabelForMatching(rawLabel));
+                    if (label && this.linkReferences.has(label)) {
+                        matched = true;
+                        const ref = this.linkReferences.get(label);
+                        destination = ref.destination;
+                        title = ref.title;
+                    }
+                }
+                if (matched) {
+                    const innerNodes = nodes.splice(opener.nodeIndex + 1);
+                    nodes.pop();
+                    this.processEmphasisAndStrikethrough(innerNodes, opener.delimiterBefore);
+                    if (opener.type === 'image') {
+                        const alt = this.extractTextFromNodes(innerNodes);
+                        nodes.push(createImageNode(destination, title, alt));
+                    }
+                    else {
+                        const linkNode = createLinkNode(destination, title);
+                        linkNode.children = innerNodes;
+                        nodes.push(linkNode);
+                    }
+                    if (opener.type === 'link') {
+                        let b = opener.prev;
+                        while (b) {
+                            if (b.type === 'link')
+                                b.active = false;
+                            b = b.prev;
+                        }
+                    }
+                    bracketStack = opener.prev;
+                    pos += consumed;
+                }
+                else {
+                    bracketStack = opener.prev;
+                    textBuffer += ']';
+                    pos++;
+                }
+                continue;
+            }
+            textBuffer += char;
+            pos++;
+        }
+        flushText();
+        this.processEmphasisAndStrikethrough(nodes, null);
+        this.flattenNestedEmphasis(nodes);
+        return nodes;
+    }
+    extractTextFromNodes(nodes) {
+        let result = '';
+        for (const node of nodes) {
+            if (node.type === 'text') {
+                result += node.literal;
+            }
+            else if (node.type === 'code_span') {
+                result += node.literal;
+            }
+            else if (node.type === 'image') {
+                result += node.alt;
+            }
+            else if (node.type === 'softbreak' || node.type === 'hardbreak') {
+                result += ' ';
+            }
+            else if ('children' in node && Array.isArray(node.children)) {
+                result += this.extractTextFromNodes(node.children);
+            }
+        }
+        return result;
+    }
+    normalizeLabelForMatching(rawLabel) {
+        let result = '';
+        let i = 0;
+        while (i < rawLabel.length) {
+            if (rawLabel[i] === '\\' && i + 1 < rawLabel.length) {
+                const next = rawLabel[i + 1];
+                if (next === '[' || next === ']' || next === '\\') {
+                    result += next;
+                    i += 2;
+                    continue;
+                }
+            }
+            result += rawLabel[i];
+            i++;
+        }
+        return result;
+    }
+    processEmphasisAndStrikethrough(nodes, stackBottom) {
+        this.processEmphasis(nodes, stackBottom);
+        if (this.enableStrikethrough) {
+            this.processStrikethrough(nodes);
+        }
+    }
+    processStrikethrough(nodes) {
+        const delimiters = [];
+        for (let i = 0; i < nodes.length; i++) {
+            const node = nodes[i];
+            if (node.type === 'text' && node.literal.length > 0 && !node.noDelim) {
+                if (node.literal.match(/^~{1,2}$/)) {
+                    const beforeNode = i > 0 ? nodes[i - 1] : null;
+                    const afterNode = i < nodes.length - 1 ? nodes[i + 1] : null;
+                    let charBefore = '\n';
+                    let charAfter = '\n';
+                    if (beforeNode) {
+                        if (beforeNode.type === 'text') {
+                            charBefore = this.getLastChar(beforeNode.literal);
+                        }
+                        else if (beforeNode.type !== 'softbreak' && beforeNode.type !== 'hardbreak') {
+                            charBefore = 'a';
+                        }
+                    }
+                    if (afterNode) {
+                        if (afterNode.type === 'text') {
+                            charAfter = this.getFirstChar(afterNode.literal);
+                        }
+                        else if (afterNode.type !== 'softbreak' && afterNode.type !== 'hardbreak') {
+                            charAfter = 'a';
+                        }
+                    }
+                    const isWhitespace = (c) => /\s/.test(c) || c === '\n';
+                    const beforeIsWhitespace = isWhitespace(charBefore);
+                    const afterIsWhitespace = isWhitespace(charAfter);
+                    const canOpen = !afterIsWhitespace;
+                    const canClose = !beforeIsWhitespace;
+                    if (canOpen || canClose) {
+                        delimiters.push({
+                            run: {
+                                char: '~',
+                                length: node.literal.length,
+                                canOpen,
+                                canClose,
+                                position: 0,
+                                origLength: node.literal.length,
+                            },
+                            node: node,
+                            active: true,
+                            nodeIndex: i,
+                        });
+                    }
+                }
+            }
+        }
+        if (delimiters.length < 2)
+            return;
+        let closerIdx = 0;
+        while (closerIdx < delimiters.length) {
+            const closer = delimiters[closerIdx];
+            if (!closer.run.canClose || !closer.active) {
+                closerIdx++;
+                continue;
+            }
+            let openerIdx = closerIdx - 1;
+            let openerFound = false;
+            while (openerIdx >= 0) {
+                const opener = delimiters[openerIdx];
+                if (opener.active && opener.run.canOpen &&
+                    canStrikethroughDelimitersMatch(opener.run, closer.run)) {
+                    openerFound = true;
+                    break;
+                }
+                openerIdx--;
+            }
+            if (!openerFound) {
+                closerIdx++;
+                continue;
+            }
+            const opener = delimiters[openerIdx];
+            const openerNodeIdx = nodes.indexOf(opener.node);
+            const closerNodeIdx = nodes.indexOf(closer.node);
+            if (openerNodeIdx === -1 || closerNodeIdx === -1) {
+                closerIdx++;
+                continue;
+            }
+            const contentNodes = nodes.slice(openerNodeIdx + 1, closerNodeIdx);
+            const strikeNode = createStrikethroughNode(contentNodes);
+            nodes.splice(openerNodeIdx, closerNodeIdx - openerNodeIdx + 1, strikeNode);
+            for (let i = openerIdx + 1; i < closerIdx; i++) {
+                delimiters[i].active = false;
+            }
+            opener.active = false;
+            closer.active = false;
+            delimiters.length = 0;
+            for (let i = 0; i < nodes.length; i++) {
+                const node = nodes[i];
+                if (node.type === 'text' && node.literal.length > 0 && !node.noDelim) {
+                    if (node.literal.match(/^~{1,2}$/)) {
+                        const beforeNode = i > 0 ? nodes[i - 1] : null;
+                        const afterNode = i < nodes.length - 1 ? nodes[i + 1] : null;
+                        let charBefore = '\n';
+                        let charAfter = '\n';
+                        if (beforeNode) {
+                            if (beforeNode.type === 'text')
+                                charBefore = this.getLastChar(beforeNode.literal);
+                            else if (beforeNode.type !== 'softbreak' && beforeNode.type !== 'hardbreak')
+                                charBefore = 'a';
+                        }
+                        if (afterNode) {
+                            if (afterNode.type === 'text')
+                                charAfter = this.getFirstChar(afterNode.literal);
+                            else if (afterNode.type !== 'softbreak' && afterNode.type !== 'hardbreak')
+                                charAfter = 'a';
+                        }
+                        const isWhitespace = (c) => /\s/.test(c) || c === '\n';
+                        const canOpen = !isWhitespace(charAfter);
+                        const canClose = !isWhitespace(charBefore);
+                        if (canOpen || canClose) {
+                            delimiters.push({
+                                run: {
+                                    char: '~',
+                                    length: node.literal.length,
+                                    canOpen,
+                                    canClose,
+                                    position: 0,
+                                    origLength: node.literal.length,
+                                },
+                                node: node,
+                                active: true,
+                                nodeIndex: i,
+                            });
+                        }
+                    }
+                }
+            }
+            closerIdx = 0;
+        }
+        for (let i = nodes.length - 1; i >= 0; i--) {
+            const node = nodes[i];
+            if (node.type === 'text' && node.literal === '') {
+                nodes.splice(i, 1);
+            }
+        }
+    }
+    processEmphasis(nodes, stackBottom) {
+        const nodeDelims = [];
+        for (let i = 0; i < nodes.length; i++) {
+            const node = nodes[i];
+            if (node.type === 'text' && node.literal.length > 0 && !node.noDelim) {
+                const firstChar = node.literal[0];
+                if ((firstChar === '*' || firstChar === '_') && node.literal.match(/^[*_]+$/)) {
+                    const beforeNode = i > 0 ? nodes[i - 1] : null;
+                    const afterNode = i < nodes.length - 1 ? nodes[i + 1] : null;
+                    let charBefore = '\n';
+                    if (beforeNode) {
+                        if (beforeNode.type === 'text') {
+                            charBefore = this.getLastChar(beforeNode.literal);
+                        }
+                        else if (beforeNode.type === 'softbreak' || beforeNode.type === 'hardbreak') {
+                            charBefore = '\n';
+                        }
+                        else {
+                            charBefore = 'a';
+                        }
+                    }
+                    let charAfter = '\n';
+                    if (afterNode) {
+                        if (afterNode.type === 'text') {
+                            charAfter = this.getFirstChar(afterNode.literal);
+                        }
+                        else if (afterNode.type === 'softbreak' || afterNode.type === 'hardbreak') {
+                            charAfter = '\n';
+                        }
+                        else {
+                            charAfter = 'a';
+                        }
+                    }
+                    const run = this.computeDelimiterRun(node.literal, charBefore, charAfter);
+                    node.delimiterOrigLength = node.delimiterOrigLength ?? node.literal.length;
+                    run.origLength = node.delimiterOrigLength;
+                    if (run.canOpen || run.canClose) {
+                        nodeDelims.push({ node, index: i, run });
+                    }
+                }
+            }
+        }
+        if (nodeDelims.length === 0)
+            return;
+        const openerBottomByChar = { '*': -1, '_': -1 };
+        let closerIdx = 0;
+        while (closerIdx < nodeDelims.length) {
+            const closer = nodeDelims[closerIdx];
+            if (!closer.run.canClose) {
+                closerIdx++;
+                continue;
+            }
+            let openerIdx = closerIdx - 1;
+            let openerFound = false;
+            while (openerIdx >= 0 && openerIdx > openerBottomByChar[closer.run.char]) {
+                const opener = nodeDelims[openerIdx];
+                if (opener.run.canOpen && opener.run.char === closer.run.char &&
+                    canDelimitersMatch(opener.run, closer.run)) {
+                    openerFound = true;
+                    break;
+                }
+                openerIdx--;
+            }
+            if (!openerFound) {
+                if (!closer.run.canOpen) {
+                    openerBottomByChar[closer.run.char] = closerIdx - 1;
+                }
+                closerIdx++;
+                continue;
+            }
+            const opener = nodeDelims[openerIdx];
+            const strong = opener.run.length >= 2 && closer.run.length >= 2;
+            const numDelims = strong ? 2 : 1;
+            opener.node.literal = opener.node.literal.slice(0, -numDelims);
+            closer.node.literal = closer.node.literal.slice(numDelims);
+            opener.run.length -= numDelims;
+            closer.run.length -= numDelims;
+            const openerNodeIdx = nodes.indexOf(opener.node);
+            const closerNodeIdx = nodes.indexOf(closer.node);
+            const contentNodes = nodes.slice(openerNodeIdx + 1, closerNodeIdx);
+            const emphNode = strong
+                ? { type: 'strong', children: contentNodes }
+                : { type: 'emphasis', children: contentNodes };
+            nodes.splice(openerNodeIdx + 1, closerNodeIdx - openerNodeIdx - 1, emphNode);
+            for (let i = openerIdx + 1; i < closerIdx; i++) {
+                nodeDelims[i].run.length = 0;
+            }
+            if (opener.run.length === 0) {
+                const idx = nodes.indexOf(opener.node);
+                if (idx !== -1 && opener.node.literal === '') {
+                    nodes.splice(idx, 1);
+                }
+            }
+            if (closer.run.length === 0) {
+                const idx = nodes.indexOf(closer.node);
+                if (idx !== -1 && closer.node.literal === '') {
+                    nodes.splice(idx, 1);
+                }
+            }
+            nodeDelims.length = 0;
+            for (let i = 0; i < nodes.length; i++) {
+                const node = nodes[i];
+                if (node.type === 'text' && node.literal.length > 0 && !node.noDelim) {
+                    const firstChar = node.literal[0];
+                    if ((firstChar === '*' || firstChar === '_') && node.literal.match(/^[*_]+$/)) {
+                        const beforeNode = i > 0 ? nodes[i - 1] : null;
+                        const afterNode = i < nodes.length - 1 ? nodes[i + 1] : null;
+                        let charBefore = '\n';
+                        let charAfter = '\n';
+                        if (beforeNode) {
+                            if (beforeNode.type === 'text')
+                                charBefore = this.getLastChar(beforeNode.literal);
+                            else if (beforeNode.type !== 'softbreak' && beforeNode.type !== 'hardbreak')
+                                charBefore = 'a';
+                        }
+                        if (afterNode) {
+                            if (afterNode.type === 'text')
+                                charAfter = this.getFirstChar(afterNode.literal);
+                            else if (afterNode.type !== 'softbreak' && afterNode.type !== 'hardbreak')
+                                charAfter = 'a';
+                        }
+                        const run = this.computeDelimiterRun(node.literal, charBefore, charAfter);
+                        node.delimiterOrigLength = node.delimiterOrigLength ?? node.literal.length;
+                        run.origLength = node.delimiterOrigLength;
+                        if (run.canOpen || run.canClose) {
+                            nodeDelims.push({ node, index: i, run });
+                        }
+                    }
+                }
+            }
+            closerIdx = 0;
+        }
+        for (let i = nodes.length - 1; i >= 0; i--) {
+            const node = nodes[i];
+            if (node.type === 'text' && node.literal === '') {
+                nodes.splice(i, 1);
+            }
+        }
+    }
+    flattenNestedEmphasis(nodes) {
+        for (const node of nodes) {
+            if ('children' in node && Array.isArray(node.children)) {
+                this.flattenNestedEmphasis(node.children);
+                if (node.type === 'strong') {
+                    const flattened = [];
+                    for (const child of node.children) {
+                        if (child.type === node.type) {
+                            flattened.push(...child.children);
+                        }
+                        else {
+                            flattened.push(child);
+                        }
+                    }
+                    node.children = flattened;
+                }
+            }
+        }
+    }
+    computeDelimiterRun(literal, charBefore, charAfter) {
+        const char = literal[0];
+        const length = literal.length;
+        const isWhitespace = (c) => /\s/.test(c) || c === '\n';
+        const isPunctuation = (c) => /[\p{P}\p{S}]/u.test(c);
+        const beforeIsWhitespace = isWhitespace(charBefore);
+        const afterIsWhitespace = isWhitespace(charAfter);
+        const beforeIsPunctuation = isPunctuation(charBefore);
+        const afterIsPunctuation = isPunctuation(charAfter);
+        const leftFlanking = !afterIsWhitespace &&
+            (!afterIsPunctuation || beforeIsWhitespace || beforeIsPunctuation);
+        const rightFlanking = !beforeIsWhitespace &&
+            (!beforeIsPunctuation || afterIsWhitespace || afterIsPunctuation);
+        let canOpen;
+        let canClose;
+        if (char === '*') {
+            canOpen = leftFlanking;
+            canClose = rightFlanking;
+        }
+        else {
+            canOpen = leftFlanking && (!rightFlanking || beforeIsPunctuation);
+            canClose = rightFlanking && (!leftFlanking || afterIsPunctuation);
+        }
+        return { char, length, canOpen, canClose, position: 0, origLength: length };
+    }
+    getFirstChar(text) {
+        if (!text)
+            return '\n';
+        return Array.from(text)[0] ?? '\n';
+    }
+    getLastChar(text) {
+        if (!text)
+            return '\n';
+        const chars = Array.from(text);
+        return chars.length > 0 ? chars[chars.length - 1] : '\n';
+    }
+}