@heroiclands/package-build 23.6.0 → 23.7.0

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

@@ -0,0 +1,227 @@
+/**
+ * Whether a note falls in a language's `data.scope`: one of its kinds catches
+ * the note, `types` (where stated) admits its type, and `skip` does not name
+ * it. A language that states no scope covers every note.
+ *
+ * @param {Record<string, any>} record - A note's index record.
+ * @param {string} address - The note's Address.
+ * @param {object|undefined} scope - The language's `data.scope`.
+ * @returns {boolean}
+ */
+export function inScope(record: Record<string, any>, address: string, scope: object | undefined): boolean;
+/**
+ * The `register` rows of a set of index records.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records, every
+ *   Address a string, already narrowed to the audience being published to.
+ * @param {Iterable<Record<string, any>>} [all] - Every record of the package;
+ *   a note carrying a name is cited only where the audience sees it.
+ * @returns {object[]} One row per register entry, in record then entry order.
+ */
+export function registerRows(records: Iterable<Record<string, any>>, all?: Iterable<Record<string, any>>): object[];
+/**
+ * The `retired` rows: one per `data.retired` entry, `instead` a list.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]}
+ */
+export function retiredRows(records: Iterable<Record<string, any>>): object[];
+/**
+ * The `tongues` rows: one per `data.tongues` entry.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]}
+ */
+export function tongueRows(records: Iterable<Record<string, any>>): object[];
+/**
+ * The `scope` rows: one per value of each kind of `data.scope`, in the order
+ * the kinds are declared.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]}
+ */
+export function scopeRows(records: Iterable<Record<string, any>>): object[];
+/**
+ * The `letters` rows: one per `data.sounds.letters` entry, `letters` and
+ * `tongue` lists.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]}
+ */
+export function letterRows(records: Iterable<Record<string, any>>): object[];
+/**
+ * The `edges` rows: one per `data.sounds.edges` entry, `sounds` a list.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]}
+ */
+export function edgeRows(records: Iterable<Record<string, any>>): object[];
+/**
+ * The `clusters` rows: one per language stating `data.sounds.clusters`.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]}
+ */
+export function clusterRows(records: Iterable<Record<string, any>>): object[];
+/**
+ * The `read_past` rows: one per `data.sounds.readPast` entry.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]}
+ */
+export function readPastRows(records: Iterable<Record<string, any>>): object[];
+/**
+ * The `sound_changes` rows: one per step of each `data.soundChanges` set, with
+ * the set's `position`, `name`, `from_language` and `to_language`, and the
+ * step's `step_position` within it.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]}
+ */
+export function soundChangeRows(records: Iterable<Record<string, any>>): object[];
+/**
+ * The `elements` rows: one per `data.elements` entry, `examples` a list.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]}
+ */
+export function elementRows(records: Iterable<Record<string, any>>): object[];
+/**
+ * The `roots` rows: one per `data.roots` entry.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]}
+ */
+export function rootRows(records: Iterable<Record<string, any>>): object[];
+/**
+ * The `cognates` rows: one per form of each `data.cognates` set, in the order
+ * the set writes them, with the set's `position`, `gloss` and `proto`.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]}
+ */
+export function cognateRows(records: Iterable<Record<string, any>>): object[];
+/**
+ * The `stress` rows: one per language stating `data.sounds.stress`.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]}
+ */
+export function stressRows(records: Iterable<Record<string, any>>): object[];
+/**
+ * The `finals` rows: one per `data.sounds.finals` entry.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]}
+ */
+export function finalRows(records: Iterable<Record<string, any>>): object[];
+/**
+ * The `syllables` rows: one per language stating `data.sounds.syllables`, a
+ * list rule always a list (`any` a list of one), the harmony's sets each a
+ * column of its own.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]}
+ */
+export function syllableRows(records: Iterable<Record<string, any>>): object[];
+/**
+ * The `joining` rows: one per `data.sounds.joining` entry.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]}
+ */
+export function joiningRows(records: Iterable<Record<string, any>>): object[];
+/**
+ * The `joins` rows: one per `data.sounds.joins` entry.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]}
+ */
+export function joinRows(records: Iterable<Record<string, any>>): object[];
+/**
+ * The `marks` rows: one per `data.sounds.marks` entry.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]}
+ */
+export function markRows(records: Iterable<Record<string, any>>): object[];
+/**
+ * The `skeleton` rows: one per `data.sounds.skeleton` entry, `second` a list.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]}
+ */
+export function skeletonRows(records: Iterable<Record<string, any>>): object[];
+/**
+ * The `frames` rows: one per `data.sounds.frames` entry, `examples` a list of
+ * `{ root, form }` in the order the frame states them.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]}
+ */
+export function frameRows(records: Iterable<Record<string, any>>): object[];
+/**
+ * The `calling_names` rows: one per `data.callingNames.closings` entry, each
+ * with the language's `min_syllables`.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]}
+ */
+export function callingNameRows(records: Iterable<Record<string, any>>): object[];
+/** Every column of the `register` relation, in order. */
+export const REGISTER_COLUMNS: readonly string[];
+/** Every column of the `retired` relation, in order. */
+export const RETIRED_COLUMNS: readonly string[];
+/** Every column of the `tongues` relation, in order. */
+export const TONGUE_COLUMNS: readonly any[];
+/** Every column of the `scope` relation, in order. */
+export const SCOPE_COLUMNS: readonly string[];
+/** Every column of the `letters` relation, in order. */
+export const LETTER_COLUMNS: readonly string[];
+/** Every column of the `edges` relation, in order. */
+export const EDGE_COLUMNS: readonly string[];
+/** Every column of the `clusters` relation, in order. */
+export const CLUSTER_COLUMNS: readonly string[];
+/** Every column of the `stress` relation, in order. */
+export const STRESS_COLUMNS: readonly string[];
+/** Every column of the `finals` relation, in order. */
+export const FINAL_COLUMNS: readonly string[];
+/** Every column of the `syllables` relation, in order: one row per language. */
+export const SYLLABLE_COLUMNS: readonly string[];
+/** Every column of the `joining` relation, in order. */
+export const JOINING_COLUMNS: readonly string[];
+/** Every column of the `joins` relation, in order. */
+export const JOIN_COLUMNS: readonly string[];
+/** Every column of the `marks` relation, in order. */
+export const MARK_COLUMNS: readonly string[];
+/** Every column of the `skeleton` relation, in order. */
+export const SKELETON_COLUMNS: readonly string[];
+/** Every column of the `frames` relation, in order. */
+export const FRAME_COLUMNS: readonly string[];
+/** Every column of the `read_past` relation, in order. */
+export const READ_PAST_COLUMNS: readonly string[];
+/** Every column of the `sound_changes` relation, in order: one row per step. */
+export const SOUND_CHANGE_COLUMNS: readonly string[];
+/** Every column of the `elements` relation, in order. */
+export const ELEMENT_COLUMNS: readonly any[];
+/** Every column of the `roots` relation, in order. */
+export const ROOT_COLUMNS: readonly string[];
+/** Every column of the `cognates` relation, in order. */
+export const COGNATE_COLUMNS: readonly string[];
+/** Every column of the `calling_names` relation, in order. */
+export const CALLING_NAME_COLUMNS: readonly string[];
+/**
+ * The type of each column that holds no text, by relation, so a relation
+ * with no row still has the type a fence's list or number function binds to.
+ *
+ * @type {Readonly<Record<string, Readonly<Record<string, string>>>>}
+ */
+export const LANGUAGE_COLUMN_TYPES: Readonly<Record<string, Readonly<Record<string, string>>>>;
+/**
+ * Every relation of a language's register, sounds, history and names: its
+ * name, its rows from the records the audience sees and every record of the
+ * package, and its columns. {@link LANGUAGE_COLUMN_TYPES} types its columns.
+ *
+ * @type {ReadonlyArray<[string, (visible: object[], all: object[]) => object[], readonly string[]]>}
+ */
+export const LANGUAGE_RELATIONS: ReadonlyArray<[string, (visible: object[], all: object[]) => object[], readonly string[]]>;

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

@@ -0,0 +1,265 @@
+/**
+ * The keys a language note states beside its words: the register of the names
+ * the setting gives in the language's reach, the tags the register uses, the
+ * forms it does not write, the notes the register covers, the letters and sound
+ * rules, the sound changes, the name elements, the roots and the cognates.
+ *
+ * A leaf module, importing nothing: the note vocabulary reads these
+ * declarations as it loads, and `language-data.mjs` checks what the values
+ * mean. Every closed list here — the edges, element positions, register
+ * kinds, stress rules, joins, marks, onsets, harmony sets and calling-name
+ * uses — holds the labels the setting's own tables use, one word for each.
+ *
+ * @module
+ */
+/** The `data` keys a language note states its sounds, names and history in. */
+export const LANGUAGE_DATA_KEYS: readonly string[];
+/**
+ * The tongue tag every language accepts without declaring it: a name given in
+ * the language of the pages.
+ */
+export const RESERVED_TONGUE: "translation";
+/**
+ * The placeholder a tongue tag closes on to declare a family of tags, one per
+ * tongue named after the colon: `exonym:<tongue>` declares `exonym:vylari`.
+ */
+export const TONGUE_PLACEHOLDER: "<tongue>";
+/**
+ * The edges of a word a sound rule names: what may open it, close it, stand
+ * inside it, and what counts as a syllable.
+ */
+export const EDGE_KINDS: readonly string[];
+/** What each edge kind holds, for the reference and for a finding. */
+export const EDGE_MEANINGS: Readonly<{
+    openConsonant: "the single consonants that may open a word, where not every one may";
+    openCluster: "the clusters that may open a word";
+    closeConsonant: "the consonants that may close a word";
+    closeCluster: "the clusters that may close a word";
+    innerCluster: "the pairs that may stand together inside a word";
+    vowelPair: "the vowels that may stand together";
+    glide: "the glides that may follow a consonant";
+    syllabic: "the consonants that may carry a syllable";
+}>;
+/** The word a sound rule's `sounds` takes in place of a list: every sound. */
+export const ANY_SOUND: "any";
+/**
+ * Where in a name an element stands: `opening` opens a name or stands inside
+ * it, `closing` closes it, `either` does both, and `link` joins two parts and
+ * never begins or ends a name.
+ */
+export const ELEMENT_POSITIONS: readonly string[];
+/** What a register name is, where a language sorts its names by kind. */
+export const REGISTER_KINDS: readonly string[];
+/** Where a language's stress falls. */
+export const STRESS_RULES: readonly string[];
+/** Which sounds meet where two parts of a word join. */
+export const JOIN_MEETINGS: readonly string[];
+/**
+ * What happens where they meet: `merge` writes one, `insert` sets the join's
+ * letters between, `drop` loses the first, `double` doubles the consonant.
+ */
+export const JOIN_RULES: readonly string[];
+/** What a written mark says of its letter. */
+export const MARK_KINDS: readonly string[];
+/** How many of a mark a word may carry: `one` at most, or `any` number. */
+export const MARK_LIMITS: readonly string[];
+/** What a syllable may open on, where the rule is stated. */
+export const ONSET_RULES: readonly string[];
+/** Which harmony a neutral vowel counts as. */
+export const HARMONY_SETS: readonly string[];
+/** Whose name a calling-name closing usually makes. */
+export const CALLING_USES: readonly string[];
+/**
+ * The keys of one `data.tongues` entry.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const TONGUE_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of one `data.register` entry.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const REGISTER_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of one `data.retired` entry.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const RETIRED_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of a language's `data.scope`: the notes its register covers. A note
+ * is in scope when any one of them catches it and `skip` does not name it.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const SCOPE_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of one `data.sounds.letters` entry.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const LETTER_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of one `data.sounds.edges` entry.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const EDGE_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of a language's `data.sounds.clusters`.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const CLUSTER_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of one `data.sounds.readPast` entry.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const READ_PAST_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of one `data.sounds.finals` entry: a syllable final, for a
+ * language whose syllables are parsed by them.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const FINAL_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of one `data.sounds.joining` entry: how two parts are written
+ * where the first closes and the second opens on the given sounds.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const JOINING_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of one `data.sounds.joins` entry: what happens where two parts of a
+ * word meet.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const JOIN_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of one `data.sounds.marks` entry: a mark the language writes on a
+ * letter.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const MARK_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of a language's `data.sounds.syllables.harmony`.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const HARMONY_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of a language's `data.sounds.syllables`: what a syllable may open
+ * and close on, and what a word may.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const SYLLABLE_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of one `data.sounds.skeleton` entry: the vowel set between a
+ * root's second and third consonants.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const SKELETON_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of one `data.sounds.frames` entry: a pattern a root is set in.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const FRAME_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of a language's `data.sounds`.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const SOUND_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of one `data.soundChanges` entry.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const SOUND_CHANGE_STEP_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of one `data.soundChanges` set: an ordered run of steps, named, and
+ * where they lead from and to.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const SOUND_CHANGE_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of one `data.elements` entry.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const ELEMENT_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of one `data.roots` entry.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const ROOT_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of one `data.cognates` entry.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const COGNATE_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of one `data.callingNames.closings` entry: an ending, or the first
+ * syllable doubled, that a calling name closes on.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const CALLING_CLOSING_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of a language's `data.callingNames`: the short name a long given
+ * name is called by.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const CALLING_NAME_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The `data` fields this module declares, in the order the vocabulary lists
+ * them. {@link module:engine/language-data.checkLanguageData} checks what the
+ * values mean.
+ *
+ * @type {readonly object[]}
+ */
+export const LANGUAGE_DATA_FIELDS: readonly object[];
+/** The keys of {@link TONGUE_FIELDS}, in declared order. */
+export const TONGUE_KEYS: readonly string[];
+/** The keys of {@link REGISTER_FIELDS}, in declared order. */
+export const REGISTER_KEYS: readonly string[];
+/** The keys of {@link RETIRED_FIELDS}, in declared order. */
+export const RETIRED_KEYS: readonly string[];
+/** The keys of {@link LETTER_FIELDS}, in declared order. */
+export const LETTER_KEYS: readonly string[];
+/** The keys of {@link EDGE_FIELDS}, in declared order. */
+export const EDGE_KEYS: readonly string[];
+/** The keys of {@link READ_PAST_FIELDS}, in declared order. */
+export const READ_PAST_KEYS: readonly string[];
+/** The keys of {@link SOUND_CHANGE_STEP_FIELDS}, in declared order. */
+export const SOUND_CHANGE_STEP_KEYS: readonly string[];
+/** The keys of {@link FINAL_FIELDS}, in declared order. */
+export const FINAL_KEYS: readonly string[];
+/** The keys of {@link JOINING_FIELDS}, in declared order. */
+export const JOINING_KEYS: readonly string[];
+/** The keys of {@link JOIN_FIELDS}, in declared order. */
+export const JOIN_KEYS: readonly string[];
+/** The keys of {@link MARK_FIELDS}, in declared order. */
+export const MARK_KEYS: readonly string[];
+/** The keys of {@link SKELETON_FIELDS}, in declared order. */
+export const SKELETON_KEYS: readonly string[];
+/** The keys of {@link CALLING_CLOSING_FIELDS}, in declared order. */
+export const CALLING_CLOSING_KEYS: readonly string[];
+/** The keys of {@link ELEMENT_FIELDS}, in declared order. */
+export const ELEMENT_KEYS: readonly string[];
+/** The keys of {@link ROOT_FIELDS}, in declared order. */
+export const ROOT_KEYS: readonly string[];
+/** The keys of {@link SCOPE_FIELDS}, in declared order. */
+export const SCOPE_KINDS: readonly string[];

package/types/engine/note-addresses.d.mts

@@ -63,6 +63,14 @@ export const STRUCTURED_ADDRESSES: readonly ({
     type: string;
     accepts: string[];
     lenient: boolean;
+} | {
+    lenient: boolean;
+    system?: string | string[] | undefined;
+    accepts?: string | string[] | undefined;
+    type?: string | string[] | undefined;
+    noteType: string;
+    path: (string | string[] | undefined)[];
+    shape: string;
 } | {
     path: string[];
     shape: string;
@@ -70,7 +78,6 @@ export const STRUCTURED_ADDRESSES: readonly ({
     accepts: string[];
     system: string;
     noteType?: undefined;
-    lenient?: undefined;
 } | {
     noteType: string;
     path: string[];
@@ -78,14 +85,5 @@ export const STRUCTURED_ADDRESSES: readonly ({
     type: string;
     accepts: string[];
     system?: undefined;
-    lenient?: undefined;
-} | {
-    noteType: string;
-    path: string[];
-    shape: string;
-    lenient: boolean;
-    type?: undefined;
-    accepts?: undefined;
-    system?: undefined;
 })[];
 export { AddressEntries, encodeAddresses, cloneAddressState, publishAddresses, readPublishedAddresses, flattenPublishedAddresses } from "./address-values.mjs";

package/types/engine/sql-tables.d.mts

@@ -7,7 +7,7 @@
  *
  * @param {string} markdown - The note body, frontmatter already stripped.
  * @returns {Array<{line: number, close: number, indent: string, query: string,
- *   allowEmpty: boolean, sectionLevel: number, layout: string, block: string}>} One entry per
+ *   allowEmpty: boolean, sectionLevel: number, showKey: boolean|"only", layout: string, block: string}>} One entry per
  *   fence, in document order.
  */
 export function findSqlBlocks(markdown: string): Array<{
@@ -17,6 +17,7 @@ export function findSqlBlocks(markdown: string): Array<{
     query: string;
     allowEmpty: boolean;
     sectionLevel: number;
+    showKey: boolean | "only";
     layout: string;
     block: string;
 }>;

package/types/engine/word-citations.d.mts

@@ -0,0 +1,43 @@
+/**
+ * A form as uses are matched against it: diacritics taken off, case folded.
+ *
+ * @param {unknown} text - A form or a use.
+ * @returns {string} The folded form.
+ */
+export function foldForm(text: unknown): string;
+/**
+ * The marked uses in a note's body: the text of every italic span that holds
+ * text alone, in document order.
+ *
+ * @param {string} body - The note's Markdown body.
+ * @returns {string[]} Each span's text.
+ */
+export function markedUses(body: string): string[];
+/**
+ * Each language note's cited words: for every word some note's marked use
+ * spells, the Addresses of the notes citing it.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @param {Iterable<{record: Record<string, any>, body: string}>} notes - The
+ *   notes whose bodies are read, each with its record.
+ * @returns {Map<string, Map<string, string[]>>} By language Address, by the
+ *   word's form, the citing notes in code-point order.
+ */
+export function wordCitations(records: Iterable<Record<string, any>>, notes: Iterable<{
+    record: Record<string, any>;
+    body: string;
+}>): Map<string, Map<string, string[]>>;
+/**
+ * Set each language record's `citations` from {@link wordCitations}: one entry
+ * per cited word, in the order the words stand, `{ form, notes }`. A language
+ * with no cited word carries no `citations`.
+ *
+ * @param {Record<string, any>[]} records - Index records, written in place.
+ * @param {Iterable<{record: Record<string, any>, body: string}>} notes - The
+ *   notes whose bodies are read.
+ * @returns {void}
+ */
+export function attachCitations(records: Record<string, any>[], notes: Iterable<{
+    record: Record<string, any>;
+    body: string;
+}>): void;