@tabnas/markdown 0.6.1 → 0.7.1

package/dist/inline.js

@@ -1,8 +1,25 @@
 "use strict";
 /* Copyright (c) 2021-2026 Richard Rodger, MIT License */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.InlineParser = void 0;
+exports.codePointBefore = codePointBefore;
+exports.codePointAt = codePointAt;
+exports.skipInitialSpaces = skipInitialSpaces;
+exports.matchSpnl = matchSpnl;
+exports.scanCodeSpan = scanCodeSpan;
+exports.scanEscape = scanEscape;
+exports.scanAngleAutolink = scanAngleAutolink;
+exports.scanHtmlTag = scanHtmlTag;
+exports.scanEntity = scanEntity;
+exports.scanDelimiterRun = scanDelimiterRun;
+exports.classifyBreak = classifyBreak;
+exports.scanLinkTitle = scanLinkTitle;
+exports.scanLinkDestination = scanLinkDestination;
+exports.scanLinkLabel = scanLinkLabel;
+exports.scanInlineLinkTail = scanInlineLinkTail;
 exports.linkifyAutolinks = linkifyAutolinks;
 exports.parseInlines = parseInlines;
+exports.forEachInlineBlock = forEachInlineBlock;
 exports.parseReference = parseReference;
 // Phase 2 of the CommonMark parse (spec 0.31.2, Appendix A, "Phase 2: inline
 // structure"). The block phase left the raw text of every paragraph and
@@ -149,6 +166,281 @@ function text(literal) {
 // punctuation the closing `*` is not right-flanking, so the line stays
 // literal text.
 const isPunctuation = common_ts_1.isUnicodePunctuation;
+// --- pure recognizers -------------------------------------------------------
+//
+// Recognition split from node building: each function inspects `subject` at
+// `pos` and reports what it found, moving nothing and touching no tree. The
+// scanner methods below delegate to them, and they are exported so any other
+// driver over the same syntax shares this exact recognition logic instead of
+// reimplementing it.
+/** Match a sticky regex at `pos`; the match text, or null. */
+function stickyAt(re, subject, pos) {
+    re.lastIndex = pos;
+    const m = re.exec(subject);
+    return null === m ? null : m[0];
+}
+/**
+ * The whole code point ending at `end`, so an astral character is classified
+ * as one character by the flanking rules rather than as a lone surrogate.
+ * Start of subject counts as a line ending (§6.4).
+ */
+function codePointBefore(subject, end) {
+    if (end <= 0)
+        return '\n';
+    const lo = subject.charCodeAt(end - 1);
+    if (lo >= 0xdc00 && lo <= 0xdfff && end >= 2) {
+        const hi = subject.charCodeAt(end - 2);
+        if (hi >= 0xd800 && hi <= 0xdbff)
+            return subject.slice(end - 2, end);
+    }
+    return subject.charAt(end - 1);
+}
+/** The whole code point at `i`; end of subject counts as a line ending. */
+function codePointAt(subject, i) {
+    if (i >= subject.length)
+        return '\n';
+    const cp = subject.codePointAt(i);
+    return undefined === cp ? '\n' : String.fromCodePoint(cp);
+}
+/** End of the run of spaces starting at `pos`. */
+function skipInitialSpaces(subject, pos) {
+    reInitialSpace.lastIndex = pos;
+    reInitialSpace.exec(subject);
+    return reInitialSpace.lastIndex;
+}
+/** End of "spaces, and at most one line ending" starting at `pos` (§6.3). */
+function matchSpnl(subject, pos) {
+    reSpnl.lastIndex = pos;
+    reSpnl.exec(subject);
+    return reSpnl.lastIndex;
+}
+/**
+ * §6.3: a code span runs from a backtick string to the next backtick string
+ * of *exactly* the same length. `closed: false` reports an unmatched opener,
+ * which is literal text; null means no backtick run starts at `pos`.
+ */
+function scanCodeSpan(subject, pos) {
+    const ticks = stickyAt(reTicksHere, subject, pos);
+    if (null === ticks)
+        return null;
+    const afterOpenTicks = pos + ticks.length;
+    reTicks.lastIndex = afterOpenTicks;
+    let m;
+    while (null !== (m = reTicks.exec(subject))) {
+        if (m[0] === ticks) {
+            const end = reTicks.lastIndex;
+            // Line endings become spaces; then one leading and one trailing space
+            // are stripped together, but only if the content is not all spaces
+            // (which is what lets a code span hold backticks).
+            const contents = subject.slice(afterOpenTicks, end - ticks.length).replace(/\n/g, ' ');
+            const literal = contents.length > 2 &&
+                ' ' === contents[0] &&
+                ' ' === contents[contents.length - 1] &&
+                null !== /[^ ]/.exec(contents)
+                ? contents.slice(1, contents.length - 1)
+                : contents;
+            return { closed: true, end, literal };
+        }
+    }
+    return { closed: false, end: afterOpenTicks, ticks };
+}
+/**
+ * §6.1/§6.7: a backslash escape, with `pos` at the backslash. Always
+ * succeeds: a backslash before anything unescapable is a literal backslash.
+ * The `linebreak` form consumes the following line's leading spaces.
+ */
+function scanEscape(subject, pos) {
+    const next = pos + 1;
+    if (next < subject.length && C_NEWLINE === subject.charCodeAt(next)) {
+        return { kind: 'linebreak', literal: '', end: skipInitialSpaces(subject, next + 1) };
+    }
+    const ch = subject.charAt(next);
+    if (reEscapable.test(ch))
+        return { kind: 'char', literal: ch, end: next + 1 };
+    return { kind: 'literal', literal: '\\', end: next };
+}
+/** §6.5: an email or URI autolink in angle brackets. */
+function scanAngleAutolink(subject, pos) {
+    let m = stickyAt(reEmailAutolink, subject, pos);
+    if (null !== m) {
+        const dest = m.slice(1, m.length - 1);
+        return { dest: 'mailto:' + dest, label: dest, end: pos + m.length };
+    }
+    m = stickyAt(reAutolink, subject, pos);
+    if (null !== m) {
+        const dest = m.slice(1, m.length - 1);
+        return { dest, label: dest, end: pos + m.length };
+    }
+    return null;
+}
+/** §6.6: a raw HTML tag (open, close, comment, PI, declaration or CDATA). */
+function scanHtmlTag(subject, pos) {
+    const m = stickyAt(reHtmlTag, subject, pos);
+    return null === m ? null : { raw: m, end: pos + m.length };
+}
+/** §6.2: an entity or numeric character reference, decoded. */
+function scanEntity(subject, pos) {
+    const m = stickyAt(reEntityHere, subject, pos);
+    return null === m ? null : { literal: (0, common_ts_1.decodeEntity)(m), end: pos + m.length };
+}
+/**
+ * §6.4: classify the run of `cc` starting at `pos` without consuming it.
+ *
+ * A run is left-flanking iff it is not followed by Unicode whitespace and
+ * either not followed by Unicode punctuation or else preceded by whitespace
+ * or punctuation; right-flanking is the mirror image. `_` additionally may
+ * not open inside a word (rules 2, 4, 6, 8), which is what keeps
+ * `snake_case_words` intact; `*` has no such restriction.
+ */
+function scanDelimiterRun(subject, pos, cc) {
+    let numdelims = 0;
+    let p = pos;
+    while (p < subject.length && cc === subject.charCodeAt(p)) {
+        numdelims += 1;
+        p += 1;
+    }
+    if (0 === numdelims)
+        return null;
+    const charBefore = codePointBefore(subject, pos);
+    const charAfter = codePointAt(subject, p);
+    const afterIsWhitespace = (0, common_ts_1.isUnicodeWhitespace)(charAfter);
+    const afterIsPunctuation = isPunctuation(charAfter);
+    const beforeIsWhitespace = (0, common_ts_1.isUnicodeWhitespace)(charBefore);
+    const beforeIsPunctuation = isPunctuation(charBefore);
+    const leftFlanking = !afterIsWhitespace &&
+        (!afterIsPunctuation || beforeIsWhitespace || beforeIsPunctuation);
+    const rightFlanking = !beforeIsWhitespace &&
+        (!beforeIsPunctuation || afterIsWhitespace || afterIsPunctuation);
+    let canOpen;
+    let canClose;
+    if (C_UNDERSCORE === cc) {
+        canOpen = leftFlanking && (!rightFlanking || beforeIsPunctuation);
+        canClose = rightFlanking && (!leftFlanking || afterIsPunctuation);
+    }
+    else {
+        canOpen = leftFlanking;
+        canClose = rightFlanking;
+    }
+    return { numdelims, canOpen, canClose };
+}
+/**
+ * §6.7/§6.8: how a line ending resolves, given the literal of the text node
+ * immediately before it. Two or more trailing spaces make a hard break;
+ * `trim` says the trailing spaces must be dropped from that node either way.
+ */
+function classifyBreak(prevTextLiteral) {
+    if (null === prevTextLiteral ||
+        ' ' !== prevTextLiteral.charAt(prevTextLiteral.length - 1)) {
+        return { hard: false, trim: false };
+    }
+    return { hard: ' ' === prevTextLiteral.charAt(prevTextLiteral.length - 2), trim: true };
+}
+/** §6.3: a link title at `pos`, without its delimiters, unescaped. */
+function scanLinkTitle(subject, pos) {
+    const m = stickyAt(reLinkTitle, subject, pos);
+    if (null === m)
+        return null;
+    return { title: (0, common_ts_1.unescapeString)(m.slice(1, m.length - 1)), end: pos + m.length };
+}
+/**
+ * §6.3: a link destination at `pos` — either `<...>`, or a bare run with
+ * balanced unescaped parentheses and no ASCII control characters or spaces.
+ *
+ * The destination is backslash-unescaped and entity-decoded, but **not**
+ * percent-encoded: `[l](/ä)` yields `/ä`, not `/%C3%A4`. Encoding is a
+ * rendering concern and `html.ts` applies `normalizeURI` when it writes the
+ * attribute; the public AST promises the decoded form.
+ */
+function scanLinkDestination(subject, pos) {
+    const braced = stickyAt(reLinkDestinationBraces, subject, pos);
+    if (null !== braced) {
+        return { dest: (0, common_ts_1.unescapeString)(braced.slice(1, braced.length - 1)), end: pos + braced.length };
+    }
+    if (pos < subject.length && C_LESSTHAN === subject.charCodeAt(pos))
+        return null;
+    let p = pos;
+    let openparens = 0;
+    let c = p < subject.length ? subject.charCodeAt(p) : -1;
+    while (-1 !== c) {
+        if (C_BACKSLASH === c && reEscapable.test(subject.charAt(p + 1))) {
+            p += 1;
+            if (p < subject.length)
+                p += 1;
+        }
+        else if (C_OPEN_PAREN === c) {
+            // Bail rather than scan on once nesting passes the limit. Without
+            // this, input like `[a](b` repeated makes every `]` scan to end of
+            // input looking for parens that never balance, which is quadratic in
+            // the document size. cmark caps nesting at the same depth, and no
+            // spec example nests more than two deep.
+            if (MAX_LINK_PAREN_NESTING <= openparens)
+                return null;
+            p += 1;
+            openparens += 1;
+        }
+        else if (C_CLOSE_PAREN === c) {
+            if (openparens < 1)
+                break;
+            p += 1;
+            openparens -= 1;
+        }
+        else if (c <= C_SPACE || C_DEL === c) {
+            // Spaces and ASCII control characters end the bare form.
+            break;
+        }
+        else {
+            p += 1;
+        }
+        c = p < subject.length ? subject.charCodeAt(p) : -1;
+    }
+    // An empty destination is only legal immediately before the closing
+    // paren of an inline link, as in `[link]()`.
+    if (p === pos && C_CLOSE_PAREN !== c)
+        return null;
+    if (0 !== openparens)
+        return null;
+    return { dest: (0, common_ts_1.unescapeString)(subject.slice(pos, p)), end: p };
+}
+/**
+ * §4.7/§6.3: a link label at `pos`, including brackets. `rawLength` is what
+ * was consumed; `length` is 0 when the label is too long to be valid (§4.7:
+ * at most 999 characters between the brackets).
+ */
+function scanLinkLabel(subject, pos) {
+    const m = stickyAt(reLinkLabel, subject, pos);
+    if (null === m)
+        return null;
+    return { rawLength: m.length, length: m.length > 1001 ? 0 : m.length };
+}
+/**
+ * §6.3: the `(destination "title")` tail of an inline link, with `pos` just
+ * after the `]`. Null unless the whole tail — through the closing paren —
+ * is present.
+ */
+function scanInlineLinkTail(subject, pos) {
+    if (pos >= subject.length || C_OPEN_PAREN !== subject.charCodeAt(pos))
+        return null;
+    let p = matchSpnl(subject, pos + 1);
+    const d = scanLinkDestination(subject, p);
+    if (null === d)
+        return null;
+    p = matchSpnl(subject, d.end);
+    let title = null;
+    // A title has to be separated from the destination by whitespace, so
+    // `[a](/url"t")` is not a titled link.
+    if (reWhitespaceChar.test(subject.charAt(p - 1))) {
+        const t = scanLinkTitle(subject, p);
+        if (null !== t) {
+            title = t.title;
+            p = t.end;
+        }
+    }
+    p = matchSpnl(subject, p);
+    if (p < subject.length && C_CLOSE_PAREN === subject.charCodeAt(p)) {
+        return { dest: d.dest, title, end: p + 1 };
+    }
+    return null;
+}
 class InlineParser {
     constructor(refmap, options) {
         this.subject = '';
@@ -182,22 +474,11 @@ class InlineParser {
      * surrogate. Start of subject counts as a line ending (§6.4).
      */
     charBefore(end) {
-        if (end <= 0)
-            return '\n';
-        const lo = this.subject.charCodeAt(end - 1);
-        if (lo >= 0xdc00 && lo <= 0xdfff && end >= 2) {
-            const hi = this.subject.charCodeAt(end - 2);
-            if (hi >= 0xd800 && hi <= 0xdbff)
-                return this.subject.slice(end - 2, end);
-        }
-        return this.subject.charAt(end - 1);
+        return codePointBefore(this.subject, end);
     }
     /** The whole code point at `i`; end of subject counts as a line ending. */
     charAtPos(i) {
-        if (i >= this.subject.length)
-            return '\n';
-        const cp = this.subject.codePointAt(i);
-        return undefined === cp ? '\n' : String.fromCodePoint(cp);
+        return codePointAt(this.subject, i);
     }
     // --- §6.3 code spans ---
     /**
@@ -205,70 +486,41 @@ class InlineParser {
      * *exactly* the same length. Unmatched opening backticks are literal text.
      */
     parseBackticks(block) {
-        const ticks = this.match(reTicksHere);
-        if (null === ticks)
+        const scan = scanCodeSpan(this.subject, this.pos);
+        if (null === scan)
             return false;
-        const afterOpenTicks = this.pos;
-        reTicks.lastIndex = this.pos;
-        let m;
-        while (null !== (m = reTicks.exec(this.subject))) {
-            this.pos = reTicks.lastIndex;
-            if (m[0] === ticks) {
-                const node = new node_ts_1.MdNode('code');
-                // Line endings become spaces; then one leading and one trailing
-                // space are stripped together, but only if the content is not all
-                // spaces (which is what lets a code span hold backticks).
-                const contents = this.subject
-                    .slice(afterOpenTicks, this.pos - ticks.length)
-                    .replace(/\n/g, ' ');
-                node.literal =
-                    contents.length > 2 &&
-                        ' ' === contents[0] &&
-                        ' ' === contents[contents.length - 1] &&
-                        null !== /[^ ]/.exec(contents)
-                        ? contents.slice(1, contents.length - 1)
-                        : contents;
-                block.appendChild(node);
-                return true;
-            }
+        this.pos = scan.end;
+        if (scan.closed) {
+            const node = new node_ts_1.MdNode('code');
+            node.literal = scan.literal;
+            block.appendChild(node);
+        }
+        else {
+            // No closing run of the same length: the opener is literal text.
+            block.appendChild(text(scan.ticks));
         }
-        // No closing run of the same length: the opener is literal text.
-        this.pos = afterOpenTicks;
-        block.appendChild(text(ticks));
         return true;
     }
     // --- §6.1 backslash escapes, §6.7 hard line breaks ---
     parseBackslash(block) {
-        this.pos += 1;
-        if (C_NEWLINE === this.peek()) {
-            this.pos += 1;
+        const scan = scanEscape(this.subject, this.pos);
+        this.pos = scan.end;
+        if ('linebreak' === scan.kind) {
             block.appendChild(new node_ts_1.MdNode('linebreak'));
-            this.match(reInitialSpace);
-        }
-        else if (reEscapable.test(this.subject.charAt(this.pos))) {
-            block.appendChild(text(this.subject.charAt(this.pos)));
-            this.pos += 1;
         }
         else {
-            block.appendChild(text('\\'));
+            block.appendChild(text(scan.literal));
         }
         return true;
     }
     // --- §6.5 autolinks ---
     parseAutolink(block) {
-        let m = this.match(reEmailAutolink);
-        if (null !== m) {
-            const dest = m.slice(1, m.length - 1);
-            block.appendChild(this.makeAutolink('mailto:' + dest, dest));
-            return true;
-        }
-        m = this.match(reAutolink);
-        if (null !== m) {
-            const dest = m.slice(1, m.length - 1);
-            block.appendChild(this.makeAutolink(dest, dest));
-            return true;
-        }
-        return false;
+        const scan = scanAngleAutolink(this.subject, this.pos);
+        if (null === scan)
+            return false;
+        this.pos = scan.end;
+        block.appendChild(this.makeAutolink(scan.dest, scan.label));
+        return true;
     }
     makeAutolink(destination, label) {
         // Autolink text is literal: no backslash escapes, no entity references.
@@ -281,56 +533,19 @@ class InlineParser {
     }
     // --- §6.6 raw HTML ---
     parseHtmlTag(block) {
-        const m = this.match(reHtmlTag);
-        if (null === m)
+        const scan = scanHtmlTag(this.subject, this.pos);
+        if (null === scan)
             return false;
+        this.pos = scan.end;
         const node = new node_ts_1.MdNode('html_inline');
-        node.literal = m;
+        node.literal = scan.raw;
         block.appendChild(node);
         return true;
     }
     // --- §6.4 emphasis: delimiter runs and flanking ---
-    /**
-     * Classify the run of `cc` starting at `pos` without consuming it.
-     *
-     * §6.4: a run is left-flanking iff it is not followed by Unicode
-     * whitespace and either not followed by Unicode punctuation or else
-     * preceded by whitespace or punctuation; right-flanking is the mirror
-     * image. `_` additionally may not open inside a word (rules 2, 4, 6, 8),
-     * which is what keeps `snake_case_words` intact; `*` has no such
-     * restriction.
-     */
+    /** Classify the run of `cc` starting at `pos` without consuming it. */
     scanDelims(cc) {
-        const startpos = this.pos;
-        let numdelims = 0;
-        while (cc === this.peek()) {
-            numdelims += 1;
-            this.pos += 1;
-        }
-        if (0 === numdelims)
-            return null;
-        const charBefore = this.charBefore(startpos);
-        const charAfter = this.charAtPos(this.pos);
-        const afterIsWhitespace = (0, common_ts_1.isUnicodeWhitespace)(charAfter);
-        const afterIsPunctuation = isPunctuation(charAfter);
-        const beforeIsWhitespace = (0, common_ts_1.isUnicodeWhitespace)(charBefore);
-        const beforeIsPunctuation = isPunctuation(charBefore);
-        const leftFlanking = !afterIsWhitespace &&
-            (!afterIsPunctuation || beforeIsWhitespace || beforeIsPunctuation);
-        const rightFlanking = !beforeIsWhitespace &&
-            (!beforeIsPunctuation || afterIsWhitespace || afterIsPunctuation);
-        let canOpen;
-        let canClose;
-        if (C_UNDERSCORE === cc) {
-            canOpen = leftFlanking && (!rightFlanking || beforeIsPunctuation);
-            canClose = rightFlanking && (!leftFlanking || afterIsPunctuation);
-        }
-        else {
-            canOpen = leftFlanking;
-            canClose = rightFlanking;
-        }
-        this.pos = startpos;
-        return { numdelims, canOpen, canClose };
+        return scanDelimiterRun(this.subject, this.pos, cc);
     }
     /** Emit a delimiter run as text and push it on the delimiter stack. */
     handleDelim(cc, block) {
@@ -487,82 +702,34 @@ class InlineParser {
     // --- §6.3 links and images ---
     /** Link title without its delimiters, unescaped; null if none here. */
     parseLinkTitle() {
-        const title = this.match(reLinkTitle);
-        if (null === title)
+        const scan = scanLinkTitle(this.subject, this.pos);
+        if (null === scan)
             return null;
-        return (0, common_ts_1.unescapeString)(title.slice(1, title.length - 1));
+        this.pos = scan.end;
+        return scan.title;
     }
     /**
      * Link destination: either `<...>`, or a bare run with balanced unescaped
-     * parentheses and no ASCII control characters or spaces.
-     */
-    /**
-     * A destination is backslash-unescaped and entity-decoded, but **not**
-     * percent-encoded: `[l](/ä)` yields `/ä`, not `/%C3%A4`.
-     *
-     * Encoding is a rendering concern and `html.ts` applies `normalizeURI` when
-     * it writes the attribute. Doing it here too would be invisible in the HTML
-     * (`normalizeURI` is idempotent over its own output) but would put the
-     * encoded form in the public AST, where mdast — and every previous release
-     * of this package — promises the decoded one.
+     * parentheses and no ASCII control characters or spaces. See
+     * `scanLinkDestination` for why the value is decoded but not
+     * percent-encoded.
      */
     parseLinkDestination() {
-        const braced = this.match(reLinkDestinationBraces);
-        if (null !== braced) {
-            return (0, common_ts_1.unescapeString)(braced.slice(1, braced.length - 1));
-        }
-        if (C_LESSTHAN === this.peek())
-            return null;
-        const savepos = this.pos;
-        let openparens = 0;
-        let c = this.peek();
-        while (-1 !== c) {
-            if (C_BACKSLASH === c && reEscapable.test(this.subject.charAt(this.pos + 1))) {
-                this.pos += 1;
-                if (-1 !== this.peek())
-                    this.pos += 1;
-            }
-            else if (C_OPEN_PAREN === c) {
-                // Bail rather than scan on once nesting passes the limit. Without
-                // this, input like `[a](b` repeated makes every `]` scan to end of
-                // input looking for parens that never balance, which is quadratic in
-                // the document size. cmark caps nesting at the same depth, and no
-                // spec example nests more than two deep.
-                if (MAX_LINK_PAREN_NESTING <= openparens)
-                    return null;
-                this.pos += 1;
-                openparens += 1;
-            }
-            else if (C_CLOSE_PAREN === c) {
-                if (openparens < 1)
-                    break;
-                this.pos += 1;
-                openparens -= 1;
-            }
-            else if (c <= C_SPACE || C_DEL === c) {
-                // Spaces and ASCII control characters end the bare form.
-                break;
-            }
-            else {
-                this.pos += 1;
-            }
-            c = this.peek();
-        }
-        // An empty destination is only legal immediately before the closing
-        // paren of an inline link, as in `[link]()`.
-        if (this.pos === savepos && C_CLOSE_PAREN !== c)
-            return null;
-        if (0 !== openparens)
+        const scan = scanLinkDestination(this.subject, this.pos);
+        if (null === scan)
             return null;
-        return (0, common_ts_1.unescapeString)(this.subject.slice(savepos, this.pos));
+        this.pos = scan.end;
+        return scan.dest;
     }
     /** Length of the link label at `pos`, including brackets; 0 if invalid. */
     parseLinkLabel() {
-        const m = this.match(reLinkLabel);
-        // §4.7: at most 999 characters between the brackets.
-        if (null === m || m.length > 1001)
+        const scan = scanLinkLabel(this.subject, this.pos);
+        if (null === scan)
             return 0;
-        return m.length;
+        // The raw match is consumed even when it is too long to be a valid
+        // label; callers that need the position back reset it themselves.
+        this.pos += scan.rawLength;
+        return scan.length;
     }
     addBracket(node, index, image) {
         if (null !== this.brackets)
@@ -630,28 +797,12 @@ class InlineParser {
         let matched = false;
         const savepos = this.pos;
         // Inline link: `](` destination title `)`.
-        if (C_OPEN_PAREN === this.peek()) {
-            this.pos += 1;
-            this.spnl();
-            const d = this.parseLinkDestination();
-            if (null !== d) {
-                this.spnl();
-                // A title has to be separated from the destination by whitespace,
-                // so `[a](/url"t")` is not a titled link.
-                let t = null;
-                if (reWhitespaceChar.test(this.subject.charAt(this.pos - 1))) {
-                    t = this.parseLinkTitle();
-                }
-                this.spnl();
-                if (C_CLOSE_PAREN === this.peek()) {
-                    this.pos += 1;
-                    dest = d;
-                    title = t;
-                    matched = true;
-                }
-            }
-            if (!matched)
-                this.pos = savepos;
+        const tail = scanInlineLinkTail(this.subject, this.pos);
+        if (null !== tail) {
+            this.pos = tail.end;
+            dest = tail.dest;
+            title = tail.title;
+            matched = true;
         }
         if (!matched) {
             // Reference forms. A second label gives the full form; an empty or
@@ -713,10 +864,11 @@ class InlineParser {
     }
     // --- §6.2 entities, §6.8/§6.9 breaks and plain text ---
     parseEntity(block) {
-        const m = this.match(reEntityHere);
-        if (null === m)
+        const scan = scanEntity(this.subject, this.pos);
+        if (null === scan)
             return false;
-        block.appendChild(text((0, common_ts_1.decodeEntity)(m)));
+        this.pos = scan.end;
+        block.appendChild(text(scan.literal));
         return true;
     }
     parseString(block) {
@@ -734,18 +886,15 @@ class InlineParser {
     parseNewline(block) {
         this.pos += 1;
         const lastc = block.lastChild;
-        if (null !== lastc &&
-            'text' === lastc.type &&
-            null !== lastc.literal &&
-            ' ' === lastc.literal.charAt(lastc.literal.length - 1)) {
-            const hardbreak = ' ' === lastc.literal.charAt(lastc.literal.length - 2);
+        const brk = classifyBreak(null !== lastc && 'text' === lastc.type ? lastc.literal : null);
+        if (brk.trim && null !== lastc && null !== lastc.literal) {
             lastc.literal = lastc.literal.replace(reFinalSpace, '');
-            block.appendChild(new node_ts_1.MdNode(hardbreak ? 'linebreak' : 'softbreak'));
+            block.appendChild(new node_ts_1.MdNode(brk.hard ? 'linebreak' : 'softbreak'));
         }
         else {
             block.appendChild(new node_ts_1.MdNode('softbreak'));
         }
-        this.match(reInitialSpace);
+        this.pos = skipInitialSpaces(this.subject, this.pos);
         return true;
     }
     /** One inline construct at `pos`; false only at the end of the subject. */
@@ -792,26 +941,45 @@ class InlineParser {
                 res = this.parseString(block);
                 break;
         }
-        if (!res) {
-            // Nothing claimed it: the character is literal text.
-            this.pos += 1;
-            block.appendChild(text(String.fromCharCode(c)));
-        }
+        if (!res)
+            this.parseLiteralChar(block);
         return true;
     }
-    /** Parse one paragraph or heading's raw content into inline children. */
-    parse(block) {
-        // Trimming is what stops trailing spaces at the end of a block from
-        // making a hard break, and drops the leading indentation of the first line.
+    /** Nothing claimed the character at `pos`: consume it as literal text. */
+    parseLiteralChar(block) {
+        const c = this.peek();
+        if (-1 === c)
+            return false;
+        this.pos += 1;
+        block.appendChild(text(String.fromCharCode(c)));
+        return true;
+    }
+    /**
+     * Reset for one block's raw content; false when the trimmed subject is
+     * empty. Trimming is what stops trailing spaces at the end of a block
+     * from making a hard break, and drops the leading indentation of the
+     * first line.
+     */
+    beginBlock(block) {
         this.subject = block.stringContent.trim();
         this.pos = 0;
         this.delimiters = null;
         this.brackets = null;
-        while (this.parseInline(block))
-            ;
+        return '' !== this.subject;
+    }
+    /** The tail of a block's inline parse: clear the raw content, resolve
+     * emphasis over the whole delimiter stack. */
+    finishBlock(block) {
         block.stringContent = '';
         this.processEmphasis(null);
     }
+    /** Parse one paragraph or heading's raw content into inline children. */
+    parse(block) {
+        this.beginBlock(block);
+        while (this.parseInline(block))
+            ;
+        this.finishBlock(block);
+    }
     /**
      * §4.7: consume leading link reference definitions. Called by the block
      * phase while finalizing a paragraph, repeatedly, until it returns 0.
@@ -882,6 +1050,7 @@ class InlineParser {
         return this.pos - startpos;
     }
 }
+exports.InlineParser = InlineParser;
 // --- GFM extended autolinks (autolink literals) -----------------------------
 //
 // GFM recognises `www.x.com`, `https://x.com` and `a@x.com` without the `<…>`
@@ -1303,12 +1472,23 @@ const INLINE_CONTENT_BLOCKS = {
  */
 function parseInlines(doc, refmap, options) {
     const parser = new InlineParser(refmap, options);
+    forEachInlineBlock(doc, options, (node) => parser.parse(node));
+}
+/**
+ * Walk the finished block tree, handing every inline content block
+ * (paragraphs, headings, table cells) to `fn` and running the GFM
+ * autolink-literal post-pass after it. This is the one iteration both
+ * inline drivers share — the hand scanner above and the engine path — so
+ * which blocks get inline parsing, and when linkify runs, is decided
+ * exactly once.
+ */
+function forEachInlineBlock(doc, options, fn) {
     const walker = doc.walker();
     let ev = walker.next();
     while (null !== ev) {
         const node = ev.node;
         if (!ev.entering && true === INLINE_CONTENT_BLOCKS[node.type]) {
-            parser.parse(node);
+            fn(node);
             if (options.gfm)
                 linkifyAutolinks(node);
         }