@heroiclands/package-build 25.2.1 → 25.4.0

package/engine/roman-verse.mjs

@@ -12,16 +12,15 @@
  */
 
 /** Logical verse text and separately located structural boundaries. @module */
-import { verseLine } from "./content-verse.mjs";
+import { parseVerse } from "./content-verse.mjs";
 import { plainRomanRun } from "./roman-run.mjs";
 
 /**
- * Remove visual indentation before checking or encoding Roman verse. Each
- * content line keeps its own boundary, including the last line before a stanza
- * or canto; those extra structural controls do not consume its line boundary.
- * The caller writes the boundaries through its selected encoding.
+ * Project verse text with explicit authored line, stanza and canto boundaries.
+ * Source newlines within a logical line are whitespace. Delimiters and visual
+ * indentation do not reach the encoder as letters.
  * @param {string} source - Complete authored source.
- * @param {Parameters<typeof plainRomanRun>[1] & {isCantoLine?: (line: string) => boolean}} [options] - Run bounds, spans and layout projection.
+ * @param {Parameters<typeof plainRomanRun>[1] & {model?: ReturnType<typeof parseVerse>, modelOffset?: number}} [options] - Run bounds, spans and layout projection.
  * @returns {ReturnType<typeof plainRomanRun> & {boundaries: Array<{kind: "line"|"stanza"|"canto", at: number, sourceOffset: number}>, errors: Array<{offset: number, message: string}>}} Visible text, positions and structural events.
  */
 export function plainRomanVerse(source, options = {}) {
@@ -29,28 +28,60 @@ export function plainRomanVerse(source, options = {}) {
         from = 0,
         to = source.length,
         exclude = [],
-        isCantoLine = (line) => /^\s*---\s+\{\.canto\}\s*$/.test(line),
+        model: sharedModel,
+        modelOffset = from,
     } = options;
-    const lines = [];
-    const layout = [...exclude];
-    let at = from;
-    for (const match of source.slice(from, to).matchAll(/([^\r\n]*)(\r\n|\r|\n|$)/g)) {
-        if (!match[0]) continue;
-        const line = match[1];
-        const end = at + line.length;
-        const kind =
-            isCantoLine(line) ? "canto"
-            : line.trim() ? "content"
-            : "blank";
-        lines.push({ from: at, to: end, kind });
-        if (kind === "canto") layout.push([at, end]);
-        else if (kind === "content") {
-            const { markerStart, markerLength } = verseLine(line);
-            if (markerLength) layout.push([at + markerStart, at + markerStart + markerLength]);
-        }
-        at += match[0].length;
+    const model = sharedModel ?? parseVerse(source.slice(from, to));
+    const base = sharedModel ? modelOffset : from;
+    const boundaries = model.boundaries
+        .map((boundary) => ({ ...boundary, sourceOffset: base + boundary.sourceOffset }))
+        .filter((boundary) => boundary.sourceOffset >= from && boundary.sourceOffset <= to);
+    const projected = plainRomanRun(source, {
+        ...options,
+        from,
+        to,
+        exclude: [
+            ...exclude,
+            ...model.layout
+                .map(([first, past]) => [Math.max(from, base + first), Math.min(to, base + past)])
+                .filter(([first, past]) => past > first),
+        ],
+    });
+    const text = [],
+        offsets = [],
+        positions = [],
+        ends = [];
+    const pending = [...boundaries];
+    let boundaryIndex = 0;
+    const appendBoundary = (boundary) => {
+        text.push("\n");
+        offsets.push(boundary.sourceOffset);
+    };
+    for (let index = 0; index < projected.text.length; index++) {
+        ends[index] = text.length;
+        while (
+            pending[boundaryIndex] &&
+            pending[boundaryIndex].sourceOffset <= projected.offsets[index]
+        )
+            appendBoundary(pending[boundaryIndex++]);
+        positions[index] = text.length;
+        const char = projected.text[index];
+        if (char === "\n" && projected.text[index - 1] === "\r") continue;
+        text.push(/[\r\n]/.test(char) ? " " : char);
+        offsets.push(projected.offsets[index]);
     }
-    const projected = plainRomanRun(source, { ...options, from, to, exclude: layout });
+    ends[projected.text.length] = text.length;
+    while (pending[boundaryIndex]) appendBoundary(pending[boundaryIndex++]);
+    positions[projected.text.length] = text.length;
+    projected.text = text.join("");
+    projected.offsets = offsets;
+    projected.spans = projected.spans.map((span) => ({
+        ...span,
+        from: positions[span.from],
+        to: ends[span.to],
+        contentFrom: positions[span.contentFrom],
+        contentTo: ends[span.contentTo],
+    }));
     const logicalAt = (offset) => {
         let first = 0,
             past = projected.offsets.length;
@@ -61,35 +92,15 @@ export function plainRomanVerse(source, options = {}) {
         }
         return first;
     };
-    /** @type {Array<{kind: "line"|"stanza"|"canto", at: number, sourceOffset: number}>} */
-    const boundaries = [];
-    for (let index = 0; index < lines.length; index++) {
-        const line = lines[index];
-        if (line.kind === "content")
-            boundaries.push({ kind: "line", at: logicalAt(line.to), sourceOffset: line.to });
-        else if (line.kind === "canto")
-            boundaries.push({ kind: "canto", at: logicalAt(line.from), sourceOffset: line.from });
-        else if (lines[index - 1]?.kind === "content") {
-            const following = lines.slice(index + 1).find((next) => next.kind !== "blank");
-            if (following?.kind === "content")
-                boundaries.push({
-                    kind: "stanza",
-                    at: logicalAt(line.from),
-                    sourceOffset: line.from,
-                });
-        }
-    }
-    const errors = [];
-    for (let index = 0; index < projected.text.length; index++) {
-        if (projected.text[index] === "⟦") {
-            const close = projected.text.indexOf("⟧", index + 1);
-            index = close < 0 ? projected.text.length : close;
-        } else if (projected.text[index] === "/")
-            errors.push({
-                offset: projected.offsets[index],
-                message:
-                    "a verse fence uses authored line endings for verse boundaries; write no literal `/` inside it",
-            });
-    }
-    return { ...projected, boundaries, errors };
+    return {
+        ...projected,
+        boundaries: boundaries.map(({ kind, sourceOffset }) => ({
+            kind,
+            sourceOffset,
+            at: logicalAt(sourceOffset),
+        })),
+        errors: model.errors
+            .map(({ offset, message }) => ({ offset: base + offset, message }))
+            .filter((error) => error.offset >= from && error.offset < to),
+    };
 }

package/engine/run-rows.mjs

@@ -12,7 +12,7 @@
  */
 
 /**
- * Spans, divs and verse fences marked with `lang=`, `font=` or `enc=`, projected
+ * Spans, divs and verse divs and quoted verse spans marked with `lang=`, `font=` or `enc=`, projected
  * from own-note index records into the SQL `runs` relation. Every value is a
  * column value and none is a key, so two notes writing one tag in different
  * case are two rows. Documentation records and assets contribute no rows.

package/engine/sql-tables.mjs

@@ -682,7 +682,7 @@ async function createNameRelation(connection, file, records, prefix, audience) {
 }
 
 /**
- * Create the `runs` relation: one row per span, div and verse fence an own
+ * Create the `runs` relation: one row per span, div and verse div an own
  * note marks with `lang=`, `font=` or `enc=`, with the columns
  * {@link module:engine/run-rows.RUN_COLUMNS} names. The columns are declared
  * rather than inferred, so every value stays a string and none becomes a

package/engine/verse-format.mjs

@@ -0,0 +1,77 @@
+/*
+ * This file is part of the Song of Heroic Lands (SoHL) system for Foundry VTT.
+ * Copyright (c) 2024-2026 Tom Rodriguez ("Toasty") — <toasty@heroiclands.org>
+ *
+ * This work is licensed under the GNU General Public License v3.0 (GPLv3).
+ * You may copy, modify, and distribute it under the terms of that license.
+ *
+ * For full terms, see the LICENSE.md file in the project root or visit:
+ * https://www.gnu.org/licenses/gpl-3.0.html
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+/** Preserve complete authored verse regions through surrounding prose formatting. @module */
+
+import { verseRegions } from "./verse-regions.mjs";
+import { scanSpans } from "./content-spans.mjs";
+
+/**
+ * Replace verse markup with opaque placeholders and restore its original bytes.
+ * @param {string} source - Complete Markdown source.
+ * @returns {{markdown: string, restore: (formatted: string) => string}} Protected source and exact restoration.
+ */
+export function protectVerseSource(source) {
+    const syntax = source.replace(/^\uFEFF?---\r?\n[^]*?\r?\n---(?:\r?\n|$)/, (frontmatter) =>
+        frontmatter.replace(/[^\r\n]/g, " "),
+    );
+    const ranges = [
+        ...verseRegions(syntax)
+            .filter((region) => region.closed)
+            .map((region) => ({ from: region.from, to: region.to, block: true })),
+        ...scanSpans(syntax)
+            .spans.filter((span) =>
+                span.attrs.some(
+                    ([key, value]) => key === "class" && value.split(/\s+/).includes("verse"),
+                ),
+            )
+            .map((span) => ({ from: span.start, to: span.end, block: false })),
+    ].sort((a, b) => a.from - b.from || b.to - a.to);
+    const outer = ranges.filter(
+        (range, index) =>
+            !ranges
+                .slice(0, index)
+                .some((parent) => parent.from <= range.from && parent.to >= range.to),
+    );
+    let prefix = "VERSEPROTECTEDTOKEN";
+    while (source.includes(prefix)) prefix += "X";
+    const replacements = outer.map((range, index) => {
+        const original = source.slice(range.from, range.to);
+        const marker = range.block ? `<!--${prefix}${index}-->` : `${prefix}${index}END`;
+        return { ...range, original, marker, newline: range.block && /\r?\n$/.test(original) };
+    });
+    let markdown = source;
+    for (const entry of [...replacements].reverse())
+        markdown =
+            markdown.slice(0, entry.from) +
+            entry.marker +
+            (entry.newline ? "\n" : "") +
+            markdown.slice(entry.to);
+    return {
+        markdown,
+        restore(formatted) {
+            let restored = formatted;
+            for (const entry of replacements) {
+                const escaped = entry.marker.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+                const pattern =
+                    entry.block ?
+                        new RegExp(`^[ \t]*${escaped}${entry.newline ? "\\r?\\n" : ""}`, "m")
+                    :   new RegExp(escaped);
+                if (!pattern.test(restored))
+                    throw new Error("the formatter changed a protected verse placeholder");
+                restored = restored.replace(pattern, () => entry.original);
+            }
+            return restored;
+        },
+    };
+}

package/engine/verse-metre.mjs

@@ -12,7 +12,7 @@
  */
 
 /**
- * **A verse fence declares its metre, and the build counts its beats.** A
+ * **A verse div declares its metre, and the build counts its beats.** A
  * metre is declared once, as an entry of a `doc` note's `data.metres`:
  *
  * ```yaml
@@ -21,7 +21,7 @@
  *     - { name: hexameter, beats: 6, kind: accentual }
  * ```
  *
- * A fence that states `scan=` with the `name` and `lang=` with a language
+ * A div that states `scan=` with the `name` and `lang=` with a language
  * whose note states `data.sounds.stress` is counted line by line, and a line
  * that cannot have the metre's beats is a warning at that line. No `scan=`
  * means no check.
@@ -60,7 +60,7 @@ import { WORD } from "./word-pattern.mjs";
 
 import MarkdownIt from "markdown-it";
 import { spanMarkdownPlugin } from "./content-spans.mjs";
-import { STANZA_BREAK, verseLine } from "./content-verse.mjs";
+import { parseVerse } from "./content-verse.mjs";
 import { inlineText } from "./name-markup.mjs";
 
 const verseParser = new MarkdownIt().use(spanMarkdownPlugin);
@@ -278,7 +278,7 @@ export function lineBeats(text, book) {
  * The warning for a line that cannot have its metre's beats.
  *
  * @param {{min: number, max: number}} beats - The line's beats.
- * @param {import("./metre-declaration.mjs").Metre} metre - The fence's metre.
+ * @param {import("./metre-declaration.mjs").Metre} metre - The div's metre.
  * @returns {string} The message.
  */
 export function metreMessage({ min, max }, metre) {
@@ -287,13 +287,13 @@ export function metreMessage({ min, max }, metre) {
 }
 
 /**
- * Check the verse fences that state `scan=`.
+ * Check the verse divs that state `scan=`.
  *
  * @param {ReadonlyArray<{start: number, end: number, indent: string, attributes: Record<string, string>, classes: string[]}>} blocks -
- *   The fences, from {@link module:engine/content-verse.scanVerse}.
+ *   The divs, from {@link module:engine/content-verse.scanVerse}.
  * @param {string[]} lines - The source's lines.
  * @param {{languages?: Readonly<Record<string, {tag: string}>>, metres?: ReadonlyMap<string, import("./metre-declaration.mjs").Metre>, metreBooks?: ReadonlyMap<string, MetreBook>, lexicons?: ReadonlyMap<string, unknown>, attributeColumns: (line: string, key: string) => {key: number, value: number}}} ctx -
- *   The metres and books, and how the fence says its columns and where its
+ *   The metres and books, and how the div says its columns and where its
  *   keys sit.
  * @returns {{errors: object[], warnings: object[]}} The findings at 1-based
  *   positions.
@@ -311,13 +311,6 @@ export function metreFindings(blocks, lines, ctx) {
             column: ctx.attributeColumns(opening, key)[part],
         });
         const error = (position, message) => errors.push({ ...position, message });
-        if (Number(block.attributes.cols ?? 1) > 1) {
-            error(
-                at("scan", "key"),
-                "`scan=` counts the beats of one language's lines; a verse with cols>1 groups independent physical lines",
-            );
-            continue;
-        }
         const metre = metres.get(name);
         if (!metre) {
             const near = nearest(name, [...metres.keys()]);
@@ -332,7 +325,7 @@ export function metreFindings(blocks, lines, ctx) {
         if (lang === undefined) {
             error(
                 at("scan", "key"),
-                "`scan=` counts beats by a language's stress rule: the fence needs a `lang=`",
+                "`scan=` counts beats by a language's stress rule: the div needs a `lang=`",
             );
             continue;
         }
@@ -346,40 +339,49 @@ export function metreFindings(blocks, lines, ctx) {
             );
             continue;
         }
-        for (let line = block.start + 1; line < block.end; line++) {
-            const text = lines[line];
-            if (!text.trim() || STANZA_BREAK.test(text.trim())) continue;
-            const reading = verseLine(text);
-            const tokens = verseParser.parseInline(reading.text, {})[0]?.children ?? [];
-            const tag = (name) => (ctx.languages?.[name]?.tag ?? name).toLowerCase();
-            const foreign = tokens.find(
-                (token) =>
-                    token.type === "span_open" &&
-                    token.attrGet("lang") &&
-                    tag(token.attrGet("lang")) !== tag(lang),
-            );
-            if (foreign) {
-                error(
-                    {
-                        line: line + 1,
-                        column:
-                            reading.textColumn +
-                            foreign.meta.start +
-                            (reading.markerStart <= reading.textColumn - 1 + foreign.meta.start ?
-                                reading.markerLength
-                            :   0),
-                    },
-                    "`scan=` counts one language's beats; this verse line contains another language",
+        const body = lines.slice(block.start + 1, block.end).join("\n");
+        const model = block.model ?? parseVerse(body);
+        const sourcePosition = (offset) => {
+            const preceding = body.slice(0, offset);
+            return {
+                line: block.start + 2 + preceding.split("\n").length - 1,
+                column: preceding.length - preceding.lastIndexOf("\n"),
+            };
+        };
+        for (const group of model.groups) {
+            if (group.cantoBreak) continue;
+            for (const reading of group.lines) {
+                const units = reading.text
+                    .split("")
+                    .map((text, index) => ({ text, offset: reading.offsets[index] }))
+                    .filter(
+                        ({ offset }) =>
+                            !model.layout.some(([from, to]) => offset >= from && offset < to),
+                    );
+                const tokens =
+                    verseParser.parseInline(units.map((unit) => unit.text).join(""), {})[0]
+                        ?.children ?? [];
+                const tag = (name) => (ctx.languages?.[name]?.tag ?? name).toLowerCase();
+                const foreign = tokens.find(
+                    (token) =>
+                        token.type === "span_open" &&
+                        token.attrGet("lang") &&
+                        tag(token.attrGet("lang")) !== tag(lang),
                 );
-                continue;
+                if (foreign) {
+                    error(
+                        sourcePosition(units[foreign.meta.start]?.offset ?? reading.from),
+                        "`scan=` counts one language's beats; this verse line contains another language",
+                    );
+                    continue;
+                }
+                const beats = lineBeats(inlineText(tokens), book);
+                if (metre.beats >= beats.min && metre.beats <= beats.max) continue;
+                warnings.push({
+                    ...sourcePosition(reading.from),
+                    message: metreMessage(beats, metre),
+                });
             }
-            const beats = lineBeats(inlineText(tokens), book);
-            if (metre.beats >= beats.min && metre.beats <= beats.max) continue;
-            warnings.push({
-                line: line + 1,
-                column: /^\s*/.exec(text)[0].length + 1,
-                message: metreMessage(beats, metre),
-            });
         }
     }
     return { errors, warnings };

package/engine/verse-regions.mjs

@@ -0,0 +1,181 @@
+/*
+ * This file is part of the Song of Heroic Lands (SoHL) system for Foundry VTT.
+ * Copyright (c) 2024-2026 Tom Rodriguez ("Toasty") — <toasty@heroiclands.org>
+ *
+ * This work is licensed under the GNU General Public License v3.0 (GPLv3).
+ * You may copy, modify, and distribute it under the terms of that license.
+ *
+ * For full terms, see the LICENSE.md file in the project root or visit:
+ * https://www.gnu.org/licenses/gpl-3.0.html
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+import MarkdownIt from "markdown-it";
+import { WIKILINK } from "./wikilink-pattern.mjs";
+import { parseExtensionAttributes } from "./extension-attributes.mjs";
+
+/**
+ * A raw verse div, opaque to ordinary Markdown block syntax.
+ * @typedef {object} VerseRegion
+ * @property {number} start - Opening line, zero based.
+ * @property {number} end - Closing line, zero based and inclusive.
+ * @property {number} from - First offset of the complete region.
+ * @property {number} to - Offset past the complete region.
+ * @property {number} bodyStart - First body offset.
+ * @property {number} bodyEnd - Offset past body text, excluding its final newline.
+ * @property {string} body - Authored body bytes.
+ * @property {Record<string,string>} attributes - Authored values.
+ * @property {string} id - Anchor or empty string.
+ * @property {string[]} classes - Authored classes including verse.
+ * @property {string} indent - Opening indentation.
+ * @property {"verse"} name - Region kind.
+ * @property {boolean} closed - Whether a closing delimiter is present.
+ * @property {string[]} problems - Attribute syntax findings.
+ */
+
+/** Recognize an opener without interpreting its body as Markdown blocks. */
+function opener(line) {
+    const named = /^ *:::verse(?:[ \t]+(.*))?$/.exec(line);
+    const generic = /^ *:::[ \t]+(\{.*)$/.exec(line);
+    if (!named && !generic) return undefined;
+    const raw = (named?.[1] ?? generic?.[1] ?? "").trim();
+    const braced = /^\{[^\n]*\}$/.test(raw);
+    const parsed = parseExtensionAttributes(braced ? raw.slice(1, -1) : raw.replace(/^\{/, ""));
+    if (!named && !parsed.classes.includes("verse")) return undefined;
+    if (raw && !braced) parsed.problems.push("verse div attributes need {…} braces");
+    if (!parsed.classes.includes("verse")) parsed.classes.unshift("verse");
+    return parsed;
+}
+
+/**
+ * Install the opaque verse-div block rule. Tokens carry raw source regions.
+ * @param {import("markdown-it")} md - Markdown parser.
+ */
+export function verseDivPlugin(md) {
+    md.block.ruler.before(
+        "code",
+        "verse_div",
+        (state, first, past, silent) => {
+            if (state.sCount[first] - state.blkIndent >= 4) return false;
+            const line = state.src.slice(
+                state.bMarks[first] + state.tShift[first],
+                state.eMarks[first],
+            );
+            const parsed = opener(line);
+            if (!parsed) return false;
+            if (silent) return true;
+            let close = first + 1;
+            while (close < past) {
+                const text = state.src.slice(
+                    state.bMarks[close] + state.tShift[close],
+                    state.eMarks[close],
+                );
+                if (/^ *:::[ \t]*$/.test(text)) break;
+                close++;
+            }
+            const closed = close < past;
+            const original = state.env.verseSource ?? state.src;
+            const rawLines = original.split(/\r\n|\r|\n/);
+            const starts = [0];
+            for (const match of original.matchAll(/\r\n|\r|\n/g))
+                starts.push(match.index + match[0].length);
+            const from = starts[first] ?? original.length;
+            const bodyStart = starts[first + 1] ?? original.length;
+            let bodyEnd = starts[close] ?? original.length;
+            if (bodyEnd > bodyStart) {
+                if (original[bodyEnd - 1] === "\n") bodyEnd--;
+                if (original[bodyEnd - 1] === "\r") bodyEnd--;
+            }
+            const region = {
+                start: first,
+                end: closed ? close : past - 1,
+                from,
+                to: starts[closed ? close + 1 : past] ?? original.length,
+                bodyStart,
+                bodyEnd,
+                body: original.slice(bodyStart, bodyEnd),
+                attributes: parsed.values,
+                id: parsed.id,
+                classes: parsed.classes,
+                indent: /^ */.exec(rawLines[first] ?? "")[0],
+                name: "verse",
+                closed,
+                problems: parsed.problems,
+            };
+            const token = state.push("verse_div", "div", 0);
+            token.block = true;
+            token.map = [first, closed ? close + 1 : past];
+            token.content = region.body;
+            token.meta = { verseRegion: region };
+            state.line = closed ? close + 1 : past;
+            return true;
+        },
+        { alt: ["paragraph", "reference", "blockquote", "list"] },
+    );
+}
+
+const parser = new MarkdownIt({ html: true }).use(verseDivPlugin);
+parser.core.ruler.disable(["inline", "linkify", "replacements", "smartquotes", "text_join"]);
+
+/**
+ * Locate complete raw verse divs while leaving literal examples untouched.
+ * @param {string} source - Authored Markdown.
+ * @returns {VerseRegion[]} Regions in source order, including unclosed divs.
+ */
+export function verseRegions(source) {
+    return parser
+        .parse(source, { verseSource: source })
+        .filter((token) => token.type === "verse_div")
+        .map((token) => token.meta.verseRegion);
+}
+
+/**
+ * Source ranges belonging to inline syntax rather than visible verse text.
+ * @param {string} source - Inline Markdown.
+ * @returns {Array<[number,number]>} Protected UTF-16 ranges.
+ */
+export function inlineSyntaxRanges(source) {
+    const ranges = [];
+    for (const match of source.matchAll(new RegExp(WIKILINK.source, "g"))) {
+        const separator = match[0].indexOf("|");
+        const close = match[0].indexOf("]]");
+        ranges.push([match.index, match.index + (separator < 0 ? close + 2 : separator + 1)]);
+        ranges.push([match.index + close, match.index + match[0].length]);
+    }
+    for (let at = 0; at < source.length; at++) {
+        if (source[at] === "\\") {
+            at++;
+            continue;
+        }
+        const char = source[at];
+        let past = -1;
+        if (char === "⟦") past = source.indexOf("⟧", at + 1) + 1;
+        else if (char === "`") {
+            const mark = /^`+/.exec(source.slice(at))[0];
+            const close = source.indexOf(mark, at + mark.length);
+            if (close >= 0) past = close + mark.length;
+        } else if (source.startsWith("<!--", at)) past = source.indexOf("-->", at + 4) + 3;
+        else if (char === "<") past = source.indexOf(">", at + 1) + 1;
+        else if (char === "{") past = source.indexOf("}", at + 1) + 1;
+        else if (char === "(" && source[at - 1] === "]") {
+            let depth = 1;
+            for (let next = at + 1; next < source.length; next++) {
+                if (source[next] === "\\") {
+                    next++;
+                    continue;
+                }
+                if (source[next] === "(") depth++;
+                if (source[next] === ")" && !--depth) {
+                    past = next + 1;
+                    break;
+                }
+            }
+        }
+        if (past > at) {
+            ranges.push([at, past]);
+            at = past - 1;
+        }
+    }
+    return ranges.sort((a, b) => a[0] - b[0] || b[1] - a[1]);
+}

package/engine/wikilink-pattern.mjs

@@ -0,0 +1,31 @@
+/*
+ * This file is part of the Song of Heroic Lands (SoHL) system for Foundry VTT.
+ * Copyright (c) 2024-2026 Tom Rodriguez ("Toasty") — <toasty@heroiclands.org>
+ *
+ * This work is licensed under the GNU General Public License v3.0 (GPLv3).
+ * You may copy, modify, and distribute it under the terms of that license.
+ *
+ * For full terms, see the LICENSE.md file in the project root or visit:
+ * https://www.gnu.org/licenses/gpl-3.0.html
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+/** The dependency-free lexical wikilink pattern. @module */
+
+/**
+ * A wikilink, as authored.
+ *
+ * **Newlines are excluded deliberately.** A link is written on one line; an
+ * unclosed `[[` is a typo, and the alternative is letting it swallow arbitrary
+ * prose in search of a closer. Erring towards "not a link" leaves the author's
+ * text as written, which is the safe direction for a rewriter.
+ *
+ * **A leading `!` makes it an embed, not a link**, and the lookbehind is what
+ * keeps every reader from seeing one as the other. Stated here rather than in
+ * each reader for the reason the rest of this module exists: the checker, the
+ * resolver and the embed reader all match on this pattern, and a copy of the
+ * exclusion in each is a place for it to be forgotten. An embed's
+ * own grammar is {@link module:engine/content-embeds}.
+ */
+export const WIKILINK = /(?<!!)\[\[([^\]\n]+)\]\](?:\{(?:[^{}"\n]|"(?:\\.|[^"\\\n])*")*\})?/g;

package/engine/wikilink-syntax.mjs

@@ -42,22 +42,8 @@ import { parseAddress, isAddressTuple, splitAnchor } from "./address.mjs";
  * @module
  */
 
-/**
- * A wikilink, as authored.
- *
- * **Newlines are excluded deliberately.** A link is written on one line; an
- * unclosed `[[` is a typo, and the alternative is letting it swallow arbitrary
- * prose in search of a closer. Erring towards "not a link" leaves the author's
- * text as written, which is the safe direction for a rewriter.
- *
- * **A leading `!` makes it an embed, not a link**, and the lookbehind is what
- * keeps every reader from seeing one as the other. Stated here rather than in
- * each reader for the reason the rest of this module exists: the checker, the
- * resolver and the embed reader all match on this pattern, and a copy of the
- * exclusion in each is a place for it to be forgotten. An embed's
- * own grammar is {@link module:engine/content-embeds}.
- */
-export const WIKILINK = /(?<!!)\[\[([^\]\n]+)\]\](?:\{(?:[^{}"\n]|"(?:\\.|[^"\\\n])*")*\})?/g;
+import { WIKILINK } from "./wikilink-pattern.mjs";
+export { WIKILINK } from "./wikilink-pattern.mjs";
 
 /**
  * The parts of a wikilink's interior.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@heroiclands/package-build",
-    "version": "25.2.1",
+    "version": "25.4.0",
     "description": "Shared toolchain for building and shipping a HeroicLands Foundry VTT package \u2014 content compilation, manifest, localization, staging, bundle, release and deployment.",
     "license": "GPL-3.0-or-later",
     "type": "module",