@heroiclands/package-build 23.12.6 → 23.12.7

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

@@ -1,3 +1,18 @@
+/**
+ * A noun's stated plural, or the first literal ending replacement that fits.
+ *
+ * @param {{form: string, class?: unknown, plural?: unknown}} word - A word of
+ *   `data.words`.
+ * @param {Record<string, any>|undefined} grammar - Its language's
+ *   `data.grammar`.
+ * @returns {string|null} The plural, or `null` for a word that is no noun or
+ *   that no rule fits.
+ */
+export function pluralOf(word: {
+    form: string;
+    class?: unknown;
+    plural?: unknown;
+}, 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/helpers.d.mts

@@ -10,12 +10,16 @@
  * @param {(address: string) => string|undefined} [resolveRole] - From a
  *   picture's address to the role its asset declares — see
  *   {@link module:engine/content-figures.scanFigures}.
+ * @param {import("./content-scripts.mjs").RunContext} [runs] - The package's
+ *   languages, faces and maps. Given, text marked with `lang=`, `font=` and
+ *   `map=` is rewritten first, so it is tagged for its language, mapped and
+ *   set in its font.
  * @returns {string} The rendered HTML.
  */
 export function renderFoundryMarkdown(body: string, figures?: Array<{
     id: string;
     label: string;
-}>, footnoteNumbers?: Map<string, number>, docId?: string, resolveRole?: (address: string) => string | undefined): string;
+}>, footnoteNumbers?: Map<string, number>, docId?: string, resolveRole?: (address: string) => string | undefined, runs?: import("./content-scripts.mjs").RunContext): string;
 /**
  * Parses a markdown file with LF or CRLF YAML frontmatter delimiters.
  *

package/types/engine/journals.d.mts

@@ -134,13 +134,15 @@ export function journalPageId(entryId: string, page: {
  *   carries its own figure already, from {@link splitPages}.
  * @param {(address: string) => string|undefined} [resolveRole] - See
  *   {@link splitPages}.
+ * @param {import("./content-scripts.mjs").RunContext} [runs] - The package's
+ *   languages, faces and maps — see {@link module:engine/helpers.renderFoundryMarkdown}.
  * @returns {Array<{_id: string, name: string, type: string,
  *   title: {show: boolean, level: number},
  *   text: {format: number, content: string}, _key: string,
  *   ownership?: {default: number}}>} The page documents, in order.
  * @throws {Error} When the note has no content at all, or repeats an anchor.
  */
-export function buildPages(rawPages: Array<object>, entryId: string, noteName: string, figures: Array<object>, resolveRole?: (address: string) => string | undefined): Array<{
+export function buildPages(rawPages: Array<object>, entryId: string, noteName: string, figures: Array<object>, resolveRole?: (address: string) => string | undefined, runs?: import("./content-scripts.mjs").RunContext): Array<{
     _id: string;
     name: string;
     type: string;
@@ -192,9 +194,11 @@ export function buildPages(rawPages: Array<object>, entryId: string, noteName: s
  *   name reads `Map 1` rather than `Figure 1` where it is due — see
  *   {@link module:engine/content-figures.scanFigures}.
  * @param {import("./content-session.mjs").ContentSyntax} [params.syntax] - Session scanner projections.
+ * @param {import("./content-scripts.mjs").RunContext} [params.runs] - The package's
+ *   languages, faces and maps — see {@link module:engine/helpers.renderFoundryMarkdown}.
  * @returns {object} The JournalEntry document, keyed for the pack.
  */
-export function buildJournalEntry({ id, name, markdown, leadName, folder, stats, infoboxes, notice, resolveRole, syntax, }: {
+export function buildJournalEntry({ id, name, markdown, leadName, folder, stats, infoboxes, notice, resolveRole, syntax, runs, }: {
     id: string;
     name: string;
     markdown: string;
@@ -209,6 +213,7 @@ export function buildJournalEntry({ id, name, markdown, leadName, folder, stats,
     notice?: string | undefined;
     resolveRole?: ((address: string) => string | undefined) | undefined;
     syntax?: import("./content-session.mjs").ContentSyntax | undefined;
+    runs?: import("./content-scripts.mjs").RunContext | undefined;
 }): object;
 /**
  * Journals pack compiler.

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

@@ -20,3 +20,5 @@ export function checkLanguageData(note: object, { index, types }?: {
     index?: object | undefined;
     types?: readonly string[] | undefined;
 }): object[];
+/** How a foreign row that its tongue's register does not bear out is reported. */
+export const FOREIGN_ROW_SEVERITY: "warning";

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

@@ -0,0 +1,8 @@
+/**
+ * Whether a value is a BCP 47 language tag.
+ *
+ * @param {unknown} value - The value to test.
+ * @returns {boolean} Whether it is a well-formed tag with no repeated variant
+ *   or extension singleton.
+ */
+export function isLanguageTag(value: unknown): boolean;

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

@@ -321,7 +321,8 @@ export const NEAR_NAME_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[]
 export const NAMING_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
 /**
  * The six present persons of the one optional regular verb pattern, in
- * presentation order. Empty endings leave the citation form unchanged.
+ * presentation order. Each ending is added to the citation form, or takes the
+ * place of its closing `replaces`; an empty ending adds nothing.
  *
  * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
  */

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

@@ -0,0 +1,274 @@
+/**
+ * Each configured language's lexicon, read from the language note its `note`
+ * names. A language with no `note`, or one naming no language note, has none.
+ *
+ * @param {Iterable<Record<string, any>>|undefined} records - Index records.
+ * @param {{languages?: Readonly<Record<string, {tag: string, note?: string}>>, contentPackage?: string}} config -
+ *   The resolved configuration.
+ * @returns {Map<string, Lexicon>} The lexicons by language name.
+ */
+export function lexiconsFromRecords(records: Iterable<Record<string, any>> | undefined, config?: {
+    languages?: Readonly<Record<string, {
+        tag: string;
+        note?: string;
+    }>>;
+    contentPackage?: string;
+}): Map<string, Lexicon>;
+/**
+ * The language note each configured language's `note` names, by language
+ * name. A language with no `note`, or one naming no language note, is absent.
+ *
+ * @param {Iterable<Record<string, any>>|undefined} records - Index records.
+ * @param {{languages?: Readonly<Record<string, {tag: string, note?: string}>>, contentPackage?: string}} config -
+ *   The resolved configuration.
+ * @returns {Map<string, Record<string, any>>} The records.
+ */
+export function languageRecordsByName(records: Iterable<Record<string, any>> | undefined, { languages, contentPackage }?: {
+    languages?: Readonly<Record<string, {
+        tag: string;
+        note?: string;
+    }>>;
+    contentPackage?: string;
+}): Map<string, Record<string, any>>;
+/**
+ * Each `languages.<name>.note` that names no language note, at its key.
+ *
+ * @param {{languages?: Readonly<Record<string, {tag: string, note?: string}>>, contentPackage?: string, configFile?: string, configText?: string}} config -
+ *   The resolved configuration, and where it was read from.
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]} The findings.
+ */
+export function languageNoteFindings(config: {
+    languages?: Readonly<Record<string, {
+        tag: string;
+        note?: string;
+    }>>;
+    contentPackage?: string;
+    configFile?: string;
+    configText?: string;
+}, records: Iterable<Record<string, any>>): object[];
+/**
+ * A lookup of a word's native form under one map in one face: the form stated
+ * for the face, else the one stated for no face.
+ *
+ * @param {Lexicon|undefined} lexicon - The lexicon.
+ * @param {string} map - The map's name.
+ * @param {string|undefined} font - The face.
+ * @returns {((word: string) => string|undefined)|undefined} The lookup, or
+ *   `undefined` with no lexicon.
+ */
+export function nativeLookup(lexicon: Lexicon | undefined, map: string, font: string | undefined): ((word: string) => string | undefined) | undefined;
+/**
+ * What a run, a passage or a listing is mapped by.
+ *
+ * @typedef {object} Mapping
+ * @property {import("./text-maps.mjs").TextMap} map - The map.
+ * @property {string|undefined} font - The face, whose own rows come first.
+ * @property {((word: string) => string|undefined)|undefined} native - The
+ *   language's native forms under the map in the face.
+ */
+/**
+ * The one path from a map, a face and a language to what rewrites the text.
+ *
+ * @param {{maps?: ReadonlyMap<string, import("./text-maps.mjs").TextMap>, lexicons?: ReadonlyMap<string, Lexicon>}} ctx -
+ *   The run context.
+ * @param {{map: string, font?: string, lang?: string}} keys - The map, the face
+ *   and the language.
+ * @returns {Mapping|undefined} The mapping, or `undefined` for an unknown map.
+ */
+export function mappingFor(ctx: {
+    maps?: ReadonlyMap<string, import("./text-maps.mjs").TextMap>;
+    lexicons?: ReadonlyMap<string, Lexicon>;
+}, { map, font, lang }: {
+    map: string;
+    font?: string;
+    lang?: string;
+}): Mapping | undefined;
+/**
+ * Why a face is not one a map is for, or `undefined` where it is.
+ *
+ * @param {import("./text-maps.mjs").TextMap} map - The map.
+ * @param {string} font - The face's slug.
+ * @returns {string|undefined} The problem.
+ */
+export function fontProblem(map: import("./text-maps.mjs").TextMap, font: string): string | undefined;
+/**
+ * What is wrong with a capitalised word whose native form the rows cannot
+ * capitalise.
+ *
+ * @param {string} word - The word as written.
+ * @param {string} lower - The lowercase form the lexicon states.
+ * @param {string|undefined} lang - The language.
+ * @param {string} map - The map's name.
+ * @returns {string} The message.
+ */
+export function uncapitalisedMessage(word: string, lower: string, lang: string | undefined, map: string): string;
+/**
+ * Map a passage exactly as the build maps a run with the same keys.
+ *
+ * @param {object} ctx - The run context.
+ * @param {{map: string, font?: string, lang?: string}} keys - The map, the face
+ *   and the language.
+ * @param {string} text - The passage, with no escapes.
+ * @returns {{text: string}|{problem: string, about: string}} The mapped text, or the problem.
+ */
+export function transliterate(ctx: object, keys: {
+    map: string;
+    font?: string;
+    lang?: string;
+}, text: string): {
+    text: string;
+} | {
+    problem: string;
+    about: string;
+};
+/**
+ * Every word of a language's lexicon with its native form under a map: the
+ * stated exception, else the rows' spelling, each exactly as the build gives
+ * it.
+ *
+ * @param {object} ctx - The run context.
+ * @param {{lang: string, map: string, font?: string}} keys - The language, the
+ *   map and the face.
+ * @returns {{entries: Array<{form: string, native: string, exception: boolean, class: string|null, gloss: string|null}>}|{problem: string, about: string}}
+ *   The words in `data.words` order, or the problem.
+ */
+export function lexiconEntries(ctx: object, { lang, map, font }: {
+    lang: string;
+    map: string;
+    font?: string;
+}): {
+    entries: Array<{
+        form: string;
+        native: string;
+        exception: boolean;
+        class: string | null;
+        gloss: string | null;
+    }>;
+} | {
+    problem: string;
+    about: string;
+};
+/**
+ * Check a mapping note's `fonts` against the installed faces: an unknown face
+ * and a face listed twice, at the entry, and each code point a listed face
+ * lacks, at the row that writes it.
+ *
+ * @param {{file: string, raw?: string, fm?: Record<string, any>}} note - The note.
+ * @param {{faces?: ReadonlyMap<string, import("./script-fonts.mjs").Face>, maps?: ReadonlyMap<string, import("./text-maps.mjs").TextMap>}} ctx -
+ *   The run context.
+ * @returns {object[]} The findings.
+ */
+export function checkMapFonts(note: {
+    file: string;
+    raw?: string;
+    fm?: Record<string, any>;
+}, ctx: {
+    faces?: ReadonlyMap<string, import("./script-fonts.mjs").Face>;
+    maps?: ReadonlyMap<string, import("./text-maps.mjs").TextMap>;
+}): object[];
+/**
+ * Check a language note's native forms against the maps and faces: an unknown
+ * map, a face the map is not for, a second form for one map and face, a form
+ * that states what the rows already give, and a code point a face it applies
+ * in does not draw. The shape of each entry is the data-key check's.
+ *
+ * @param {{file: string, raw?: string, fm?: Record<string, any>}} note - The note.
+ * @param {{faces?: ReadonlyMap<string, import("./script-fonts.mjs").Face>, maps?: ReadonlyMap<string, import("./text-maps.mjs").TextMap>}} ctx -
+ *   The run context.
+ * @returns {object[]} The findings.
+ */
+export function checkLexiconNatives(note: {
+    file: string;
+    raw?: string;
+    fm?: Record<string, any>;
+}, ctx: {
+    faces?: ReadonlyMap<string, import("./script-fonts.mjs").Face>;
+    maps?: ReadonlyMap<string, import("./text-maps.mjs").TextMap>;
+}): object[];
+/**
+ * One row per native form of a language note's word, for the `natives`
+ * relation: a text is a value of a row, never a struct key, so forms that
+ * differ only in case stay apart.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {Array<Record<string, string|number|null>>} The rows; `word` is the
+ *   word's 0-based place in `data.words`, `native` the form's in its `native`.
+ */
+export function nativeRows(records: Iterable<Record<string, any>>): Array<Record<string, string | number | null>>;
+/** Every column of the `natives` relation, in order. */
+export const NATIVE_COLUMNS: readonly string[];
+/**
+ * One native form, read.
+ */
+export type NativeForm = {
+    /**
+     * - The map it is written for.
+     */
+    map: string;
+    /**
+     * - The one face it is for.
+     */
+    font: string | undefined;
+    /**
+     * - The word in the script.
+     */
+    text: string;
+};
+/**
+ * One word of a lexicon.
+ */
+export type LexiconWord = {
+    /**
+     * - The word as cited.
+     */
+    form: string;
+    /**
+     * - Its class.
+     */
+    class: string | null;
+    /**
+     * - Its senses, joined by `; `.
+     */
+    gloss: string | null;
+    /**
+     * - Its native forms.
+     */
+    natives: readonly NativeForm[];
+};
+/**
+ * A language's lexicon.
+ */
+export type Lexicon = {
+    /**
+     * - The language's configured name.
+     */
+    language: string;
+    /**
+     * - Its words, in `data.words` order.
+     */
+    words: readonly LexiconWord[];
+    /**
+     * - The native
+     * forms by the word's form, NFC; the first word of a form keeps it.
+     */
+    byForm: ReadonlyMap<string, readonly NativeForm[]>;
+};
+/**
+ * What a run, a passage or a listing is mapped by.
+ */
+export type Mapping = {
+    /**
+     * - The map.
+     */
+    map: import("./text-maps.mjs").TextMap;
+    /**
+     * - The face, whose own rows come first.
+     */
+    font: string | undefined;
+    /**
+     * - The
+     * language's native forms under the map in the face.
+     */
+    native: ((word: string) => string | undefined) | undefined;
+};

package/types/engine/markup-validation.d.mts

@@ -4,9 +4,14 @@
  * @param {string} source - Complete Markdown source, optionally with frontmatter.
  * @param {string} file - Diagnostic filename.
  * @param {import("./content-session.mjs").ContentSyntax} [syntax] - Exact-text scanner projections.
- * @returns {Array<{file: string, line: number, column: number, severity: string, message: string}>} Syntax errors.
+ * @param {import("./content-scripts.mjs").RunContext} [runs] - The package's
+ *   languages, faces and maps. Given, text marked with `lang=`, `font=` and
+ *   `map=` is checked against them; a caller with no package configuration
+ *   leaves it out.
+ * @returns {Array<{file: string, line: number, column: number, severity: string, message: string}>} Syntax errors,
+ *   then warnings.
  */
-export function markupFindings(source: string, file: string, syntax?: import("./content-session.mjs").ContentSyntax): Array<{
+export function markupFindings(source: string, file: string, syntax?: import("./content-session.mjs").ContentSyntax, runs?: import("./content-scripts.mjs").RunContext): Array<{
     file: string;
     line: number;
     column: number;

package/types/engine/pdf-build.d.mts

@@ -184,17 +184,33 @@ export function buildPdf({ config, configPath, book, out, version, compile, read
  * @param {string} typPath - The `.typ` file.
  * @param {string} pdfPath - Where the PDF goes.
  * @param {object} [pdf] - The resolved `pdf:` block.
+ * @param {{rootDir?: string, paths?: {content?: string}}} [config] - The
+ *   resolved configuration; the installed faces are searched when a note sets
+ *   text in one.
  * @returns {string[]} The arguments, in order.
  */
-export function typstArgs(typPath: string, pdfPath: string, pdf?: object): string[];
+export function typstArgs(typPath: string, pdfPath: string, pdf?: object, config?: {
+    rootDir?: string;
+    paths?: {
+        content?: string;
+    };
+}): string[];
 /**
  * The flags that decide which faces a layout uses, shared by the compile and by
  * the page measurement so both lay the book out in the same metrics.
  *
  * @param {object} [pdf] - The resolved `pdf:` block.
+ * @param {{rootDir?: string, paths?: {content?: string}}} [config] - The
+ *   resolved configuration; the installed faces are searched when a note sets
+ *   text in one.
  * @returns {string[]} The arguments, in order.
  */
-export function typstFontArgs(pdf?: object): string[];
+export function typstFontArgs(pdf?: object, config?: {
+    rootDir?: string;
+    paths?: {
+        content?: string;
+    };
+}): string[];
 /**
  * The compiler's own warnings, as findings.
  *
@@ -224,10 +240,17 @@ export function typstWarnings(output: string): Array<{
  * @param {string} typPath - The `.typ` file.
  * @param {string} pdfPath - Where the PDF goes.
  * @param {object} pdf - The resolved `pdf:` block.
+ * @param {{rootDir?: string, paths?: {content?: string}}} [config] - The
+ *   resolved configuration, for the installed faces.
  * @returns {{ok: boolean, message: string, findings: object[]}} What happened,
  *   and what the compiler warned about on the way.
  */
-export function compileTypst(typPath: string, pdfPath: string, pdf?: object): {
+export function compileTypst(typPath: string, pdfPath: string, pdf?: object, config?: {
+    rootDir?: string;
+    paths?: {
+        content?: string;
+    };
+}): {
     ok: boolean;
     message: string;
     findings: object[];

package/types/engine/pdf-render.d.mts

@@ -85,6 +85,9 @@ export function stripHtmlComments(markdown: string): string;
  *   Typst and is told nothing.
  * @param {string} [opts.file] - The file the markdown came from, named in every
  *   finding.
+ * @param {import("./content-scripts.mjs").RunContext} [opts.runs] - The
+ *   package's languages, faces and maps, which text marked with `lang=`,
+ *   `font=` and `map=` is checked against and set by.
  * @param {number} [opts.bodyLine] - The 1-based file line the body starts on, so
  *   a finding's line is the file's rather than the body's.
  * @param {number} [opts.bodyColumn] - The 1-based column the body starts at.
@@ -124,6 +127,7 @@ export function markdownToTypst(markdown: string, opts?: {
     anchorPrefix?: string | undefined;
     findings?: object[] | undefined;
     file?: string | undefined;
+    runs?: import("./content-scripts.mjs").RunContext | undefined;
     bodyLine?: number | undefined;
     bodyColumn?: number | undefined;
     lineMap?: {
@@ -228,9 +232,17 @@ export function crossBookReference(inner: string, away: {
  * carries are not the same set, and a missing glyph on 2,000 feet is a
  * tofu box on every page of the book.
  *
+ * @param {import("./content-scripts.mjs").RunContext} [runs] - The installed
+ *   faces, each of whose classes sets its family.
+ * @param {{serif?: string, sans?: string, mono?: string}} [families] - The
+ *   book's own serif, sans and mono, which `font=serif`, `sans` and `mono` set.
  * @returns {string} Typst markup.
  */
-export function bookTypstPreamble(): string;
+export function bookTypstPreamble(runs?: import("./content-scripts.mjs").RunContext, families?: {
+    serif?: string;
+    sans?: string;
+    mono?: string;
+}): string;
 /**
  * The whole book, as one Typst document.
  *
@@ -345,9 +357,11 @@ export function bookTypstPreamble(): string;
  * @param {object} [opts.index] - As {@link module:engine/pdf-index.indexTerms}:
  *   `owns` limits the index to the notes this book is home to, and `foreign`
  *   (present only under `pdf.indexSeeAlso`) lists notes another book prints.
+ * @param {import("./content-scripts.mjs").RunContext} [opts.runs] - The
+ *   installed faces, which the preamble maps to font families.
  * @returns {string} A complete `.typ` document.
  */
-export function renderBook({ plan, bodies, title, subtitle, front, fonts, version, preamble, banners, maps, coverImage, authors, copyright, license, index, }?: {
+export function renderBook({ plan, bodies, title, subtitle, front, fonts, version, preamble, banners, maps, coverImage, authors, copyright, license, index, runs, }?: {
     plan: object;
     bodies: Map<string, string>;
     title: string;
@@ -369,6 +383,7 @@ export function renderBook({ plan, bodies, title, subtitle, front, fonts, versio
     copyright?: string | undefined;
     license?: string | undefined;
     index?: object | undefined;
+    runs?: import("./content-scripts.mjs").RunContext | undefined;
 }): string;
 /**
  * Point every internal link at a label the document actually declares.

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

@@ -0,0 +1,89 @@
+/**
+ * One run as an index record carries it.
+ *
+ * @typedef {object} RecordRun
+ * @property {"span"|"block"|"poetry"} kind - The construct.
+ * @property {string|null} lang - The language it is set in, as written: its
+ *   own `lang=`, else the one the div or fence around it states.
+ * @property {string|null} tag - The BCP 47 tag it resolves to, or null.
+ * @property {string|null} font - Its font, as written and inherited the same way.
+ * @property {string|null} map - Its map, as written and inherited the same way.
+ * @property {number} line - 1-based file line of its opening.
+ * @property {number} column - 1-based UTF-16 file column of its opening.
+ */
+/**
+ * @typedef {RecordRun & {owner: string|null}} RunRow
+ */
+/**
+ * A note body's runs, at file positions, as an index record carries them.
+ *
+ * @param {string} body - The note's body.
+ * @param {object} options - Options.
+ * @param {import("./content-scripts.mjs").RunContext} [options.context] - The
+ *   configured languages, which give a declared name its tag.
+ * @param {number} [options.bodyLine] - The 1-based file line the body starts on.
+ * @param {number} [options.bodyColumn] - The 1-based column of its first character.
+ * @param {import("./content-session.mjs").ContentSyntax} [options.syntax] -
+ *   Session scanner projections.
+ * @returns {RecordRun[]} One entry per run, in source order.
+ */
+export function recordRuns(body: string, { context, bodyLine, bodyColumn, syntax }?: {
+    context?: import("./content-scripts.mjs").RunContext | undefined;
+    bodyLine?: number | undefined;
+    bodyColumn?: number | undefined;
+    syntax?: import("./content-session.mjs").ContentSyntax | undefined;
+}): RecordRun[];
+/**
+ * The containing page's NOTE identity.
+ *
+ * @param {Record<string, any>} record - An own-note index record.
+ * @returns {string|null} The page Address, or null for an unaddressable record.
+ */
+export function ownerOf(record: Record<string, any>): string | null;
+/**
+ * Project recorded runs without reading sources or changing records.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records, already
+ *   narrowed to the audience.
+ * @returns {RunRow[]} One row per run, in record then source order.
+ */
+export function runsRows(records: Iterable<Record<string, any>>): RunRow[];
+/** Every column of the `runs` relation, in order. */
+export const RUN_COLUMNS: readonly string[];
+/**
+ * One run as an index record carries it.
+ */
+export type RecordRun = {
+    /**
+     * - The construct.
+     */
+    kind: "span" | "block" | "poetry";
+    /**
+     * - The language it is set in, as written: its
+     * own `lang=`, else the one the div or fence around it states.
+     */
+    lang: string | null;
+    /**
+     * - The BCP 47 tag it resolves to, or null.
+     */
+    tag: string | null;
+    /**
+     * - Its font, as written and inherited the same way.
+     */
+    font: string | null;
+    /**
+     * - Its map, as written and inherited the same way.
+     */
+    map: string | null;
+    /**
+     * - 1-based file line of its opening.
+     */
+    line: number;
+    /**
+     * - 1-based UTF-16 file column of its opening.
+     */
+    column: number;
+};
+export type RunRow = RecordRun & {
+    owner: string | null;
+};