@voithos-labs/aragonite 0.10.4 → 0.10.7

package/dist/core/inline/live-edit/read-back.js

@@ -0,0 +1,50 @@
+/**
+ * A live rewrite's candidate read back where it will be stored (`docs/design/live-mode.md` § 2):
+ * through the position's write rules and read at its slot, as a reload reads it there. Every
+ * rewrite that removes bytes reads its candidate through here.
+ */
+import { getContentRange, isProseKind, readInline } from '../index';
+import { CONTENT_VISIBILITY, renderedText } from '../visibility';
+import { isBlankText, ownTrailingLineEnding } from '../../lines';
+/** `bytes` as `store` keeps them: exactly one prose block at the slot, or the inline surface's
+ *  text. Null where the reload would read anything else. */
+export function readBack(bytes, store) {
+    const { resolver, grammar } = store.reading;
+    const raw = store.stored(bytes);
+    if (store.surface === 'inline') {
+        return {
+            raw,
+            block: null,
+            inlines: readInline(raw, 0, raw.length, resolver, grammar),
+            lead: ''
+        };
+    }
+    const blocks = store.readSlot(raw)?.children ?? [];
+    if (blocks.length !== 1 || !isProseKind(blocks[0].kind))
+        return null;
+    const block = blocks[0];
+    const lead = raw.endsWith(block.raw) ? raw.slice(0, raw.length - block.raw.length) : '';
+    if (!isBlankText(lead))
+        return null;
+    const range = getContentRange(block);
+    return {
+        raw,
+        block,
+        inlines: readInline(block.raw, range.start, range.end, resolver, grammar),
+        lead
+    };
+}
+/** The bytes `read.inlines` index into. */
+export const readSource = (read) => read.block?.raw ?? read.raw;
+/** What the reader sees of a read, in the content reading (live-mode.md § 2). */
+export function shownOf(read, store) {
+    const render = { grammar: store.reading.grammar };
+    return read.lead + renderedText(read.inlines, readSource(read), CONTENT_VISIBILITY, render);
+}
+/** Whether `line` still reads as `node`'s kind where `store` keeps it: always, on an inline
+ *  surface, which never reads its text as a block. */
+export function keepsKindAt(node, line, store) {
+    if (store.surface === 'inline')
+        return true;
+    return readBack(line + ownTrailingLineEnding(node.raw), store)?.block?.kind === node.kind;
+}

package/dist/core/inline/picture.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Whether a paragraph is a picture on the page: it holds images and nothing else a user reads,
+ * so it is an object picked up whole rather than prose. Read from the editor's inline parse, so
+ * the answer is the one render draws: a reference image counts only once its definition exists.
+ */
+import type { NodeView } from '../node-views';
+import { type InlineReading } from './inline-cache';
+export declare function isImageOnlyParagraph(node: NodeView, reading: InlineReading): boolean;
+/** How many images a paragraph of pictures holds; 0 for any block that is not one. */
+export declare function pictureImageCount(node: NodeView, reading: InlineReading): number;

package/dist/core/inline/picture.js

@@ -0,0 +1,40 @@
+/**
+ * Whether a paragraph is a picture on the page: it holds images and nothing else a user reads,
+ * so it is an object picked up whole rather than prose. Read from the editor's inline parse, so
+ * the answer is the one render draws: a reference image counts only once its definition exists.
+ */
+import { isBlankText } from '../lines';
+import { resolvedInlineContent } from './inline-cache';
+import { inlineDescendants } from './walk';
+export function isImageOnlyParagraph(node, reading) {
+    return pictureImageCount(node, reading) > 0;
+}
+/** How many images a paragraph of pictures holds; 0 for any block that is not one. */
+export function pictureImageCount(node, reading) {
+    // Most paragraphs hold no image at all, and this runs for every block that renders.
+    if (node.kind !== 'paragraph' || !node.raw.includes('!['))
+        return 0;
+    const nodes = resolvedInlineContent(node, reading);
+    if (!nodes.every(isPictureOrBlank))
+        return 0;
+    let images = 0;
+    for (const part of inlineDescendants(nodes))
+        if (part.kind === 'image')
+            images++;
+    return images;
+}
+// A linked image is still a picture: the link is where a click on it goes.
+function isPicturePart(node) {
+    if (node.kind === 'image')
+        return true;
+    const children = node.children ?? [];
+    return node.kind === 'link' && children.some(isPicturePart) && children.every(isPictureOrBlank);
+}
+function isPictureOrBlank(node) {
+    return isPicturePart(node) || isBlank(node);
+}
+function isBlank(node) {
+    if (node.kind === 'hardLineBreak')
+        return true;
+    return node.kind === 'text' && isBlankText(node.text ?? '');
+}

package/dist/core/inline/scan/autolinks.d.ts

@@ -1,8 +1,9 @@
 /**
  * `<` dispatch (spec autolinks §6.5, then raw HTML §6.6) plus the GFM §6.9 bare/www/email pass
  * over completed text runs. No conformance reference covers the extension: these rules follow
- * the GFM spec text, then cmark-gfm where its prose runs out (`scanEmailDomain`), and diverge
- * from both at `hasValidDomain`: a scheme'd host needs no period, so `http://localhost` links.
+ * the GFM spec text, then cmark-gfm where its prose runs out (the email domain and its `mailto:`
+ * and `xmpp:` prefixes), and diverge from both at `hasValidDomain`: a scheme'd host needs no
+ * period, so `http://localhost` links.
  */
 import { type ScanContext } from './scan-state';
 /**
@@ -10,14 +11,12 @@ import { type ScanContext } from './scan-state';
  * entity-shaped tail (`&` + alphanumerics + `;`) is excluded with its `&` (spec ex. 626).
  */
 export declare function trimTrailingPunctuation(raw: string, urlStart: number, urlEnd: number): number;
-/**
- * GFM §6.9: valid only at start-of-region or after whitespace, `*`, `_`, `~`, or `(`. Applied to
- * every bare form here, per the spec text; cmark-gfm applies it to the `www.` form alone.
- */
-export declare function isValidLeadingBoundary(raw: string, pos: number, regionStart: number): boolean;
+/** GFM §6.9: valid at the scan range start or after ASCII whitespace, `*`, `_`, `~` or `(`. Every
+ *  bare form checks it, as the spec text says; cmark-gfm checks it for `www.` alone. */
+export declare function isValidLeadingBoundary(raw: string, pos: number, scanStart: number): boolean;
 export declare function handleAngle(ctx: ScanContext): void;
 /**
  * Runs before emphasis pairing so a delimiter absorbed into a URL can never pair; consumed
- * delimiters are pruned. Children of already-wrapped link/image nodes are scanned too.
+ * delimiters are pruned. Children of already-built nodes are scanned too, except a link's.
  */
 export declare function scanGfmAutolinks(ctx: ScanContext): void;

package/dist/core/inline/scan/autolinks.js

@@ -1,9 +1,11 @@
 /**
  * `<` dispatch (spec autolinks §6.5, then raw HTML §6.6) plus the GFM §6.9 bare/www/email pass
  * over completed text runs. No conformance reference covers the extension: these rules follow
- * the GFM spec text, then cmark-gfm where its prose runs out (`scanEmailDomain`), and diverge
- * from both at `hasValidDomain`: a scheme'd host needs no period, so `http://localhost` links.
+ * the GFM spec text, then cmark-gfm where its prose runs out (the email domain and its `mailto:`
+ * and `xmpp:` prefixes), and diverge from both at `hasValidDomain`: a scheme'd host needs no
+ * period, so `http://localhost` links.
  */
+import { isWhitespaceChar } from '../../lines';
 import { matchHtmlFormAt } from '../html-tag-grammar';
 import { appendNode } from './scan-state';
 import { percentEncodeUri } from './url';
@@ -53,12 +55,16 @@ export function trimTrailingPunctuation(raw, urlStart, urlEnd) {
     }
     return end;
 }
+/** GFM §6.9: a bare url runs to whitespace or a `<`, before the trims above apply. */
+function urlRunEnd(raw, from, end) {
+    let urlEnd = from;
+    while (urlEnd < end && raw[urlEnd] !== '<' && !isWhitespaceChar(raw[urlEnd]))
+        urlEnd++;
+    return urlEnd;
+}
 const HOST_CHAR = /[\p{L}\p{N}_.-]/u;
-/**
- * GFM §6.9: no underscore in either of a domain's last two dot-separated segments, so
- * `www.xxx._yyy.zzz` stays literal while `www._xxx.yyy.zzz` links. cmark-gfm's extra exemption
- * for 10+-dot hosts is an implementation artifact, deliberately not reproduced (file header).
- */
+/** GFM §6.9: no underscore in a domain's last two dot-separated segments, so `www.xxx._yyy.zzz`
+ *  stays literal while `www._xxx.yyy.zzz` links; cmark-gfm's 10+-dot exemption is left out. */
 function hasValidDomain(raw, domainStart, limit) {
     let hostEnd = domainStart;
     while (hostEnd < limit && HOST_CHAR.test(raw[hostEnd]))
@@ -74,15 +80,13 @@ function hasValidDomain(raw, domainStart, limit) {
     }
     return true;
 }
-/**
- * GFM §6.9: valid only at start-of-region or after whitespace, `*`, `_`, `~`, or `(`. Applied to
- * every bare form here, per the spec text; cmark-gfm applies it to the `www.` form alone.
- */
-export function isValidLeadingBoundary(raw, pos, regionStart) {
-    if (pos <= regionStart)
+/** GFM §6.9: valid at the scan range start or after ASCII whitespace, `*`, `_`, `~` or `(`. Every
+ *  bare form checks it, as the spec text says; cmark-gfm checks it for `www.` alone. */
+export function isValidLeadingBoundary(raw, pos, scanStart) {
+    if (pos <= scanStart)
         return true;
     const ch = raw[pos - 1];
-    return /\s/.test(ch) || ch === '*' || ch === '_' || ch === '~' || ch === '(';
+    return isWhitespaceChar(ch) || ch === '*' || ch === '_' || ch === '~' || ch === '(';
 }
 // ── `<` handler: spec autolink, then raw HTML tag ───────────────────────────
 // commonmark.js 0.31.2 reEmailAutolink / reAutolink, tried in that order.
@@ -124,14 +128,14 @@ function matchAngleConstruct(raw, pos, end) {
 // ── GFM §6.9 pass over completed text runs ──────────────────────────────────
 /**
  * Runs before emphasis pairing so a delimiter absorbed into a URL can never pair; consumed
- * delimiters are pruned. Children of already-wrapped link/image nodes are scanned too.
+ * delimiters are pruned. Children of already-built nodes are scanned too, except a link's.
  */
 export function scanGfmAutolinks(ctx) {
-    const matches = spliceBareAutolinks(ctx.raw, ctx.nodes);
+    const matches = spliceBareAutolinks(ctx.raw, ctx.start, ctx.nodes, 0);
     if (matches.length > 0) {
         ctx.delimiters = ctx.delimiters.filter((d) => !meetsAMatch(matches, d.node.start, d.node.end));
     }
-    scanChildren(ctx.raw, ctx.nodes);
+    scanChildren(ctx.raw, ctx.start, ctx.nodes);
 }
 /** Matches are disjoint and ascending; the linear alternative is quadratic on a dense block. */
 function meetsAMatch(matches, start, end) {
@@ -146,25 +150,29 @@ function meetsAMatch(matches, start, end) {
     }
     return lo < matches.length && matches[lo].start < end;
 }
-function scanChildren(raw, nodes) {
+function scanChildren(raw, scanStart, nodes) {
     // Iterative: nesting depth is input-controlled, so per-level recursion overflows the stack.
     const pending = [nodes];
     while (pending.length > 0) {
         for (const node of pending.pop()) {
+            // Text inside a link never becomes a nested link, as in cmark-gfm; inline and
+            // reference links are both built before this pass, so both skip here.
+            if (node.kind === 'link')
+                continue;
             if (node.children !== undefined && node.children.length > 0) {
-                spliceBareAutolinks(raw, node.children);
+                // An image's alt sits inside its own open bracket.
+                spliceBareAutolinks(raw, scanStart, node.children, node.kind === 'image' ? 1 : 0);
                 pending.push(node.children);
             }
         }
     }
 }
-/**
- * The replacement is accumulated and written back rather than spliced per run: spreading a match
- * array as call arguments hits V8's argument limit past ~65k matches, and the block never heals.
- */
-function spliceBareAutolinks(raw, nodes) {
+/** Written back once rather than spliced per run, since spreading ~65k matches as arguments hits
+ *  V8's argument limit. `openBrackets` counts the `[` still open where `nodes` start. */
+function spliceBareAutolinks(raw, scanStart, nodes, openBrackets) {
     const all = [];
     const rebuilt = [];
+    const brackets = { open: openBrackets };
     let i = 0;
     while (i < nodes.length) {
         if (nodes[i].kind !== 'text') {
@@ -175,7 +183,7 @@ function spliceBareAutolinks(raw, nodes) {
         let j = i;
         while (j + 1 < nodes.length && nodes[j + 1].kind === 'text')
             j++;
-        const matches = scanRunForBareAutolinks(raw, nodes[i].start, nodes[j].end);
+        const matches = scanRunForBareAutolinks(raw, scanStart, nodes[i].start, nodes[j].end, brackets);
         if (matches.length === 0) {
             for (let k = i; k <= j; k++)
                 rebuilt.push(nodes[k]);
@@ -229,20 +237,31 @@ function spliceRun(raw, runNodes, matches) {
     }
     return out;
 }
-function scanRunForBareAutolinks(raw, start, end) {
+/** As in cmark-gfm, the www and url forms match only where no `[` is open, while the email form
+ *  matches anywhere. `brackets.open` carries that count from one run to the next. */
+function scanRunForBareAutolinks(raw, scanStart, start, end, brackets) {
     const out = [];
     let pos = start;
+    // The email form walks backwards from its `@`, so it must stop where the last link ended.
+    let claimedEnd = start;
     while (pos < end) {
         const ch = raw[pos];
         let matched = null;
-        if (ch === 'h' || ch === 'H')
-            matched = matchBareHttpAutolink(raw, pos, start, end);
-        else if (ch === 'w' || ch === 'W')
-            matched = matchBareWwwAutolink(raw, pos, start, end);
+        if (ch === '[')
+            brackets.open++;
+        else if (ch === ']')
+            brackets.open = Math.max(0, brackets.open - 1);
         else if (ch === '@')
-            matched = matchBareEmailAutolink(raw, pos, start, end);
+            matched = matchBareEmailAutolink(raw, pos, scanStart, end, claimedEnd);
+        else if (brackets.open === 0) {
+            if (ch === 'h' || ch === 'H')
+                matched = matchBareHttpAutolink(raw, pos, scanStart, end);
+            else if (ch === 'w' || ch === 'W')
+                matched = matchBareWwwAutolink(raw, pos, scanStart, end);
+        }
         if (matched !== null) {
             out.push(matched);
+            claimedEnd = matched.end;
             pos = matched.end;
             continue;
         }
@@ -264,15 +283,13 @@ function matchesCI(raw, pos, lit) {
     }
     return true;
 }
-function matchBareHttpAutolink(raw, pos, regionStart, end) {
-    if (!isValidLeadingBoundary(raw, pos, regionStart))
+function matchBareHttpAutolink(raw, pos, scanStart, end) {
+    if (!isValidLeadingBoundary(raw, pos, scanStart))
         return null;
     const schemeLen = matchesCI(raw, pos, 'https://') ? 8 : matchesCI(raw, pos, 'http://') ? 7 : 0;
     if (schemeLen === 0)
         return null;
-    let urlEnd = pos + schemeLen;
-    while (urlEnd < end && !/\s/.test(raw[urlEnd]))
-        urlEnd++;
+    let urlEnd = urlRunEnd(raw, pos + schemeLen, end);
     if (urlEnd <= pos + schemeLen)
         return null;
     urlEnd = trimTrailingPunctuation(raw, pos, urlEnd);
@@ -282,19 +299,17 @@ function matchBareHttpAutolink(raw, pos, regionStart, end) {
         return null;
     return { kind: 'autolink', start: pos, end: urlEnd, url: raw.slice(pos, urlEnd) };
 }
-function matchBareWwwAutolink(raw, pos, regionStart, end) {
-    if (!isValidLeadingBoundary(raw, pos, regionStart))
+function matchBareWwwAutolink(raw, pos, scanStart, end) {
+    if (!isValidLeadingBoundary(raw, pos, scanStart))
         return null;
     if (!matchesCI(raw, pos, 'www.'))
         return null;
-    let urlEnd = pos + 4;
-    while (urlEnd < end && !/\s/.test(raw[urlEnd]))
-        urlEnd++;
+    let urlEnd = urlRunEnd(raw, pos + 4, end);
     if (urlEnd <= pos + 4)
         return null;
     urlEnd = trimTrailingPunctuation(raw, pos, urlEnd);
-    // `.` is trailing punctuation, so the trim can cross the `www.` prefix and leave a bare
-    // `www`, a live link to a host the user never wrote. Hence at-or-below floor checks here.
+    // `.` is trailing punctuation, so the trim can cut into `www.` and leave a bare `www`, a
+    // link to a host the user never wrote; the check below refuses that.
     if (urlEnd <= pos + 4)
         return null;
     if (!hasValidDomain(raw, pos, urlEnd))
@@ -307,13 +322,9 @@ const EMAIL_LOCAL = /[A-Za-z0-9._+-]/;
 const EMAIL_DOMAIN_CHAR = /[A-Za-z0-9_-]/;
 const EMAIL_LABEL_START = /[A-Za-z0-9]/;
 const EMAIL_DOMAIN_END = /[A-Za-z]/;
-/**
- * The email domain per GFM §6.9: alphanumerics/`-`/`_` separated by periods, at least one
- * period, no `-`/`_` at the end. Past that prose the rule is cmark-gfm's: the last character
- * must be a LETTER, and a `.` separates labels only when an alphanumeric follows (`a@b._c` and
- * `a@b.c1` stay literal; `a@.b` is accepted). Returns the domain end, or -1.
- */
-function scanEmailDomain(raw, domainStart, regionEnd) {
+/** GFM §6.9's email domain plus cmark-gfm's rules: it ends in a letter, and a `.` separates labels
+ *  only before an alphanumeric (`a@b._c` is literal). An xmpp address may hold `/`. -1 if none. */
+function scanEmailDomain(raw, domainStart, regionEnd, allowsResource) {
     let end = domainStart;
     let separators = 0;
     while (end < regionEnd) {
@@ -323,7 +334,7 @@ function scanEmailDomain(raw, domainStart, regionEnd) {
                 break;
             separators++;
         }
-        else if (!EMAIL_DOMAIN_CHAR.test(ch)) {
+        else if (!EMAIL_DOMAIN_CHAR.test(ch) && !(allowsResource && ch === '/')) {
             break;
         }
         end++;
@@ -333,22 +344,32 @@ function scanEmailDomain(raw, domainStart, regionEnd) {
     // The walk stops before any `.` it did not count, so `end - 1` is a domain character.
     return EMAIL_DOMAIN_END.test(raw[end - 1]) ? end : -1;
 }
-function matchBareEmailAutolink(raw, atPos, regionStart, regionEnd) {
+/** The scheme a bare address may carry in front of its local part, matched byte for byte and
+ *  lowercase only, as cmark-gfm matches it. */
+const EMAIL_PREFIXES = ['mailto:', 'xmpp:'];
+function emailPrefixBefore(raw, localStart, floor) {
+    return EMAIL_PREFIXES.find((prefix) => localStart - prefix.length >= floor && raw.startsWith(prefix, localStart - prefix.length));
+}
+/** `claimedEnd` is where the last link in this run ended: no byte before it can join this one. */
+function matchBareEmailAutolink(raw, atPos, scanStart, regionEnd, claimedEnd) {
     let localStart = atPos;
-    while (localStart > regionStart && EMAIL_LOCAL.test(raw[localStart - 1]))
+    while (localStart > claimedEnd && EMAIL_LOCAL.test(raw[localStart - 1]))
         localStart--;
     if (localStart === atPos)
-        return null; // empty local-part
-    // The boundary applies at the URL's start, which for email is the local-part start.
-    if (!isValidLeadingBoundary(raw, localStart, regionStart))
         return null;
-    const domainEnd = scanEmailDomain(raw, atPos + 1, regionEnd);
+    const prefix = emailPrefixBefore(raw, localStart, claimedEnd);
+    const linkStart = localStart - (prefix?.length ?? 0);
+    // The boundary applies at the URL's start: the prefix when there is one, else the local part.
+    if (!isValidLeadingBoundary(raw, linkStart, scanStart))
+        return null;
+    const domainEnd = scanEmailDomain(raw, atPos + 1, regionEnd, prefix === 'xmpp:');
     if (domainEnd < 0)
         return null;
+    const text = raw.slice(linkStart, domainEnd);
     return {
         kind: 'autolink',
-        start: localStart,
+        start: linkStart,
         end: domainEnd,
-        url: `mailto:${raw.slice(localStart, domainEnd)}`
+        url: prefix ? text : `mailto:${text}`
     };
 }

package/dist/core/inline/scan/brackets.d.ts

@@ -2,8 +2,8 @@
  * Bracket stack for inline and reference links/images (CommonMark §6.3), ported onto the flat
  * working-node list. A failed `]` leaves its brackets literal, except full/collapsed references
  * that miss the resolver: those commit to one opaque `unresolvedReference` node (editor deviation).
- * `url`/`title` are spec-processed for inline forms and byte-exact from the resolver for reference
- * forms; neither is ever serialized, so offsets stay lossless.
+ * `url`/`title` are spec-processed in both forms (a reference form's come from its definition);
+ * neither is ever serialized, so offsets stay lossless.
  */
 import { type ScanContext } from './scan-state';
 export declare function handleOpenBracket(ctx: ScanContext): void;

package/dist/core/inline/scan/brackets.js

@@ -2,15 +2,14 @@
  * Bracket stack for inline and reference links/images (CommonMark §6.3), ported onto the flat
  * working-node list. A failed `]` leaves its brackets literal, except full/collapsed references
  * that miss the resolver: those commit to one opaque `unresolvedReference` node (editor deviation).
- * `url`/`title` are spec-processed for inline forms and byte-exact from the resolver for reference
- * forms; neither is ever serialized, so offsets stay lossless.
+ * `url`/`title` are spec-processed in both forms (a reference form's come from its definition);
+ * neither is ever serialized, so offsets stay lossless.
  */
-import { ESCAPABLE_PUNCTUATION } from '../../escapable';
 import { parseImageDimensions } from '../image-dimensions';
+import { parseLinkDestination, parseLinkLabel, parseLinkTitle } from '../link-destination';
 import { normalizeLinkLabel } from '../link-reference-resolver';
 import { processEmphasis } from './emphasis';
 import { appendNode, flushPendingText, mergeAdjacentText } from './scan-state';
-import { processDestination, unescapeSpecString } from './url';
 // ── Scan-time handlers ──────────────────────────────────────────────────────
 export function handleOpenBracket(ctx) {
     pushBracket(ctx, false);
@@ -139,21 +138,6 @@ function parseReferenceTail(ctx, bracket, labelEnd) {
         return null; // shortcut never commits on a miss
     return { label: normalizeLinkLabel(rawLabel), end: afterText, resolved };
 }
-/** CommonMark §6.3 label: at most 999 content chars, no unescaped brackets. */
-function parseLinkLabel(raw, pos, end) {
-    if (pos >= end || raw[pos] !== '[')
-        return null;
-    let i = pos + 1;
-    while (i < end && i - pos <= 1000) {
-        const ch = raw[i];
-        if (ch === ']')
-            return i + 1;
-        if (ch === '[')
-            return null;
-        i += ch === '\\' ? 2 : 1;
-    }
-    return null;
-}
 function emitUnresolvedReference(ctx, bracket, ref) {
     ctx.brackets.pop();
     ctx.delimiters.length = bracket.delimiterFloor;
@@ -174,14 +158,14 @@ function parseInlineLinkTail(raw, pos, end) {
     if (pos >= end || raw[pos] !== '(')
         return null;
     let i = skipSpnl(raw, pos + 1, end);
-    const dest = parseDestination(raw, i, end);
+    const dest = parseLinkDestination(raw, i, end);
     if (dest === null)
         return null;
     i = skipSpnl(raw, dest.end, end);
     // A title needs real whitespace after the destination; a quote abutting it is destination content.
     let title;
     if (i > dest.end) {
-        const parsed = parseTitle(raw, i, end);
+        const parsed = parseLinkTitle(raw, i, end);
         if (parsed !== null) {
             title = parsed.title;
             i = skipSpnl(raw, parsed.end, end);
@@ -191,7 +175,7 @@ function parseInlineLinkTail(raw, pos, end) {
         return null;
     return { url: dest.url, ...(title !== undefined ? { title } : {}), end: i + 1 };
 }
-/** The reference's spnl: spaces, at most one newline, spaces — tabs excluded. */
+/** commonmark.js's optional whitespace: spaces, at most one newline, spaces, but no tab. */
 function skipSpnl(raw, pos, end) {
     while (pos < end && raw[pos] === ' ')
         pos++;
@@ -202,84 +186,3 @@ function skipSpnl(raw, pos, end) {
     }
     return pos;
 }
-function parseDestination(raw, pos, end) {
-    if (pos < end && raw[pos] === '<')
-        return parseAngleDestination(raw, pos, end);
-    return parseBareDestination(raw, pos, end);
-}
-function parseAngleDestination(raw, pos, end) {
-    let i = pos + 1;
-    while (i < end) {
-        const ch = raw[i];
-        if (ch === '>')
-            return { url: processDestination(raw.slice(pos + 1, i)), end: i + 1 };
-        if (ch === '<' || ch === '\n' || ch === '\u0000')
-            return null;
-        if (ch === '\\') {
-            const next = i + 1 < end ? raw[i + 1] : '';
-            if (next === '' || next === '\n' || next === '\r' || next === '\u2028' || next === '\u2029') {
-                return null;
-            }
-            i += 2;
-        }
-        else {
-            i++;
-        }
-    }
-    return null;
-}
-// The reference's destination terminator set (reWhitespaceChar): other control characters,
-// and U+00A0, are destination content.
-const DESTINATION_TERMINATORS = new Set(' \t\n\u000b\u000c\r');
-/** Bare form: balanced parens, no depth cap. Empty is valid only just before the closing `)`. */
-function parseBareDestination(raw, pos, end) {
-    let i = pos;
-    let openParens = 0;
-    while (i < end) {
-        const ch = raw[i];
-        if (ch === '\\' && i + 1 < end && ESCAPABLE_PUNCTUATION.has(raw[i + 1])) {
-            i += 2;
-        }
-        else if (ch === '(') {
-            openParens++;
-            i++;
-        }
-        else if (ch === ')') {
-            if (openParens < 1)
-                break;
-            openParens--;
-            i++;
-        }
-        else if (DESTINATION_TERMINATORS.has(ch)) {
-            break;
-        }
-        else {
-            i++;
-        }
-    }
-    if (i === pos && (i >= end || raw[i] !== ')'))
-        return null;
-    if (openParens !== 0)
-        return null;
-    return { url: processDestination(raw.slice(pos, i)), end: i };
-}
-/** Paren titles cannot nest. */
-function parseTitle(raw, pos, end) {
-    const marker = raw[pos];
-    if (marker !== '"' && marker !== "'" && marker !== '(')
-        return null;
-    const close = marker === '(' ? ')' : marker;
-    let i = pos + 1;
-    while (i < end) {
-        const ch = raw[i];
-        if (ch === close)
-            return { title: unescapeSpecString(raw.slice(pos + 1, i)), end: i + 1 };
-        if (ch === '\u0000' || (marker === '(' && ch === '('))
-            return null;
-        if (ch === '\\' && i + 1 < end)
-            i += 2;
-        else
-            i++;
-    }
-    return null;
-}

package/dist/core/inline/scan/code-spans.d.ts

@@ -3,5 +3,9 @@
  * plus content; `text` holds raw content bytes, unfolded (display folding is the normalizer's).
  * An unmatched run stays whole in the pending text, so an inner backtick is never retried.
  */
+import type { InlineNode } from '../../nodes';
 import { type ScanContext } from './scan-state';
+/** The width of each of a code span's two equal delimiter runs, which every caller places the
+ *  content by; 0 when the bytes outside `text` don't split evenly, so the node is all content. */
+export declare function codeSpanFence(node: InlineNode): number;
 export declare function handleBacktick(ctx: ScanContext): void;

package/dist/core/inline/scan/code-spans.js

@@ -5,6 +5,14 @@
  */
 import { findBacktickCloser, indexBacktickRuns } from '../backticks';
 import { appendNode } from './scan-state';
+/** The width of each of a code span's two equal delimiter runs, which every caller places the
+ *  content by; 0 when the bytes outside `text` don't split evenly, so the node is all content. */
+export function codeSpanFence(node) {
+    if (node.text === undefined)
+        return 0;
+    const fence = (node.end - node.start - node.text.length) / 2;
+    return Number.isInteger(fence) && fence > 0 ? fence : 0;
+}
 export function handleBacktick(ctx) {
     const { raw, pos, end } = ctx;
     let runEnd = pos;