@heroiclands/package-build 25.3.0 → 25.5.0

package/engine/content-scripts.mjs

@@ -45,6 +45,7 @@ import { blockTokens } from "./markdown-blocks.mjs";
 import { scanBlocks, BLOCK_CONTAINERS } from "./content-blocks.mjs";
 import { scanVerse } from "./content-verse.mjs";
 import { scanSpans } from "./content-spans.mjs";
+import { footnoteLabels, footnoteReferences } from "./content-footnotes.mjs";
 import { scanScrolls, scrollParagraphs } from "./content-scroll.mjs";
 import { directionsFromRecords } from "./script-direction.mjs";
 import { isLanguageTag } from "./language-tag.mjs";
@@ -126,7 +127,7 @@ const CONFIG = "package-build.config.yaml";
  */
 
 /**
- * One span, div, verse fence or scroll fence carrying run attributes.
+ * One span, div, verse div or scroll fence carrying run attributes.
  * Values combine explicit choices, class-only inheritance, encoding-document
  * language/font defaults and the Roman default encoding.
  *
@@ -232,7 +233,7 @@ function withinOneEdit(a, b) {
 }
 
 /** The word each construct is called in a finding. */
-const CONSTRUCT = Object.freeze({ span: "span", block: "div", verse: "verse fence" });
+const CONSTRUCT = Object.freeze({ span: "span", block: "div", verse: "verse div" });
 
 /** Line starts of a source, for offsets to positions. */
 function lineStarts(text) {
@@ -834,9 +835,7 @@ function analyseRuns(source, ctx, syntax) {
         );
     const errors = [];
     const warnings = [];
-    const footnotes = new Set(
-        [...text.matchAll(/^ {0,3}\[\^([^\]\s]+)\]:/gm)].map((match) => match[1]),
-    );
+    const footnotes = footnoteLabels(text);
     /** @param {{line: number, column: number}} at @param {string} message */
     const report = (at, message) => errors.push({ line: at.line, column: at.column, message });
     /** @param {Record<string, string>} values */
@@ -890,6 +889,7 @@ function analyseRuns(source, ctx, syntax) {
     const collect = (offset, body) => {
         const scanned = offset === 0 && syntax ? syntax(body).blocks : scanBlocks(body);
         for (const block of scanned.blocks) {
+            if (block.name === "verse" || block.classes?.includes("verse")) continue;
             const first = offset + block.start;
             const last = offset + block.end;
             const opening = lines[first];
@@ -911,7 +911,7 @@ function analyseRuns(source, ctx, syntax) {
                 for (const key of Object.keys(keys))
                     report(
                         at(key, "key"),
-                        `\`${key}=\` is read on a span, a div or a verse fence, not on a ${block.name} block`,
+                        `\`${key}=\` is read on a span, a div or a verse div, not on a ${block.name} block`,
                     );
             } else {
                 divs.set(first, block);
@@ -948,7 +948,6 @@ function analyseRuns(source, ctx, syntax) {
     for (const poem of scanVerse(text).blocks) {
         poems.set(poem.start, poem);
         const keys = runKeys(poem.attributes);
-        if (!Object.keys(keys).length && !poem.classes.includes(NATIVEFONT_CLASS)) continue;
         const opening = lines[poem.start];
         constructs.push({
             kind: "verse",
@@ -1196,10 +1195,35 @@ function analyseRuns(source, ctx, syntax) {
     }
 
     const verseMarkers = new Map();
-    const verseContexts = new Map();
-    for (const poem of scanVerse(text, { checkWorks: false }).blocks) {
-        for (let line = poem.start + 1; line < poem.end; line++) verseContexts.set(line, poem);
-        const bodyStart = starts[poem.start + 1];
+    const verseContexts = [
+        ...scanVerse(text, { checkWorks: false }).blocks,
+        ...spans
+            .filter((span) => span.verseModel)
+            .map((span) => ({
+                bodyStart: span.start + 1,
+                bodyEnd: span.contentEnd,
+                body: text.slice(span.start + 1, span.contentEnd),
+                model: span.verseModel,
+            })),
+    ];
+    // A reference with its own run keys is an independent child, just as
+    // the presentation span produced by the link resolver is. Keep its label
+    // out of the enclosing language and encoder without rewriting its target.
+    const independentReferences = rawReferences.filter(
+        (reference) =>
+            Object.keys(reference.construct.keys).length &&
+            verseContexts.some(
+                (poem) =>
+                    reference.where.start >= poem.bodyStart && reference.where.end <= poem.bodyEnd,
+            ),
+    );
+    const referenceSpans = independentReferences.map((reference) => ({
+        start: reference.where.start,
+        end: reference.where.end,
+        contentEnd: reference.to,
+    }));
+    for (const poem of verseContexts) {
+        const bodyStart = poem.bodyStart;
         for (const [from, to] of poem.model.layout)
             verseMarkers.set(bodyStart + from, bodyStart + to);
         for (const match of poem.body.matchAll(WIKILINK)) {
@@ -1227,11 +1251,7 @@ function analyseRuns(source, ctx, syntax) {
             if (poem.body[at] !== "[") continue;
             const end = closing(poem.body, at);
             if (end < 0) continue;
-            const label = poem.body.slice(at + 1, end);
-            if (/^\^[^\s\]]+$/.test(label) && footnotes.has(label.slice(1))) {
-                verseMarkers.set(bodyStart + at, bodyStart + end + 1);
-                at = end;
-            } else if (poem.body[end + 1] === "(" && poem.body[at - 1] !== "!") {
+            if (poem.body[end + 1] === "(" && poem.body[at - 1] !== "!") {
                 const past = closing(poem.body, end + 1);
                 if (past < 0) continue;
                 verseMarkers.set(bodyStart + at, bodyStart + at + 1);
@@ -1240,10 +1260,52 @@ function analyseRuns(source, ctx, syntax) {
         }
     }
 
+    const noteReferences = [
+        ...new Map(
+            [
+                ...footnoteReferences(text, { definitions: footnotes }),
+                ...spans.flatMap((span) => {
+                    const label = referenceLabel(span.text);
+                    if (!label) return [];
+                    const base = span.start + 1 + label[0];
+                    return footnoteReferences(span.text.slice(label[0], label[1]), {
+                        definitions: footnotes,
+                        inline: true,
+                    }).map((reference) => ({
+                        ...reference,
+                        from: base + reference.from,
+                        to: base + reference.to,
+                    }));
+                }),
+                ...verseContexts.flatMap((region) =>
+                    footnoteReferences(region.body, { definitions: footnotes, inline: true }).map(
+                        (reference) => ({
+                            ...reference,
+                            from: reference.from + region.bodyStart,
+                            to: reference.to + region.bodyStart,
+                        }),
+                    ),
+                ),
+            ].map((reference) => [reference.from, reference]),
+        ).values(),
+    ];
+
     /** Nested spans and verse markers excluded from a run, by absolute offset. */
     const holesIn = (from, to) =>
         new Map([
+            ...noteReferences
+                .filter((reference) => reference.from >= from && reference.from < to)
+                .map((reference) => [reference.from, reference.to]),
             ...[...verseMarkers].filter(([start]) => start >= from && start < to),
+            ...independentReferences
+                .filter((reference) => reference.where.start >= from && reference.where.start < to)
+                .map((reference) => [reference.where.start, reference.where.end]),
+            ...verseContexts
+                .filter(
+                    (region) =>
+                        Number.isFinite(region.from) && region.from >= from && region.from < to,
+                )
+                .map((region) => [region.from, Math.min(region.to, to)]),
             ...active
                 .filter(
                     (construct) =>
@@ -1406,6 +1468,7 @@ function analyseRuns(source, ctx, syntax) {
             selection: enc === undefined ? undefined : encodingFor(ctx, { enc, font, lang }),
             holes: new Map(),
             body: undefined,
+            verseModel: construct.kind === "span" ? construct.node.verseModel : undefined,
             contentEnd: construct.kind === "span" ? construct.node.contentEnd : undefined,
             reference: undefined,
             languageEmphasis: lang === undefined ? undefined : ctx.languageEmphases?.get(lang),
@@ -1416,7 +1479,10 @@ function analyseRuns(source, ctx, syntax) {
         detail.conventions = conventionsOf(detail, ctx);
         details.push(detail);
         const nonEnglishSpan =
-            construct.kind === "span" && run.tag !== undefined && !/^en(?:-|$)/i.test(run.tag);
+            construct.kind === "span" &&
+            !construct.node.verseModel &&
+            run.tag !== undefined &&
+            !/^en(?:-|$)/i.test(run.tag);
         const emphasis = construct.own.classes.filter(
             (name) => name === "emph" || name === "strong",
         );
@@ -1447,7 +1513,14 @@ function analyseRuns(source, ctx, syntax) {
                 [from, to] = detail.reference;
             }
             const inline = text.slice(from, to);
-            detail.holes = label ? new Map() : holesIn(from, to);
+            detail.holes =
+                label ?
+                    new Map(
+                        noteReferences
+                            .filter((reference) => reference.from >= from && reference.to <= to)
+                            .map((reference) => [reference.from, reference.to]),
+                    )
+                :   holesIn(from, to);
             if (nonEnglishSpan) {
                 const relative = new Map(
                     [...detail.holes].map(([from, to]) => [
@@ -1471,8 +1544,15 @@ function analyseRuns(source, ctx, syntax) {
 
         const first = construct.line0 + 1;
         const last = construct.last;
-        const from = starts[first] ?? text.length;
-        const to = last > first ? starts[last] - 1 : from;
+        // Verse regions retain authored UTF-16 bounds, including the full
+        // width of a CRLF terminator. A one-byte closing-line adjustment
+        // would leave CR outside the model and lose verse projection.
+        const from =
+            construct.kind === "verse" ? construct.node.bodyStart : (starts[first] ?? text.length);
+        const to =
+            construct.kind === "verse" ? construct.node.bodyEnd
+            : last > first ? starts[last] - 1
+            : from;
         detail.body = [from, to];
         detail.holes = holesIn(from, to);
 
@@ -1507,7 +1587,7 @@ function analyseRuns(source, ctx, syntax) {
                     said(
                         top,
                         token.info.trim().split(/\s/)[0] === "verse" ?
-                            "a verse fence"
+                            "a code fence named `verse`; write a `::: {.verse}` div"
                         :   "a code fence",
                     );
                 else if (Object.hasOwn(BLOCK_WHAT, token.type)) said(top, BLOCK_WHAT[token.type]);
@@ -1572,7 +1652,23 @@ function analyseRuns(source, ctx, syntax) {
         const owned = details.filter((detail) => ownerOf(detail) === owner);
         for (const detail of owned) detail.owner = owner;
         const excluded = [
-            ...[...verseMarkers].filter(([start]) => start >= bounds[0] && start < bounds[1]),
+            ...noteReferences
+                .filter((reference) => reference.from >= bounds[0] && reference.from < bounds[1])
+                .map((reference) => [reference.from, reference.to]),
+            ...[...verseMarkers].filter(
+                ([start]) =>
+                    start >= bounds[0] &&
+                    start < bounds[1] &&
+                    !referenceSpans.some((span) => start === span.start),
+            ),
+            ...verseContexts
+                .filter(
+                    (region) =>
+                        Number.isFinite(region.from) &&
+                        region.from >= bounds[0] &&
+                        region.from < bounds[1],
+                )
+                .map((region) => [region.from, Math.min(region.to, bounds[1])]),
             ...owned.flatMap((detail) =>
                 detail.emphasis.map((delimiter) => [
                     delimiter.offset,
@@ -1583,22 +1679,21 @@ function analyseRuns(source, ctx, syntax) {
         const projectionOptions = {
             from: bounds[0],
             to: bounds[1],
-            spans,
+            spans: [...spans, ...referenceSpans],
             exclude: excluded,
             includeSpan: (span) =>
                 spanDetails.has(span.start) && ownerOf(spanDetails.get(span.start)) === owner,
         };
-        const poem =
-            owner.run.kind === "verse" ?
-                poems.get(owner.run.start)
-            :   verseContexts.get(owner.run.line - 1);
+        const poem = verseContexts
+            .filter((region) => region.bodyStart <= bounds[0] && region.bodyEnd >= bounds[1])
+            .sort((a, b) => a.bodyEnd - a.bodyStart - (b.bodyEnd - b.bodyStart))[0];
         const verse = poem !== undefined;
         const projection =
             verse ?
                 plainRomanVerse(text, {
                     ...projectionOptions,
                     model: poem.model,
-                    modelOffset: starts[poem.start + 1],
+                    modelOffset: poem.bodyStart,
                 })
             :   plainRomanRun(text, projectionOptions);
         const before = errors.length;
@@ -1680,12 +1775,25 @@ function analyseRuns(source, ctx, syntax) {
         }
         if (verse) {
             for (const boundary of projection.boundaries) {
-                const target =
-                    boundary.kind === "line" ?
-                        encodeText(owner.selection.encoding, "/", { font: owner.selection.font })
-                    :   owner.selection.encoding.controls[
-                            boundary.kind === "stanza" ? "verseStanza" : "verseCanto"
-                        ];
+                let target;
+                if (boundary.kind === "canto") {
+                    const encoded = encodeWithLanguage(owner.selection.encoding, "***", {
+                        font: owner.selection.font,
+                        lexicon: owner.selection.lexicon,
+                        verse: true,
+                    });
+                    for (const message of new Set(
+                        encoded.findings.map((finding) => finding.message),
+                    ))
+                        report(positionOf(starts, boundary.sourceOffset), message);
+                    target = encoded.text;
+                } else
+                    target =
+                        boundary.kind === "line" ?
+                            encodeText(owner.selection.encoding, "/", {
+                                font: owner.selection.font,
+                            })
+                        :   owner.selection.encoding.controls.verseStanza;
                 if (target === undefined) continue;
                 pieces.push({
                     from: "",
@@ -1734,6 +1842,17 @@ function analyseRuns(source, ctx, syntax) {
         });
     }
 
+    for (const reference of independentReferences) {
+        const book = ctx.wordBooks?.get(reference.lang);
+        if (!book) continue;
+        const projection = plainRomanRun(text, { from: reference.from, to: reference.to });
+        for (const problem of unknownWords(projection.text, book))
+            report(
+                positionOf(starts, projection.offsets[problem.offset] ?? reference.from),
+                unknownWordMessage(problem.word, reference.lang),
+            );
+    }
+
     const firstEncodingRun =
         active.find(native) ??
         rawReferences.find((reference) => native(reference.construct))?.construct;
@@ -1776,7 +1895,7 @@ function analyseRuns(source, ctx, syntax) {
     details.sort((a, b) => order(a.run, b.run));
     errors.sort(order);
     warnings.sort(order);
-    return { runs, details, errors, warnings, spans, divs, poems };
+    return { runs, details, errors, warnings, spans, divs, poems, references: noteReferences };
 }
 
 /**
@@ -1802,7 +1921,7 @@ function diagnosticColumns(source, findings) {
 }
 
 /**
- * Find the spans, divs and verse fences marked with `lang=`, `font=` or
+ * Find the spans, divs and verse divs marked with `lang=`, `font=` or
  * `enc=`, and every fault in their markup and their text.
  *
  * @param {string} source - Authored Markdown: a note body, or a whole file
@@ -2033,7 +2152,7 @@ function setRange(text, from, to, detail, lineStart, book) {
  *   scanner projections.
  * @param {{target?: "site"|"foundry"|"book"}} [options] - The target the
  *   Markdown is rendered for; only `site` writes the search marker.
- * @returns {{markdown: string, errors: Array<{file?: string, line: number, column: number, message: string}>, scrolls: Map<string, import("./content-scroll.mjs").ScrollLayout>, verses: Map<string, {model: ReturnType<typeof import("./content-verse.mjs").parseVerse>, classes: string[], attributes: Record<string, string>}>}}
+ * @returns {{markdown: string, errors: Array<{file?: string, line: number, column: number, message: string}>, scrolls: Map<string, import("./content-scroll.mjs").ScrollLayout>, verses: Map<string, {model: ReturnType<typeof import("./content-verse.mjs").parseVerse>, classes: string[], attributes: Record<string, string>, inline: boolean}>}}
  *   The rewritten Markdown, the findings of {@link scanRuns}, and each
  *   rewritten scroll fence's layout, by its rewritten body.
  */
@@ -2046,7 +2165,7 @@ export function renderRuns(source, ctx = {}, syntax, options = {}) {
     const verses = new Map();
     if (!/\b(?:lang|font|enc)=|\bnativefont\b|\.(?:emph|strong)\b|⟦/.test(text))
         return { markdown: text, errors: [], scrolls, verses };
-    const { details, errors } = analyseRuns(text, ctx, syntax);
+    const { details, errors, references } = analyseRuns(text, ctx, syntax);
     if (!details.length)
         return { markdown: text, errors: diagnosticColumns(text, errors), scrolls, verses };
     const lines = text.split("\n");
@@ -2067,9 +2186,24 @@ export function renderRuns(source, ctx = {}, syntax, options = {}) {
 
     /** @type {Array<{from: number, to: number, text: string}>} */
     const edits = [];
-    const poems = scanVerse(text, { checkWorks: false }).blocks;
+    const poems = [
+        ...scanVerse(text, { checkWorks: false }).blocks.map((block) => ({
+            ...block,
+            inline: false,
+        })),
+        ...scanSpans(text)
+            .spans.filter((span) => span.verseModel)
+            .map((span) => ({
+                ...span,
+                inline: true,
+                model: span.verseModel,
+                body: text.slice(span.start + 1, span.contentEnd),
+                bodyStart: span.start + 1,
+                bodyEnd: span.contentEnd,
+            })),
+    ].sort((a, b) => a.bodyStart - b.bodyStart);
     const logicalRanges = poems.flatMap((poem) => {
-        const base = starts[poem.start + 1];
+        const base = poem.bodyStart;
         return poem.model.groups.flatMap((group) =>
             group.cantoBreak ? [] : group.lines.map((line) => [base + line.from, base + line.to]),
         );
@@ -2223,11 +2357,19 @@ export function renderRuns(source, ctx = {}, syntax, options = {}) {
         if (attributes !== undefined) {
             const open = lines[run.start].indexOf("{");
             const close = lines[run.start].lastIndexOf("}");
-            edits.push({
-                from: starts[run.start] + open + 1,
-                to: starts[run.start] + close,
-                text: attributes,
-            });
+            if (open < 0 && run.kind === "verse") {
+                const opening = lines[run.start];
+                edits.push({
+                    from: starts[run.start] + opening.indexOf(":::"),
+                    to: starts[run.start] + opening.replace(/\r$/, "").length,
+                    text: `::: {${attributes}}`,
+                });
+            } else
+                edits.push({
+                    from: starts[run.start] + open + 1,
+                    to: starts[run.start] + close,
+                    text: attributes,
+                });
         }
         if (detail.plain && detail.body)
             for (const [from, to] of outsideHoles(detail.body[0], detail.body[1], detail.holes)) {
@@ -2260,22 +2402,79 @@ export function renderRuns(source, ctx = {}, syntax, options = {}) {
         }
     }
 
+    const restoredReferences = new Map();
+    for (const reference of references) {
+        const nativeDiv = details.find(
+            (detail) =>
+                detail.run.kind === "verse" &&
+                detail.selection &&
+                detail.run.enc !== "default" &&
+                detail.body &&
+                reference.from >= detail.body[0] &&
+                reference.to <= detail.body[1] &&
+                !faulted(detail.run),
+        );
+        const nativeSpans = details
+            .filter(
+                (detail) =>
+                    detail.run.kind === "span" &&
+                    detail.selection &&
+                    detail.run.enc !== "default" &&
+                    reference.from > detail.run.start &&
+                    reference.to <= detail.contentEnd &&
+                    !faulted(detail.run),
+            )
+            .sort((a, b) => a.run.start - b.run.start);
+        const outer = nativeSpans[0];
+        if (!nativeDiv && !outer) continue;
+        if (!edits.some((edit) => edit.from <= reference.from && edit.to >= reference.to))
+            edits.push({ from: reference.from, to: reference.to, text: "" });
+        if (nativeDiv) continue;
+        if (!restoredReferences.has(outer.run.end)) restoredReferences.set(outer.run.end, []);
+        restoredReferences.get(outer.run.end).push(reference);
+    }
+    for (const [at, notes] of restoredReferences)
+        edits.push({
+            from: at,
+            to: at,
+            text: notes
+                .sort((a, b) => a.from - b.from)
+                .map((reference) => reference.text)
+                .join(""),
+        });
+
     let markdown = text;
     for (const edit of edits.sort((a, b) => b.from - a.from))
         markdown = markdown.slice(0, edit.from) + edit.text + markdown.slice(edit.to);
     // Models retain authored structure; a native script may draw the boundaries
     // as glyphs which must not be reparsed as Roman delimiters.
-    const rewritten = scanVerse(markdown, { checkWorks: false }).blocks;
+    const rewritten = [
+        ...scanVerse(markdown, { checkWorks: false }).blocks.map((block) => ({
+            ...block,
+            inline: false,
+        })),
+        ...scanSpans(markdown)
+            .spans.filter((span) => span.verseModel)
+            .map((span) => ({
+                ...span,
+                inline: true,
+                body: markdown.slice(span.start + 1, span.contentEnd),
+                bodyStart: span.start + 1,
+                bodyEnd: span.contentEnd,
+            })),
+    ].sort((a, b) => a.bodyStart - b.bodyStart);
     const pairedEdits = [];
     for (const [index, poem] of poems.entries()) {
         const detail = details.find(
-            (detail) => detail.run.kind === "verse" && detail.run.start === poem.start,
+            (detail) =>
+                detail.run.kind === (poem.inline ? "span" : "verse") &&
+                detail.run.start === poem.start,
         );
         if (!detail || detail.run.enc === "default" || !detail.selection || faulted(detail.run))
             continue;
         const block = rewritten[index];
         if (!block) continue;
-        const base = starts[poem.start + 1];
+        const base = poem.bodyStart;
         const applyLine = (line) => {
             const patches = [];
             for (const edit of edits) {
@@ -2327,9 +2526,16 @@ export function renderRuns(source, ctx = {}, syntax, options = {}) {
                 return true;
             });
         const model = structuredClone(poem.model);
+        for (const note of model.notes ?? []) {
+            note.romanText = romanLine(note.text);
+            note.text = "";
+        }
         for (const group of model.groups) {
             if (group.cantoBreak) {
-                group.text = detail.selection.encoding.controls.verseCanto ?? "";
+                group.text =
+                    detail.plan?.pieces.find(
+                        (piece) => piece.boundary === "canto" && piece.offset === base + group.from,
+                    )?.to ?? "";
                 continue;
             }
             for (const line of group.lines) {
@@ -2346,21 +2552,58 @@ export function renderRuns(source, ctx = {}, syntax, options = {}) {
                 });
             }
         }
+        if (poem.inline) {
+            const values = Object.fromEntries(
+                block.attrs.filter(([key]) => !["id", "class"].includes(key)),
+            );
+            const classes = (block.attrs.find(([key]) => key === "class")?.[1] ?? "")
+                .split(/\s+/)
+                .filter((name) => name && name !== "verse");
+            const attributes = attributeText({
+                lang: values.lang,
+                id: block.id,
+                classes,
+                values: Object.entries(values).filter(([key]) => key !== "lang"),
+            });
+            const fragments = model.groups.flatMap((group) =>
+                group.cantoBreak ? [{ from: group.from, text: group.text ?? "" }] : group.lines,
+            );
+            // Consecutive boundaries can stand between logical lines. They
+            // still contribute controls even when no line owns their offsets.
+            for (const piece of detail.plan?.pieces ?? []) {
+                if (!piece.boundary || piece.boundary === "canto") continue;
+                const offset = piece.anchor - base;
+                if (
+                    model.groups.some((group) =>
+                        group.lines.some((line) => offset >= line.from && offset <= line.to),
+                    )
+                )
+                    continue;
+                fragments.push({ from: offset, text: escapeRoman(piece.to, false) });
+            }
+            const native = fragments
+                .sort((a, b) => a.from - b.from)
+                .map((fragment) => fragment.text)
+                .join("");
+            pairedEdits.push({
+                from: block.start,
+                to: block.end,
+                text: `[${native}]{${attributes}}`,
+            });
+            continue;
+        }
         const classes = [SCRIPT_CLASS, ...(detail.face ? [detail.face.class] : [])];
         const attributes = {
             ...(detail.run.tag ? { lang: detail.run.tag } : {}),
             ...(detail.face?.direction === "rtl" ? { dir: "rtl" } : {}),
             ...(search ? { "data-pagefind-ignore": "true" } : {}),
         };
-        const body = `<!--verse-pair:${verses.size + 1}-->\n${block.body}`;
-        verses.set(body, { model, classes, attributes });
-        const rewrittenStarts = lineStarts(markdown);
-        pairedEdits.push({
-            at: rewrittenStarts[block.start + 1],
-            text: `<!--verse-pair:${verses.size}-->\n`,
-        });
+        const marker = `<!--verse-pair:${verses.size + 1}-->${poem.inline ? "" : "\n"}`;
+        const body = marker + block.body;
+        verses.set(body, { model, classes, attributes, inline: poem.inline });
+        pairedEdits.push({ from: block.bodyStart, to: block.bodyStart, text: marker });
     }
-    for (const edit of pairedEdits.sort((a, b) => b.at - a.at))
-        markdown = markdown.slice(0, edit.at) + edit.text + markdown.slice(edit.at);
+    for (const edit of pairedEdits.sort((a, b) => b.from - a.from))
+        markdown = markdown.slice(0, edit.from) + edit.text + markdown.slice(edit.to);
     return { markdown, errors: diagnosticColumns(text, errors), scrolls, verses };
 }

package/engine/content-scroll.mjs

@@ -43,6 +43,7 @@
  */
 
 import { blockTokens } from "./markdown-blocks.mjs";
+import { verseRegions } from "./verse-regions.mjs";
 
 import { parseExtensionAttributes, refusedAttributes } from "./extension-attributes.mjs";
 
@@ -114,7 +115,7 @@ function keyColumns(line, key) {
  * Read every `scroll` fence in a source, and every fault in its opening.
  *
  * A fence inside a block quote or an HTML block is not read, and neither is a
- * fence quoted inside another fence.
+ * fence quoted inside another fence. Verse lines are inline content.
  *
  * @param {string} source - Markdown.
  * @returns {{blocks: Scroll[], errors: Array<{line: number, column: number, message: string}>}}
@@ -125,8 +126,12 @@ export function scanScrolls(source) {
     const blocks = [];
     const errors = [];
     if (!/^ *(?:`{3,}|~{3,}) *scroll(?:\s|$)/m.test(text)) return { blocks, errors };
-    const lines = text.split("\n");
-    const literalLines = new Set();
+    const lines = text.split(/\r?\n/);
+    const literalLines = new Set(
+        verseRegions(text).flatMap((region) =>
+            Array.from({ length: region.end - region.start + 1 }, (_, i) => region.start + i),
+        ),
+    );
     for (const token of blockTokens(text)) {
         if (!token.map || !["blockquote_open", "html_block"].includes(token.type)) continue;
         for (let line = token.map[0]; line < token.map[1]; line++) literalLines.add(line);