@heroiclands/package-build 25.3.0 → 25.5.0

package/engine/content-spans.mjs

@@ -14,7 +14,10 @@
 import MarkdownIt from "markdown-it";
 import { alertMarkdownPlugin } from "./content-alerts.mjs";
 import { slugify } from "./content-slug.mjs";
-import { scanVerse } from "./content-verse.mjs";
+import { scanVerse, parseVerse, inlineVerseFindings } from "./content-verse.mjs";
+import { verseDivPlugin } from "./verse-regions.mjs";
+import { codeRegions } from "./code-fences.mjs";
+import { footnoteLabels } from "./content-footnotes.mjs";
 import footnotePlugin from "markdown-it-footnote";
 import { parseExtensionAttributes, refusedAttributes } from "./extension-attributes.mjs";
 import { inlineText } from "./name-markup.mjs";
@@ -25,8 +28,9 @@ import { cartoucheProblems, glyphProblems } from "./content-glyphs.mjs";
  * @param {object} [options] - Surface presentation.
  * @param {boolean} [options.source] - Emit opaque authored source tokens for buffer preview.
  * @param {boolean} [options.spoilers] - Add focusable CSS spoiler wrappers (Foundry).
+ * @param {(token: any, state: any) => void} [options.verseInline] - Populate an opaque quoted-verse token during inline parsing.
  */
-export function spanMarkdownPlugin(md, { spoilers = false, source = false } = {}) {
+export function spanMarkdownPlugin(md, { spoilers = false, source = false, verseInline } = {}) {
     {
         md.renderer.rules.span_open = (tokens, index, options, env, renderer) => {
             const token = tokens[index];
@@ -63,7 +67,6 @@ export function spanMarkdownPlugin(md, { spoilers = false, source = false } = {}
                 state.src[state.src.indexOf("]", start + 2) + 1] === "]") ||
             /@[A-Za-z]+$/.test(state.src.slice(0, start)) ||
             state.src[start + 1] === "^" ||
-            state.src[start + 1] === "!" ||
             ["!", "]"].includes(state.src[start - 1]) ||
             (state.src[start - 1] === "[" && state.linkLevel === 0)
         )
@@ -71,6 +74,7 @@ export function spanMarkdownPlugin(md, { spoilers = false, source = false } = {}
         const end = state.md.helpers.parseLinkLabel(state, start, false);
         if (
             end < 0 ||
+            (state.src[start + 1] === "!" && state.src[end + 1] !== "{") ||
             ["(", "["].includes(state.src[end + 1]) ||
             (state.src[start + 1] === "[" && state.src[end + 1] !== "{")
         )
@@ -110,7 +114,10 @@ export function spanMarkdownPlugin(md, { spoilers = false, source = false } = {}
             state.src[start - 1] === "[" &&
             !["lang", "font", "enc"].some((key) => Object.hasOwn(parsed.values, key)) &&
             !parsed.classes.some(
-                (name) => name === "script" || /^font-(?:mono|serif|sans)$/.test(name),
+                (name) =>
+                    name === "verse" ||
+                    name === "script" ||
+                    /^font-(?:mono|serif|sans)$/.test(name),
             )
         )
             return false;
@@ -141,7 +148,12 @@ export function spanMarkdownPlugin(md, { spoilers = false, source = false } = {}
             state.pos = finish;
             return true;
         }
-        const token = state.push("span_open", emphasis ?? "span", 1);
+        const verse = parsed.classes.includes("verse") && typeof verseInline === "function";
+        const token = state.push(
+            verse ? "verse_inline" : "span_open",
+            emphasis ?? "span",
+            verse ? 0 : 1,
+        );
         token.meta = {
             span: true,
             start,
@@ -164,6 +176,11 @@ export function spanMarkdownPlugin(md, { spoilers = false, source = false } = {}
         if (parsed.classes.length) token.attrSet("class", parsed.classes.join(" "));
         for (const [key, value] of Object.entries(parsed.values))
             if (!refusedAttributes({ [key]: value }).length) token.attrSet(key, value);
+        if (verse) {
+            verseInline(token, state);
+            state.pos = finish;
+            return true;
+        }
         const nested = [];
         state.md.inline.parse(state.src.slice(start + 1, end), state.md, state.env, nested);
         for (const child of nested)
@@ -184,6 +201,7 @@ export function spanMarkdownPlugin(md, { spoilers = false, source = false } = {}
 }
 
 const parser = new MarkdownIt({ html: true })
+    .use(verseDivPlugin)
     .use(footnotePlugin)
     .use(alertMarkdownPlugin)
     .use(spanMarkdownPlugin);
@@ -197,6 +215,7 @@ export function scanSpans(source) {
         tokens = parser.parse(text, env),
         spans = [],
         errors = [];
+    const sourcePositions = new Map();
     const lines = text.split("\n"),
         starts = [];
     let offset = 0;
@@ -226,6 +245,14 @@ export function scanSpans(source) {
                 if (children[close].type === "span_open") depth++;
                 if (children[close].type === "span_close" && --depth === 0) break;
             }
+            if ((child.attrGet("class") ?? "").split(/\s+/).includes("verse"))
+                sourcePositions.set(
+                    start,
+                    Array.from(
+                        { length: child.meta.text.length + 1 },
+                        (_, index) => position(child.meta.start + 1 + index) - start - 1,
+                    ),
+                );
             spans.push({
                 id: child.attrGet("id") ?? "",
                 line,
@@ -296,8 +323,82 @@ export function scanSpans(source) {
     for (const poem of scanVerse(text, { checkWorks: false }).blocks) {
         const children = [];
         parser.inline.parse(poem.body, parser, env, children);
-        collect(children, (pos) => starts[poem.start + 1] + pos);
+        collect(children, (pos) => poem.bodyStart + pos);
     }
+    const raw = text.split("");
+    for (const region of codeRegions(text))
+        for (let offset = region.start; offset < region.end; offset++)
+            if (!/[\r\n]/.test(raw[offset])) raw[offset] = " ";
+    const rawText = raw.join("");
+    const quoted = [];
+    parser.inline.parse(rawText, parser, env, quoted);
+    const verseTokens = quoted.filter(
+        (token) =>
+            token.meta?.span &&
+            (token.attrGet("class") ?? "").split(/\s+/).includes("verse") &&
+            !spans.some((span) => span.start === token.meta.start && span.end === token.meta.end),
+    );
+    collect(verseTokens, (pos) => pos);
+    for (const match of rawText.matchAll(/\{[^{}\r\n]*(?:\}|$)/gm)) {
+        if (
+            !parseExtensionAttributes(match[0].slice(1).replace(/\}$/, "")).classes.includes(
+                "verse",
+            )
+        )
+            continue;
+        if (rawText[match.index - 1] !== "]") continue;
+        if (
+            spans.some(
+                (span) =>
+                    span.contentEnd + 1 === match.index &&
+                    span.end >= match.index + match[0].length,
+            )
+        )
+            continue;
+        const { line, column } = located(match.index, match.index + match[0].length);
+        errors.push({
+            line,
+            column,
+            message:
+                "an inline .verse quotation needs balanced brackets and closing {…} attributes",
+        });
+    }
+    for (const span of spans)
+        if (
+            span.attrs.some(
+                ([key, value]) => key === "class" && value.split(/\s+/).includes("verse"),
+            )
+        ) {
+            const model = parseVerse(span.text, {
+                inline: true,
+                footnotes: footnoteLabels(text),
+            });
+            // The parser removes container prefixes and normalizes CRLF. Map
+            // every logical range back through its original source positions.
+            const positions = sourcePositions.get(span.start);
+            const at = (offset) => positions[offset];
+            const ranges = new Set([
+                ...model.groups,
+                ...model.cantos.flatMap((canto) => canto.stanzas),
+                ...model.groups.flatMap((group) => (group.cantoBreak ? [] : group.lines)),
+                ...model.notes,
+            ]);
+            for (const range of ranges) {
+                range.from = at(range.from);
+                range.to = at(range.to);
+                if ("offsets" in range) range.offsets = range.offsets.map(at);
+            }
+            for (const boundary of model.boundaries)
+                boundary.sourceOffset = at(boundary.sourceOffset);
+            for (const finding of model.errors) finding.offset = at(finding.offset);
+            model.layout = model.layout.map(([from, to]) => [at(from), at(to)]);
+            for (let index = 1; index < positions.length; index++)
+                if (positions[index] > positions[index - 1] + 1)
+                    model.layout.push([positions[index - 1] + 1, positions[index]]);
+            model.layout.sort((a, b) => a[0] - b[0]);
+            span.verseModel = model;
+            errors.push(...inlineVerseFindings(span, text));
+        }
     spans.sort((a, b) => a.start - b.start);
     errors.sort((a, b) => a.line - b.line || a.column - b.column);
     return {