@voithos-labs/aragonite 0.10.1

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

@@ -0,0 +1,23 @@
+/**
+ * `<` 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.
+ */
+import { type ScanContext } from './scan-state';
+/**
+ * GFM §6.9 trailing-punctuation trim. `)` goes only when unbalanced; `;` normally stays, but an
+ * 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;
+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.
+ */
+export declare function scanGfmAutolinks(ctx: ScanContext): void;

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

@@ -0,0 +1,354 @@
+/**
+ * `<` 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.
+ */
+import { matchHtmlFormAt } from '../html-tag-grammar';
+import { appendNode } from './scan-state';
+import { percentEncodeUri } from './url';
+// ── GFM §6.9 boundary and trim rules ────────────────────────────────────────
+const TRAILING_PUNCT = new Set(['?', '!', '.', ',', ':', '*', '_', '~']);
+/**
+ * GFM §6.9 trailing-punctuation trim. `)` goes only when unbalanced; `;` normally stays, but an
+ * entity-shaped tail (`&` + alphanumerics + `;`) is excluded with its `&` (spec ex. 626).
+ */
+export function trimTrailingPunctuation(raw, urlStart, urlEnd) {
+    // Parens counted once and the balance maintained while trimming: a recount per
+    // trimmed `)` makes paren floods quadratic.
+    let opens = 0;
+    let closes = 0;
+    for (let i = urlStart; i < urlEnd; i++) {
+        if (raw[i] === '(')
+            opens++;
+        else if (raw[i] === ')')
+            closes++;
+    }
+    let end = urlEnd;
+    while (end > urlStart) {
+        const ch = raw[end - 1];
+        if (TRAILING_PUNCT.has(ch)) {
+            end--;
+            continue;
+        }
+        if (ch === ')') {
+            if (closes > opens) {
+                end--;
+                closes--;
+                continue;
+            }
+            break;
+        }
+        if (ch === ';') {
+            let j = end - 2;
+            while (j > urlStart && /[A-Za-z0-9]/.test(raw[j]))
+                j--;
+            if (j >= urlStart && raw[j] === '&' && j < end - 2) {
+                end = j;
+                continue;
+            }
+            break;
+        }
+        break;
+    }
+    return end;
+}
+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).
+ */
+function hasValidDomain(raw, domainStart, limit) {
+    let hostEnd = domainStart;
+    while (hostEnd < limit && HOST_CHAR.test(raw[hostEnd]))
+        hostEnd++;
+    let dotsSeen = 0;
+    let i = hostEnd;
+    while (i > domainStart && dotsSeen < 2) {
+        i--;
+        if (raw[i] === '.')
+            dotsSeen++;
+        else if (raw[i] === '_')
+            return false;
+    }
+    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)
+        return true;
+    const ch = raw[pos - 1];
+    return /\s/.test(ch) || ch === '*' || ch === '_' || ch === '~' || ch === '(';
+}
+// ── `<` handler: spec autolink, then raw HTML tag ───────────────────────────
+// commonmark.js 0.31.2 reEmailAutolink / reAutolink, tried in that order.
+const EMAIL_AUTOLINK = /^<([a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*)>/;
+// eslint-disable-next-line no-control-regex -- commonmark reAutolink excludes control chars + space from the URI
+const URI_AUTOLINK = /^<[A-Za-z][A-Za-z0-9.+-]{1,31}:[^<>\x00-\x20]*>/;
+export function handleAngle(ctx) {
+    const node = matchAngleConstruct(ctx.raw, ctx.pos, ctx.end);
+    if (node !== null)
+        appendNode(ctx, node);
+    else
+        ctx.pos++;
+}
+function matchAngleConstruct(raw, pos, end) {
+    const ahead = raw.slice(pos, end);
+    const email = EMAIL_AUTOLINK.exec(ahead);
+    if (email !== null) {
+        return {
+            kind: 'autolink',
+            start: pos,
+            end: pos + email[0].length,
+            url: percentEncodeUri('mailto:' + email[1])
+        };
+    }
+    const uri = URI_AUTOLINK.exec(ahead);
+    if (uri !== null) {
+        return {
+            kind: 'autolink',
+            start: pos,
+            end: pos + uri[0].length,
+            url: percentEncodeUri(uri[0].slice(1, -1))
+        };
+    }
+    const tag = matchHtmlFormAt(raw, pos, end);
+    if (tag !== null)
+        return { kind: 'rawHtml', start: pos, end: pos + tag.length };
+    return null;
+}
+// ── 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.
+ */
+export function scanGfmAutolinks(ctx) {
+    const matches = spliceBareAutolinks(ctx.raw, ctx.nodes);
+    if (matches.length > 0) {
+        ctx.delimiters = ctx.delimiters.filter((d) => !meetsAMatch(matches, d.node.start, d.node.end));
+    }
+    scanChildren(ctx.raw, ctx.nodes);
+}
+/** Matches are disjoint and ascending; the linear alternative is quadratic on a dense block. */
+function meetsAMatch(matches, start, end) {
+    let lo = 0;
+    let hi = matches.length;
+    while (lo < hi) {
+        const mid = (lo + hi) >>> 1;
+        if (matches[mid].end <= start)
+            lo = mid + 1;
+        else
+            hi = mid;
+    }
+    return lo < matches.length && matches[lo].start < end;
+}
+function scanChildren(raw, 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()) {
+            if (node.children !== undefined && node.children.length > 0) {
+                spliceBareAutolinks(raw, node.children);
+                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) {
+    const all = [];
+    const rebuilt = [];
+    let i = 0;
+    while (i < nodes.length) {
+        if (nodes[i].kind !== 'text') {
+            rebuilt.push(nodes[i]);
+            i++;
+            continue;
+        }
+        let j = i;
+        while (j + 1 < nodes.length && nodes[j + 1].kind === 'text')
+            j++;
+        const matches = scanRunForBareAutolinks(raw, nodes[i].start, nodes[j].end);
+        if (matches.length === 0) {
+            for (let k = i; k <= j; k++)
+                rebuilt.push(nodes[k]);
+        }
+        else {
+            for (const match of matches)
+                all.push(match);
+            for (const node of spliceRun(raw, nodes.slice(i, j + 1), matches))
+                rebuilt.push(node);
+        }
+        i = j + 1;
+    }
+    // In place: the working list is held by identity (ctx.nodes, a parent's children).
+    if (all.length > 0) {
+        nodes.length = 0;
+        for (const node of rebuilt)
+            nodes.push(node);
+    }
+    return all;
+}
+/**
+ * Untouched text nodes keep their identity: live delimiters reference their run node by object,
+ * so only nodes overlapping a match may be re-cut (their delimiters having been pruned).
+ */
+function spliceRun(raw, runNodes, matches) {
+    const runEnd = runNodes[runNodes.length - 1].end;
+    const out = [];
+    let cursor = runNodes[0].start;
+    let k = 0;
+    let mi = 0;
+    while (cursor < runEnd) {
+        if (mi < matches.length && matches[mi].start === cursor) {
+            out.push(matches[mi]);
+            cursor = matches[mi].end;
+            mi++;
+            continue;
+        }
+        while (runNodes[k].end <= cursor)
+            k++;
+        const node = runNodes[k];
+        const boundary = mi < matches.length ? matches[mi].start : runEnd;
+        if (node.start === cursor && node.end <= boundary) {
+            out.push(node);
+            cursor = node.end;
+        }
+        else {
+            const sliceEnd = Math.min(node.end, boundary);
+            out.push({ kind: 'text', start: cursor, end: sliceEnd, text: raw.slice(cursor, sliceEnd) });
+            cursor = sliceEnd;
+        }
+    }
+    return out;
+}
+function scanRunForBareAutolinks(raw, start, end) {
+    const out = [];
+    let pos = 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);
+        else if (ch === '@')
+            matched = matchBareEmailAutolink(raw, pos, start, end);
+        if (matched !== null) {
+            out.push(matched);
+            pos = matched.end;
+            continue;
+        }
+        pos++;
+    }
+    return out;
+}
+// ── GFM bare/www/email matchers ─────────────────────────────────────────────
+/**
+ * `lit` is lowercase. Folds letters only: a blind `| 0x20` would let control characters alias
+ * punctuation (0x0E | 0x20 is `.`).
+ */
+function matchesCI(raw, pos, lit) {
+    for (let i = 0; i < lit.length; i++) {
+        const code = raw.charCodeAt(pos + i);
+        const lower = lit.charCodeAt(i);
+        if (code !== lower && !(lower >= 0x61 && lower <= 0x7a && code === lower - 0x20))
+            return false;
+    }
+    return true;
+}
+function matchBareHttpAutolink(raw, pos, regionStart, end) {
+    if (!isValidLeadingBoundary(raw, pos, regionStart))
+        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++;
+    if (urlEnd <= pos + schemeLen)
+        return null;
+    urlEnd = trimTrailingPunctuation(raw, pos, urlEnd);
+    if (urlEnd <= pos + schemeLen)
+        return null;
+    if (!hasValidDomain(raw, pos + schemeLen, urlEnd))
+        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))
+        return null;
+    if (!matchesCI(raw, pos, 'www.'))
+        return null;
+    let urlEnd = pos + 4;
+    while (urlEnd < end && !/\s/.test(raw[urlEnd]))
+        urlEnd++;
+    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.
+    if (urlEnd <= pos + 4)
+        return null;
+    if (!hasValidDomain(raw, pos, urlEnd))
+        return null;
+    // GFM §6.9: a www autolink carries no scheme in its bytes. The raw span stays verbatim;
+    // only the derived href gains `http://`, exactly as email prepends `mailto:`.
+    return { kind: 'autolink', start: pos, end: urlEnd, url: 'http://' + raw.slice(pos, urlEnd) };
+}
+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) {
+    let end = domainStart;
+    let separators = 0;
+    while (end < regionEnd) {
+        const ch = raw[end];
+        if (ch === '.') {
+            if (end + 1 >= regionEnd || !EMAIL_LABEL_START.test(raw[end + 1]))
+                break;
+            separators++;
+        }
+        else if (!EMAIL_DOMAIN_CHAR.test(ch)) {
+            break;
+        }
+        end++;
+    }
+    if (separators === 0)
+        return -1;
+    // 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) {
+    let localStart = atPos;
+    while (localStart > regionStart && 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);
+    if (domainEnd < 0)
+        return null;
+    return {
+        kind: 'autolink',
+        start: localStart,
+        end: domainEnd,
+        url: `mailto:${raw.slice(localStart, domainEnd)}`
+    };
+}

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

@@ -0,0 +1,11 @@
+/**
+ * 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.
+ */
+import { type ScanContext } from './scan-state';
+export declare function handleOpenBracket(ctx: ScanContext): void;
+export declare function handleBang(ctx: ScanContext): void;
+export declare function handleCloseBracket(ctx: ScanContext): void;

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

@@ -0,0 +1,284 @@
+/**
+ * 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.
+ */
+import { ESCAPABLE_PUNCTUATION } from '../../escapable';
+import { parseImageDimensions } from '../image-dimensions';
+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);
+}
+export function handleBang(ctx) {
+    if (ctx.pos + 1 < ctx.end && ctx.raw[ctx.pos + 1] === '[')
+        pushBracket(ctx, true);
+    else
+        ctx.pos++;
+}
+function pushBracket(ctx, isImage) {
+    const start = ctx.pos;
+    const end = start + (isImage ? 2 : 1);
+    appendNode(ctx, { kind: 'text', start, end, text: ctx.raw.slice(start, end) });
+    const enclosing = ctx.brackets[ctx.brackets.length - 1];
+    if (enclosing !== undefined)
+        enclosing.bracketAfter = true;
+    ctx.brackets.push({
+        nodeIndex: ctx.nodes.length - 1,
+        isImage,
+        active: true,
+        bracketAfter: false,
+        delimiterFloor: ctx.delimiters.length
+    });
+}
+export function handleCloseBracket(ctx) {
+    const bracket = ctx.brackets[ctx.brackets.length - 1];
+    if (bracket === undefined) {
+        ctx.pos++;
+        return;
+    }
+    if (!bracket.active) {
+        ctx.brackets.pop();
+        ctx.pos++;
+        return;
+    }
+    const labelEnd = ctx.pos;
+    const inline = parseInlineLinkTail(ctx.raw, labelEnd + 1, ctx.end);
+    if (inline !== null) {
+        wrapMatchedBracket(ctx, bracket, labelEnd, inline);
+        return;
+    }
+    const ref = parseReferenceTail(ctx, bracket, labelEnd);
+    if (ref === null) {
+        ctx.brackets.pop();
+        ctx.pos++;
+        return;
+    }
+    if (ref.resolved === undefined) {
+        emitUnresolvedReference(ctx, bracket, ref);
+        return;
+    }
+    wrapMatchedBracket(ctx, bracket, labelEnd, {
+        url: ref.resolved.url,
+        ...(ref.resolved.title !== undefined ? { title: ref.resolved.title } : {}),
+        label: ref.label,
+        end: ref.end
+    });
+}
+function wrapMatchedBracket(ctx, bracket, labelEnd, target) {
+    ctx.brackets.pop();
+    flushPendingText(ctx, labelEnd);
+    processEmphasis(ctx, bracket.delimiterFloor);
+    const opener = ctx.nodes[bracket.nodeIndex];
+    const children = mergeAdjacentText(ctx.nodes.splice(bracket.nodeIndex + 1));
+    ctx.nodes[bracket.nodeIndex] = bracket.isImage
+        ? buildImage(ctx.raw, opener, labelEnd, target, children)
+        : buildLink(opener, target, children);
+    ctx.pos = target.end;
+    ctx.textStart = target.end;
+    // §6.3 no links inside links: a matched link deactivates enclosing link openers, not images.
+    if (!bracket.isImage) {
+        for (const open of ctx.brackets) {
+            if (!open.isImage)
+                open.active = false;
+        }
+    }
+}
+function buildLink(opener, target, children) {
+    return {
+        kind: 'link',
+        start: opener.start,
+        end: target.end,
+        children,
+        url: target.url,
+        ...(target.title !== undefined ? { title: target.title } : {}),
+        ...(target.label !== undefined ? { label: target.label } : {})
+    };
+}
+function buildImage(raw, opener, labelEnd, target, children) {
+    const dims = parseImageDimensions(raw.slice(opener.end, labelEnd));
+    return {
+        kind: 'image',
+        start: opener.start,
+        end: target.end,
+        children,
+        alt: dims.displayAlt,
+        url: target.url,
+        ...(target.title !== undefined ? { title: target.title } : {}),
+        ...(dims.width !== undefined ? { width: dims.width } : {}),
+        ...(dims.height !== undefined ? { height: dims.height } : {}),
+        ...(target.label !== undefined ? { label: target.label } : {})
+    };
+}
+function parseReferenceTail(ctx, bracket, labelEnd) {
+    const { raw, end, resolver } = ctx;
+    if (resolver === undefined)
+        return null;
+    const afterText = labelEnd + 1;
+    const secondEnd = parseLinkLabel(raw, afterText, end);
+    if (secondEnd !== null && secondEnd > afterText + 2) {
+        const rawLabel = raw.slice(afterText + 1, secondEnd - 1);
+        return { label: normalizeLinkLabel(rawLabel), end: secondEnd, resolved: resolver(rawLabel) };
+    }
+    // Collapsed/shortcut reuse the link text as label, and a bracket opened inside it can never
+    // be part of a valid label, so skip the lookup outright (the reference's bracketAfter guard).
+    if (bracket.bracketAfter)
+        return null;
+    const rawLabel = raw.slice(ctx.nodes[bracket.nodeIndex].end, labelEnd);
+    if (secondEnd !== null) {
+        return { label: normalizeLinkLabel(rawLabel), end: secondEnd, resolved: resolver(rawLabel) };
+    }
+    const resolved = resolver(rawLabel);
+    if (resolved === undefined)
+        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;
+    const start = ctx.nodes[bracket.nodeIndex].start;
+    ctx.nodes.length = bracket.nodeIndex;
+    ctx.nodes.push({
+        kind: 'unresolvedReference',
+        start,
+        end: ref.end,
+        label: ref.label,
+        refKind: bracket.isImage ? 'image' : 'link'
+    });
+    ctx.pos = ref.end;
+    ctx.textStart = ref.end;
+}
+// ── Inline-link tail: "(" destination title? ")" ────────────────────────────
+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);
+    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);
+        if (parsed !== null) {
+            title = parsed.title;
+            i = skipSpnl(raw, parsed.end, end);
+        }
+    }
+    if (i >= end || raw[i] !== ')')
+        return null;
+    return { url: dest.url, ...(title !== undefined ? { title } : {}), end: i + 1 };
+}
+/** The reference's spnl: spaces, at most one newline, spaces — tabs excluded. */
+function skipSpnl(raw, pos, end) {
+    while (pos < end && raw[pos] === ' ')
+        pos++;
+    if (pos < end && raw[pos] === '\n') {
+        pos++;
+        while (pos < end && raw[pos] === ' ')
+            pos++;
+    }
+    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

@@ -0,0 +1,7 @@
+/**
+ * Backtick handler over the shared run index in ../backticks.ts. A matched span covers fences
+ * 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 ScanContext } from './scan-state';
+export declare function handleBacktick(ctx: ScanContext): void;