@dskripchenko/math 0.0.0-stage → 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,149 @@
+/** Whether a formula can be read: null when it can, the error (with its place) when not. */
+export declare function checkMath(tex: string, options?: ParseOptions): MathError | null;
+
+/**
+ * Letter styles (`\mathbf`, `\mathbb`, `\mathcal`…) as the characters
+ * Unicode has for them: MathML Core has no `mathvariant` beyond `normal`, and
+ * the Mathematical Alphanumeric Symbols draw the same in any math font.
+ */
+export declare type Font = 'normal' | 'bold' | 'italic' | 'bold-italic' | 'double-struck' | 'script' | 'bold-script' | 'fraktur' | 'bold-fraktur' | 'sans-serif' | 'bold-sans-serif' | 'sans-serif-italic' | 'monospace';
+
+/**
+ * The page's part: a math font for the formulas (only a font with an OpenType
+ * MATH table lets fences, roots and big operators stretch — STIX Two Math on
+ * macOS, Cambria Math on Windows; elsewhere one the page provides), a displayed
+ * formula's margins, and the look of TeX that could not be read.
+ */
+export declare const MATH_CSS = "math.dsk-math{font-family:\"STIX Two Math\",\"Cambria Math\",\"Latin Modern Math\",\"Noto Sans Math\",math}\nmath.dsk-math[display=\"block\"]{margin:.75em 0}\n.dsk-math-error{color:#d1242f;font-family:ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;border-bottom:1px dotted}";
+
+export declare class MathError extends Error {
+    /** Where in the TeX it went wrong (a character offset). */
+    readonly position: number;
+    constructor(message: string, 
+    /** Where in the TeX it went wrong (a character offset). */
+    position: number);
+}
+
+export declare type MathNode = 
+/** An identifier: a letter, a name; `upright` for a name set as text (`sin`, `\mathrm{d}`). */
+    {
+    type: 'ident';
+    text: string;
+    upright?: boolean;
+} | {
+    type: 'number';
+    text: string;
+} | {
+    type: 'op';
+    text: string;
+    kind: OpKind;
+    /** Stretches to its content (a fence), or to a fixed height in em (`\big`). */
+    stretchy?: boolean;
+    size?: number;
+    /** A big operator's limits go under and over when the formula is displayed. */
+    movableLimits?: boolean;
+} | {
+    type: 'text';
+    text: string;
+} | {
+    type: 'space';
+    width: number;
+} | {
+    type: 'row';
+    children: MathNode[];
+}
+/** Scripts beside the base (`x_1^2`), or under and over it (`\sum_{i}^{n}` displayed, `\overset`). */
+| {
+    type: 'scripts';
+    base: MathNode;
+    sub?: MathNode;
+    sup?: MathNode;
+    over?: boolean;
+}
+/** A fraction; `thickness: 0` for a binomial's stack, `style` for `\dfrac` and `\tfrac`. */
+| {
+    type: 'frac';
+    num: MathNode;
+    den: MathNode;
+    thickness?: 0;
+    style?: 'display' | 'text';
+} | {
+    type: 'sqrt';
+    body: MathNode;
+    index?: MathNode;
+}
+/** Content between stretching fences (`\left( … \right)`), with the `\middle` ones inside. */
+| {
+    type: 'fenced';
+    open: string;
+    close: string;
+    body: MathNode;
+}
+/** A mark over or under the base: a hat, a bar, a brace. */
+| {
+    type: 'accent';
+    base: MathNode;
+    mark: string;
+    under?: boolean;
+    stretchy?: boolean;
+}
+/** Rows and cells: a matrix, cases, aligned equations, an array. */
+| {
+    type: 'table';
+    rows: MathNode[][];
+    /** Each column's alignment; the last repeats. */
+    align: ('l' | 'c' | 'r')[];
+    /** Lines between columns (`array{c|c}`). */
+    lines?: ('none' | 'solid')[];
+    /** Aligned equations: columns paired right-left, no space between a pair. */
+    aligned?: boolean;
+    /** A matrix's or cases' own fences. */
+    open?: string;
+    close?: string;
+    small?: boolean;
+} | {
+    type: 'style';
+    body: MathNode;
+    display?: boolean;
+    scriptLevel?: number;
+    color?: string;
+} | {
+    type: 'phantom';
+    body: MathNode;
+} | {
+    type: 'boxed';
+    body: MathNode;
+};
+
+export declare interface MathOptions extends ParseOptions {
+    /** A formula on its own line (`$$…$$`): big operators take limits under and over, fractions are full size. */
+    display?: boolean;
+    /** Throw a `MathError` for TeX that cannot be read, rather than show the TeX marked as an error. */
+    throwOnError?: boolean;
+}
+
+/** How an operator sits: a binary operation, a relation, a fence, punctuation, a big operator. */
+export declare type OpKind = 'bin' | 'rel' | 'open' | 'close' | 'punct' | 'large' | 'ord' | 'prefix';
+
+/** The formula as a tree. Throws `MathError` for TeX it cannot read. */
+export declare function parseMath(tex: string, options?: ParseOptions): MathNode;
+
+declare interface ParseOptions {
+    /** Commands of the writer's own: `{ R: '\\mathbb{R}', norm: '\\left\\|#1\\right\\|' }`; `#1`…`#9` are arguments. */
+    macros?: Record<string, string>;
+}
+
+/**
+ * The formula as a `<math>` element: MathML Core, its TeX kept in an
+ * annotation (copied with it, read back by `texOf`). TeX it cannot read comes
+ * out as a `<span class="dsk-math-error">` with the TeX and the reason in its
+ * title — or throws, with `throwOnError`.
+ */
+export declare function renderMath(tex: string, options?: MathOptions): string;
+
+/** The TeX a drawn formula was made from (its annotation, or an error's text); null for anything else. */
+export declare function texOf(element: Element): string | null;
+
+export declare function toMathML(node: MathNode): string;
+
+export { }