@heroiclands/package-build 23.12.8 → 24.0.0

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

@@ -14,7 +14,7 @@ export function runContext(config: {
     rootDir?: string;
 } | undefined, records?: Iterable<Record<string, any>>): RunContext;
 /**
- * Find the spans, divs and poetry fences marked with `lang=`, `font=` or
+ * Find the spans, divs and verse fences marked with `lang=`, `font=` or
  * `map=`, and every fault in their markup and their text.
  *
  * @param {string} source - Authored Markdown: a note body, or a whole file
@@ -44,10 +44,17 @@ export function scanRuns(source: string, ctx?: RunContext, syntax?: import("./co
 };
 /**
  * Rewrite text marked with `lang=`, `font=` and `map=` into the plain span,
- * div and poetry grammar the rest of each chain renders, one line for one line.
+ * div and verse grammar the rest of each chain renders, one line for one line.
  *
+ * - **A verse in columns is expanded first** into one span per column entry
+ *   per verse line, by {@link module:engine/content-verse.expandVerse}, so
+ *   each entry is mapped and set as a span with its keys is. That is the one
+ *   rewrite that changes the number of lines.
  * - **The map, if any, is applied first.** Characters Markdown would read are
  *   then backslash-escaped, so they reach every later pass as characters.
+ * - **Emphasis in a face** becomes an `<em>` or a `<strong>` carrying its
+ *   convention's class, or no class where none is stated. The book reads
+ *   only the classed form, so a classless one writes nothing there.
  * - **The construct carries** the language's tag as `lang`, the face's class
  *   (with `script`, and `script-block` on a div) or the generic family's
  *   class. On the site, a face's construct also carries
@@ -86,6 +93,27 @@ export const GENERIC_FONTS: Readonly<{
     serif: "font-serif";
     sans: "font-sans";
 }>;
+/**
+ * One `*`, `_`, `**` or `__` that Markdown reads as opening or closing emphasis.
+ */
+export type Delimiter = {
+    /**
+     * - Its first character's offset.
+     */
+    offset: number;
+    /**
+     * - 1 for `*` or `_`, 2 for `**` or `__`.
+     */
+    length: number;
+    /**
+     * - Which level it opens or closes.
+     */
+    tag: "em" | "strong";
+    /**
+     * - Whether it opens.
+     */
+    open: boolean;
+};
 /**
  * One marked construct, with what rendering it needs beside its {@link Run}.
  */
@@ -141,6 +169,21 @@ export type RunDetail = {
      * - A span's offset of its closing `]`.
      */
     contentEnd: number | undefined;
+    /**
+     * -
+     * The convention its language's note states.
+     */
+    languageEmphasis: import("./script-emphasis.mjs").LanguageEmphasis | undefined;
+    /**
+     * -
+     * What its emphasis is set by: its language's convention, else its face's
+     * script's; `undefined` sets it plain.
+     */
+    conventions: import("./script-emphasis.mjs").Emphasis | undefined;
+    /**
+     * - The emphasis it holds, by absolute offset.
+     */
+    emphasis: Delimiter[];
 };
 /**
  * What a run is checked against.
@@ -177,9 +220,32 @@ export type RunContext = {
      * {@link module :engine/run-words.wordBooksFromRecords}.
      */
     wordBooks?: ReadonlyMap<string, import("./run-words.mjs").WordBook> | undefined;
+    /**
+     * -
+     * The metres the `doc` notes declare, by name.
+     */
+    metres?: ReadonlyMap<string, import("./metre-declaration.mjs").Metre> | undefined;
+    /**
+     * -
+     * What each configured language's verse is counted by, from
+     * {@link module :engine/verse-metre.metreBooksFromRecords}.
+     */
+    metreBooks?: ReadonlyMap<string, import("./verse-metre.mjs").MetreBook> | undefined;
+    /**
+     * -
+     * Each face's emphasis conventions, from the script notes, by
+     * {@link module :engine/script-emphasis.emphasesFromRecords}.
+     */
+    emphases?: ReadonlyMap<string, import("./script-emphasis.mjs").Emphasis> | undefined;
+    /**
+     * -
+     * The convention each configured language's note states, by language name,
+     * from {@link module :engine/script-emphasis.languageEmphasesOf}.
+     */
+    languageEmphases?: ReadonlyMap<string, import("./script-emphasis.mjs").LanguageEmphasis> | undefined;
 };
 /**
- * One span, div or poetry fence carrying `lang=`, `font=` or `map=`. Its
+ * One span, div or verse fence carrying `lang=`, `font=` or `map=`. Its
  * `lang`, `font` and `map` are the ones it is set with: its own, else the
  * innermost div or fence around it that states one.
  */
@@ -187,7 +253,7 @@ export type Run = {
     /**
      * - Which construct.
      */
-    kind: "span" | "block" | "poetry";
+    kind: "span" | "block" | "verse";
     /**
      * - The language as written.
      */

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

@@ -13,7 +13,7 @@ export function spanMarkdownPlugin(md: typeof import("markdown-it"), { spoilers,
  * @returns {import("./name-markup.mjs").SpanScan} Actual spans, explicit names and located diagnostics.
  */
 export function scanSpans(source: string): import("./name-markup.mjs").SpanScan;
-/** Emit span tags while leaving their inline content as Markdown for Hugo.
+/** Emit span tags while leaving their inline content as Markdown.
  * @param {string} source - Authored Markdown.
  */
 export function renderSpans(source: string): {

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

@@ -0,0 +1,33 @@
+/**
+ * The rules the Foundry content stylesheet shares with other surfaces, scoped
+ * to a selector.
+ *
+ * @param {string} scope - The selector that replaces the Foundry roots.
+ * @returns {string} The rules.
+ * @throws {Error} When the stylesheet marks no shared rules.
+ */
+export function sharedContentRules(scope: string): string;
+/**
+ * The rules that colour highlighted code, scoped to a selector.
+ *
+ * A rule belongs to the set when one of its selectors names a `hljs-` token
+ * class. The rules are taken from the shared stretches, so the colours, their
+ * custom properties and their `light-dark()` pairs are the stylesheet's own.
+ *
+ * @param {string} scope - The selector that replaces the Foundry roots.
+ * @returns {string} The token rules, one per block.
+ */
+export function highlightRules(scope: string): string;
+/**
+ * The stylesheet a site links for highlighted code.
+ *
+ * A site sets no colour scheme, and the token colours are `light-dark()` pairs
+ * that read the scheme in force, so code is given the dark one its pages are
+ * drawn in.
+ *
+ * @param {string} [scope] - The element the page body sits in.
+ * @returns {string} The stylesheet.
+ */
+export function siteCodeStylesheet(scope?: string): string;
+/** The roots the shipped content stylesheet scopes its rules to. */
+export const CONTENT_ROOTS: ":is(.journal-entry-page, .journal-entry-content, .editor-content, .prosemirror)";

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

@@ -0,0 +1,35 @@
+/**
+ * Markdown-it plugin: write each cartouche placeholder as the inline HTML of
+ * its figure, in whatever paragraph, cell or title it stands.
+ * @param {import("markdown-it")} md - Parser to extend.
+ */
+export function cartoucheFigures(md: typeof import("markdown-it")): void;
+/**
+ * Write each glyph and cartouche span as the HTML that draws its picture. A
+ * cartouche is written as a placeholder that {@link cartoucheFigures} turns
+ * into its figure.
+ *
+ * @param {string} source - Markdown that may contain glyph and cartouche spans.
+ * @param {(src: string) => string} [resolveSrc] - From a sign's authored
+ *   pathname to the address the target serves; omitted, the pathname.
+ * @param {object} [options]
+ * @param {boolean} [options.glyphs] - Write glyph spans; `false` leaves them
+ *   as the source they were written in. Default `true`.
+ * @returns {string} The Markdown with each well-formed sign written as HTML or a placeholder.
+ */
+export function renderSymbolSpans(source: string, resolveSrc?: (src: string) => string, { glyphs }?: {
+    glyphs?: boolean | undefined;
+}): string;
+/**
+ * Every picture the glyphs and cartouches of a body name, for a stage that has
+ * to place the files before a compiler reads them.
+ *
+ * @param {string} body - The note's Markdown.
+ * @returns {Array<{src: string, locate: string}>} The authored pathname of each
+ *   picture and the slug that locates it in the note's text, in document order
+ *   within glyphs and then cartouches.
+ */
+export function symbolImagesIn(body: string): Array<{
+    src: string;
+    locate: string;
+}>;

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

@@ -0,0 +1,240 @@
+/** The authored verse lines, excluding stanza separators. */
+export function verseLines(body: any): string[];
+/**
+ * The least-indented verse is level zero. Every two additional leading spaces
+ * add one level; a leftover space is discarded and the level stops at eight.
+ * Blank lines divide stanzas rather than contributing to the baseline.
+ */
+export function verseStanzas(body: any): {
+    text: string;
+    level: number;
+}[][];
+/** A verse is inline Markdown even when it starts with block syntax. */
+export function inlineVerse(text: any): string;
+/**
+ * Keep stanzas as Markdown paragraphs and make every verse line a hard break.
+ * The surrounding renderer still sees the entire note, so links and footnote
+ * definitions remain in scope. The span carries the indent for each line.
+ */
+export function verseMarkdown(body: any, step?: number): string;
+/**
+ * The number a line shows: `undefined` when the verse is not numbered, `""`
+ * when this line is not one of every `step`th.
+ *
+ * @param {number} line - The line's number, 1-based across the verse.
+ * @param {number} step - The verse's `numstep`.
+ * @returns {string|undefined} The number shown.
+ */
+export function lineNumber(line: number, step: number): string | undefined;
+/** Read verse code fences; start/end are inclusive zero-based source lines.
+ * @param {string} source - Authored Markdown.
+ */
+export function scanVerse(source: string): {
+    blocks: {
+        end: number;
+        body: string;
+        start: number;
+        fence: string;
+        name: string;
+        attributes: {};
+        id: string;
+        classes: never[];
+        indent: string;
+    }[];
+    errors: {
+        line: number;
+        column: number;
+        message: string;
+    }[];
+};
+/** Whether a verse states a column. */
+export function hasColumns(block: any): boolean;
+/**
+ * A column's stacked entries, each with its offset in the written value.
+ *
+ * @param {string} value - A `col1=` or `col2=` value.
+ * @returns {Array<{raw: string, offset: number, lang?: string, map?: string, font?: string, offsets: {lang: number, map?: number, font?: number}}>}
+ *   Each entry; one whose `lang` is `undefined` is malformed.
+ */
+export function columnEntries(value: string): Array<{
+    raw: string;
+    offset: number;
+    lang?: string;
+    map?: string;
+    font?: string;
+    offsets: {
+        lang: number;
+        map?: number;
+        font?: number;
+    };
+}>;
+/**
+ * The columns of a verse, the left first, each entry located in the opening
+ * line.
+ *
+ * @param {object} block - A verse from {@link scanVerse}.
+ * @param {string} opening - Its opening line.
+ * @returns {Array<{key: string, entries: Array<ReturnType<typeof columnEntries>[number] & {column: number, columns: {lang: number, map?: number, font?: number}}>}>}
+ *   1-based columns.
+ */
+export function verseColumns(block: object, opening: string): Array<{
+    key: string;
+    entries: Array<ReturnType<typeof columnEntries>[number] & {
+        column: number;
+        columns: {
+            lang: number;
+            map?: number;
+            font?: number;
+        };
+    }>;
+}>;
+/**
+ * The verse lines of a verse in columns: each blank-line group of span lines
+ * is one verse line, and a line holding only `***` breaks the stanza.
+ *
+ * @param {object} block - A verse from {@link scanVerse}.
+ * @param {string[]} lines - The source, by line.
+ * @returns {Array<{stanzaBreak: true, line: number}|{stanzaBreak?: false, parts: Array<{line: number, column: number, text: string, textColumn: number, lang?: string, span: boolean, extra: boolean, indent: number}>}>}
+ *   0-based lines, 1-based columns.
+ */
+export function verseGroups(block: object, lines: string[]): Array<{
+    stanzaBreak: true;
+    line: number;
+} | {
+    stanzaBreak?: false;
+    parts: Array<{
+        line: number;
+        column: number;
+        text: string;
+        textColumn: number;
+        lang?: string;
+        span: boolean;
+        extra: boolean;
+        indent: number;
+    }>;
+}>;
+/**
+ * Whether text runs right to left: its first letter is in a right-to-left
+ * block. A face's right-to-left code points sit in U+1E800–U+1EFFF.
+ *
+ * @param {string} text - Text, after any map.
+ * @returns {boolean} Whether it starts right to left.
+ */
+export function rightToLeft(text: string): boolean;
+/**
+ * Where a line of {@link expandVerseOrigins}'s output came from.
+ *
+ * @typedef {object} VerseOrigin
+ * @property {number} line - The source line, 0-based.
+ * @property {number} [textColumn] - For an entry's line, the 1-based source
+ *   column of its text's first character.
+ * @property {boolean} [span] - Whether the source line is a span, whose `[`
+ *   sits before its text.
+ * @property {number} [textLength] - The length of the entry's text.
+ * @property {{line: number, columns: {lang: number, map?: number, font?: number}}} [entry] -
+ *   Where the entry is written in the opening line.
+ */
+/**
+ * Write each verse line of a sound verse in columns as one span per column
+ * entry, the left column's entries first, each with the entry's language,
+ * mapping and font. Every target runs it before marked text is rewritten, so
+ * each entry is set exactly as a span with those keys is. The verse gains the
+ * class {@link COLUMNS_CLASS}; a verse already carrying it, a verse with a
+ * finding, and a verse without columns are left as written.
+ *
+ * @param {string} source - Markdown.
+ * @returns {{markdown: string, origins: VerseOrigin[]}} The Markdown, and
+ *   where each of its lines came from.
+ */
+export function expandVerseOrigins(source: string): {
+    markdown: string;
+    origins: VerseOrigin[];
+};
+/**
+ * {@link expandVerseOrigins}'s Markdown alone.
+ *
+ * @param {string} source - Markdown.
+ * @returns {string} The Markdown with each verse in columns expanded.
+ */
+export function expandVerse(source: string): string;
+/**
+ * Where a position in {@link expandVerseOrigins}'s output was written.
+ *
+ * A position in an entry's text is the same character of the source line; a
+ * position in its keys is the entry's part in the opening line that states
+ * the key it falls in.
+ *
+ * @param {{line: number, column: number}} at - 1-based, in the output.
+ * @param {string[]} expanded - The output, by line.
+ * @param {VerseOrigin[]} origins - From {@link expandVerseOrigins}.
+ * @returns {{line: number, column: number}} 1-based, in the source.
+ */
+export function sourcePosition(at: {
+    line: number;
+    column: number;
+}, expanded: string[], origins: VerseOrigin[]): {
+    line: number;
+    column: number;
+};
+/** Replace verse fences with HTML wrappers whose body remains inline Markdown.
+ * @param {string} source - Authored Markdown.
+ */
+export function renderVerse(source: string): {
+    markdown: string;
+    errors: {
+        line: number;
+        column: number;
+        message: string;
+    }[];
+};
+/** The keys that set a verse in columns, the left first. */
+export const COLUMN_KEYS: readonly string[];
+/** The class the build gives a verse in columns once its lines are expanded. */
+export const COLUMNS_CLASS: "verse-columns";
+/**
+ * The keys a verse fence's attribute block takes. `lang`, `font` and `map`
+ * are read by `scanRuns` in content-scripts.mjs; `dir`, and on the site
+ * `data-pagefind-ignore`, are written by its rewrite of a fence set in one of
+ * the faces, and reach the element as they are written.
+ */
+export const VERSE_KEYS: readonly string[];
+/**
+ * The line that breaks a stanza in a verse in columns, `***`, also as the
+ * rewrite of marked text escapes it.
+ */
+export const STANZA_BREAK: RegExp;
+/**
+ * Where a line of {@link expandVerseOrigins}'s output came from.
+ */
+export type VerseOrigin = {
+    /**
+     * - The source line, 0-based.
+     */
+    line: number;
+    /**
+     * - For an entry's line, the 1-based source
+     * column of its text's first character.
+     */
+    textColumn?: number | undefined;
+    /**
+     * - Whether the source line is a span, whose `[`
+     * sits before its text.
+     */
+    span?: boolean | undefined;
+    /**
+     * - The length of the entry's text.
+     */
+    textLength?: number | undefined;
+    /**
+     * -
+     * Where the entry is written in the opening line.
+     */
+    entry?: {
+        line: number;
+        columns: {
+            lang: number;
+            map?: number;
+            font?: number;
+        };
+    } | undefined;
+};

package/types/engine/core-report.d.mts

@@ -0,0 +1,45 @@
+/**
+ * The core report of a set of index records.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @param {{language?: string}} [options] - A language to report alone, by its
+ *   name, shortcode or reference slug whether or not it states `data.core`.
+ * @returns {{concepts: number, languages: Array<{name: string, language: string, core: boolean, total: number, covered: number, missing: Array<{group: string, count: number, total: number, concepts: Array<{id: string, gloss: string}>}>}>}|{problem: string, about: string}}
+ *   The report, or the problem when there is no concept list or the language
+ *   asked for is none.
+ */
+export function coreReport(records: Iterable<Record<string, any>>, { language }?: {
+    language?: string;
+}): {
+    concepts: number;
+    languages: Array<{
+        name: string;
+        language: string;
+        core: boolean;
+        total: number;
+        covered: number;
+        missing: Array<{
+            group: string;
+            count: number;
+            total: number;
+            concepts: Array<{
+                id: string;
+                gloss: string;
+            }>;
+        }>;
+    }>;
+} | {
+    problem: string;
+    about: string;
+};
+/**
+ * A core report as text: one block per language, its missing concepts under
+ * their groups with counts, each concept's id and gloss tab-separated.
+ *
+ * @param {{concepts: number, languages: Array<object>}} report - A report from {@link coreReport}.
+ * @returns {string} The text, ending in a newline.
+ */
+export function coreReportText(report: {
+    concepts: number;
+    languages: Array<object>;
+}): string;

package/types/engine/core-vocabulary.d.mts

@@ -0,0 +1,53 @@
+/**
+ * Every concept id the index's notes state.
+ *
+ * @param {{notes?: Iterable<object>}|undefined} index - The lint index.
+ * @returns {Set<string>|undefined} The ids, or `undefined` without an index.
+ */
+export function conceptIdsIn(index: {
+    notes?: Iterable<object>;
+} | undefined): Set<string> | undefined;
+/**
+ * Check a `doc` note's `data.concepts`: each id's spelling, an id stated twice,
+ * an id another note states, and a blank `gloss` or `group`.
+ *
+ * @param {{file: string, raw?: string, fm?: Record<string, any>}} note - The note.
+ * @param {{index?: {notes?: Iterable<object>}}} [context] - The lint index.
+ * @returns {object[]} The findings, each at its key.
+ */
+export function checkConceptList(note: {
+    file: string;
+    raw?: string;
+    fm?: Record<string, any>;
+}, { index }?: {
+    index?: {
+        notes?: Iterable<object>;
+    };
+}): object[];
+/**
+ * Check a `skill` note's `data.core`: stated on a language only.
+ *
+ * @param {{file: string, raw?: string, fm?: Record<string, any>}} note - A `skill` note.
+ * @returns {object[]} The findings.
+ */
+export function checkCoreFlag(note: {
+    file: string;
+    raw?: string;
+    fm?: Record<string, any>;
+}): object[];
+/**
+ * What is wrong with a word's `concept`: an id the list does not declare, and
+ * an id stated twice.
+ *
+ * @param {unknown} value - The word's `concept`: an id, or a list of them.
+ * @param {Set<string>|undefined} known - The ids the index declares, or
+ *   `undefined` where there is no index to check against.
+ * @returns {Array<{entry: number|null, message: string}>} Each problem and the
+ *   list entry it sits at, `null` for a single id.
+ */
+export function conceptProblems(value: unknown, known: Set<string> | undefined): Array<{
+    entry: number | null;
+    message: string;
+}>;
+/** What a concept's `id` is made of. */
+export const CONCEPT_ID: RegExp;

package/types/engine/dictionary-html.d.mts

@@ -0,0 +1,8 @@
+/**
+ * Group each term of every definition list with its definitions.
+ *
+ * @param {string} html - A page's HTML.
+ * @returns {string} The HTML with a `dictionary` class on each `dl` and a `div`
+ *   around each term and the definitions that follow it.
+ */
+export function groupDictionaryLists(html: string): string;

package/types/engine/dictionary-rows.d.mts

@@ -13,6 +13,16 @@ export function pluralOf(word: {
     class?: unknown;
     plural?: unknown;
 }, grammar: Record<string, any> | undefined): string | null;
+/**
+ * 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: string, grammar: Record<string, any> | undefined): string | 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/types/engine/field-reference.d.mts

@@ -45,7 +45,7 @@ export function renderItemFieldReference({ title, preamble, generatedBy, config,
  * The one question that decides whether `docs item-fields` writes a note
  * envelope: `assets/content/` walks every file under it for its `type:`, so a
  * generated page filed there needs one to publish at all, while a page filed
- * anywhere else — a repository's own `docs/` — is read by nobody but Hugo's
+ * anywhere else — a repository's own `docs/` — is read by nobody but the
  * `--check` guard and the reader following a link, neither of which wants
  * frontmatter.
  *
@@ -84,7 +84,7 @@ export function shortcodeFromBasename(destination: string): string;
  *   {@link shortcodeFromBasename}.
  * @param {Record<string, unknown>} [options.frontmatter] - The consumer's
  *   declared `docs.itemFields.frontmatter`.
- * @returns {Record<string, unknown>} The envelope, ready for `matter.stringify`.
+ * @returns {Record<string, unknown>} The envelope, ready for `writeMatter`.
  */
 export function itemFieldsEnvelope({ title, shortcode, frontmatter }: {
     title: string;

package/types/engine/heading-attributes.d.mts

@@ -82,6 +82,26 @@ export function scanHeadingAttributes(source: string, bodyLine?: number): {
  * @returns {void}
  */
 export function headingAttributesPlugin(md: object): void;
+/**
+ * The id a heading's text gives it on the web: GitHub's form, lower case, each
+ * space or hyphen a hyphen, every character that is not a letter, a digit or
+ * an underscore dropped.
+ *
+ * @param {string} text - The heading's text, without its markup.
+ * @returns {string} The id, or `heading` when nothing is left of the text.
+ */
+export function headingId(text: string): string;
+/**
+ * Give every heading an id, so a page's contents list and a reader's link can
+ * name any section.
+ *
+ * An authored `{#id}` is kept, and every other heading takes {@link headingId}
+ * of its text. A repeated id takes `-1`, `-2` and so on, counted over every id
+ * on the page that came before it.
+ *
+ * @param {import("markdown-it")} md - Markdown parser to extend.
+ */
+export function headingIdsPlugin(md: typeof import("markdown-it")): void;
 /**
  * Parse one line as a heading, and say whether it starts a journal page.
  *

package/types/engine/helpers.d.mts

@@ -432,7 +432,7 @@ export function buildContentLinkIndex(contentBase: string, router?: object, { co
  * @param {number} [ctx.bodyLine] - 1-based file line of the body's first line.
  * @param {number} [ctx.bodyColumn] - 1-based file column of the same character.
  * @param {Array<{line: number, generated: boolean}>} [ctx.lineMap] - Which
- *   authored line each body line came from, from {@link expandNoteTables}.
+ *   authored line each body line came from, from {@link module:engine/content-tables.expandContentTables}.
  * @returns {{markdown: string, unresolved: Array<object>}}
  * @throws {Error} On any link that does not resolve — an unlabelled one, a
  *   target that is not an address, or an address nothing publishes — and on a
@@ -491,15 +491,8 @@ export function expandNoteTables(body: string, { name, bodyLine, sqlTables, page
  * @returns {string} Filename for the folder.
  */
 export function folderFilename(name: string, id: string): string;
-/**
- * The markdown renderer every surface shares.
- *
- * `html: true` is long-standing and load-bearing — notes carry raw blocks — and
- * it is also why {@link module:engine/content-icons} exists rather than an
- * instruction to write `<i class="fa-solid …">` by hand: that would render on
- * the two HTML surfaces and be silently dropped by the third.
- */
-export const md: import("markdown-it").MarkdownIt;
+/** The Foundry renderer's parser, for callers that parse or render a fragment. */
+export const md: typeof import("markdown-it");
 export { slugify } from "./content-slug.mjs";
 export { makeId } from "./ids.mjs";
 export { getFrontmatter, sohlField, folderField, resolveCharges, resolveSkillAptitudes, resolveRelation, requireSubType, parseValueDesc } from "./frontmatter.mjs";