rpg-engine 0.0.0-stage → 0.1.0

package/dist/pages/markdown.js

@@ -0,0 +1,271 @@
+import { rememberedByText } from "../core/memo.js";
+import { comparableText, linkTargetName } from "../core/text.js";
+const headingPattern = /^(#{1,6})[ \t]+(.+?)(?:[ \t]+#+)?[ \t]*$/;
+// A callout may stand up to three spaces in, as under an item of a list, and Obsidian still draws it as one.
+const secretPattern = /^[ \t]{0,3}>[ \t]*\[!secret\][+-]?[ \t]*(.*?)[ \t]*$/i;
+const quotePattern = /^[ \t]{0,3}>[ \t]?/;
+// Comments as Obsidian hides them in reading view: between %% marks, and HTML ones.
+const htmlCommentPattern = /<!--[\s\S]*?(?:-->|$)/g;
+const fencePattern = /^[ \t]*(`{3,}|~{3,})(.*)$/;
+// Inline code, as `x` or ``x``: a run of backticks closed by a run just as long.
+const inlineCodePattern = /(?<!`)(`+)(?!`)(.*?)(?<!`)\1(?!`)/g;
+const linkPattern = /\[\[([^\]|#^]+)(?:#([^\]|^]*))?(?:\^[^\]|]*)?(?:\|[^\]]*)?\]\]/g;
+// A goal as a quest lists it, a checkbox: - [ ] to do, - [x] done; in a quote or a secret too.
+const goalPattern = /^[ \t>]*[-*+][ \t]+\[([ xX])\]/;
+/** The titles of the sections in a markdown text. Read once for each text: rules looks through every page's (RUL-6). */
+export function sectionTitles(text) {
+    return rememberedTitles(text);
+}
+const rememberedTitles = rememberedByText((text) => headingsOf(text.split("\n")).map((heading) => heading.title), 20_000);
+/** The names of the secret blocks, written `> [!secret] Name`, in a markdown text. */
+export function secretNames(text) {
+    return secretsOf(text.split("\n")).map((secret) => secret.title);
+}
+/** Names that a text gives to more than one section or secret, ignoring case; each is listed once, as first written. */
+export function repeatedNames(text) {
+    const names = [...sectionTitles(text), ...secretNames(text)];
+    const keys = names.map(comparableText);
+    return names.filter((name, index) => keys.indexOf(keys[index]) === index && keys.lastIndexOf(keys[index]) !== index);
+}
+/** The sections and secrets of a text, in order, each with its own text: a section's heading and lines up to the next heading, without the secrets in them, which are parts of their own. */
+export function textParts(text) {
+    const lines = text.split("\n");
+    const headings = headingsOf(lines);
+    const secrets = secretsOf(lines);
+    const inSecret = (index) => secrets.some((secret) => index >= secret.start && index < secret.end);
+    const sections = headings.map((heading, index) => {
+        const own = lines.slice(heading.line, headings[index + 1]?.line ?? lines.length).filter((_, offset) => !inSecret(heading.line + offset));
+        return { start: heading.line, name: heading.title, text: trimBlankLines(own.join("\n").replace(/\n{3,}/g, "\n\n")) };
+    });
+    const blocks = secrets.map((secret) => ({ start: secret.start, name: secret.title, text: lines.slice(secret.start, secret.end).join("\n") }));
+    return [...sections, ...blocks].sort((first, second) => first.start - second.start).map(({ name, text: partText }) => ({ name, text: partText }));
+}
+/** The introduction of a text, before the first heading, without its secrets. */
+export function introductionText(text) {
+    const lines = text.split("\n");
+    const end = headingsOf(lines)[0]?.line ?? lines.length;
+    const secrets = secretsOf(lines);
+    const own = lines.slice(0, end).filter((_, index) => !secrets.some((secret) => index >= secret.start && index < secret.end));
+    return trimBlankLines(own.join("\n").replace(/\n{3,}/g, "\n\n"));
+}
+/** The own text of a section, without its heading, subsections and secrets, or of a secret, without its mark and quotes; undefined when the text has no part with that name. */
+export function partContent(text, name) {
+    const lines = text.split("\n");
+    const section = findSection(lines, name, "own");
+    if (section !== undefined) {
+        const secrets = secretsWithin(lines, { start: section.start + 1, end: section.end });
+        const own = lines.slice(section.start + 1, section.end).filter((_, offset) => !secrets.some((secret) => section.start + 1 + offset >= secret.start && section.start + 1 + offset < secret.end));
+        return { secret: false, content: trimBlankLines(own.join("\n").replace(/\n{3,}/g, "\n\n")) };
+    }
+    const secret = findSecret(lines, name);
+    return secret === undefined ? undefined : { secret: true, content: trimBlankLines(lines.slice(secret.start + 1, secret.end).map((line) => line.replace(quotePattern, "")).join("\n")) };
+}
+/** A section with its subsections, down to the next heading of the same or a higher level, or a secret block. Names ignore case. */
+export function readSection(text, title) {
+    const lines = text.split("\n");
+    const range = findSection(lines, title, "whole") ?? findSecret(lines, title);
+    return range === undefined ? undefined : trimBlankLines(lines.slice(range.start, range.end).join("\n"));
+}
+/**
+ * Writes the introduction (the text before the first heading), a section's own text (its subsections stay) or a secret block.
+ * Secret blocks inside a rewritten text stay, after the new text. A missing section is added at the end: at the page's top heading level, or as a secret block.
+ */
+export function writeText(text, newText, options) {
+    const lines = text.split("\n");
+    if (options.section === undefined) {
+        const introduction = { start: 0, end: headingsOf(lines)[0]?.line ?? lines.length };
+        return joinBlocks(newContent(lines, introduction, newText, options.mode), lines.slice(introduction.end).join("\n"));
+    }
+    const title = options.section.trim();
+    const section = findSection(lines, title, "own");
+    if (section !== undefined) {
+        if (options.secret) {
+            throw new Error(`"${title}" is a section, not a secret: write it without secret, or give the secret another name.`);
+        }
+        if (options.mode === "remove") {
+            return removeSection(lines, title, section);
+        }
+        const content = newContent(lines, { start: section.start + 1, end: section.end }, newText, options.mode);
+        return joinBlocks(lines.slice(0, section.start).join("\n"), lines[section.start], content, lines.slice(section.end).join("\n"));
+    }
+    const secret = findSecret(lines, title);
+    if (secret !== undefined) {
+        if (options.mode === "remove") {
+            return joinBlocks(lines.slice(0, secret.start).join("\n"), lines.slice(secret.end).join("\n"));
+        }
+        const content = lines.slice(secret.start + 1, secret.end).map((line) => line.replace(quotePattern, "")).join("\n");
+        const quoted = quoteLines(options.mode === "append" ? joinBlocks(content, newText) : newText);
+        return [...lines.slice(0, secret.start + 1), ...quoted, ...lines.slice(secret.end)].join("\n");
+    }
+    if (options.mode === "remove") {
+        throw new Error(`There is no section or secret "${title}" to remove: show the page to see their names, or give some text to create it.`);
+    }
+    const block = options.secret ? [`> [!secret] ${title}`, ...quoteLines(newText)].join("\n") : `${"#".repeat(topHeadingLevel(lines))} ${title}\n\n${newText}`;
+    return joinBlocks(text, block);
+}
+/** The pages a text links to, as in [[Page]], [[Page#Section]], [[Page|label]] or [[folder/Page.md]]. Links in code and in %% comments %% do not count. */
+export function linkedPages(text) {
+    return links(text).map((link) => link.page);
+}
+/**
+ * The links of a text, with the section or secret they point to, as in [[Page#Section]]. Links in code and in %% comments %%, and attachments as ![[map.png]],
+ * do not count. Read once for each text.
+ */
+export function links(text) {
+    return rememberedLinks(text);
+}
+const rememberedLinks = rememberedByText((text) => {
+    // A file of another kind, as ![[map.png]], is an attachment, not a page.
+    const page = (target) => !/\.(?!md$)[a-z0-9]+$/i.test(target.trim());
+    return lineViews(text.split("\n")).flatMap((view) => [...view.prose.matchAll(linkPattern)].filter((match) => page(match[1])).map((match) => linkOf(match[1], match[2])));
+}, 20_000);
+/** Removes the blank lines at the start and the white space at the end. */
+export function trimBlankLines(text) {
+    return text.replace(/^(?:[ \t]*\n)+/, "").trimEnd();
+}
+/** The new text of a range: added to the old one, or in its place, keeping the secret blocks that the new text does not write again. */
+function newContent(lines, range, newText, mode) {
+    if (mode === "append") {
+        return joinBlocks(lines.slice(range.start, range.end).join("\n"), newText);
+    }
+    const rewritten = secretNames(newText).map(comparableText);
+    const kept = secretsWithin(lines, range).filter((secret) => !rewritten.includes(comparableText(secret.title)));
+    return joinBlocks(newText, ...kept.map((secret) => lines.slice(secret.start, secret.end).join("\n")));
+}
+/** Removes a section with its own text; one with subsections or secrets is refused, so that nothing ends up elsewhere or is lost. */
+function removeSection(lines, title, own) {
+    if (findSection(lines, title, "whole")?.end !== own.end) {
+        throw new Error(`"${title}" has subsections: remove them first, then the section.`);
+    }
+    const [secret] = secretsWithin(lines, { start: own.start + 1, end: own.end });
+    if (secret !== undefined) {
+        throw new Error(`"${title}" holds the secret "${secret.title}": remove or move it first, then the section.`);
+    }
+    return joinBlocks(lines.slice(0, own.start).join("\n"), lines.slice(own.end).join("\n"));
+}
+/** Text as the quoted lines of a secret block. */
+function quoteLines(text) {
+    return trimBlankLines(text).split("\n").map((line) => (line === "" ? ">" : `> ${line}`));
+}
+function joinBlocks(...blocks) {
+    return blocks.map(trimBlankLines).filter((block) => block !== "").join("\n\n");
+}
+/** The lines of a section: the whole of it, or only its own text, up to its first subsection. */
+function findSection(lines, title, scope) {
+    const headings = headingsOf(lines);
+    const index = headings.findIndex((heading) => comparableText(heading.title) === comparableText(title.trim()));
+    if (index === -1) {
+        return undefined;
+    }
+    const heading = headings[index];
+    const next = headings.slice(index + 1).find((other) => scope === "own" || other.level <= heading.level);
+    return { start: heading.line, end: next?.line ?? lines.length };
+}
+function secretsWithin(lines, range) {
+    return secretsOf(lines).filter((secret) => secret.start >= range.start && secret.start < range.end);
+}
+function findSecret(lines, title) {
+    return secretsOf(lines).find((secret) => comparableText(secret.title) === comparableText(title.trim()));
+}
+function topHeadingLevel(lines) {
+    const levels = headingsOf(lines).map((heading) => heading.level);
+    return levels.length > 0 ? Math.min(...levels) : 2;
+}
+function headingsOf(lines) {
+    const views = lineViews(lines);
+    const headings = [];
+    lines.forEach((line, index) => {
+        const match = isProse(views[index]) ? headingPattern.exec(line) : null;
+        if (match) {
+            headings.push({ line: index, level: match[1].length, title: match[2].trim() });
+        }
+    });
+    return headings;
+}
+/** The secret blocks: a `> [!secret] Name` line and the quoted lines after it. */
+function secretsOf(lines) {
+    const views = lineViews(lines);
+    const secrets = [];
+    lines.forEach((line, index) => {
+        const match = isProse(views[index]) ? secretPattern.exec(line) : null;
+        if (match) {
+            let end = index + 1;
+            while (end < lines.length && quotePattern.test(lines[end]) && !secretPattern.test(lines[end])) {
+                end++;
+            }
+            secrets.push({ start: index, end, title: match[1] });
+        }
+    });
+    return secrets;
+}
+/** A text without its comments, as Obsidian shows it in reading view: what lies between %% marks, also across lines, and HTML comments; code stays as it is (LNK-2). */
+export function withoutComments(text) {
+    const lines = text.split("\n");
+    const views = lineViews(lines);
+    const shown = lines.map((line, index) => {
+        const parts = line.split("%%");
+        // A line that loses a comment loses the space before it too.
+        return views[index].code || (parts.length === 1 && !views[index].commented) ? line : parts.filter((_, part) => (part % 2 === 0) === !views[index].commented).join("").trimEnd();
+    });
+    return trimBlankLines(shown.join("\n").replace(htmlCommentPattern, "").replace(/\n[ \t]*(?:\n[ \t]*){2,}/g, "\n\n"));
+}
+/** The lines, counted from 1, that mark a secret the engine does not read as one, as a callout four spaces in: written for a secret, read as public text. */
+export function unreadSecretLines(text) {
+    const lines = text.split("\n");
+    const views = lineViews(lines);
+    return lines.flatMap((line, index) => (isProse(views[index]) && /\[!secret\]/i.test(line) && !secretPattern.test(line) ? [index + 1] : []));
+}
+/** The goals a text lists as checkboxes, outside code blocks, each with whether it is ticked; and the text without them, for a quest's card (VIEW-8). */
+export function goalsIn(text) {
+    const lines = text.replace(/\r\n/g, "\n").split("\n");
+    const views = lineViews(lines);
+    const goals = [];
+    const rest = lines.filter((line, index) => {
+        const match = isProse(views[index]) ? goalPattern.exec(line) : null;
+        if (match !== null) {
+            goals.push({ text: line.slice(match[0].length).trim(), done: match[1] !== " " });
+        }
+        return match === null;
+    });
+    return { goals, rest: trimBlankLines(rest.join("\n")) };
+}
+/** Whether a text lists goals as checkboxes, outside code blocks, and every one is ticked. */
+export function everyGoalTicked(text) {
+    const lines = text.replace(/\r\n/g, "\n").split("\n");
+    const views = lineViews(lines);
+    const marks = lines.flatMap((line, index) => (isProse(views[index]) ? (goalPattern.exec(line)?.slice(1) ?? []) : []));
+    return marks.length > 0 && marks.every((mark) => mark !== " ");
+}
+/**
+ * Each line as links and titles read it (LNK-2): whether it is code, a fence or a line of a block, which only a fence of the same character, at least as long and
+ * with nothing after it, closes; whether it begins inside a %% comment, which may span lines; and its prose, without inline code and comments.
+ */
+function lineViews(lines) {
+    let fence;
+    let comment = false;
+    return lines.map((line) => {
+        const [, marks, rest] = fencePattern.exec(line) ?? [];
+        const closes = fence !== undefined && marks?.[0] === fence[0] && marks.length >= fence.length && rest.trim() === "";
+        if (marks !== undefined && !comment && (fence === undefined || closes)) {
+            fence = fence === undefined ? marks : undefined;
+            return { code: true, commented: false, prose: "" };
+        }
+        if (fence !== undefined) {
+            return { code: true, commented: false, prose: "" };
+        }
+        const commented = comment;
+        const parts = line.replace(inlineCodePattern, "").split("%%");
+        comment = parts.length % 2 === 0 ? !comment : comment;
+        return { code: false, commented, prose: parts.filter((_, index) => (index % 2 === 0) === !commented).join("") };
+    });
+}
+/** Whether a line can hold a title, a secret or a goal: neither code nor begun inside a comment. */
+function isProse(view) {
+    return !view.code && !view.commented;
+}
+/** The page and section a link points to: [[folder/Page.md]], and [[Page\|label]] as written in tables, point to Page. */
+function linkOf(target, section) {
+    const page = linkTargetName(target);
+    const title = section?.replace(/\\$/, "").trim();
+    return title === undefined || title === "" ? { page } : { page, section: title };
+}

package/dist/pages/page-file.d.ts

@@ -0,0 +1,26 @@
+/** A page file: its YAML frontmatter, if any, and its markdown text. */
+export interface PageFile {
+    frontmatter?: string;
+    body: string;
+}
+/** Fields to set or remove, and items to add to lists or remove from them. */
+export interface FieldChange {
+    set?: Record<string, unknown>;
+    unset?: string[];
+    add?: Record<string, unknown[]>;
+    remove?: Record<string, unknown[]>;
+}
+export declare function splitPageFile(text: string): PageFile;
+export declare function joinPageFile(file: PageFile): string;
+/** The fields of a frontmatter; `path` names the file in error messages. */
+export declare function readFields(frontmatter: string | undefined, path: string): Record<string, unknown>;
+/** Applies a change to the fields and keeps the rest of the frontmatter, comments included, as it is. With no fields left, the frontmatter goes. */
+export declare function changeFields(frontmatter: string | undefined, change: FieldChange, path: string): string;
+/** Fields with a change applied, for fields kept outside a page file, such as a copy's in the scene. */
+export declare function changedFields(fields: Record<string, unknown>, change: FieldChange): Record<string, unknown>;
+/** Fields written as YAML, to show them. */
+export declare function formatFields(fields: Record<string, unknown>): string;
+/** Reads a field value written as text: a link [[Page]], links separated by commas, a number, true or false, a YAML list, map or quoted text, or else plain text. */
+export declare function readFieldValue(text: string): unknown;
+/** Whether a value holds a list inside a list, which a field cannot hold. */
+export declare function holdsNestedList(value: unknown): boolean;

package/dist/pages/page-file.js

@@ -0,0 +1,166 @@
+import { Document, isMap, isScalar, isSeq, parseDocument, stringify } from "yaml";
+import { comparableText } from "../core/text.js";
+import { links, trimBlankLines } from "./markdown.js";
+import { isEmptyField } from "./standard-fields.js";
+const singleLink = /^\[\[[^\]]+\]\]$/;
+// Links separated by commas, each with a number after it or none: [[A]], [[B]] or, for classes with their levels, [[Fighter]] 3, [[Wizard]] 2.
+const linkList = /^\[\[[^\]]+\]\](?:\s+[+-]?\d+)?(?:\s*,\s*\[\[[^\]]+\]\](?:\s+[+-]?\d+)?)+$/;
+// A link, with the number after it if any: an item of such a list.
+const linkItem = /\[\[[^\]]+\]\](?:\s+[+-]?\d+)?/g;
+// Lists in brackets stay as [a, b], the way people write them, and long values stay on one line.
+const yamlStyle = { flowCollectionPadding: false, lineWidth: 0 };
+// A value that appears twice, such as the same list read from two fields, is written twice: never as an anchor and an alias, which is no list.
+const nodeOptions = { aliasDuplicateObjects: false };
+export function splitPageFile(text) {
+    const lines = text.replace(/^/, "").replaceAll("\r\n", "\n").split("\n");
+    const end = isSeparator(lines[0]) ? lines.findIndex((line, index) => index > 0 && isSeparator(line)) : -1;
+    if (end === -1) {
+        return { body: trimBlankLines(lines.join("\n")) };
+    }
+    return { frontmatter: lines.slice(1, end).join("\n"), body: trimBlankLines(lines.slice(end + 1).join("\n")) };
+}
+export function joinPageFile(file) {
+    return [frontmatterBlock(file), file.body].filter((block) => block !== "").join("\n\n") + "\n";
+}
+/** The fields of a frontmatter; `path` names the file in error messages. */
+export function readFields(frontmatter, path) {
+    if (frontmatter === undefined) {
+        return {};
+    }
+    const document = parseFrontmatter(frontmatter, path);
+    let fields;
+    try {
+        fields = document.toJS() ?? {};
+    }
+    catch (error) {
+        // Such as an alias to an anchor that is not there.
+        throw new Error(`The frontmatter of ${path} is not valid YAML; fix it by hand: ${String(error instanceof Error ? error.message : error).split("\n")[0]}`);
+    }
+    if (typeof fields !== "object" || Array.isArray(fields)) {
+        throw new Error(`The frontmatter of ${path} must hold fields, such as "name: value". Fix it by hand.`);
+    }
+    return fields;
+}
+/** Applies a change to the fields and keeps the rest of the frontmatter, comments included, as it is. With no fields left, the frontmatter goes. */
+export function changeFields(frontmatter, change, path) {
+    const document = frontmatter === undefined ? new Document({}) : parseFrontmatter(frontmatter, path);
+    applyChange(document, change);
+    return isMap(document.contents) && document.contents.items.length === 0 ? "" : document.toString(yamlStyle);
+}
+/** Fields with a change applied, for fields kept outside a page file, such as a copy's in the scene. */
+export function changedFields(fields, change) {
+    const document = new Document(fields, nodeOptions);
+    applyChange(document, change);
+    return (document.toJS() ?? {});
+}
+function applyChange(document, change) {
+    for (const [name, value] of Object.entries(change.set ?? {})) {
+        // As a node, so that items can be added to or removed from it in the same change.
+        document.set(name, document.createNode(value, nodeOptions));
+    }
+    for (const name of change.unset ?? []) {
+        document.delete(name);
+    }
+    for (const [name, values] of Object.entries(change.add ?? {})) {
+        addToList(document, name, values);
+    }
+    for (const [name, values] of Object.entries(change.remove ?? {})) {
+        removeFromList(document, name, values);
+    }
+}
+/** Fields written as YAML, to show them. */
+export function formatFields(fields) {
+    return stringify(fields, yamlStyle).trimEnd();
+}
+/** Reads a field value written as text: a link [[Page]], links separated by commas, a number, true or false, a YAML list, map or quoted text, or else plain text. */
+export function readFieldValue(text) {
+    const value = text.trim();
+    if (singleLink.test(value)) {
+        return value;
+    }
+    if (linkList.test(value)) {
+        return [...value.matchAll(linkItem)].map((match) => match[0]);
+    }
+    if (/^-?\d+(\.\d+)?$/.test(value)) {
+        return Number(value);
+    }
+    if (value === "true" || value === "false") {
+        return value === "true";
+    }
+    // What does not read as YAML stays plain text, as in "[[La cripta]], piano inferiore".
+    const document = /^["'[{]/.test(value) ? parseDocument(value) : undefined;
+    const parsed = document === undefined || document.errors.length > 0 ? value : document.toJS();
+    if (holdsNestedList(parsed)) {
+        throw new Error(`${value} would be a list inside a list, which a field cannot hold. For a list of links write [[A]], [[B]]; to add one item to a list, use add.`);
+    }
+    return parsed;
+}
+function addToList(document, name, values) {
+    const list = document.get(name);
+    if (isEmptyField(list)) {
+        document.set(name, [...new Set(values)]);
+        return;
+    }
+    if (!isSeq(list)) {
+        throw new Error(`"${name}" is not a list, so nothing can be added to it.`);
+    }
+    for (const value of values.filter((candidate) => !list.items.some((item) => sameValue(item, candidate)))) {
+        list.add(document.createNode(value, nodeOptions));
+    }
+}
+/** Removes every item that is the value, a link however it is written (CON-7). */
+function removeFromList(document, name, values) {
+    const list = document.get(name);
+    if (!isSeq(list)) {
+        throw new Error(isEmptyField(list) ? `There is no "${name}" to remove from.` : `"${name}" is not a list, so nothing can be removed from it.`);
+    }
+    for (const value of values) {
+        const kept = list.items.filter((item) => !sameValue(item, value));
+        if (kept.length === list.items.length) {
+            throw new Error(`"${name}" does not hold ${String(value)}.`);
+        }
+        list.items = kept;
+    }
+}
+/** Whether a list's item is the value: the same, or the same link however written, as [[bruna]] and [[Bruna]], or [[items/Lanterna.md|la lanterna]] and [[Lanterna]]. */
+function sameValue(item, value) {
+    const written = isScalar(item) ? item.value : item;
+    return written === value || sameLink(written, value);
+}
+function sameLink(first, second) {
+    if (typeof first !== "string" || typeof second !== "string" || !singleLink.test(first.trim()) || !singleLink.test(second.trim())) {
+        return false;
+    }
+    const [one] = links(first);
+    const [other] = links(second);
+    return one !== undefined && other !== undefined && comparableText(one.page) === comparableText(other.page) && comparableText(one.section ?? "") === comparableText(other.section ?? "");
+}
+/** Whether a value holds a list inside a list, which a field cannot hold. */
+export function holdsNestedList(value) {
+    if (Array.isArray(value)) {
+        return value.some((item) => Array.isArray(item) || holdsNestedList(item));
+    }
+    if (value !== null && typeof value === "object") {
+        return Object.values(value).some(holdsNestedList);
+    }
+    return false;
+}
+function parseFrontmatter(frontmatter, path) {
+    const document = parseDocument(frontmatter);
+    if (document.errors.length > 0) {
+        // Only the first line of the parser's message: the rest quotes the file, which may hold secrets.
+        throw new Error(`The frontmatter of ${path} is not valid YAML; fix it by hand: ${document.errors[0].message.split("\n")[0]}`);
+    }
+    return document;
+}
+/** The frontmatter between --- lines. A text that starts with --- gets an empty one, or it would be read back as a frontmatter. */
+function frontmatterBlock(file) {
+    const fields = file.frontmatter?.trimEnd() ?? "";
+    if (fields.trim() !== "") {
+        return `---\n${fields}\n---`;
+    }
+    return isSeparator(file.body.split("\n")[0]) ? "---\n---" : "";
+}
+function isSeparator(line) {
+    return line?.trimEnd() === "---";
+}

package/dist/pages/page-types.d.ts

@@ -0,0 +1,17 @@
+/** The types of page the core knows, each with its folder in the world. Systems will add their own. */
+export declare const pageTypes: {
+    readonly character: "characters";
+    readonly place: "places";
+    readonly faction: "factions";
+    readonly quest: "quests";
+    readonly item: "items";
+    readonly event: "events";
+    readonly topic: "topics";
+    readonly creature: "creatures";
+};
+export type PageType = keyof typeof pageTypes;
+export declare const pageTypeNames: [PageType, ...PageType[]];
+/** The campaign folder that holds the world's pages. */
+export declare const worldFolderName = "world";
+/** The type whose pages live in `folder`, if any. */
+export declare function typeOfFolder(folder: string): PageType | undefined;

package/dist/pages/page-types.js

@@ -0,0 +1,18 @@
+/** The types of page the core knows, each with its folder in the world. Systems will add their own. */
+export const pageTypes = {
+    character: "characters",
+    place: "places",
+    faction: "factions",
+    quest: "quests",
+    item: "items",
+    event: "events",
+    topic: "topics",
+    creature: "creatures",
+};
+export const pageTypeNames = Object.keys(pageTypes);
+/** The campaign folder that holds the world's pages. */
+export const worldFolderName = "world";
+/** The type whose pages live in `folder`, if any. */
+export function typeOfFolder(folder) {
+    return pageTypeNames.find((type) => pageTypes[type] === folder);
+}

package/dist/pages/positions.d.ts

@@ -0,0 +1,11 @@
+/** A point in metres east and north of the map's centre; west and south are negative. */
+export interface Position {
+    east: number;
+    north: number;
+}
+/** How the engine writes a position, for messages. */
+export declare const positionHelp = "km east or west, then km north or south of the map's centre, such as 8.5 km E, 3 km S";
+/** A position as the engine writes it (POS-1), such as 8.5 km E, 3 km S; undefined for anything else, a relation among them. */
+export declare function readPosition(value: unknown): Position | undefined;
+/** A position as the engine writes it, to the ten metres: 8.5 km E, 3 km S; 0 km E, 0 km N at the centre. */
+export declare function formatPosition(position: Position): string;

package/dist/pages/positions.js

@@ -0,0 +1,23 @@
+// Where a place is on the world map (D-259, POS-1): a point in km east and north of the map's centre, as the engine writes it, such as 8.5 km E, 3 km S.
+import { readLength } from "../core/length.js";
+/** How the engine writes a position, for messages. */
+export const positionHelp = "km east or west, then km north or south of the map's centre, such as 8.5 km E, 3 km S";
+const partPattern = /^(.+?)\s+([EWNS])$/i;
+/** A position as the engine writes it (POS-1), such as 8.5 km E, 3 km S; undefined for anything else, a relation among them. */
+export function readPosition(value) {
+    const parts = typeof value === "string" ? value.split(",").map((part) => partPattern.exec(part.trim())) : [];
+    if (parts.length !== 2 || parts[0] === null || parts[1] === null) {
+        return undefined;
+    }
+    const [[, eastText, eastWay], [, northText, northWay]] = [parts[0], parts[1]];
+    const [east, north] = [readLength(eastText) ?? (/^0(\s*k?m)?$/i.test(eastText.trim()) ? 0 : undefined), readLength(northText) ?? (/^0(\s*k?m)?$/i.test(northText.trim()) ? 0 : undefined)];
+    if (east === undefined || north === undefined || !/^[EW]$/i.test(eastWay) || !/^[NS]$/i.test(northWay)) {
+        return undefined;
+    }
+    return { east: /^W$/i.test(eastWay) ? -east : east, north: /^S$/i.test(northWay) ? -north : north };
+}
+/** A position as the engine writes it, to the ten metres: 8.5 km E, 3 km S; 0 km E, 0 km N at the centre. */
+export function formatPosition(position) {
+    const km = (metres) => `${Math.round(Math.abs(metres) / 10) / 100} km`;
+    return `${km(position.east)} ${position.east < -5 ? "W" : "E"}, ${km(position.north)} ${position.north < -5 ? "S" : "N"}`;
+}

package/dist/pages/rename-page.d.ts

@@ -0,0 +1,39 @@
+import { type Page, type World } from "./world.ts";
+/** A page renamed: its new file, and the pages whose links now name it so. */
+export interface Renamed {
+    path: string;
+    links: number;
+    pages: string[];
+    /** The other page that keeps the old name, whose links are left as they are. */
+    kept?: string;
+}
+/** A rename checked and ready to write: the page's new file, the pages whose links change, and the old file to remove, as full paths. */
+export interface RenamePlan extends Renamed {
+    own: {
+        path: string;
+        text: string;
+    };
+    others: {
+        path: string;
+        text: string;
+    }[];
+    old: {
+        path: string;
+        text: string;
+    };
+}
+/**
+ * Plans the rename of a page of the campaign and of every link to it in the campaign's pages, writing nothing; refused for a page of the game system, a name
+ * or an alias another page has, or a name that would leave a frontmatter unreadable. A rename stopped half way is planned again, to finish it.
+ */
+export declare function planRename(world: World, page: Page, to: string): RenamePlan;
+/**
+ * Writes a planned rename: the page's new file first, then the links, and the old file goes last, so that a rename stopped half way leaves the page whole
+ * and is finished by planning it again. A change of case alone is the same file on Windows and macOS: the links first, then the file anew.
+ */
+export declare function applyRename(plan: RenamePlan): void;
+/** A text with its links to a page renamed, [[Lupa]], [[Lupa#Morso]] and [[Lupa|la lupa]] alike, in any case; and how many it renamed. */
+export declare function renamedLinks(text: string, from: string, to: string): {
+    renamed: string;
+    count: number;
+};