@heroiclands/package-build 24.0.4 → 24.1.0

package/engine/content-verse.mjs

@@ -11,39 +11,80 @@
  * SPDX-License-Identifier: GPL-3.0-or-later
  */
 
-/** The authored verse lines, excluding stanza separators. */
+/** The authored verse lines, excluding blank lines and stanza separators. */
 export function verseLines(body) {
     return String(body ?? "")
         .split("\n")
-        .filter((line) => line.trim());
+        .filter((line) => line.trim() && !STANZA_BREAK.test(line.trim()));
 }
 
 /**
- * The least-indented verse is level zero. Every two additional leading spaces
- * add one level; a leftover space is discarded and the level stops at eight.
- * Blank lines divide stanzas rather than contributing to the baseline.
+ * Read one verse line. Marker offsets are zero-based in the authored line;
+ * textColumn is the one-based column of its first non-space character.
+ * Periods inside a span set indentation only when that span starts the line.
+ */
+export function verseLine(line) {
+    const source = String(line ?? "");
+    const spaces = /^ */.exec(source)[0].length;
+    const written = source.slice(spaces).trimEnd();
+    let markerStart = spaces;
+    let markerLength = /^\.+/.exec(written)?.[0].length ?? 0;
+    if (!markerLength) {
+        const span = leadingSpan(written);
+        const html = /^<span\b[^>]*>/.exec(written);
+        const prefix =
+            span ? 1
+            : html ? html[0].length
+            : 0;
+        if (prefix) {
+            markerStart += prefix;
+            markerLength = /^\.+/.exec(written.slice(prefix))?.[0].length ?? 0;
+        }
+    }
+    const start = markerStart - spaces;
+    return {
+        text: written.slice(0, start) + written.slice(start + markerLength),
+        level: markerLength,
+        markerStart,
+        markerLength,
+        textColumn: spaces + 1,
+    };
+}
+
+/**
+ * Blank lines divide verse groups. A standalone `***` is its own group and
+ * separates stanzas. Each text line carries its period-based indentation.
  */
 export function verseStanzas(body) {
-    const lines = String(body ?? "").split("\n");
-    const verses = verseLines(body);
-    if (!verses.length) return [];
-    const baseline = Math.min(...verses.map((line) => /^ */.exec(line)[0].length));
-    const stanzas = [];
-    let stanza = [];
-    for (const line of lines) {
+    const groups = [];
+    let group = [];
+    const end = () => {
+        if (group.length) groups.push(group);
+        group = [];
+    };
+    for (const line of String(body ?? "").split("\n")) {
         if (!line.trim()) {
-            if (stanza.length) stanzas.push(stanza);
-            stanza = [];
+            end();
             continue;
         }
-        const spaces = /^ */.exec(line)[0].length;
-        stanza.push({
-            text: line.slice(spaces).trimEnd(),
-            level: Math.min(8, Math.floor((spaces - baseline) / 2)),
-        });
+        if (STANZA_BREAK.test(line.trim())) {
+            end();
+            groups.push([{ text: "***", level: 0 }]);
+            continue;
+        }
+        const { text, level } = verseLine(line);
+        group.push({ text, level });
     }
-    if (stanza.length) stanzas.push(stanza);
-    return stanzas;
+    end();
+    return groups;
+}
+
+/** A stanza separator group, independent of the surrounding verse lines. */
+export const stanzaSeparator = (group) => group.length === 1 && STANZA_BREAK.test(group[0].text);
+
+/** HTML indentation attributes; large levels retain their full authored depth. */
+function indentStyle(level) {
+    return level > 8 ? ` style="--verse-indent: ${level * 1.25}em"` : "";
 }
 
 /** A verse is inline Markdown even when it starts with block syntax. */
@@ -54,7 +95,8 @@ export function inlineVerse(text) {
 }
 
 /**
- * Keep stanzas as Markdown paragraphs and make every verse line a hard break.
+ * Keep blank-line verse groups as paragraphs and each text line a hard break.
+ * A standalone `***` emits a separate stanza gap.
  * The surrounding renderer still sees the entire note, so links and footnote
  * definitions remain in scope. The span carries the indent for each line.
  */
@@ -62,12 +104,14 @@ export function verseMarkdown(body, step = 0) {
     let count = 0;
     return verseStanzas(body)
         .map((stanza) =>
-            stanza
-                .map(({ text, level }) => {
-                    const number = lineNumber(++count, step);
-                    return `<span class="verse-line${level ? ` i${level}` : ""}">${number === undefined || number === "" ? "" : `<span class="verse-number">${number}</span>`}${inlineVerse(text)}</span>`;
-                })
-                .join("  \n"),
+            stanzaSeparator(stanza) ?
+                '<span class="verse-stanza-break" aria-hidden="true"></span>'
+            :   stanza
+                    .map(({ text, level }) => {
+                        const number = lineNumber(++count, step);
+                        return `<span class="verse-line${level ? ` i${level}` : ""}"${indentStyle(level)}>${number === undefined || number === "" ? "" : `<span class="verse-number">${number}</span>`}${inlineVerse(text)}</span>`;
+                    })
+                    .join("  \n"),
         )
         .join("\n\n");
 }
@@ -86,49 +130,40 @@ export function lineNumber(line, step) {
 }
 
 /**
- * The rows of an expanded verse in columns: one row per verse line, holding
- * its number when the verse is numbered, then each column's entries stacked,
+ * The numbered-column rows, each holding its logical line number and each
+ * column’s physical readings stacked in authored order,
  * the first in the normal tone and each later one `verse-secondary`. A part
  * whose text runs right to left carries `dir="rtl"`. A row is a line of a
  * paragraph, and a paragraph a stanza, so each part stays inline Markdown.
  *
- * @param {object} block - An expanded verse from {@link scanVerse}.
+ * @param {object} block - A numbered-column verse from {@link scanVerse}.
  * @param {string[]} lines - The source, by line.
  * @param {number} step - The verse's `numstep`.
  * @returns {string} The rows as Markdown with inline HTML.
  */
 function columnsMarkdown(block, lines, step) {
-    const counts = verseColumns(block, lines[block.start]).map((column) => column.entries.length);
-    const total = counts.reduce((sum, n) => sum + n, 0);
+    const width = verseColumnCount(block);
     const stanzas = [[]];
     let count = 0;
-    const body = lines.slice(block.start + 1, block.end).map((line) => line.trim());
-    for (let at = 0; at < body.length;) {
-        if (!body[at]) {
-            at++;
-            continue;
-        }
-        if (STANZA_BREAK.test(body[at])) {
-            stanzas.push([]);
-            at++;
+    for (const group of verseGroups(block, lines)) {
+        if (group.stanzaBreak) {
+            stanzas.push(['<span class="verse-stanza-break" aria-hidden="true"></span>'], []);
             continue;
         }
-        const parts = body.slice(at, at + total);
-        at += total;
         const number = lineNumber(++count, step);
-        let next = 0;
-        const cells = counts.map(
-            (n) =>
+        const cells = Array.from({ length: width }, (_, column) => {
+            const parts = group.parts.filter((part) => part.column === column + 1);
+            return (
                 '<span class="verse-column">' +
                 parts
-                    .slice(next, (next += n))
                     .map(
-                        (part, k) =>
-                            `<span class="verse-part${k ? " verse-secondary" : ""}"${rightToLeft(part) ? ' dir="rtl"' : ""}>${part}</span>`,
+                        ({ text, indent }, index) =>
+                            `<span class="verse-part${index ? " verse-secondary" : ""}${indent ? ` i${indent}` : ""}"${indentStyle(indent)}${rightToLeft(text) ? ' dir="rtl"' : ""}>${inlineVerse(text)}</span>`,
                     )
                     .join("") +
-                "</span>",
-        );
+                "</span>"
+            );
+        });
         stanzas
             .at(-1)
             .push(
@@ -146,14 +181,20 @@ function columnsMarkdown(block, lines, step) {
 
 import MarkdownIt from "markdown-it";
 import { slugify } from "./content-slug.mjs";
+import { spanMarkdownPlugin } from "./content-spans.mjs";
 import { parseExtensionAttributes, refusedAttributes } from "./extension-attributes.mjs";
 
 const structureParser = new MarkdownIt({ html: true });
+const lineParser = new MarkdownIt({ html: true }).use(spanMarkdownPlugin);
 
-/** The keys that set a verse in columns, the left first. */
-export const COLUMN_KEYS = Object.freeze(["col1", "col2"]);
+/** The structural first span of a line, with its source ranges and keys. */
+function leadingSpan(text) {
+    if (!text.startsWith("[")) return undefined;
+    const tokens = lineParser.parseInline(text, {})[0]?.children ?? [];
+    return tokens.find((token) => token.meta?.span && token.meta.start === 0);
+}
 
-/** The class the build gives a verse in columns once its lines are expanded. */
+/** The layout class the build gives a verse whose cols count exceeds one. */
 export const COLUMNS_CLASS = "verse-columns";
 
 /**
@@ -169,7 +210,7 @@ export const VERSE_KEYS = Object.freeze([
     "font",
     "map",
     "numstep",
-    ...COLUMN_KEYS,
+    "cols",
     "dir",
     "data-pagefind-ignore",
 ]);
@@ -216,10 +257,6 @@ export function scanVerse(source) {
                     }
                     const block = { ...opening, end: i, body };
                     const columned = hasColumns(block);
-                    const count =
-                        columned ?
-                            verseGroups(block, lines).filter((group) => !group.stanzaBreak).length
-                        :   verseLines(body).length;
                     if (columned) errors.push(...columnFindings(block, lines));
                     blocks.push(block);
                 }
@@ -252,17 +289,20 @@ export function scanVerse(source) {
         for (const message of [...parsed.problems, ...refusedAttributes(parsed.values)])
             errors.push({ ...at, message });
         for (const [key, value] of Object.entries(parsed.values)) {
-            if (/^col/.test(key) && !COLUMN_KEYS.includes(key))
+            if (!VERSE_KEYS.includes(key))
                 errors.push({
                     line: i + 1,
                     column: keyColumn(lines[i], key),
-                    message: `\`${key}=\` is not a column: a verse has at most two, \`col1=\` and \`col2=\``,
+                    message: `${key}= is not a verse attribute`,
                 });
-            else if (!VERSE_KEYS.includes(key))
+            else if (
+                key === "cols" &&
+                (!/^[1-9]\d*$/.test(value) || !Number.isSafeInteger(Number(value)))
+            )
                 errors.push({
                     line: i + 1,
-                    column: keyColumn(lines[i], key),
-                    message: `${key}= is not a verse attribute`,
+                    column: keyColumn(lines[i], key) + key.length + 1,
+                    message: "verse cols= is a positive whole number",
                 });
             else if (key === "numstep" && !/^\d+$/.test(value))
                 errors.push({
@@ -298,97 +338,29 @@ function keyColumn(opening, key) {
     return (at < 0 ? brace : brace + at) + 1;
 }
 
-/** Whether a verse states a column. */
-export function hasColumns(block) {
-    return COLUMN_KEYS.some((key) => Object.hasOwn(block.attributes ?? {}, key));
-}
-
-/** One part of a column entry, `language[/mapping[/font]]`. */
-const ENTRY_PART = /^[A-Za-z0-9_-]+$/;
-
-/**
- * A column's stacked entries, each with its offset in the written value.
- *
- * @param {string} value - A `col1=` or `col2=` value.
- * @returns {Array<{raw: string, offset: number, lang?: string, map?: string, font?: string, offsets: {lang: number, map?: number, font?: number}}>}
- *   Each entry; one whose `lang` is `undefined` is malformed.
- */
-export function columnEntries(value) {
-    const entries = [];
-    let offset = 0;
-    for (const raw of String(value).split(":")) {
-        const parts = raw.split("/");
-        const sound = parts.length <= 3 && parts.every((part) => ENTRY_PART.test(part));
-        const offsets = { lang: offset };
-        let at = offset;
-        for (const [n, name] of [
-            [1, "map"],
-            [2, "font"],
-        ]) {
-            if (parts.length <= n) break;
-            at += parts[n - 1].length + 1;
-            offsets[name] = at;
-        }
-        entries.push({
-            raw,
-            offset,
-            offsets,
-            ...(sound ?
-                {
-                    lang: parts[0],
-                    ...(parts[1] === undefined ? {} : { map: parts[1] }),
-                    ...(parts[2] === undefined ? {} : { font: parts[2] }),
-                }
-            :   {}),
-        });
-        offset += raw.length + 1;
-    }
-    return entries;
+/** The number of verse columns; an omitted or invalid count uses the ordinary layout. */
+export function verseColumnCount(block) {
+    const raw = block.attributes?.cols;
+    const value = Number(raw ?? 1);
+    return /^[1-9]\d*$/.test(String(raw ?? 1)) && Number.isSafeInteger(value) ? value : 1;
 }
 
-/**
- * The columns of a verse, the left first, each entry located in the opening
- * line.
- *
- * @param {object} block - A verse from {@link scanVerse}.
- * @param {string} opening - Its opening line.
- * @returns {Array<{key: string, entries: Array<ReturnType<typeof columnEntries>[number] & {column: number, columns: {lang: number, map?: number, font?: number}}>}>}
- *   1-based columns.
- */
-export function verseColumns(block, opening) {
-    return COLUMN_KEYS.filter((key) => Object.hasOwn(block.attributes, key)).map((key) => {
-        const start = keyColumn(opening, key) + key.length + 1;
-        const quoted = opening[start - 1] === '"' ? 1 : 0;
-        return {
-            key,
-            entries: columnEntries(block.attributes[key]).map((entry) => ({
-                ...entry,
-                column: start + quoted + entry.offset,
-                columns: Object.fromEntries(
-                    Object.entries(entry.offsets).map(([name, at]) => [name, start + quoted + at]),
-                ),
-            })),
-        };
-    });
+/** Whether a verse uses the numbered multi-column protocol. */
+export function hasColumns(block) {
+    return verseColumnCount(block) > 1;
 }
 
-/**
- * The line that breaks a stanza in a verse in columns, `***`, also as the
- * rewrite of marked text escapes it.
- */
+/** A line separating stanzas, including escaped output from a native run. */
 export const STANZA_BREAK = /^(?:\\?\*){3}$/;
 
-/** A whole-line span, `[text]{attributes}`. */
-const LINE_SPAN = /^\[(.*)\]\{([^{}]*)\}$/;
-
 /**
- * The verse lines of a verse in columns: each blank-line group of span lines
- * is one verse line, and a line holding only `***` breaks the stanza.
+ * Blank-separated multi-column rows with ordered physical parts. Text retains
+ * its authored inline markup and spacing after the numeric prefix. All source
+ * offsets are measured before prefixes or indentation periods are removed.
  *
- * @param {object} block - A verse from {@link scanVerse}.
- * @param {string[]} lines - The source, by line.
- * @returns {Array<{stanzaBreak: true, line: number}|{stanzaBreak?: false, parts: Array<{line: number, column: number, text: string, textColumn: number, lang?: string, span: boolean, extra: boolean, indent: number}>}>}
- *   0-based lines, 1-based columns.
+ * @param {object} block - A verse from scanVerse.
+ * @param {string[]} lines - The complete source, by line.
+ * @returns {Array<{stanzaBreak: true, line: number}|{stanzaBreak?: false, parts: Array<{column: number, line: number, sourceColumn: number, textColumn: number, text: string, indent: number, markerStart: number, markerLength: number, prefixLength: number}>}>}
  */
 export function verseGroups(block, lines) {
     const groups = [];
@@ -397,130 +369,82 @@ export function verseGroups(block, lines) {
         if (parts.length) groups.push({ parts });
         parts = [];
     };
-    const body = lines.slice(block.start + 1, block.end).filter((line) => line.trim());
-    const baseline = body.length ? Math.min(...body.map((line) => /^ */.exec(line)[0].length)) : 0;
     for (let at = block.start + 1; at < block.end; at++) {
         const line = lines[at];
         if (!line.trim()) {
             end();
             continue;
         }
-        if (line.trim() === "***") {
+        if (STANZA_BREAK.test(line.trim())) {
             end();
             groups.push({ stanzaBreak: true, line: at });
             continue;
         }
         const spaces = /^ */.exec(line)[0].length;
-        const written = line.slice(spaces).trimEnd();
-        const span = LINE_SPAN.exec(written);
-        const parsed = span ? parseExtensionAttributes(span[2]) : undefined;
+        const prefix = hasColumns(block) ? /^(\d+)( +)/.exec(line.slice(spaces)) : undefined;
+        const prefixLength = prefix?.[0].length ?? 0;
+        const contentStart = spaces + prefixLength;
+        const parsed = verseLine(line.slice(contentStart));
         parts.push({
+            column: prefix ? Number(prefix[1]) : 1,
             line: at,
-            column: spaces + 1,
-            indent: spaces - baseline,
-            span: Boolean(span),
-            text: span ? span[1] : written,
-            textColumn: spaces + 1 + (span ? 1 : 0),
-            lang: span ? parsed.values.lang : block.attributes.lang,
-            extra:
-                Boolean(parsed) &&
-                (parsed.problems.length > 0 ||
-                    Boolean(parsed.id) ||
-                    parsed.classes.length > 0 ||
-                    Object.keys(parsed.values).some((key) => key !== "lang") ||
-                    parsed.values.lang === undefined),
+            sourceColumn: spaces + 1,
+            textColumn: contentStart + 1,
+            text: parsed.text,
+            indent: parsed.level,
+            markerStart: contentStart + parsed.markerStart,
+            markerLength: parsed.markerLength,
+            prefixLength,
         });
     }
     end();
     return groups;
 }
 
-/**
- * What is wrong with a verse in columns, each finding at its own text.
- *
- * @param {object} block - A verse from {@link scanVerse} stating a column.
- * @param {string[]} lines - The source, by line.
- * @returns {Array<{line: number, column: number, message: string}>} 1-based.
- */
+/** Locate an invalid numbered line without changing its authored text. */
 function columnFindings(block, lines) {
     const errors = [];
+    const width = verseColumnCount(block);
     const opening = lines[block.start];
     const report = (line, column, message) => errors.push({ line: line + 1, column, message });
-    for (const key of ["font", "map"])
-        if (Object.hasOwn(block.attributes, key))
-            report(
-                block.start,
-                keyColumn(opening, key),
-                `a verse in columns sets each column's fonts and maps in \`col1=\` and \`col2=\`, not with \`${key}=\``,
-            );
     if (block.classes.includes(COLUMNS_CLASS))
         report(
             block.start,
             keyColumn(opening, `.${COLUMNS_CLASS}`),
             `\`.${COLUMNS_CLASS}\` is the class the build gives a verse in columns; leave it out`,
         );
-    const columns = verseColumns(block, opening);
-    for (const { key, entries } of columns)
-        for (const entry of entries)
-            if (entry.lang === undefined)
-                report(
-                    block.start,
-                    entry.column,
-                    `\`${entry.raw}\` in \`${key}=\` is not an entry: an entry is \`language[/mapping[/font]]\``,
-                );
-    const named = new Map();
-    for (const { key, entries } of columns)
-        for (const entry of entries)
-            if (entry.lang !== undefined && !named.has(entry.lang)) named.set(entry.lang, key);
     for (const group of verseGroups(block, lines)) {
         if (group.stanzaBreak) continue;
-        const seen = new Set();
-        let unlabelled = false;
+        let previous = 0;
         for (const part of group.parts) {
-            if (part.indent > 0)
-                report(part.line, part.column, "a line of a verse in columns is not indented");
-            if (part.span && part.extra) {
+            if (!part.prefixLength) {
                 report(
                     part.line,
-                    part.column,
-                    "a line of a verse in columns is `[text]{lang=…}`, or plain text in the verse's `lang=`, and takes no other key",
+                    part.sourceColumn,
+                    "a verse with cols>1 starts each content line with a column number and spaces",
                 );
-                if (part.lang === undefined) {
-                    unlabelled = true;
-                    continue;
-                }
+                continue;
             }
-            if (part.lang === undefined) {
-                unlabelled = true;
+            if (!part.text.trim())
                 report(
                     part.line,
-                    part.column,
-                    "this line names no language: write it `[text]{lang=…}`, or give the verse `lang=`",
+                    part.sourceColumn,
+                    "a numbered verse line needs content after its column number",
                 );
-                continue;
-            }
-            if (!named.has(part.lang))
+            if (!Number.isSafeInteger(part.column) || part.column < 1 || part.column > width)
                 report(
                     part.line,
-                    part.column,
-                    `no column sets \`${part.lang}\`; a verse line gives the languages \`col1=\` and \`col2=\` name`,
+                    part.sourceColumn,
+                    `column ${part.column} is outside 1..${width}`,
                 );
-            else if (seen.has(part.lang))
+            else if (part.column < previous)
                 report(
                     part.line,
-                    part.column,
-                    `this verse line gives \`${part.lang}\` twice; give each language once`,
+                    part.sourceColumn,
+                    "column numbers must not decrease within a verse row",
                 );
-            seen.add(part.lang);
+            previous = part.column;
         }
-        if (unlabelled) continue;
-        for (const [lang, key] of named)
-            if (!seen.has(lang))
-                report(
-                    group.parts[0].line,
-                    group.parts[0].column,
-                    `this verse line has no \`${lang}\` line, which \`${key}=\` sets`,
-                );
     }
     return errors;
 }
@@ -533,7 +457,11 @@ function columnFindings(block, lines) {
  * @returns {boolean} Whether it starts right to left.
  */
 export function rightToLeft(text) {
-    const first = /[\p{L}\p{M}\p{Co}\p{Cn}]/u.exec(String(text).replace(/\{[^}]*\}/g, ""));
+    const first = /[\p{L}\p{M}\p{Co}\p{Cn}]/u.exec(
+        String(text)
+            .replace(/<[^>]*>/g, "")
+            .replace(/\{[^}]*\}/g, ""),
+    );
     return Boolean(
         first &&
         /[\u0590-\u08FF\uFB1D-\uFDFF\uFE70-\uFEFF\u{10800}-\u{10FFF}\u{1E800}-\u{1EFFF}]/u.test(
@@ -542,155 +470,11 @@ export function rightToLeft(text) {
     );
 }
 
-/** An attribute value as the shared attribute grammar reads it back. */
-function attributeValue(value) {
-    return /^[A-Za-z0-9_.:/@%+-]+$/.test(value) ? value : `"${value.replace(/[\\"]/g, "\\$&")}"`;
-}
-
-/**
- * Where a line of {@link expandVerseOrigins}'s output came from.
- *
- * @typedef {object} VerseOrigin
- * @property {number} line - The source line, 0-based.
- * @property {number} [textColumn] - For an entry's line, the 1-based source
- *   column of its text's first character.
- * @property {boolean} [span] - Whether the source line is a span, whose `[`
- *   sits before its text.
- * @property {number} [textLength] - The length of the entry's text.
- * @property {{line: number, columns: {lang: number, map?: number, font?: number}}} [entry] -
- *   Where the entry is written in the opening line.
- */
-
-/**
- * Write each verse line of a sound verse in columns as one span per column
- * entry, the left column's entries first, each with the entry's language,
- * mapping and font. Every target runs it before marked text is rewritten, so
- * each entry is set exactly as a span with those keys is. The verse gains the
- * class {@link COLUMNS_CLASS}; a verse already carrying it, a verse with a
- * finding, and a verse without columns are left as written.
- *
- * @param {string} source - Markdown.
- * @returns {{markdown: string, origins: VerseOrigin[]}} The Markdown, and
- *   where each of its lines came from.
- */
-export function expandVerseOrigins(source) {
-    const text = String(source ?? "");
-    const lines = text.split("\n");
-    const identity = () => lines.map((_, line) => ({ line }));
-    if (!/\bcol[12]=/.test(text)) return { markdown: text, origins: identity() };
-    const { blocks, errors } = scanVerse(text);
-    const output = [];
-    const origins = [];
-    let cursor = 0;
-    const copy = (from, to) => {
-        for (let line = from; line < to; line++) {
-            output.push(lines[line]);
-            origins.push({ line });
-        }
-    };
-    for (const block of blocks) {
-        if (!hasColumns(block) || block.classes.includes(COLUMNS_CLASS)) continue;
-        if (errors.some((error) => error.line - 1 >= block.start && error.line - 1 <= block.end))
-            continue;
-        copy(cursor, block.start);
-        const opening = lines[block.start];
-        const close = opening.lastIndexOf("}");
-        output.push(`${opening.slice(0, close)} .${COLUMNS_CLASS}${opening.slice(close)}`);
-        origins.push({ line: block.start });
-        const entries = verseColumns(block, opening).flatMap((column) => column.entries);
-        let first = true;
-        for (const group of verseGroups(block, lines)) {
-            if (!first) {
-                output.push(block.indent);
-                origins.push({ line: block.start });
-            }
-            first = false;
-            if (group.stanzaBreak) {
-                output.push(`${block.indent}***`);
-                origins.push({ line: group.line });
-                continue;
-            }
-            for (const entry of entries) {
-                const part = group.parts.find((candidate) => candidate.lang === entry.lang);
-                const keys = [
-                    `lang=${attributeValue(entry.lang)}`,
-                    ...(entry.map === undefined ? [] : [`map=${attributeValue(entry.map)}`]),
-                    ...(entry.font === undefined ? [] : [`font=${attributeValue(entry.font)}`]),
-                ];
-                output.push(`${block.indent}[${part.text}]{${keys.join(" ")}}`);
-                origins.push({
-                    line: part.line,
-                    textColumn: part.textColumn,
-                    indent: block.indent.length,
-                    span: part.span,
-                    textLength: part.text.length,
-                    entry: { line: block.start, columns: entry.columns },
-                });
-            }
-        }
-        output.push(lines[block.end]);
-        origins.push({ line: block.end });
-        cursor = block.end + 1;
-    }
-    copy(cursor, lines.length);
-    return { markdown: output.join("\n"), origins };
-}
-
-/**
- * {@link expandVerseOrigins}'s Markdown alone.
- *
- * @param {string} source - Markdown.
- * @returns {string} The Markdown with each verse in columns expanded.
- */
-export function expandVerse(source) {
-    return expandVerseOrigins(source).markdown;
-}
-
-/**
- * Where a position in {@link expandVerseOrigins}'s output was written.
- *
- * A position in an entry's text is the same character of the source line; a
- * position in its keys is the entry's part in the opening line that states
- * the key it falls in.
- *
- * @param {{line: number, column: number}} at - 1-based, in the output.
- * @param {string[]} expanded - The output, by line.
- * @param {VerseOrigin[]} origins - From {@link expandVerseOrigins}.
- * @returns {{line: number, column: number}} 1-based, in the source.
- */
-export function sourcePosition(at, expanded, origins) {
-    const origin = origins[at.line - 1];
-    if (!origin) return at;
-    if (origin.entry === undefined) return { line: origin.line + 1, column: at.column };
-    const local = at.column - (origin.indent ?? 0);
-    if (local <= origin.textLength + 1) {
-        const column = origin.textColumn + local - 2;
-        return {
-            line: origin.line + 1,
-            column: Math.max(origin.textColumn - (origin.span ? 1 : 0), column),
-        };
-    }
-    const line = expanded[at.line - 1];
-    const brace = line.lastIndexOf("{");
-    let key = "lang";
-    let best = -1;
-    for (const name of ["lang", "map", "font"]) {
-        const found = line.indexOf(`${name}=`, brace);
-        if (found >= 0 && found <= at.column - 1 && found > best) {
-            best = found;
-            key = name;
-        }
-    }
-    const column = origin.entry.columns[key] ?? origin.entry.columns.lang;
-    return { line: origin.entry.line + 1, column };
-}
-
 /** Replace verse fences with HTML wrappers whose body remains inline Markdown.
  * @param {string} source - Authored Markdown.
  */
 export function renderVerse(source) {
     const { errors } = scanVerse(source);
-    source = expandVerse(source);
     const { blocks } = scanVerse(source),
         lines = String(source ?? "").split("\n"),
         output = [];
@@ -704,10 +488,11 @@ export function renderVerse(source) {
     for (const block of blocks) {
         output.push(...lines.slice(cursor, block.start));
         const step = Number(block.attributes.numstep ?? 0) || 0;
-        const columns = block.classes.includes(COLUMNS_CLASS);
+        const columns = hasColumns(block);
         const attrs = [
-            `class="${escape(["verse", ...block.classes, ...(step ? ["verse-numbered"] : [])].join(" "))}"`,
+            `class="${escape(["verse", ...block.classes, ...(columns ? [COLUMNS_CLASS] : []), ...(step ? ["verse-numbered"] : [])].join(" "))}"`,
         ];
+        if (columns) attrs.push(`style="--verse-columns: ${verseColumnCount(block)}"`);
         if (block.id) attrs.push(`id="${escape(slugify(block.id))}"`);
         for (const [key, value] of Object.entries(block.attributes))
             if (!refusedAttributes({ [key]: value }).length)