@heroiclands/package-build 25.6.0 → 25.6.2

package/engine/encoding.mjs

@@ -114,14 +114,14 @@ function rows(value, key, vowels, allowEmpty) {
     if (!Array.isArray(value)) fault(key, `\`${key}\` must be a list of rows`);
     return value.map((value, order) => {
         const at = `${key}.${order}`;
-        let from, to, before, position;
+        let from, to, after, before, position;
         if (Array.isArray(value)) {
             if (value.length !== 2) fault(at, "A row is two strings, [from, to]");
             [from, to] = value;
         } else if (object(value)) {
-            keys(value, new Set(["from", "to", "before", "at"]), at);
-            ({ from, to, before, at: position } = value);
-        } else fault(at, "A row is [from, to] or {from, to, before?, at?}");
+            keys(value, new Set(["from", "to", "after", "before", "at"]), at);
+            ({ from, to, after, before, at: position } = value);
+        } else fault(at, "A row is [from, to] or {from, to, after?, before?, at?}");
         string(from, `${at}.from`, true);
         string(to, `${at}.to`);
         if (from.includes(OPEN) || from.includes(CLOSE))
@@ -130,12 +130,23 @@ function rows(value, key, vowels, allowEmpty) {
             fault(`${at}.from`, "Whitespace is stated by separator");
         if (!to && !allowEmpty && from !== " ")
             fault(`${at}.to`, "An exact row must write a nonempty output");
+        if (after !== undefined) {
+            if (
+                !["vowel", "consonant"].includes(after) &&
+                (typeof after !== "string" ||
+                    !LETTER.test(after) ||
+                    after !== after.normalize("NFC"))
+            )
+                fault(`${at}.after`, "after is one NFC Unicode letter, vowel or consonant");
+            if (["vowel", "consonant"].includes(after) && !vowels)
+                fault(`${at}.after`, "after categories need vowels");
+        }
         if (before !== undefined && !["vowel", "consonant"].includes(before))
             fault(`${at}.before`, "before is vowel or consonant");
         if (before && !vowels) fault(`${at}.before`, "before needs vowels");
         if (position !== undefined && !["start", "end", "line-start"].includes(position))
             fault(`${at}.at`, "at is start, end or line-start");
-        return Object.freeze({ from, to, before, at: position, order, key: at });
+        return Object.freeze({ from, to, after, before, at: position, order, key: at });
     });
 }
 function indexRows(rows) {
@@ -149,7 +160,8 @@ function indexRows(rows) {
         group.sort(
             (a, b) =>
                 length(b.from) - length(a.from) ||
-                Number(Boolean(b.before || b.at)) - Number(Boolean(a.before || a.at)) ||
+                Number(Boolean(b.after || b.before || b.at)) -
+                    Number(Boolean(a.after || a.before || a.at)) ||
                 a.order - b.order,
         );
     return index;
@@ -328,6 +340,15 @@ function beforeHolds(condition, char, vowels) {
     );
 }
 function holds(row, text, start, end, vowels) {
+    if (row.after) {
+        const preceding = start > 0 ? previousAt(text, start) : undefined;
+        if (
+            ["vowel", "consonant"].includes(row.after) ?
+                !beforeHolds(row.after, preceding, vowels)
+            :   preceding !== row.after
+        )
+            return false;
+    }
     if (row.before && !beforeHolds(row.before, firstAt(text, end), vowels)) return false;
     if (row.at === "line-start") {
         let slash = text.lastIndexOf("/", start - 1);
@@ -470,7 +491,11 @@ function checkGroupCase(enc, groups, text, at, bound) {
  * @param {string} text
  * @param {{font?: string, verse?: boolean, start?: number, end?: number}} [options]
  */
-function encodeRawPieces(enc, text, { font, verse = false, start = 0, end = text.length } = {}) {
+function encodeRawPieces(
+    enc,
+    text,
+    { font, verse = false, start = 0, end = text.length, stops = [] } = {},
+) {
     const groups = tiers(enc, font);
     if (typeof text !== "string") throw new EncodingError("Text must be a string");
     if (
@@ -485,9 +510,13 @@ function encodeRawPieces(enc, text, { font, verse = false, start = 0, end = text
         });
     const bound = end;
     const out = [];
-    let at = start;
+    let at = start,
+        stop = 0;
     while (at < bound) {
         const first = firstAt(text, at);
+        while (stop < stops.length && stops[stop] <= at) stop++;
+        // A row never spans the start of a diaeresis vowel written by its plain vowel.
+        const limit = Math.min(bound, stops[stop] ?? bound);
         if (first === OPEN) {
             const close = span(text.slice(0, bound), at, OPEN, CLOSE);
             out.push(
@@ -545,7 +574,7 @@ function encodeRawPieces(enc, text, { font, verse = false, start = 0, end = text
             continue;
         }
         if (!enc.template) checkGroupCase(enc, groups, text, at, bound);
-        const row = enc.accepted.has(first) ? rowAt(enc, groups, text, at, bound) : null;
+        const row = enc.accepted.has(first) ? rowAt(enc, groups, text, at, limit) : null;
         if (!row)
             refused(
                 enc,
@@ -688,7 +717,13 @@ function sourceDetails(enc, text, options) {
                     pointSlice(normalized.slice(0, bound), at, enc.template.maxVowelGroup)
                 :   "";
             const lower = lookahead.normalize("NFD").replace(/\p{M}/gu, "").toLowerCase();
-            const group = enc.template?.vowelGroups.find((value) => lower.startsWith(value));
+            const group = enc.template?.vowelGroups.find(
+                (value) =>
+                    lower.startsWith(value) &&
+                    [...lookahead]
+                        .slice(1, [...value].length)
+                        .every((letter) => !/[\u0308\u0300]/u.test(letter.normalize("NFD"))),
+            );
             if (group) {
                 let cursor = at;
                 for (let i = 0; i < [...group].length; i++) {
@@ -713,7 +748,16 @@ function sourceDetails(enc, text, options) {
             });
         throw error;
     }
-    return projection;
+    const letters = enc.template?.apart?.letters;
+    if (!letters) return { ...projection, folded: normalized, stops: [] };
+    const stops = [];
+    let folded = "";
+    for (let at = 0; at < normalized.length; at++) {
+        const plain = at >= begin && at < bound ? letters[normalized[at]] : undefined;
+        if (plain) stops.push(at);
+        folded += plain ?? normalized[at];
+    }
+    return { ...projection, folded, stops };
 }
 
 /**
@@ -736,16 +780,49 @@ export function validateSource(enc, text, options = {}) {
  */
 export function encodePieces(enc, text, options = {}) {
     if (!enc?.template) return encodeRawPieces(enc, text, options);
-    const { normalized, sourceAt, begin, bound } = sourceDetails(enc, text, options);
+    const { normalized, folded, stops, sourceAt, begin, bound } = sourceDetails(enc, text, options);
     try {
-        return encodeRawPieces(enc, normalized, { ...options, start: begin, end: bound }).map(
-            (one) => ({
-                ...one,
-                from: text.slice(sourceAt[one.start], sourceAt[one.end]),
-                start: sourceAt[one.start],
-                end: sourceAt[one.end],
-            }),
-        );
+        const pieces = encodeRawPieces(enc, folded, {
+            ...options,
+            start: begin,
+            end: bound,
+            stops,
+        });
+        if (enc.roundTrip === "exact" && stops.length) {
+            const native = pieces.map((one) => one.to).join("");
+            const decoded = decodeTemplatePieces(enc, native, options);
+            let nativeAt = 0;
+            for (const one of pieces) {
+                const expected = normalized.slice(one.start, one.end);
+                const marked = stops.find(
+                    (at) =>
+                        at >= one.start &&
+                        at < one.end &&
+                        splitsDeclaredGroup(enc, normalized, at, begin, bound),
+                );
+                if (
+                    marked !== undefined &&
+                    !decoded.some(
+                        (step) =>
+                            step.start === nativeAt &&
+                            step.end === nativeAt + one.to.length &&
+                            step.from === expected,
+                    )
+                )
+                    textError(
+                        folded,
+                        marked,
+                        "The encoding cannot distinguish this diaeresis split in an exact round trip",
+                    );
+                nativeAt += one.to.length;
+            }
+        }
+        return pieces.map((one) => ({
+            ...one,
+            from: text.slice(sourceAt[one.start], sourceAt[one.end]),
+            start: sourceAt[one.start],
+            end: sourceAt[one.end],
+        }));
     } catch (error) {
         if (error instanceof EncodingError && error.offset !== undefined)
             throw new EncodingError(error.message, {
@@ -845,6 +922,12 @@ function decodeRawText(enc, text, { font } = {}) {
  */
 export function decodeText(enc, text, options = {}) {
     if (!enc?.template) return decodeRawText(enc, text, options);
+    return decodeTemplatePieces(enc, text, options)
+        .map((one) => one.from)
+        .join("");
+}
+
+function decodeTemplatePieces(enc, text, options = {}) {
     const readings = tiers(enc, options.font)[0].readings;
     if (typeof text !== "string") throw new EncodingError("Text must be a string");
     if (!templateReaders.has(enc)) {
@@ -905,7 +988,7 @@ export function decodeText(enc, text, options = {}) {
                 failedContext = Math.min(failedContext, at);
                 continue;
             }
-            paths.set(at, { from: row.from, next });
+            paths.set(at, { from: row.from, row, next });
         }
     }
     if (!paths.has(0)) {
@@ -950,8 +1033,76 @@ export function decodeText(enc, text, options = {}) {
     const out = [];
     for (let at = 0; at < text.length;) {
         const step = paths.get(at);
-        out.push(step.from);
+        out.push({ from: step.from, row: step.row, start: at, end: step.next });
         at = step.next;
     }
-    return out.join("");
+    const apart = enc.template.apart;
+    if (!apart) return out;
+    return restoreDiaeresis(enc, out, options);
+}
+
+/** Restore only joins contradicted by the selected native row boundaries. */
+function restoreDiaeresis(enc, pieces, options) {
+    const text = pieces.map((one) => one.from).join("");
+    const letters = [];
+    let offset = 0;
+    for (const [part, piece] of pieces.entries()) {
+        for (const char of piece.from) {
+            letters.push({ char, part, offset, literal: !piece.row });
+            offset += char.length;
+        }
+    }
+    const groups = tiers(enc, options.font);
+    for (let i = 0; i < letters.length; i++) {
+        if (letters[i].literal) continue;
+        const group = enc.template.apart.groups.find((value) => {
+            const span = [...value];
+            if (
+                !span.every((char, k) => {
+                    const letter = letters[i + k];
+                    return (
+                        letter &&
+                        !letter.literal &&
+                        letter.char.normalize("NFD").replace(/\p{M}/gu, "").toLowerCase() ===
+                            char &&
+                        (k === 0 || letter.char.normalize("NFD").length === 1)
+                    );
+                })
+            )
+                return false;
+            const row = rowAt(enc, groups, text, letters[i].offset);
+            return row && row.from.toLowerCase() === value;
+        });
+        if (!group) continue;
+        const end = i + [...group].length;
+        let boundary = i + 1;
+        while (boundary < end && letters[boundary].part === letters[i].part) boundary++;
+        if (boundary === end) {
+            i = end - 1;
+            continue;
+        }
+        const letter = letters[boundary];
+        const marked = (letter.char + "\u0308").normalize("NFC");
+        if (enc.template.apart.letters[marked]) {
+            letter.char = marked;
+            i = boundary - 1;
+        }
+    }
+    const output = pieces.map((piece) => ({ ...piece, from: "" }));
+    for (const letter of letters) output[letter.part].from += letter.char;
+    return output;
+}
+
+/** Whether a derived mark actually splits one of this note's declared groups. */
+function splitsDeclaredGroup(enc, text, at, begin, bound) {
+    for (const group of enc.template.apart.groups) {
+        const count = [...group].length;
+        // The supported diaeresis letters are one NFC UTF-16 unit each.
+        for (let start = Math.max(begin, at - count + 1); start < at; start++) {
+            const span = pointSlice(text.slice(0, bound), start, count);
+            if (start + span.length <= at) continue;
+            if (span.normalize("NFD").replace(/\p{M}/gu, "").toLowerCase() === group) return true;
+        }
+    }
+    return false;
 }

package/engine/language-terms.mjs

@@ -154,10 +154,10 @@ export const JOIN_RULES = Object.freeze(["merge", "insert", "drop", "double"]);
 
 /**
  * What a written mark says of its letter: `stress` falls on it, `length` holds
- * it longer, `apart` says it apart from its neighbour, and `quality` changes
- * which vowel is said.
+ * it longer, `apart` says it apart from its neighbour, `quality` changes
+ * which vowel is said, and `tone` marks a rising or falling pitch.
  */
-export const MARK_KINDS = Object.freeze(["stress", "length", "apart", "quality"]);
+export const MARK_KINDS = Object.freeze(["stress", "length", "apart", "quality", "tone"]);
 
 /** How many of a mark a word may carry: `one` at most, or `any` number. */
 export const MARK_LIMITS = Object.freeze(["one", "any"]);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@heroiclands/package-build",
-    "version": "25.6.0",
+    "version": "25.6.2",
     "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",

package/types/engine/content-scripts.d.mts

@@ -261,6 +261,12 @@ export type RunContext = {
             maxVowelGroup: number;
             stress: "󠄔" | undefined;
             diaeresis: boolean;
+            apart: Readonly<{
+                letters: Readonly<{
+                    [k: string]: string;
+                }>;
+                groups: any;
+            }> | undefined;
             grave: boolean;
         }> | undefined;
         fonts: readonly any[];

package/types/engine/encoding-integrity.d.mts

@@ -2,13 +2,14 @@
 /**
  * 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 {Array<{from:string,to:string,key:string,after?:string,before?:string,at?:string}>} rows - Validated ordinary rows.
  * @param {(key:string,message:string)=>never} fault - Positioned schema-error constructor.
  */
 export function assertUniqueOutputs(rows: Array<{
     from: string;
     to: string;
     key: string;
+    after?: string;
     before?: string;
     at?: string;
 }>, fault: (key: string, message: string) => never): void;

package/types/engine/encoding-lexicon.d.mts

@@ -90,6 +90,12 @@ export function encodingFor(ctx: import("./content-scripts.mjs").RunContext, { e
             maxVowelGroup: number;
             stress: "󠄔" | undefined;
             diaeresis: boolean;
+            apart: Readonly<{
+                letters: Readonly<{
+                    [k: string]: string;
+                }>;
+                groups: any;
+            }> | undefined;
             grave: boolean;
         }> | undefined;
         fonts: readonly any[];

package/types/engine/encoding-template.d.mts

@@ -38,6 +38,12 @@ export function templateProgram(data: any, options: {
             maxVowelGroup: number;
             stress: "󠄔" | undefined;
             diaeresis: boolean;
+            apart: Readonly<{
+                letters: Readonly<{
+                    [k: string]: string;
+                }>;
+                groups: any;
+            }> | undefined;
             grave: boolean;
         }>;
     };

package/types/engine/encoding.d.mts

@@ -16,6 +16,12 @@ export function compileEncoding(data: any, options?: {
         maxVowelGroup: number;
         stress: "󠄔" | undefined;
         diaeresis: boolean;
+        apart: Readonly<{
+            letters: Readonly<{
+                [k: string]: string;
+            }>;
+            groups: any;
+        }> | undefined;
         grave: boolean;
     }> | undefined;
     fonts: readonly any[];
@@ -59,6 +65,12 @@ export function compileRows(definition: any, metadata?: Partial<ReturnType<typeo
         maxVowelGroup: number;
         stress: "󠄔" | undefined;
         diaeresis: boolean;
+        apart: Readonly<{
+            letters: Readonly<{
+                [k: string]: string;
+            }>;
+            groups: any;
+        }> | undefined;
         grave: boolean;
     }> | undefined;
     fonts: readonly any[];

package/types/engine/language-terms.d.mts

@@ -96,8 +96,8 @@ export const JOIN_MEETINGS: readonly string[];
 export const JOIN_RULES: readonly string[];
 /**
  * What a written mark says of its letter: `stress` falls on it, `length` holds
- * it longer, `apart` says it apart from its neighbour, and `quality` changes
- * which vowel is said.
+ * it longer, `apart` says it apart from its neighbour, `quality` changes
+ * which vowel is said, and `tone` marks a rising or falling pitch.
  */
 export const MARK_KINDS: readonly string[];
 /** How many of a mark a word may carry: `one` at most, or `any` number. */