rpg-engine 0.0.0-stage → 0.1.0

package/dist/pictures/svg.js

@@ -0,0 +1,129 @@
+// An SVG picture drawn by a model (D-342, D-390), never trusted: rebuilt from a white list of elements and attributes, everything else dropped with all it
+// holds, as probes proved it on scripts, events, styles, outer links, foreign objects, nested roots, animation, use, text and quotes.
+// The elements kept, by their names in any case, each written as SVG names it.
+const elements = new Map(["svg", "g", "defs", "path", "rect", "circle", "ellipse", "polygon", "polyline", "line", "linearGradient", "radialGradient", "stop", "clipPath", "mask", "filter", "feGaussianBlur"]
+    .map((name) => [name.toLowerCase(), name]));
+const attributes = new Set([
+    "viewbox",
+    "preserveaspectratio",
+    "id",
+    "d",
+    "x",
+    "y",
+    "x1",
+    "y1",
+    "x2",
+    "y2",
+    "cx",
+    "cy",
+    "r",
+    "rx",
+    "ry",
+    "fx",
+    "fy",
+    "width",
+    "height",
+    "points",
+    "transform",
+    "fill",
+    "fill-opacity",
+    "fill-rule",
+    "stroke",
+    "stroke-width",
+    "stroke-opacity",
+    "stroke-linecap",
+    "stroke-linejoin",
+    "stroke-dasharray",
+    "stroke-miterlimit",
+    "opacity",
+    "offset",
+    "stop-color",
+    "stop-opacity",
+    "gradientunits",
+    "gradienttransform",
+    "spreadmethod",
+    "clip-path",
+    "clip-rule",
+    "clippathunits",
+    "mask",
+    "maskunits",
+    "maskcontentunits",
+    "filter",
+    "filterunits",
+    "primitiveunits",
+    "stddeviation",
+    "in",
+    "result",
+    "edgemode",
+    "mix-blend-mode",
+    "vector-effect",
+]);
+// Attributes SVG writes in camel case, which the browser reads only so.
+const camel = new Map(["viewBox", "preserveAspectRatio", "gradientUnits", "gradientTransform", "spreadMethod", "clipPathUnits", "maskUnits", "maskContentUnits", "filterUnits", "primitiveUnits", "stdDeviation", "edgeMode"].map((name) => [name.toLowerCase(), name]));
+// The largest SVG taken, in bytes: the largest of the probe weighed 16 KB.
+const largest = 100 * 1024;
+const token = /<!--[\s\S]*?-->|<!\[CDATA\[[\s\S]*?\]\]>|<![^>]*>|<\?[\s\S]*?\?>|<\/?([A-Za-z][\w:.-]*)((?:\s+[^\s=>/]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s>]+))?)*)\s*(\/?)>|[^<]+|</g;
+const attribute = /([^\s=>/]+)(?:\s*=\s*("[^"]*"|'[^']*'|[^\s>]+))?/g;
+/** The SVG rebuilt from what is allowed, its root always in the SVG namespace; undefined when it has no single allowed root, does not close, or is too large. */
+export function cleanSvg(svg) {
+    if (Buffer.byteLength(svg) > largest) {
+        return undefined;
+    }
+    const kept = [];
+    const open = [];
+    let skipping = 0;
+    let roots = 0;
+    for (const [whole, rawName, rawAttributes = "", selfClosing] of svg.matchAll(token)) {
+        if (rawName === undefined) {
+            continue;
+        }
+        const name = elements.get(rawName.toLowerCase());
+        if (whole.startsWith("</")) {
+            if (open.at(-1)?.name === (name ?? rawName.toLowerCase())) {
+                const closed = open.pop();
+                if (closed?.skipped === true) {
+                    skipping--;
+                }
+                else {
+                    kept.push(`</${closed?.name}>`);
+                }
+            }
+            continue;
+        }
+        if (skipping > 0 || name === undefined || (name === "svg" && (open.length > 0 || roots > 0))) {
+            if (selfClosing !== "/") {
+                open.push({ name: name ?? rawName.toLowerCase(), skipped: true });
+                skipping++;
+            }
+            continue;
+        }
+        roots += name === "svg" ? 1 : 0;
+        const namespace = name === "svg" ? ' xmlns="http://www.w3.org/2000/svg"' : "";
+        kept.push(`<${name}${namespace}${keptAttributes(rawAttributes)}${selfClosing === "/" ? "/" : ""}>`);
+        if (selfClosing !== "/") {
+            open.push({ name, skipped: false });
+        }
+    }
+    return roots === 1 && open.length === 0 ? kept.join("") : undefined;
+}
+/** The SVG in a model's answer, from <svg to </svg>, whatever came around it; undefined when there is none. */
+export function svgIn(answer) {
+    const start = answer.indexOf("<svg");
+    const end = answer.lastIndexOf("</svg>");
+    return start < 0 || end < start ? undefined : answer.slice(start, end + "</svg>".length);
+}
+/** An element's allowed attributes, each once, with no outer url(), no markup in a value, and no double quote, which could close the value and open another. */
+function keptAttributes(rawAttributes) {
+    const seen = new Set();
+    return [...rawAttributes.matchAll(attribute)].flatMap(([, rawKey, rawValue = '""']) => {
+        const key = rawKey.toLowerCase();
+        const quoted = rawValue.length >= 2 && (rawValue[0] === '"' || rawValue[0] === "'") && rawValue.at(-1) === rawValue[0];
+        const value = (quoted ? rawValue.slice(1, -1) : rawValue).replaceAll('"', "'");
+        const urls = [...value.matchAll(/url\s*\(([^)]*)\)/gi)].map((found) => found[1].trim().replace(/^'|'$/g, ""));
+        if (!attributes.has(key) || seen.has(key) || urls.some((url) => !/^#[\w-]+$/.test(url)) || /[<>&]/.test(value)) {
+            return [];
+        }
+        seen.add(key);
+        return [` ${camel.get(key) ?? key}="${value}"`];
+    }).join("");
+}

package/dist/player-notes/index.d.ts

@@ -0,0 +1 @@
+export { type Note, playerFolderName, readNotes, removeNote, writeNote } from "./notes.ts";

package/dist/player-notes/index.js

@@ -0,0 +1,2 @@
+// The player's notes (D-371), outside the game.
+export { playerFolderName, readNotes, removeNote, writeNote } from "./notes.js";

package/dist/player-notes/notes.d.ts

@@ -0,0 +1,21 @@
+/** The folder of what is the player's alone in a campaign. */
+export declare const playerFolderName = ".player";
+/** One of the player's notes. */
+export interface Note {
+    id: string;
+    title: string;
+    text: string;
+    /** When it was last written, in real time. */
+    at: string;
+    /** When it was last shared with the master, if it was since it was written. */
+    shared?: string;
+}
+/**
+ * The player's notes, the last written first, as the disk has them, which another chat may have written; none when there is no file. A file that does not read
+ * stops here, so that no note is ever written over it.
+ */
+export declare function readNotes(root: string): Note[];
+/** Writes a note, new or changed, by its id. */
+export declare function writeNote(root: string, note: Note): void;
+/** Takes a note away by its id; whether there was one. */
+export declare function removeNote(root: string, id: string): boolean;

package/dist/player-notes/notes.js

@@ -0,0 +1,50 @@
+// The player's notes (D-371): free notes, a title and a text each, kept in the campaign but outside the game, in a folder with a dot at its top, which the saves
+// leave as it is (SAV-2) and the master's tools never read.
+import { join } from "node:path";
+import { files } from "../core/store.js";
+/** The folder of what is the player's alone in a campaign. */
+export const playerFolderName = ".player";
+const notesFileName = "notes.json";
+/**
+ * The player's notes, the last written first, as the disk has them, which another chat may have written; none when there is no file. A file that does not read
+ * stops here, so that no note is ever written over it.
+ */
+export function readNotes(root) {
+    const bytes = files().bytes(notesPath(root));
+    if (bytes === undefined) {
+        return [];
+    }
+    let read;
+    try {
+        read = JSON.parse(new TextDecoder().decode(bytes));
+    }
+    catch {
+        read = undefined;
+    }
+    if (!Array.isArray(read) || !read.every(isNote)) {
+        throw new Error(`Your notes in ${join(playerFolderName, notesFileName)} do not read: fix the file by hand, or move it away to start again. Nothing changed.`);
+    }
+    return read.toSorted((one, other) => other.at.localeCompare(one.at));
+}
+/** Writes a note, new or changed, by its id. */
+export function writeNote(root, note) {
+    saveNotes(root, [note, ...readNotes(root).filter((other) => other.id !== note.id)]);
+}
+/** Takes a note away by its id; whether there was one. */
+export function removeNote(root, id) {
+    const notes = readNotes(root);
+    const kept = notes.filter((note) => note.id !== id);
+    saveNotes(root, kept);
+    return kept.length < notes.length;
+}
+function saveNotes(root, notes) {
+    files().write(notesPath(root), `${JSON.stringify(notes, null, 2)}\n`);
+}
+function notesPath(root) {
+    return join(root, playerFolderName, notesFileName);
+}
+function isNote(value) {
+    const note = value;
+    return note !== null && typeof note === "object" && typeof note.id === "string" && typeof note.title === "string" && typeof note.text === "string" && typeof note.at === "string"
+        && (note.shared === undefined || typeof note.shared === "string");
+}

package/dist/progression/index.d.ts

@@ -0,0 +1 @@
+export { featureParts, fieldName, type GainedFeature, gainedFeatures, levelledFeatures, type LevelTable, levelTable, mergedFeatures, rowFields } from "./level-table.ts";

package/dist/progression/index.js

@@ -0,0 +1 @@
+export { featureParts, fieldName, gainedFeatures, levelledFeatures, levelTable, mergedFeatures, rowFields } from "./level-table.js";

package/dist/progression/level-table.d.ts

@@ -0,0 +1,41 @@
+/** A table whose first column counts levels: the names of its columns, and the cells of each row by its level. */
+export interface LevelTable {
+    columns: string[];
+    rows: Map<number, string[]>;
+}
+/** A feature gained at a level, as a name and, when the table gives one, its value in parentheses: Bardic Inspiration (d8). */
+export interface GainedFeature {
+    level: number;
+    name: string;
+}
+/**
+ * The first table of a markdown text that has a column by this name, such as Features, and whose first column counts levels, 1st, 2nd… or 1, 2… (PRO-1): a table
+ * of a die that comes before it, such as d6 and Personality Trait, is not one. Undefined when it has none.
+ */
+export declare function levelTable(text: string, column: string): LevelTable | undefined;
+/**
+ * The fields the row at a level gives (PRO-2): each column but the first, the features column and those skipped, named in lowercase with hyphens (Rage Damage
+ * gives rage-damage), with its cell; an empty cell or a dash gives nothing. None when the table has no row at that level.
+ */
+export declare function rowFields(table: LevelTable, level: number, skip: string[]): [string, string][];
+/**
+ * The features the rows give up to a level, in order (PRO-3): those of the column named so, split at commas, each with its level. Only a name that `title`
+ * recognizes counts, as `title` gives it, with its value in parentheses: "Path feature" or "Wild Shape improvement" are no features.
+ */
+export declare function gainedFeatures(table: LevelTable, column: string, upTo: number, title: (name: string) => string | undefined): GainedFeature[];
+/** The features a list gives with their levels, written "Improved Critical 3" (PRO-3): each with its level; undefined for an item without one. */
+export declare function levelledFeatures(items: string[]): (GainedFeature | undefined)[];
+/**
+ * Features in the order they come, each name once (PRO-3): one written again with another value in parentheses takes the place of the one before, as Bardic
+ * Inspiration (d8) does Bardic Inspiration (d6).
+ */
+export declare function mergedFeatures<Feature extends {
+    name: string;
+}>(features: Feature[]): Feature[];
+/** A feature's name without its value in parentheses, and the value: "Channel Divinity (2/rest)" gives "Channel Divinity" and "(2/rest)". */
+export declare function featureParts(entry: string): {
+    name: string;
+    value?: string;
+};
+/** The name of the field a column gives: in lowercase, words joined by hyphens, as Rage Damage gives rage-damage. */
+export declare function fieldName(column: string): string;

package/dist/progression/level-table.js

@@ -0,0 +1,123 @@
+// The table of a page that counts levels, such as a class's (D-201, D-219, PRO-1–PRO-3): the row at a level gives its columns, and the rows up to it the
+// features gained so far. It reads markdown and knows no game: the system says which column holds the features and which columns give nothing.
+import { comparableText } from "../core/text.js";
+/**
+ * The first table of a markdown text that has a column by this name, such as Features, and whose first column counts levels, 1st, 2nd… or 1, 2… (PRO-1): a table
+ * of a die that comes before it, such as d6 and Personality Trait, is not one. Undefined when it has none.
+ */
+export function levelTable(text, column) {
+    const lines = text.split(/\r?\n/);
+    for (let index = 0; index < lines.length - 1; index++) {
+        if (!isTableLine(lines[index]) || !isSeparatorLine(lines[index + 1])) {
+            continue;
+        }
+        const body = [];
+        let next = index + 2;
+        for (; next < lines.length && isTableLine(lines[next]); next++) {
+            body.push(cellsOf(lines[next]));
+        }
+        const columns = cellsOf(lines[index]);
+        const levels = body.map((cells) => levelOf(cells[0] ?? ""));
+        if (body.length > 0 && levels.every((level) => level !== undefined) && columns.slice(1).some((name) => comparableText(name) === comparableText(column))) {
+            return { columns, rows: new Map(body.map((cells, position) => [levels[position], cells])) };
+        }
+        index = next - 1;
+    }
+    return undefined;
+}
+/**
+ * The fields the row at a level gives (PRO-2): each column but the first, the features column and those skipped, named in lowercase with hyphens (Rage Damage
+ * gives rage-damage), with its cell; an empty cell or a dash gives nothing. None when the table has no row at that level.
+ */
+export function rowFields(table, level, skip) {
+    const row = table.rows.get(level);
+    const skipped = new Set(skip.map(comparableText));
+    return row === undefined ? [] : table.columns.flatMap((column, index) => {
+        const cell = (row[index] ?? "").trim();
+        return index === 0 || skipped.has(comparableText(column)) || isEmptyCell(cell) ? [] : [[fieldName(column), cell]];
+    });
+}
+/**
+ * The features the rows give up to a level, in order (PRO-3): those of the column named so, split at commas, each with its level. Only a name that `title`
+ * recognizes counts, as `title` gives it, with its value in parentheses: "Path feature" or "Wild Shape improvement" are no features.
+ */
+export function gainedFeatures(table, column, upTo, title) {
+    const index = table.columns.findIndex((name) => comparableText(name) === comparableText(column));
+    if (index <= 0) {
+        return [];
+    }
+    return [...table.rows.entries()].filter(([level]) => level <= upTo).sort(([first], [second]) => first - second).flatMap(([level, row]) => splitOutsideParentheses(row[index] ?? "").flatMap((entry) => {
+        const { name, value } = featureParts(entry);
+        const titled = isEmptyCell(entry) ? undefined : title(name);
+        return titled === undefined ? [] : [{ level, name: value === undefined ? titled : `${titled} ${value}` }];
+    }));
+}
+/** The features a list gives with their levels, written "Improved Critical 3" (PRO-3): each with its level; undefined for an item without one. */
+export function levelledFeatures(items) {
+    return items.map((item) => {
+        const match = /^(.*?)\s+(\d+)$/.exec(item.trim());
+        return match === null || match[1].trim() === "" ? undefined : { level: Number(match[2]), name: match[1].trim() };
+    });
+}
+/**
+ * Features in the order they come, each name once (PRO-3): one written again with another value in parentheses takes the place of the one before, as Bardic
+ * Inspiration (d8) does Bardic Inspiration (d6).
+ */
+export function mergedFeatures(features) {
+    const merged = [];
+    for (const feature of features) {
+        const position = merged.findIndex((other) => comparableText(featureParts(other.name).name) === comparableText(featureParts(feature.name).name));
+        if (position === -1) {
+            merged.push(feature);
+        }
+        else if (featureParts(feature.name).value !== undefined) {
+            merged[position] = feature;
+        }
+    }
+    return merged;
+}
+/** A feature's name without its value in parentheses, and the value: "Channel Divinity (2/rest)" gives "Channel Divinity" and "(2/rest)". */
+export function featureParts(entry) {
+    const match = /^(.*?)\s*(\([^()]*\))$/.exec(entry.trim());
+    return match === null || match[1] === "" ? { name: entry.trim() } : { name: match[1], value: match[2] };
+}
+/** The name of the field a column gives: in lowercase, words joined by hyphens, as Rage Damage gives rage-damage. */
+export function fieldName(column) {
+    return column.trim().toLowerCase().replace(/[^\p{L}\p{N}]+/gu, "-").replace(/^-+|-+$/g, "");
+}
+function isTableLine(line) {
+    return line.trim().startsWith("|");
+}
+function isSeparatorLine(line) {
+    return /^\s*\|?\s*:?-{3,}:?\s*(\|\s*:?-{3,}:?\s*)*\|?\s*$/.test(line);
+}
+/** The cells of a table line, without the bars at its ends; a bar written \| belongs to its cell. */
+function cellsOf(line) {
+    const cells = line.trim().replace(/^\|/, "").replace(/(?<!\\)\|$/, "").split(/(?<!\\)\|/);
+    return cells.map((cell) => cell.replace(/\\\|/g, "|").trim());
+}
+/** The level a first cell counts: 3 for "3rd" or "3". */
+function levelOf(cell) {
+    const match = /^(\d+)(?:st|nd|rd|th)?$/i.exec(cell.trim());
+    return match === null ? undefined : Number(match[1]);
+}
+function isEmptyCell(cell) {
+    return /^[\s—–-]*$/.test(cell);
+}
+/** "Rage, Unarmored Defense": the entries of a cell, split at commas outside parentheses. */
+function splitOutsideParentheses(cell) {
+    const entries = [];
+    let depth = 0;
+    let current = "";
+    for (const character of cell) {
+        depth += character === "(" ? 1 : character === ")" ? -1 : 0;
+        if (character === "," && depth === 0) {
+            entries.push(current.trim());
+            current = "";
+        }
+        else {
+            current += character;
+        }
+    }
+    return [...entries, current.trim()].filter((entry) => entry !== "");
+}

package/dist/rules/index.d.ts

@@ -0,0 +1,3 @@
+export { bookTitles, readRuleBook, ruleFiles, type RuleSection, ruleSections } from "./rule-book.ts";
+export { findRules, hasAllWords, isTitled, type RuleFinding } from "./search.ts";
+export { type ShownRule, shownRules } from "./shown.ts";

package/dist/rules/index.js

@@ -0,0 +1,4 @@
+// Rules as text (D-161, D-178, RUL): the sections of markdown files, found by their words and read exactly as they are written.
+export { bookTitles, readRuleBook, ruleFiles, ruleSections } from "./rule-book.js";
+export { findRules, hasAllWords, isTitled } from "./search.js";
+export { shownRules } from "./shown.js";

package/dist/rules/rule-book.d.ts

@@ -0,0 +1,31 @@
+/**
+ * A section of a rules text (RUL-1): a heading; a title in bold that opens a paragraph ("***Escaping a Grapple.*** A grappled creature…"), one level below the heading it is under;
+ * or the caption of a table in bold, with its table.
+ */
+export interface RuleSection {
+    /** Where the rules come from, as the caller names them: the campaign's house rules, a game system. */
+    source: string;
+    /** The file it is in, without .md: a chapter, or a house rule, with its folder when it is in one. */
+    file: string;
+    /** The titles from the top of the file down to the section's own, which is the last. */
+    path: string[];
+    /** How deep it is: 1 for a top heading; 0 for the text of a file before its first heading. */
+    level: number;
+    /** The section as the file writes it, with its parts: the exact text. */
+    text: string;
+    /** The section without its parts: what a search reads. */
+    ownText: string;
+    /** The titles of its parts, one level below. */
+    parts: string[];
+}
+/** The sections of the markdown files in a folder and its folders, file by file in order of path; none when there is no such folder. */
+export declare function readRuleBook(folder: string, source: string): RuleSection[];
+/** The files of rules in a folder and its folders, without .md, in order of path: the chapters of a game system, or the campaign's house rules. */
+export declare function ruleFiles(folder: string): string[];
+/** The title each file of a book opens with, in order: the house rules as status names them (D-178). */
+export declare function bookTitles(sections: RuleSection[]): string[];
+/**
+ * The sections of one rules text (RUL-1). A text before the first heading is a section named after the file, holding the whole file.
+ * A byte order mark and the properties at the top (---) are not text; code blocks and %% comments hold no titles.
+ */
+export declare function ruleSections(text: string, file: string, source: string): RuleSection[];

package/dist/rules/rule-book.js

@@ -0,0 +1,157 @@
+import { relative, resolve } from "node:path";
+import { frozen } from "../core/frozen.js";
+import { files } from "../core/store.js";
+/** The sections of the markdown files in a folder and its folders, file by file in order of path; none when there is no such folder. */
+export function readRuleBook(folder, source) {
+    // Each file is cut into sections once in a call (D-194).
+    const sectionsOf = (path) => files().read(path, `rules ${source} ${resolve(folder)}`, (text) => ruleSections(text, relative(folder, path).replace(/\\/g, "/").replace(/\.md$/i, ""), source)) ?? [];
+    return frozen(markdownFiles(folder).flatMap(sectionsOf));
+}
+/** The files of rules in a folder and its folders, without .md, in order of path: the chapters of a game system, or the campaign's house rules. */
+export function ruleFiles(folder) {
+    return markdownFiles(folder).map((path) => relative(folder, path).replace(/\\/g, "/").replace(/\.md$/i, ""));
+}
+/** The title each file of a book opens with, in order: the house rules as status names them (D-178). */
+export function bookTitles(sections) {
+    const files = [...new Set(sections.map((section) => section.file))];
+    return files.map((file) => sections.find((section) => section.file === file)?.path[0] ?? file);
+}
+/**
+ * The sections of one rules text (RUL-1). A text before the first heading is a section named after the file, holding the whole file.
+ * A byte order mark and the properties at the top (---) are not text; code blocks and %% comments hold no titles.
+ */
+export function ruleSections(text, file, source) {
+    const content = withoutProperties(text.replace(/^/, "").replace(/\r\n/g, "\n"));
+    const markers = markersOf(content);
+    const firstStart = markers[0]?.start ?? content.length;
+    if (content.slice(0, firstStart).trim() !== "") {
+        markers.unshift({ title: file.split("/").at(-1) ?? file, level: 0, start: 0, end: undefined });
+    }
+    const parents = parentsOf(markers);
+    const ends = endsOf(markers, content.length);
+    const children = markers.map(() => []);
+    parents.forEach((parent, index) => parent === undefined || children[parent].push(index));
+    const paths = [];
+    return markers.map((marker, index) => {
+        const parent = parents[index];
+        paths.push([...(parent === undefined ? [] : paths[parent]), marker.title]);
+        const parts = children[index];
+        let ownText = "";
+        let from = marker.start;
+        for (const part of parts) {
+            ownText += content.slice(from, markers[part].start);
+            from = ends[part];
+        }
+        ownText += content.slice(from, ends[index]);
+        return {
+            source,
+            file,
+            path: paths[index],
+            level: marker.level,
+            text: content.slice(marker.start, ends[index]).trimEnd(),
+            ownText: ownText.replace(/\n{3,}/g, "\n\n").trimEnd(),
+            parts: parts.map((part) => markers[part].title),
+        };
+    });
+}
+const headingPattern = /^(#{1,6})[ \t]+(.+?)[ \t]*#*[ \t]*$/;
+// A title in bold that opens a paragraph and is followed by its text: ***Finesse.*** When making an attack…, **Dim light**, also called…
+const boldTitlePattern = /^(\*{2,3})([^*\n]+?)\1[ \t]*[.:,]?[ \t]+\S/;
+// A line all in bold: the caption of a table when one follows.
+const captionPattern = /^(\*{2,3})([^*\n]+?)\1[ \t]*$/;
+function markersOf(content) {
+    const markers = [];
+    const lines = content.split("\n");
+    const starts = [];
+    lines.reduce((start, line) => (starts.push(start), start + line.length + 1), 0);
+    let heading = 0;
+    let fence;
+    let comment = false;
+    for (const [index, line] of lines.entries()) {
+        const fenceMark = /^(`{3,}|~{3,})/.exec(line)?.[1];
+        if (fenceMark !== undefined && !comment && (fence === undefined || (fenceMark[0] === fence[0] && fenceMark.length >= fence.length))) {
+            fence = fence === undefined ? fenceMark : undefined;
+            continue;
+        }
+        if (fence === undefined && (line.match(/%%/g)?.length ?? 0) % 2 === 1) {
+            comment = !comment;
+            continue;
+        }
+        if (fence !== undefined || comment) {
+            continue;
+        }
+        const headingMatch = headingPattern.exec(line);
+        const captionMatch = headingMatch === null ? captionPattern.exec(line) : null;
+        const boldMatch = headingMatch === null && captionMatch === null ? boldTitlePattern.exec(line) : null;
+        if (headingMatch !== null) {
+            heading = headingMatch[1].length;
+            markers.push({ title: plainTitle(headingMatch[2]), level: heading, start: starts[index], end: undefined });
+        }
+        else if (boldMatch !== null) {
+            markers.push({ title: plainTitle(boldMatch[2]), level: heading + 1, start: starts[index], end: undefined });
+        }
+        else if (captionMatch !== null) {
+            const table = tableAfter(lines, index);
+            if (table !== undefined) {
+                const last = table.at(-1) ?? index;
+                markers.push({ title: plainTitle(captionMatch[2]), level: heading + 1, start: starts[index], end: starts[last] + lines[last].length });
+            }
+        }
+    }
+    return markers;
+}
+/** The lines of the table right after a caption, blank lines between them allowed; undefined when no table follows. */
+function tableAfter(lines, caption) {
+    let index = caption + 1;
+    while (index < lines.length && lines[index].trim() === "") {
+        index++;
+    }
+    const rows = [];
+    while (index < lines.length && lines[index].trimStart().startsWith("|")) {
+        rows.push(index);
+        index++;
+    }
+    return rows.length > 0 ? rows : undefined;
+}
+/** For each marker, the one it is part of: the nearest before it of a lower level, unless that one has ended. */
+function parentsOf(markers) {
+    const open = [];
+    return markers.map((marker, index) => {
+        while (open.length > 0) {
+            const top = markers[open[open.length - 1]];
+            if (top.level < marker.level && (top.end === undefined || top.end > marker.start)) {
+                break;
+            }
+            open.pop();
+        }
+        const parent = open.at(-1);
+        open.push(index);
+        return parent;
+    });
+}
+/** Where each section ends: a caption where its table does, the others at the next marker of their level or above, or at the end of the text. */
+function endsOf(markers, length) {
+    const ends = markers.map((marker) => marker.end ?? length);
+    const open = [];
+    for (const [index, marker] of markers.entries()) {
+        while (open.length > 0 && markers[open[open.length - 1]].level >= marker.level) {
+            ends[open.pop() ?? index] = marker.start;
+        }
+        if (marker.end === undefined) {
+            open.push(index);
+        }
+    }
+    return ends;
+}
+/** The text without the properties at its top: Obsidian writes them between two lines of three dashes. */
+function withoutProperties(content) {
+    const match = /^---\n[\s\S]*?\n(---|\.\.\.)(\n|$)/.exec(content);
+    return match === null ? content : content.slice(match[0].length).replace(/^\n+/, "");
+}
+/** A title without its markdown marks and the stop that ends a title in bold: "*fly*" is fly, "Finesse." is Finesse. */
+function plainTitle(title) {
+    return title.replace(/[*_`]/g, "").replace(/[.:,]$/, "").trim();
+}
+function markdownFiles(folder) {
+    return files().files(folder, (name) => /\.md$/i.test(name)).sort((first, second) => (first < second ? -1 : first > second ? 1 : 0));
+}

package/dist/rules/search.d.ts

@@ -0,0 +1,18 @@
+import type { RuleSection } from "./rule-book.ts";
+/** A section that a search finds: named by the text, or holding its words, with how well. */
+export interface RuleFinding {
+    section: RuleSection;
+    /** The text names it: its title, or titles of its path. */
+    titled: boolean;
+    /** How much of the search it holds, the rarest words weighing most and counting twice in its title. */
+    score: number;
+}
+/**
+ * The sections that a text finds, best first (RUL-3, RUL-5): those it names, then those with its words, the rarest words weighing most, in the title most of all.
+ * After sections it names, the others are found by the words of its last title alone: "Combat › Grappling" looks for grappling.
+ */
+export declare function findRules(sections: RuleSection[], text: string): RuleFinding[];
+/** Whether a section is the one a text names: its title, or titles of its path ending with its own, as in "Combat › Grappling". */
+export declare function isTitled(section: RuleSection, text: string): boolean;
+/** Whether a text holds every word of a search, as search compares words: what finds a precedent. */
+export declare function hasAllWords(text: string, search: string): boolean;