@heroiclands/package-build 24.0.0 → 24.0.2

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

@@ -0,0 +1,179 @@
+/**
+ * Read every `scroll` fence in a source, and every fault in its opening.
+ *
+ * A fence inside a block quote or an HTML block is not read, and neither is a
+ * fence quoted inside another fence.
+ *
+ * @param {string} source - Markdown.
+ * @returns {{blocks: Scroll[], errors: Array<{line: number, column: number, message: string}>}}
+ *   The fences, and each finding at its 1-based position.
+ */
+export function scanScrolls(source: string): {
+    blocks: Scroll[];
+    errors: Array<{
+        line: number;
+        column: number;
+        message: string;
+    }>;
+};
+/**
+ * A scroll's paragraphs: each run of nonblank lines, its lines trimmed and
+ * joined by a space.
+ *
+ * @param {string[]} lines - The body's lines.
+ * @returns {string[]} The paragraphs, in order.
+ */
+export function scrollParagraphs(lines: string[]): string[];
+/**
+ * Replace each well-formed `scroll` fence with the HTML block the site, the
+ * preview and Foundry show: a `<div class="scroll">` holding a `<p>` for each
+ * paragraph, its size carried as `--scroll-rows` and `--scroll-cols`. A fence
+ * with a finding in its opening is left as a code fence.
+ *
+ * @param {string} source - Markdown, its marked text already rewritten.
+ * @returns {{markdown: string}} The Markdown.
+ */
+export function renderScroll(source: string): {
+    markdown: string;
+};
+/**
+ * One character of a scroll as the book draws it.
+ *
+ * @typedef {object} ScrollCell
+ * @property {string} text - The character, one code point.
+ * @property {string} roman - The source text it was written from: the text of
+ *   the piece of the map it begins, with the text of any piece before it that
+ *   wrote nothing; `""` for a later character of the same piece.
+ * @property {"rubric"|"overline"} [emphasis] - The convention it is set by.
+ */
+/**
+ * A scroll's text, as the book lays it out.
+ *
+ * @typedef {object} ScrollLayout
+ * @property {ScrollCell[][]} paragraphs - Each paragraph's characters.
+ * @property {import("./script-fonts.mjs").Face|undefined} face - The face it
+ *   is drawn in.
+ */
+/**
+ * Lay a scroll's paragraphs into columns and the columns into panels.
+ *
+ * Each paragraph starts a fresh column, filled from the top, `rows` characters
+ * to a column; the columns are read from the right and grouped `cols` to a
+ * panel. Without `rows`, a column is as long as the longest paragraph, up to
+ * {@link BOOK_SCROLL_ROWS}; without `cols`, each column is a panel of its own,
+ * so the book sets as many beside one another as fit its measure.
+ *
+ * @param {ScrollCell[][]} paragraphs - The characters of each paragraph.
+ * @param {{rows?: number, cols?: number}} size - The fence's size.
+ * @returns {{rows: number, panels: ScrollCell[][][]}} The column length, and
+ *   each panel's columns, the first column the rightmost.
+ */
+export function scrollPanels(paragraphs: ScrollCell[][], { rows, cols }?: {
+    rows?: number;
+    cols?: number;
+}): {
+    rows: number;
+    panels: ScrollCell[][][];
+};
+/**
+ * The roman text a panel was written from, as its alt text: each paragraph's
+ * source text, a space between paragraphs, its spacing collapsed.
+ *
+ * @param {ScrollCell[][]} panel - The panel's columns.
+ * @param {ScrollCell[][]} paragraphs - The scroll's paragraphs, so a column
+ *   that begins a paragraph is told from one that continues it.
+ * @returns {string} The text.
+ */
+export function panelRoman(panel: ScrollCell[][], paragraphs: ScrollCell[][]): string;
+/**
+ * The keys a scroll fence's attribute block takes. `lang`, `font` and `map`
+ * are read by `scanRuns`; `data-pagefind-ignore` is written on the site by its
+ * rewrite of a fence set in a face, and reaches the element as written.
+ */
+export const SCROLL_KEYS: readonly string[];
+/**
+ * The distance from one column to the next, in ems: the character's one em
+ * and a gap of half an em.
+ */
+export const SCROLL_PITCH: 1.5;
+/**
+ * The longest column the book sets when a fence states no `rows=`: each
+ * paragraph is one column as long as the longest, up to this many characters.
+ */
+export const BOOK_SCROLL_ROWS: 40;
+/** The class every scroll carries. */
+export const SCROLL_CLASS: "scroll";
+/**
+ * One `scroll` fence.
+ */
+export type Scroll = {
+    /**
+     * - The 0-based line of its opening.
+     */
+    start: number;
+    /**
+     * - The 0-based line of its closing.
+     */
+    end: number;
+    /**
+     * - Its fence marker.
+     */
+    fence: string;
+    /**
+     * - The opening line's indentation.
+     */
+    indent: string;
+    /**
+     * - Its `key=value` attributes.
+     */
+    attributes: Record<string, string>;
+    /**
+     * - Its classes.
+     */
+    classes: string[];
+    /**
+     * - Its `rows=`, where it is valid.
+     */
+    rows: number | undefined;
+    /**
+     * - Its `cols=`, where it is valid.
+     */
+    cols: number | undefined;
+    /**
+     * - Whether its opening has a finding.
+     */
+    invalid: boolean;
+};
+/**
+ * One character of a scroll as the book draws it.
+ */
+export type ScrollCell = {
+    /**
+     * - The character, one code point.
+     */
+    text: string;
+    /**
+     * - The source text it was written from: the text of
+     * the piece of the map it begins, with the text of any piece before it that
+     * wrote nothing; `""` for a later character of the same piece.
+     */
+    roman: string;
+    /**
+     * - The convention it is set by.
+     */
+    emphasis?: "rubric" | "overline" | undefined;
+};
+/**
+ * A scroll's text, as the book lays it out.
+ */
+export type ScrollLayout = {
+    /**
+     * - Each paragraph's characters.
+     */
+    paragraphs: ScrollCell[][];
+    /**
+     * - The face it
+     * is drawn in.
+     */
+    face: import("./script-fonts.mjs").Face | undefined;
+};

package/types/engine/font-outlines.d.mts

@@ -0,0 +1,67 @@
+/**
+ * The outlines of a TrueType face, read once per file.
+ *
+ * @param {string} file - The `.ttf`.
+ * @returns {Outlines} Its outlines.
+ * @throws {Error} When the file is not a TrueType face with outlines.
+ */
+export function fontOutlines(file: string): Outlines;
+/**
+ * One panel of a scroll as SVG: its columns read from the right, `rows` ems
+ * tall, each character centred in its column, in red where it is set in the
+ * rubric and with a line beside it, on the right, where it is overlined.
+ *
+ * @param {import("./content-scroll.mjs").ScrollCell[][]} panel - Its columns,
+ *   the first the rightmost.
+ * @param {number} rows - The characters in a column.
+ * @param {Outlines} outlines - The face.
+ * @returns {string} The SVG.
+ */
+export function scrollPanelSvg(panel: import("./content-scroll.mjs").ScrollCell[][], rows: number, outlines: Outlines): string;
+/** The book's rubric red, which its preamble names `book-rubric`. */
+export const BOOK_RUBRIC: "#9c281b";
+/** The book's ink, which its preamble names `book-ink`. */
+export const BOOK_INK: "#241f1a";
+/**
+ * A point of a contour.
+ */
+export type Point = {
+    x: number;
+    y: number;
+    on: boolean;
+};
+/**
+ * One glyph, in font units, its y axis pointing down from the baseline.
+ */
+export type Glyph = {
+    /**
+     * - Its glyph index.
+     */
+    index: number;
+    /**
+     * - Its outline as SVG path data; `""` for none.
+     */
+    d: string;
+    /**
+     * - Its horizontal advance.
+     */
+    advance: number;
+    /**
+     * - From the top of its cell to its baseline.
+     */
+    top: number;
+};
+/**
+ * A face's outlines.
+ */
+export type Outlines = {
+    /**
+     * - Its units per em.
+     */
+    unitsPerEm: number;
+    /**
+     * - The glyph a code
+     * point is drawn with, or `undefined` when the face does not draw it.
+     */
+    glyph: (point: number) => Glyph | undefined;
+};

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

@@ -6,6 +6,19 @@
  * @returns {boolean}
  */
 export function tongueDeclared(tag: string, declared: Set<string>): boolean;
+/**
+ * Check a `doc` note's `data.sounds`, a spelling guide's letters and marks:
+ * each letter row's `tongue` names language notes. The data-key check owns
+ * the keys, so a sound rule a guide does not state is refused there.
+ *
+ * @param {object} note - A `doc` note: `file`, `raw` and parsed `fm`.
+ * @param {object} [context]
+ * @param {object} [context.index] - The index, for whether an Address resolves.
+ * @returns {object[]} The findings.
+ */
+export function checkGuideSounds(note: object, { index }?: {
+    index?: object | undefined;
+}): object[];
 /**
  * Check a `skill` note's language data against what it means.
  *

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

@@ -42,8 +42,8 @@ export function tongueRows(records: Iterable<Record<string, any>>): object[];
  */
 export function scopeRows(records: Iterable<Record<string, any>>): object[];
 /**
- * The `letters` rows: one per `data.sounds.letters` entry, `letters` and
- * `tongue` lists.
+ * The `letters` rows: one per `data.sounds.letters` entry of a language note
+ * or a spelling guide, `letters` and `tongue` lists.
  *
  * @param {Iterable<Record<string, any>>} records - Index records.
  * @returns {object[]}
@@ -207,7 +207,8 @@ export function joiningRows(records: Iterable<Record<string, any>>): object[];
  */
 export function joinRows(records: Iterable<Record<string, any>>): object[];
 /**
- * The `marks` rows: one per `data.sounds.marks` entry.
+ * The `marks` rows: one per `data.sounds.marks` entry of a language note or a
+ * spelling guide.
  *
  * @param {Iterable<Record<string, any>>} records - Index records.
  * @returns {object[]}

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

@@ -233,6 +233,13 @@ export const MUTATION_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
  * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
  */
 export const SOUND_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of a spelling guide's `data.sounds`: a `doc` note stating the
+ * letters and marks every tongue of a setting is written by.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const GUIDE_SOUND_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
 /**
  * The keys of one `data.soundChanges` entry.
  *

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

@@ -151,14 +151,15 @@ export function transliterate(ctx: object, keys: {
  * writing, the signs a run writes directly for that sense.
  *
  * @param {object} ctx - The run context.
- * @param {{lang: string, map: string, font?: string, derived?: boolean}} keys -
- *   The language, the map, the face, and whether to list derived forms.
+ * @param {{lang: string, map?: string, font?: string, derived?: boolean}} keys -
+ *   The language, the map, the face, and whether to list derived forms. A map
+ *   or a face left out is the one the language's `data.writtenIn` names.
  * @returns {{entries: Array<{form: string, native: string, exception?: boolean, source?: "own"|"parts"|"none", ambiguous?: true, class: string|null, gloss: string|null, from?: string}>}|{problem: string, about: string}}
  *   The words in `data.words` order, then any derived forms, or the problem.
  */
 export function lexiconEntries(ctx: object, { lang, map, font, derived }: {
     lang: string;
-    map: string;
+    map?: string;
     font?: string;
     derived?: boolean;
 }): {

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

@@ -1,3 +1,13 @@
+/**
+ * The tables an sfnt file holds, by tag.
+ *
+ * @param {Buffer} buf - The font file.
+ * @returns {Map<string, {offset: number, length: number}>} Its table directory.
+ */
+export function tableDirectory(buf: Buffer): Map<string, {
+    offset: number;
+    length: number;
+}>;
 /**
  * Every glyph name a font carries, with the codepoint that reaches it.
  *

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

@@ -2,12 +2,14 @@
  * One run as an index record carries it.
  *
  * @typedef {object} RecordRun
- * @property {"span"|"block"|"verse"} kind - The construct.
+ * @property {"span"|"block"|"verse"|"scroll"} 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 {string|null} font - Its font, as written and inherited the same
+ *   way, else its language's script's.
+ * @property {string|null} map - Its map, as written and inherited the same way,
+ *   else its language's script's.
  * @property {number} line - 1-based file line of its opening.
  * @property {number} column - 1-based UTF-16 file column of its opening.
  */
@@ -33,6 +35,24 @@ export function recordRuns(body: string, { context, bodyLine, bodyColumn, syntax
     bodyColumn?: number | undefined;
     syntax?: import("./content-session.mjs").ContentSyntax | undefined;
 }): RecordRun[];
+/**
+ * Give every recorded run the map and face its language's note names in
+ * `data.writtenIn`, where the run leaves them unstated, as a run is set. Read
+ * once every record exists, since a run's language note may be recorded after
+ * the note that marks it.
+ *
+ * @param {Record<string, any>[]} records - The package's index records; each
+ *   note record's `runs` is updated in place.
+ * @param {{languages?: Readonly<Record<string, {tag: string, note?: string}>>, contentPackage?: string}} config -
+ *   The configured languages, whose `note` names each language note.
+ */
+export function fillWrittenIn(records: Record<string, any>[], config: {
+    languages?: Readonly<Record<string, {
+        tag: string;
+        note?: string;
+    }>>;
+    contentPackage?: string;
+}): void;
 /**
  * The containing page's NOTE identity.
  *
@@ -57,7 +77,7 @@ export type RecordRun = {
     /**
      * - The construct.
      */
-    kind: "span" | "block" | "verse";
+    kind: "span" | "block" | "verse" | "scroll";
     /**
      * - The language it is set in, as written: its
      * own `lang=`, else the one the div or fence around it states.
@@ -68,11 +88,13 @@ export type RecordRun = {
      */
     tag: string | null;
     /**
-     * - Its font, as written and inherited the same way.
+     * - Its font, as written and inherited the same
+     * way, else its language's script's.
      */
     font: string | null;
     /**
-     * - Its map, as written and inherited the same way.
+     * - Its map, as written and inherited the same way,
+     * else its language's script's.
      */
     map: string | null;
     /**

package/types/engine/script-direction.d.mts

@@ -0,0 +1,10 @@
+/**
+ * Each face's direction, from the script notes among the index records. The
+ * first note to list a face keeps it; a face whose note states no direction,
+ * or one the build does not know, is absent.
+ *
+ * @param {Iterable<Record<string, any>>|undefined} records - Index records.
+ * @returns {Map<string, "vertical-rl">} The directions, by face slug.
+ */
+export function directionsFromRecords(records: Iterable<Record<string, any>> | undefined): Map<string, "vertical-rl">;
+export { SCRIPT_DIRECTIONS } from "./script-emphasis-terms.mjs";

package/types/engine/script-emphasis-terms.d.mts

@@ -1,7 +1,8 @@
 /**
- * **The words a script note and a language note state emphasis by.** Read by
- * the vocabulary as it is declared, so this module imports nothing; the
- * checks and the conventions' use are in {@link module:engine/script-emphasis}.
+ * **The words a script note and a language note state emphasis and direction
+ * by.** Read by the vocabulary as it is declared, so this module imports
+ * nothing; the checks and the conventions' use are in
+ * {@link module:engine/script-emphasis} and {@link module:engine/script-direction}.
  *
  * @module
  */
@@ -17,5 +18,11 @@ export const EMPHASIS_CLASSES: Readonly<{
  * `words` marks emphasis with a word, so a mark in its text is a finding.
  */
 export const LANGUAGE_EMPHASES: readonly string[];
+/**
+ * The directions a script states it is written in. `vertical-rl` is columns,
+ * top to bottom, read from the right; a script stating none is written in
+ * lines.
+ */
+export const SCRIPT_DIRECTIONS: readonly string[];
 /** The `subType` of a script note. */
 export const SCRIPT_SUBTYPE: "script";

package/types/engine/script-font-delivery.d.mts

@@ -1,7 +1,9 @@
 /**
- * The faces the package's notes set text in with `font=`, read from the
- * notes themselves: every Markdown file under the content tree that writes
- * `font=` is scanned for its runs.
+ * The faces the package's notes set text in, read from the notes
+ * themselves: every Markdown file under the content tree that writes `font=`
+ * is scanned for its runs, and the face every language note names in
+ * `data.writtenIn` counts, since a run marked with the language alone is set
+ * in it.
  *
  * @param {DeliveryConfig} config - The resolved configuration.
  * @param {import("./script-fonts.mjs").ScriptFonts} installed - The fonts package.

package/types/engine/script-fonts.d.mts

@@ -28,6 +28,9 @@
  * @property {string} direction - `ltr` or `rtl`.
  * @property {string[]} features - OpenType features it turns on.
  * @property {ReadonlySet<number>} draws - Every code point it draws.
+ * @property {string|undefined} file - The absolute path of its TrueType file,
+ *   which the book draws a `scroll` fence's outlines from; `undefined` when the
+ *   manifest lists none.
  */
 /**
  * The installed fonts package, as a consumer sees it.
@@ -140,6 +143,12 @@ export type Face = {
      * - Every code point it draws.
      */
     draws: ReadonlySet<number>;
+    /**
+     * - The absolute path of its TrueType file,
+     * which the book draws a `scroll` fence's outlines from; `undefined` when the
+     * manifest lists none.
+     */
+    file: string | undefined;
 };
 /**
  * The installed fonts package, as a consumer sees it.

package/types/engine/site-reach.d.mts

@@ -0,0 +1,76 @@
+/**
+ * The internal targets a page links.
+ *
+ * @param {string} html - A rendered page.
+ * @param {string} from - The page's own address, beginning with `/`.
+ * @param {string} base - The site's base path, beginning and ending with `/`.
+ * @returns {string[]} Absolute paths inside the base, without fragment or query.
+ */
+export function internalLinks(html: string, from: string, base: string): string[];
+/**
+ * The address a link to a file names a page by: `…/index.html` is its
+ * directory, and a bare directory ends in a slash.
+ *
+ * @param {string} pathname - An absolute path.
+ * @returns {string} The page address it would be keyed by.
+ */
+export function pageAddress(pathname: string): string;
+/**
+ * The pages reachable from the homepage.
+ *
+ * @param {object} options - The inputs.
+ * @param {string} options.base - The site's base path, beginning and ending
+ *   with `/`; the homepage is at the base.
+ * @param {(url: string) => string|undefined} options.html - A page's rendered
+ *   HTML by its address, or `undefined` where the site has no such page.
+ * @param {(pathname: string) => readonly string[]} [options.expand] - The page
+ *   addresses a linked non-page file, such as a feed, lists.
+ * @returns {Set<string>} The address of every reachable page, the homepage
+ *   included.
+ */
+export function reachablePages({ base, html, expand }: {
+    base: string;
+    html: (url: string) => string | undefined;
+    expand?: ((pathname: string) => readonly string[]) | undefined;
+}): Set<string>;
+/**
+ * The page addresses an Atom feed lists, as paths.
+ *
+ * @param {string} xml - The feed.
+ * @returns {string[]} The `href` of every `<link>` that is an absolute URL,
+ *   as its path.
+ */
+export function feedPaths(xml: string): string[];
+/**
+ * A page body split at {@link GENERATED_MARK}.
+ *
+ * @param {string} html - A page body.
+ * @returns {{authored: string, generated: string}} The author's text, and the
+ *   generated sections after it, `""` where there are none.
+ */
+export function splitContent(html: string): {
+    authored: string;
+    generated: string;
+};
+/**
+ * Generated sections with the entries that lead outside a set of pages taken
+ * out.
+ *
+ * An entry is a list item, a table row, or a link in a paragraph's comma
+ * separated run; a paragraph, list or table left with no entry goes, and so
+ * does a section left with nothing under its heading. A link to anything that
+ * is not a page of the site is kept, and so is text that was never a link.
+ *
+ * @param {string} html - The generated sections, rendered.
+ * @param {(href: string) => boolean} outside - Whether an `href` names a page
+ *   of the site that is not reachable.
+ * @returns {string} The sections, or `""` when nothing is left.
+ */
+export function pruneGenerated(html: string, outside: (href: string) => boolean): string;
+/**
+ * The comment that separates a page's authored text from the sections the
+ * build generated after it, in the HTML the renderer writes.
+ *
+ * @type {string}
+ */
+export const GENERATED_MARK: string;

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

@@ -50,8 +50,9 @@ export function writeThemeFiles(out: string, staticDir?: string): string[];
  * @param {string} [options.staticDir] - The theme's own files, copied first.
  * @param {ReadonlySet<string>} [options.only] - The addresses of the pages to
  *   draw again into a site already written. Nothing else is touched.
- * @returns {{files: string[], pages: string[], findings: object[]}} Every file
- *   written, the address of every page, and the layouts' findings.
+ * @returns {{files: string[], pages: string[], reachable: string[],
+ *   findings: object[]}} Every file written, the address of every page, the
+ *   address of each page reachable from the homepage, and the layouts' findings.
  * @throws {Error} When a page's address is outside the site, or a site served
  *   under a path asks for a sitemap index.
  */
@@ -65,6 +66,7 @@ export function writeSite({ site, pages, out, report, staticDir, only }: {
 }): {
     files: string[];
     pages: string[];
+    reachable: string[];
     findings: object[];
 };
 /**

package/types/engine/site-root.d.mts

@@ -42,6 +42,7 @@ export function headers({ pkg, base, fonts }?: {
 export function indexSite(where: {
     site: string;
     output: string;
+    base?: string;
 }): Promise<{
     pages: number;
 }>;
@@ -125,6 +126,7 @@ export const ORIGIN_SUFFIX: string;
 export type SiteIndexer = (where: {
     site: string;
     output: string;
+    base?: string;
 }) => Promise<{
     pages: number;
 }>;

package/types/engine/written-in.d.mts

@@ -0,0 +1,76 @@
+/**
+ * Whether a map is drawn in a face: it lists the face, or lists none.
+ *
+ * @param {import("./text-maps.mjs").TextMap} map - The map.
+ * @param {string} font - The face's slug.
+ * @returns {boolean} Whether the map may set text in it.
+ */
+export function drawnIn(map: import("./text-maps.mjs").TextMap, font: string): boolean;
+/**
+ * The script each configured language's note names, where the map is known
+ * and is drawn in the face. A default that names an unknown map or a face its
+ * map is not drawn in is the note's finding, and fills no run.
+ *
+ * @param {ReadonlyMap<string, Record<string, any>>} byName - Each configured
+ *   language's note record, by language name, from
+ *   {@link module:engine/map-lexicon.languageRecordsByName}.
+ * @param {ReadonlyMap<string, import("./text-maps.mjs").TextMap>} maps - The
+ *   maps by name.
+ * @returns {Map<string, WrittenIn>} The scripts, by language name.
+ */
+export function writtenInOf(byName: ReadonlyMap<string, Record<string, any>>, maps: ReadonlyMap<string, import("./text-maps.mjs").TextMap>): Map<string, WrittenIn>;
+/**
+ * The keys a run takes from its language's script: each of `map` and `font`
+ * the run does not state, where it agrees with the one the run does.
+ *
+ * @param {{lang?: string, map?: string, font?: string}} keys - The run's keys,
+ *   its own and those it inherits.
+ * @param {ReadonlyMap<string, WrittenIn>|undefined} scripts - Each language's
+ *   script, from {@link writtenInOf}.
+ * @param {ReadonlyMap<string, import("./text-maps.mjs").TextMap>|undefined} maps -
+ *   The maps by name.
+ * @returns {{map?: string, font?: string}} What the run takes; empty when it
+ *   takes nothing.
+ */
+export function fromWrittenIn(keys: {
+    lang?: string;
+    map?: string;
+    font?: string;
+}, scripts: ReadonlyMap<string, WrittenIn> | undefined, maps: ReadonlyMap<string, import("./text-maps.mjs").TextMap> | undefined): {
+    map?: string;
+    font?: string;
+};
+/**
+ * Check a note's `data.writtenIn`: that the note is a language, that `map`
+ * names a map a mapping note declares, and that the map is drawn in `font`.
+ * The data-key check owns the keys and their kinds.
+ *
+ * @param {{file: string, raw?: string, fm?: Record<string, any>}} note - The note.
+ * @param {{index?: {notes?: Iterable<object>}}} [context] - The lint index;
+ *   without one, only the note's `subType` is checked.
+ * @returns {object[]} The findings, each at its key or value.
+ */
+export function checkWrittenIn(note: {
+    file: string;
+    raw?: string;
+    fm?: Record<string, any>;
+}, { index }?: {
+    index?: {
+        notes?: Iterable<object>;
+    };
+}): object[];
+/** The `data` key a language note names its script in. */
+export const WRITTEN_IN_KEY: "writtenIn";
+/**
+ * A language's script.
+ */
+export type WrittenIn = {
+    /**
+     * - The `data.map.name` of the mapping note.
+     */
+    map: string;
+    /**
+     * - The slug of the face, one the map is drawn in.
+     */
+    font: string;
+};