@heroiclands/package-build 25.2.1 → 25.4.0

package/engine/content-scripts.mjs

@@ -34,9 +34,8 @@
  *
  * Span, div, verse and scroll scanners retain original UTF-16 source offsets.
  * Public diagnostics count Unicode code-point columns. A scroll's face must
- * belong to a script written vertically, and parallel verse selects encoding
- * on each reading rather than the fence. Every native content line retains
- * its line boundary before a stanza or canto.
+ * belong to a script written vertically. An encoded verse derives native and
+ * Roman presentations from one authored text and retains explicit boundaries.
  * @module
  */
 
@@ -44,8 +43,9 @@ import MarkdownIt from "markdown-it";
 import { blockTokens } from "./markdown-blocks.mjs";
 
 import { scanBlocks, BLOCK_CONTAINERS } from "./content-blocks.mjs";
-import { scanVerse, hasColumns, verseLine, verseGroups, STANZA_BREAK } from "./content-verse.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";
@@ -127,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.
  *
@@ -233,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) {
@@ -835,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 */
@@ -891,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];
@@ -912,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);
@@ -949,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",
@@ -1055,11 +1053,6 @@ function analyseRuns(source, ctx, syntax) {
                 nativeAt(construct),
                 "`.nativefont` is not an accepted class; select an encoding with `enc=`",
             );
-        if (native(construct) && construct.kind === "verse" && hasColumns(construct.node))
-            report(
-                construct.at("enc", "value"),
-                "a verse with cols>1 selects encoding on individual runs, not the fence",
-            );
 
         if (lang !== undefined && !Object.hasOwn(languages, lang)) {
             if (isLanguageTag(lang)) {
@@ -1202,48 +1195,98 @@ function analyseRuns(source, ctx, syntax) {
     }
 
     const verseMarkers = new Map();
-    const verseContexts = new Map();
-    const verseReadings = new Map();
-    for (const poem of scanVerse(text).blocks) {
-        for (let line = poem.start + 1; line < poem.end; line++) verseContexts.set(line, poem);
-        for (let line = poem.start + 1; line < poem.end; line++)
-            if (
-                STANZA_BREAK.test(lines[line].trim()) ||
-                /^---\s+\{\.canto\}$/.test(lines[line].trim())
-            )
-                verseMarkers.set(starts[line], starts[line] + lines[line].length);
-        if (hasColumns(poem)) {
-            for (const group of verseGroups(poem, lines)) {
-                if (group.stanzaBreak) continue;
-                for (const part of group.parts) {
-                    verseReadings.set(part.line, part);
-                    const start = starts[part.line];
-                    if (part.prefixLength)
-                        verseMarkers.set(
-                            start + part.sourceColumn - 1,
-                            start + part.textColumn - 1,
-                        );
-                    if (part.markerLength)
-                        verseMarkers.set(
-                            start + part.markerStart,
-                            start + part.markerStart + part.markerLength,
-                        );
-                }
+    const verseContexts = [
+        ...scanVerse(text, { checkWorks: false }).blocks,
+        ...spans
+            .filter((span) => span.verseModel)
+            .map((span) => ({
+                bodyStart: span.start + 1,
+                bodyEnd: span.contentEnd,
+                body: span.text,
+                model: span.verseModel,
+            })),
+    ];
+    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)) {
+            const bar = match[1].indexOf("|");
+            if (bar < 0) {
+                verseMarkers.set(
+                    bodyStart + match.index,
+                    bodyStart + match.index + match[0].length,
+                );
+                continue;
             }
-        } else
-            for (let line = poem.start + 1; line < poem.end; line++) {
-                const { markerStart, markerLength } = verseLine(lines[line]);
-                if (markerLength) {
-                    const from = starts[line] + markerStart;
-                    verseMarkers.set(from, from + markerLength);
-                }
+            verseMarkers.set(bodyStart + match.index, bodyStart + match.index + 3 + bar);
+            verseMarkers.set(
+                bodyStart + match.index + match[0].indexOf("]]"),
+                bodyStart + match.index + match[0].length,
+            );
+        }
+        // Link destinations and footnote references remain Markdown; only a
+        // link's visible label contributes text to the encoding projection.
+        for (let at = 0; at < poem.body.length; at++) {
+            if (poem.body[at] === "\\") {
+                at++;
+                continue;
+            }
+            if (poem.body[at] !== "[") continue;
+            const end = closing(poem.body, at);
+            if (end < 0) continue;
+            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);
+                verseMarkers.set(bodyStart + end, bodyStart + past + 1);
             }
+        }
     }
 
+    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),
+            ...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 +1449,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 +1460,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 +1494,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]) => [
@@ -1507,7 +1561,7 @@ function analyseRuns(source, ctx, syntax) {
                     said(
                         top,
                         token.info.trim().split(/\s/)[0] === "verse" ?
-                            "a verse fence"
+                            "a verse div"
                         :   "a code fence",
                     );
                 else if (Object.hasOwn(BLOCK_WHAT, token.type)) said(top, BLOCK_WHAT[token.type]);
@@ -1560,23 +1614,7 @@ function analyseRuns(source, ctx, syntax) {
         }
         return owners.get(detail);
     };
-    const wholeVerseReading = (detail) => {
-        if (detail.run.kind === "verse") return true;
-        if (detail.run.kind !== "span") return false;
-        const line = detail.run.line - 1;
-        const poem = verseContexts.get(line);
-        if (!poem) return false;
-        const end = starts[line] + lines[line].length;
-        if (detail.run.end > end) return false;
-        const reading = verseReadings.get(line);
-        const from =
-            hasColumns(poem) ? starts[line] + (reading?.textColumn ?? 1) - 1 : starts[line];
-        return (
-            from <= detail.run.start &&
-            /^[ \t.]*$/.test(text.slice(from, detail.run.start)) &&
-            /^[ \t\r]*$/.test(text.slice(detail.run.end, end))
-        );
-    };
+
     const spanDetails = new Map(
         details
             .filter((detail) => detail.run.kind === "span")
@@ -1588,7 +1626,18 @@ function analyseRuns(source, ctx, syntax) {
         const owned = details.filter((detail) => ownerOf(detail) === owner);
         for (const detail of owned) detail.owner = owner;
         const excluded = [
+            ...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]),
+            ...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,
@@ -1604,13 +1653,16 @@ function analyseRuns(source, ctx, syntax) {
             includeSpan: (span) =>
                 spanDetails.has(span.start) && ownerOf(spanDetails.get(span.start)) === owner,
         };
-        const verse = wholeVerseReading(owner);
+        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,
-                    isCantoLine: (line) =>
-                        STANZA_BREAK.test(line.trim()) || /^---\s+\{\.canto\}$/.test(line.trim()),
+                    model: poem.model,
+                    modelOffset: poem.bodyStart,
                 })
             :   plainRomanRun(text, projectionOptions);
         const before = errors.length;
@@ -1628,18 +1680,7 @@ function analyseRuns(source, ctx, syntax) {
                 );
         for (const problem of projection.errors ?? [])
             report(positionOf(starts, problem.offset), problem.message);
-        if (!verse && verseContexts.has(owner.run.line - 1))
-            for (const match of projection.text.matchAll(/\//g)) {
-                if (
-                    projection.text.lastIndexOf("⟦", match.index) >
-                    projection.text.lastIndexOf("⟧", match.index)
-                )
-                    continue;
-                report(
-                    positionOf(starts, projection.offsets[match.index]),
-                    "a verse fence uses authored line endings for verse boundaries; write no literal `/` inside it",
-                );
-            }
+
         const book = ctx.wordBooks?.get(owner.run.lang);
         if (book) {
             const mask = projection.text.split("");
@@ -1799,7 +1840,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 };
 }
 
 /**
@@ -1825,7 +1866,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
@@ -2026,11 +2067,10 @@ function setRange(text, from, to, detail, lineStart, book) {
 
 /**
  * Rewrite text marked with `lang=`, `font=` and `enc=` into the plain span,
- * div and verse grammar the rest of each chain renders, one line for one line.
+ * div and verse grammar the rest of each chain renders.
  *
- * - **Numbered verse prefixes and indentation markers** stay outside run text.
- *   Each authored run chooses its own language and presentation; physical
- *   lines and source positions remain unchanged.
+ * - **Verse layout markers** stay outside encoded text. A shared logical
+ *   structure retains authored source positions and both presentations.
  * - **The enc, if any, is applied first.** Characters Markdown would read are
  *   then backslash-escaped, so they reach every later pass as characters.
  * - **Emphasis in a face** becomes an `<em>` or a `<strong>` carrying its
@@ -2057,7 +2097,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>}}
+ * @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.
  */
@@ -2067,11 +2107,12 @@ export function renderRuns(source, ctx = {}, syntax, options = {}) {
     const text = String(source ?? "");
     /** @type {Map<string, import("./content-scroll.mjs").ScrollLayout>} */
     const scrolls = new Map();
+    const verses = new Map();
     if (!/\b(?:lang|font|enc)=|\bnativefont\b|\.(?:emph|strong)\b|⟦/.test(text))
-        return { markdown: text, errors: [], scrolls };
-    const { details, errors } = analyseRuns(text, ctx, syntax);
+        return { markdown: text, errors: [], scrolls, verses };
+    const { details, errors, references } = analyseRuns(text, ctx, syntax);
     if (!details.length)
-        return { markdown: text, errors: diagnosticColumns(text, errors), scrolls };
+        return { markdown: text, errors: diagnosticColumns(text, errors), scrolls, verses };
     const lines = text.split("\n");
     const starts = lineStarts(text);
 
@@ -2090,6 +2131,33 @@ export function renderRuns(source, ctx = {}, syntax, options = {}) {
 
     /** @type {Array<{from: number, to: number, text: string}>} */
     const edits = [];
+    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: span.text,
+                bodyStart: span.start + 1,
+                bodyEnd: span.contentEnd,
+            })),
+    ].sort((a, b) => a.bodyStart - b.bodyStart);
+    const logicalRanges = poems.flatMap((poem) => {
+        const base = poem.bodyStart;
+        return poem.model.groups.flatMap((group) =>
+            group.cantoBreak ? [] : group.lines.map((line) => [base + line.from, base + line.to]),
+        );
+    });
+    const rangesWithin = (from, to) => {
+        const cuts = logicalRanges.flat().filter((at) => at > from && at < to);
+        const points = [from, ...new Set(cuts.sort((a, b) => a - b)), to];
+        return points.slice(1).map((past, index) => [points[index], past]);
+    };
 
     /**
      * A scroll fence's body set as one line per paragraph, and its layout.
@@ -2207,8 +2275,11 @@ export function renderRuns(source, ctx = {}, syntax, options = {}) {
                 for (const [from, to] of detail.reference ?
                     [detail.reference]
                 :   outsideHoles(run.start + 1, contentEnd, detail.holes)) {
-                    const set = setRange(text, from, to, detail, false, book);
-                    if (set !== text.slice(from, to)) edits.push({ from, to, text: set });
+                    for (const [first, past] of rangesWithin(from, to)) {
+                        const set = setRange(text, first, past, detail, false, book);
+                        if (set !== text.slice(first, past))
+                            edits.push({ from: first, to: past, text: set });
+                    }
                 }
             continue;
         }
@@ -2239,9 +2310,12 @@ export function renderRuns(source, ctx = {}, syntax, options = {}) {
         }
         if (detail.plain && detail.body)
             for (const [from, to] of outsideHoles(detail.body[0], detail.body[1], detail.holes)) {
-                const lineStart = from === 0 || text[from - 1] === "\n";
-                const set = setRange(text, from, to, detail, lineStart, book);
-                if (set !== text.slice(from, to)) edits.push({ from, to, text: set });
+                for (const [first, past] of rangesWithin(from, to)) {
+                    const lineStart = first === 0 || text[first - 1] === "\n";
+                    const set = setRange(text, first, past, detail, lineStart, book);
+                    if (set !== text.slice(first, past))
+                        edits.push({ from: first, to: past, text: set });
+                }
             }
     }
 
@@ -2265,8 +2339,190 @@ 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);
-    return { markdown, errors: diagnosticColumns(text, errors), scrolls };
+    // 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.map((block) => ({
+            ...block,
+            inline: false,
+        })),
+        ...scanSpans(markdown)
+            .spans.filter((span) => span.verseModel)
+            .map((span) => ({
+                ...span,
+                inline: true,
+                body: span.text,
+                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 === (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 = poem.bodyStart;
+        const applyLine = (line) => {
+            const patches = [];
+            for (const edit of edits) {
+                const positions = line.offsets.flatMap((offset, index) => {
+                    const sourceOffset = base + offset;
+                    return sourceOffset >= edit.from && sourceOffset < edit.to ? [index] : [];
+                });
+                if (positions.length)
+                    patches.push({ from: positions[0], to: positions.at(-1) + 1, text: edit.text });
+                else if (edit.from === edit.to && edit.from === base + line.to)
+                    patches.push({ from: line.text.length, to: line.text.length, text: edit.text });
+            }
+            let result = line.text;
+            for (const edit of patches.sort((a, b) => b.from - a.from))
+                result = result.slice(0, edit.from) + edit.text + result.slice(edit.to);
+            return result.replace(/\r?\n[ ]*/g, "").trim();
+        };
+        const rewriteSpanAttributes = (source, rewrite) => {
+            const changes = scanSpans(source).spans.flatMap((span) => {
+                const attrs = parseExtensionAttributes(
+                    source.slice(span.contentEnd + 2, span.end - 1),
+                );
+                if (!rewrite(attrs, span)) return [];
+                return [
+                    {
+                        from: span.contentEnd + 2,
+                        to: span.end - 1,
+                        text: attributeText({
+                            lang: attrs.values.lang,
+                            id: attrs.id,
+                            classes: attrs.classes,
+                            values: Object.entries(attrs.values).filter(([key]) => key !== "lang"),
+                        }),
+                    },
+                ];
+            });
+            let result = source;
+            for (const change of changes.sort((a, b) => b.from - a.from))
+                result = result.slice(0, change.from) + change.text + result.slice(change.to);
+            return result;
+        };
+        const romanLine = (source) =>
+            rewriteSpanAttributes(source, (attrs) => {
+                const lang = attrs.values.lang;
+                if (lang !== undefined) attrs.values.lang = ctx.languages?.[lang]?.tag ?? lang;
+                delete attrs.values.enc;
+                delete attrs.values.font;
+                attrs.id = "";
+                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 ?? "";
+                continue;
+            }
+            for (const line of group.lines) {
+                line.romanText = romanLine(line.text);
+                const ids = new Set(
+                    scanSpans(line.text)
+                        .spans.map((span) => span.id)
+                        .filter(Boolean),
+                );
+                line.text = rewriteSpanAttributes(applyLine(line), (attrs, span) => {
+                    if (!span.id || ids.has(span.id)) return false;
+                    attrs.id = "";
+                    return true;
+                });
+            }
+        }
+        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 native = model.groups
+                .flatMap((group) =>
+                    group.cantoBreak ? [group.text ?? ""] : group.lines.map((line) => line.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 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.from - a.from))
+        markdown = markdown.slice(0, edit.from) + edit.text + markdown.slice(edit.to);
+    return { markdown, errors: diagnosticColumns(text, errors), scrolls, verses };
 }