@heroiclands/package-build 25.0.0 → 25.1.1

package/engine/content-scroll.mjs

@@ -16,7 +16,7 @@
  * from the right, as a handscroll unrolls.
  *
  * ````markdown
- * ```scroll {rows=25 cols=12 lang=tsu map=tengchou}
+ * ```scroll {rows=25 cols=12 lang=tsu enc=tengchou}
  * chen teng chou hing
  * tan tsou dou rou
  *
@@ -29,7 +29,7 @@
  *   blank line starts the next paragraph, flush at the top of a fresh column.
  * - **`rows=`** is the characters in a column and **`cols=`** the columns in a
  *   panel, each a whole number above zero. Either may be left out.
- * - **`lang=`, `font=` and `map=`** are read by
+ * - **`lang=`, `font=` and `enc=`** are read by
  *   {@link module:engine/content-scripts.scanRuns}, which maps the text and
  *   refuses a fence whose script its note does not state is written in
  *   columns.
@@ -56,7 +56,7 @@ export const SCROLL_KEYS = Object.freeze([
     "cols",
     "lang",
     "font",
-    "map",
+    "enc",
     "data-pagefind-ignore",
 ]);
 
@@ -195,7 +195,7 @@ export function scanScrolls(source) {
                 errors.push({
                     line: i + 1,
                     column: columns.key,
-                    message: `\`${key}=\` is not a scroll attribute; a scroll takes \`rows=\`, \`cols=\`, \`lang=\`, \`font=\` and \`map=\``,
+                    message: `\`${key}=\` is not a scroll attribute; a scroll takes \`rows=\`, \`cols=\`, \`lang=\`, \`font=\` and \`enc=\``,
                 });
                 scroll.invalid = true;
             } else if (Object.hasOwn(SIZE_KEYS, key)) {

package/engine/content-spans.mjs

@@ -27,11 +27,11 @@ import { cartoucheProblems, glyphProblems } from "./content-glyphs.mjs";
  * @param {boolean} [options.spoilers] - Add focusable CSS spoiler wrappers (Foundry).
  */
 export function spanMarkdownPlugin(md, { spoilers = false, source = false } = {}) {
-    if (spoilers) {
+    {
         md.renderer.rules.span_open = (tokens, index, options, env, renderer) => {
             const token = tokens[index];
             const secret = (token.attrGet("class") ?? "").split(/\s+/).includes("secret");
-            if (secret) {
+            if (spoilers && secret) {
                 token.attrSet("data-inline-spoiler", "");
                 token.attrSet("tabindex", "0");
                 if (!token.attrGet("title"))
@@ -39,7 +39,18 @@ export function spanMarkdownPlugin(md, { spoilers = false, source = false } = {}
                 if (!token.attrGet("aria-label"))
                     token.attrSet("aria-label", "Spoiler; focus to reveal");
             }
-            return renderer.renderToken(tokens, index, options);
+            const original = token.attrs;
+            if (["em", "strong"].includes(token.tag))
+                token.attrs = (token.attrs ?? []).flatMap(([key, value]) => {
+                    if (key !== "class") return [[key, value]];
+                    const classes = value
+                        .split(/\s+/)
+                        .filter((name) => !["emph", "strong"].includes(name));
+                    return classes.length ? [[key, classes.join(" ")]] : [];
+                });
+            const rendered = renderer.renderToken(tokens, index, options);
+            token.attrs = original;
+            return rendered;
         };
     }
     md.inline.ruler.after("link", "bracket_span", (state, silent) => {
@@ -97,7 +108,7 @@ export function spanMarkdownPlugin(md, { spoilers = false, source = false } = {}
         // there for ordinary spans, including names used by the first-use audit.
         if (
             state.src[start - 1] === "[" &&
-            !["lang", "font", "map"].some((key) => Object.hasOwn(parsed.values, key)) &&
+            !["lang", "font", "enc"].some((key) => Object.hasOwn(parsed.values, key)) &&
             !parsed.classes.some(
                 (name) => name === "script" || /^font-(?:mono|serif|sans)$/.test(name),
             )
@@ -110,7 +121,11 @@ export function spanMarkdownPlugin(md, { spoilers = false, source = false } = {}
             state.pos = finish;
             return true;
         }
-        if (source) {
+        const emphasis =
+            parsed.classes.includes("emph") ? "em"
+            : parsed.classes.includes("strong") ? "strong"
+            : undefined;
+        if (source && !emphasis) {
             // An incomplete attribute stays opaque through the end of its line.
             if (state.src[finish] === "{") {
                 const newline = state.src.indexOf("\n", finish);
@@ -126,7 +141,7 @@ export function spanMarkdownPlugin(md, { spoilers = false, source = false } = {}
             state.pos = finish;
             return true;
         }
-        const token = state.push("span_open", "span", 1);
+        const token = state.push("span_open", emphasis ?? "span", 1);
         token.meta = {
             span: true,
             start,
@@ -162,7 +177,7 @@ export function spanMarkdownPlugin(md, { spoilers = false, source = false } = {}
                     }
             }
         state.tokens.push(...nested);
-        state.push("span_close", "span", -1);
+        state.push("span_close", emphasis ?? "span", -1);
         state.pos = finish;
         return true;
     });
@@ -315,7 +330,23 @@ export function renderSpans(source) {
             (span) => !spans.some((parent) => parent.start < span.start && parent.end >= span.end),
         )
         .sort((a, b) => b.start - a.start)) {
-        const attrs = span.attrs.map(([key, value]) => ` ${key}="${escape(value)}"`).join("");
+        const classes = (span.attrs.find(([key]) => key === "class")?.[1] ?? "").split(/\s+/);
+        const tag =
+            classes.includes("emph") ? "em"
+            : classes.includes("strong") ? "strong"
+            : "span";
+        const attrs = span.attrs
+            .flatMap(([key, value]) => {
+                if (key === "class" && tag !== "span") {
+                    value = value
+                        .split(/\s+/)
+                        .filter((name) => !["emph", "strong"].includes(name))
+                        .join(" ");
+                    if (!value) return [];
+                }
+                return [` ${key}="${escape(value)}"`];
+            })
+            .join("");
         const inner = renderSpans(markdown.slice(span.start + 1, span.contentEnd)).markdown;
         const secret = span.attrs.some(
             ([key, value]) => key === "class" && value.split(/\s+/).includes("secret"),
@@ -323,7 +354,7 @@ export function renderSpans(source) {
         const content =
             secret ?
                 `<span${attrs} data-inline-secret data-pagefind-ignore><button type="button" class="inline-secret-toggle" aria-label="Show spoiler" aria-expanded="false">Show spoiler</button><span class="inline-secret-content" hidden>${inner}</span></span>`
-            :   `<span${attrs}>${inner}</span>`;
+            :   `<${tag}${attrs}>${inner}</${tag}>`;
         markdown = markdown.slice(0, span.start) + content + markdown.slice(span.end);
     }
     return { markdown, errors };

package/engine/content-verse.mjs

@@ -208,7 +208,7 @@ export const VERSE_KEYS = Object.freeze([
     "scan",
     "lang",
     "font",
-    "map",
+    "enc",
     "numstep",
     "cols",
     "dir",

package/engine/converter-data.mjs

@@ -0,0 +1,70 @@
+/*
+ * 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
+ */
+/** Build the browser's JSON inputs from the same context that renders native runs. */
+import fs from "node:fs";
+import path from "node:path";
+import { runContext } from "./content-scripts.mjs";
+import { languageRecordsByName, serializeLexicon } from "./encoding-lexicon.mjs";
+import { indexRecordsFor } from "./content-index.mjs";
+import { validateData } from "../convert.mjs";
+
+/** Return only the published definitions and lexical inputs the converter reads. */
+export function buildConverterData(config, records) {
+    const context = runContext(config, records);
+    if (context.encodingFindings?.length)
+        throw new Error(context.encodingFindings.map((finding) => finding.message).join("\n"));
+    const languageNotes = languageRecordsByName(records, config);
+    const data = { format: 2, contentPackage: config.contentPackage, encodings: {}, languages: {} };
+    for (const [name, definition] of context.encodingDefinitions ?? [])
+        data.encodings[name] = definition;
+    for (const language of Object.keys(config.languages ?? {})) {
+        const note = languageNotes.get(language);
+        const name = note?.name;
+        data.languages[language] = {
+            name: typeof name === "string" ? name : (name?.full ?? language),
+            ...(context.lexicons?.has(language) ?
+                { lexicon: serializeLexicon(context.lexicons.get(language)) }
+            :   {}),
+        };
+    }
+    return validateData(data);
+}
+
+/** Write opted-in converter inputs during the package's manifest build. */
+export function writeConverterData({ config, packageBuild, records }) {
+    if (!packageBuild.converterData) return undefined;
+    const stage = path.resolve(config.rootDir, packageBuild.stageDir);
+    const out = path.resolve(stage, packageBuild.converterData);
+    const relative = path.relative(stage, out);
+    if (
+        !relative ||
+        relative.startsWith(`..${path.sep}`) ||
+        relative === ".." ||
+        path.isAbsolute(relative)
+    )
+        throw new Error("converterData must be a file within the build stage");
+    const problems = [];
+    const inputs =
+        records ??
+        indexRecordsFor({
+            config,
+            contentBase: config.paths.content,
+            skipDirectories: config.skipDirectories,
+            problems,
+        });
+    if (problems.length) throw new Error(problems.map((finding) => finding.message).join("\n"));
+    const data = buildConverterData(config, inputs);
+    fs.mkdirSync(path.dirname(out), { recursive: true });
+    fs.writeFileSync(out, JSON.stringify(data, null, 4) + "\n", "utf8");
+    return { path: out, data };
+}

package/engine/dictionary-rows.mjs

@@ -48,6 +48,8 @@
  * @module
  */
 
+import { pluralOf, pluralByRule } from "./word-inflections.mjs";
+export { pluralOf, pluralByRule } from "./word-inflections.mjs";
 import { createHash } from "node:crypto";
 import { parseAddress, renderAddress } from "./address.mjs";
 import { glossaryLanguage } from "./glossary-language.mjs";
@@ -130,40 +132,6 @@ const isSingleWord = (title) => !/[\s\-‐‑]/u.test(title);
 /** Whether a glossary entry states a definition. */
 const defines = (entry) => typeof entry.definition === "string" && entry.definition.trim() !== "";
 
-/**
- * A noun's stated plural, or the first literal ending replacement that fits.
- *
- * @param {{form: string, class?: unknown, plural?: unknown}} word - A word of
- *   `data.words`.
- * @param {Record<string, any>|undefined} grammar - Its language's
- *   `data.grammar`.
- * @returns {string|null} The plural, or `null` for a word that is no noun or
- *   that no rule fits.
- */
-export function pluralOf(word, grammar) {
-    if (parseWordClass(word.class).base !== "n") return null;
-    if (typeof word.plural === "string" && word.plural) return word.plural;
-    return pluralByRule(word.form, grammar);
-}
-
-/**
- * The plural a language's `data.grammar.plural` rule gives a form: the first
- * literal ending replacement that fits, whatever the form's class.
- *
- * @param {string} form - The form.
- * @param {Record<string, any>|undefined} grammar - Its language's
- *   `data.grammar`.
- * @returns {string|null} The plural, or `null` where no rule fits.
- */
-export function pluralByRule(form, grammar) {
-    for (const rule of Array.isArray(grammar?.plural) ? grammar.plural : []) {
-        if (typeof rule?.ending !== "string" || typeof rule.becomes !== "string") continue;
-        if (form.endsWith(rule.ending))
-            return (rule.ending ? form.slice(0, -rule.ending.length) : form) + rule.becomes;
-    }
-    return null;
-}
-
 /**
  * The stable prose anchor of a word in one language's dictionary. The exact
  * language and NFC form identify it, including case and accents.

package/engine/encoding-integrity.mjs

@@ -0,0 +1,94 @@
+/*
+ * 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
+ */
+
+/** Prove ordinary output tokens uniquely decodable without adding invisible metadata. */
+
+/**
+ * Check codeword integrity with a trie and finite Sardinas–Patterson residuals.
+ * Source-equivalent compositions are redundant rules, not distinct spellings.
+ * @param {Array<{from:string,to:string,key:string,before?:string,at?:string}>} rows - Validated ordinary rows.
+ * @param {(key:string,message:string)=>never} fault - Positioned schema-error constructor.
+ */
+export function assertUniqueOutputs(rows, fault) {
+    const bySource = new Map();
+    for (const row of rows) {
+        if (row.before || row.at) continue;
+        const first = [...row.from][0];
+        if (!bySource.has(first)) bySource.set(first, []);
+        bySource.get(first).push(row);
+    }
+    for (const group of bySource.values()) group.sort((a, b) => b.from.length - a.from.length);
+    const redundant = (row) => {
+        if (row.before || row.at || [...row.from].length < 2) return false;
+        let at = 0,
+            output = "";
+        while (at < row.from.length) {
+            const first = String.fromCodePoint(row.from.codePointAt(at));
+            const part = (bySource.get(first) ?? []).find(
+                (one) => one.from.length < row.from.length && row.from.startsWith(one.from, at),
+            );
+            if (!part) return false;
+            output += part.to;
+            at += part.from.length;
+        }
+        return output === row.to;
+    };
+    const words = [
+        ...new Map(rows.filter((row) => !redundant(row)).map((row) => [row.to, row])).values(),
+    ];
+    const node = () => ({ children: new Map(), word: undefined, words: [] });
+    const root = node();
+    for (const word of words) {
+        let cursor = root;
+        cursor.words.push(word);
+        for (const char of word.to) {
+            if (!cursor.children.has(char)) cursor.children.set(char, node());
+            cursor = cursor.children.get(char);
+            cursor.words.push(word);
+        }
+        cursor.word = word;
+    }
+    const pending = [],
+        seen = new Set();
+    const add = (residual, key) => {
+        if (!residual)
+            fault(key, "Output sequences are ambiguous; the encoding must be uniquely decodable");
+        if (!seen.has(residual)) {
+            seen.add(residual);
+            pending.push({ residual, key });
+        }
+    };
+    // A residual is the unmatched suffix after cancelling one output prefix.
+    for (const word of words) {
+        let cursor = root,
+            offset = 0;
+        for (const char of word.to) {
+            cursor = cursor.children.get(char);
+            offset += char.length;
+            if (cursor.word && offset < word.to.length) add(word.to.slice(offset), word.key);
+        }
+    }
+    for (let i = 0; i < pending.length; i++) {
+        const { residual, key } = pending[i];
+        let cursor = root,
+            offset = 0;
+        for (const char of residual) {
+            cursor = cursor.children.get(char);
+            if (!cursor) break;
+            offset += char.length;
+            if (cursor.word) add(residual.slice(offset), key);
+        }
+        if (cursor && offset === residual.length)
+            for (const word of cursor.words) add(word.to.slice(offset), key);
+    }
+}