explico 0.12.0 → 0.13.1

package/dist/reference/math-glyphs.d.mts

@@ -39,6 +39,64 @@ export function operatorDisplayLatex(name: string): string;
  * @returns {string | undefined}
  */
 export function decorationOfEntry(latex: string): string | undefined;
+/** True for a letter that is a running index wherever it is a whole slot. */
+export function isRunningIndexLetter(text: any): boolean;
+/**
+ * The key of a derived entry: a base entry composed with an index entry
+ * (`\mathbf{v}_0` from `velocity-vector` and `{}_0`). The build materializes
+ * it from the two (`derived-notation.mjs`); it is never authored, and an
+ * authored key that equals one fails the build.
+ *
+ * @param {string} baseKey
+ * @param {string} indexKey
+ * @returns {string}
+ */
+export function derivedNotationKey(baseKey: string, indexKey: string): string;
+/**
+ * The subscript an **index entry** explains — an empty group with a subscript:
+ * `{}_0`, `{}_x`, `{}_{\mathrm{max}}` — as the source after `{}`, else
+ * `undefined`. Such an entry binds no symbol of its own; composed with the
+ * entry of the symbol it indexes, it makes a derived card (rule N23).
+ *
+ * @param {string} latex
+ * @returns {string | undefined}
+ */
+export function indexOfEntry(latex: string): string | undefined;
+/**
+ * The symbol a base entry gives a derived card: its whole `latex`, or the
+ * glyph it lends to — the head of a function form (`v` of `v(t)`), the base
+ * of a superscript form (`j` of `j^{(m)}`).
+ *
+ * @param {string} notation
+ * @returns {string}
+ */
+export function baseSymbolLatex(notation: string): string;
+/**
+ * The symbol of a derived card: the base's symbol with the index entry's
+ * subscript — `\mathbf{v}` and `{}_0` make `\mathbf{v}_0`.
+ *
+ * @param {string} baseNotation
+ * @param {string} indexNotation
+ * @returns {string}
+ */
+export function derivedNotationLatex(baseNotation: string, indexNotation: string): string;
+/**
+ * How an index entry is shown on its own — over a placeholder square, as an
+ * operator entry is (`\square_0`). Display only.
+ *
+ * @param {string} latex
+ * @returns {string}
+ */
+export function indexDisplayLatex(latex: string): string;
+/**
+ * Whether an entry's `latex` has a subscript on a symbol anywhere — what an
+ * `\explain{key}{X_i}` wrap needs from `key` before its card can explain the
+ * index (rule N23, `index-swallowed`).
+ *
+ * @param {string} latex
+ * @returns {boolean}
+ */
+export function entryHasIndex(latex: string): boolean;
 /**
  * Resolve and annotate one KaTeX expression against a page's flat glyph table.
  * Source offsets in the result always refer to the original, unmodified LaTeX.
@@ -51,15 +109,28 @@ export function decorationOfEntry(latex: string): string | undefined;
  * decorated form no whole form covers is reported in `unresolved`, marked
  * `suspended`.
  *
+ * A symbol with a subscript (rule N23) takes its exact whole form, else the
+ * family whose index has its shape, else — with `options.derive`, which page
+ * math sets (a lesson body, its assessments, labs and diagrams) — a derived
+ * card from an index entry (`{}_0`) and the base's entry; each such card
+ * wraps the whole indexed symbol. `derived`
+ * lists the derived cards used, as `{ key, base, index }`, for the build to
+ * materialize; `indices` says how each indexed symbol is explained (see
+ * `classifyIndexed`). A definition may carry `fixedIndex: true`: its index
+ * (or, on a letter, the letter as an index) is a fixed label, not a running
+ * one, so it is no family.
+ *
  * @param {string} latex
- * @param {Array<{key: string, notation: string}>} definitions
- * @param {{ suspended?: readonly string[] }} [options]
+ * @param {Array<{key: string, notation: string, fixedIndex?: boolean}>} definitions
+ * @param {{ suspended?: readonly string[], derive?: boolean }} [options]
  */
 export function resolveMathGlyphs(latex: string, definitions: Array<{
     key: string;
     notation: string;
+    fixedIndex?: boolean;
 }>, options?: {
     suspended?: readonly string[];
+    derive?: boolean;
 }): {
     latex: string;
     bindings: {
@@ -72,11 +143,32 @@ export function resolveMathGlyphs(latex: string, definitions: Array<{
     decorations: {
         token: string;
         wholeForm: any;
+        wholeFormExplicit: boolean;
         operator: any;
         start: any;
         end: any;
         name: any;
     }[];
+    indices: {
+        token: string;
+        start: any;
+        end: any;
+        base: any;
+        index: any;
+        how: any;
+        key: any;
+        explained: boolean;
+        baseExplained: boolean;
+        unexplained: any[];
+        running: {
+            letter: any;
+            start: any;
+            end: any;
+            key: any;
+            cover: any;
+        }[];
+    }[];
+    derived: any[];
 };
 /**
  * Every named operator in one KaTeX expression: a built-in `op` node