docx 9.7.2 → 9.8.1

package/dist/math.d.cts

@@ -0,0 +1,676 @@
+import { BuilderElement } from 'docx';
+import { createMathAccentCharacter } from 'docx';
+import { createMathBase } from 'docx';
+import { createMathLimitLocation } from 'docx';
+import { createMathNAryProperties } from 'docx';
+import { createMathPreSubSuperScriptProperties } from 'docx';
+import { createMathSubScriptElement } from 'docx';
+import { createMathSubScriptProperties } from 'docx';
+import { createMathSubSuperScriptProperties } from 'docx';
+import { createMathSuperScriptElement } from 'docx';
+import { createMathSuperScriptProperties } from 'docx';
+import { IMathFractionOptions } from 'docx';
+import { IMathFunctionOptions } from 'docx';
+import { IMathIntegralOptions } from 'docx';
+import { IMathLimitLowerOptions } from 'docx';
+import { IMathLimitUpperOptions } from 'docx';
+import { IMathOptions } from 'docx';
+import { IMathPreSubSuperScriptOptions } from 'docx';
+import { IMathRadicalOptions } from 'docx';
+import { IMathSubScriptOptions } from 'docx';
+import { IMathSubSuperScriptOptions } from 'docx';
+import { IMathSumOptions } from 'docx';
+import { IMathSuperScriptOptions } from 'docx';
+import { Math as Math_2 } from 'docx';
+import { MathAngledBrackets } from 'docx';
+import { MathComponent } from 'docx';
+import { MathCurlyBrackets } from 'docx';
+import { MathDegree } from 'docx';
+import { MathDenominator } from 'docx';
+import { MathFraction } from 'docx';
+import { MathFractionType } from 'docx';
+import { MathFunction } from 'docx';
+import { MathFunctionName } from 'docx';
+import { MathFunctionProperties } from 'docx';
+import { MathIntegral } from 'docx';
+import { MathLimit } from 'docx';
+import { MathLimitLower } from 'docx';
+import { MathLimitsPosition } from 'docx';
+import { MathLimitUpper } from 'docx';
+import { MathNumerator } from 'docx';
+import { MathPreSubSuperScript } from 'docx';
+import { MathRadical } from 'docx';
+import { MathRadicalProperties } from 'docx';
+import { MathRoundBrackets } from 'docx';
+import { MathRun } from 'docx';
+import { MathRunOptions } from 'docx';
+import { MathRunScript } from 'docx';
+import { MathRunStyle } from 'docx';
+import { MathSquareBrackets } from 'docx';
+import { MathSubScript } from 'docx';
+import { MathSubSuperScript } from 'docx';
+import { MathSum } from 'docx';
+import { MathSuperScript } from 'docx';
+
+export { createMathAccentCharacter }
+
+export { createMathBase }
+
+export { createMathLimitLocation }
+
+export { createMathNAryProperties }
+
+export { createMathPreSubSuperScriptProperties }
+
+export { createMathSubScriptElement }
+
+export { createMathSubScriptProperties }
+
+export { createMathSubSuperScriptProperties }
+
+export { createMathSuperScriptElement }
+
+export { createMathSuperScriptProperties }
+
+export { IMathFractionOptions }
+
+export { IMathFunctionOptions }
+
+export { IMathIntegralOptions }
+
+export { IMathLimitLowerOptions }
+
+export { IMathLimitUpperOptions }
+
+export { IMathOptions }
+
+export { IMathPreSubSuperScriptOptions }
+
+export { IMathRadicalOptions }
+
+export { IMathSubScriptOptions }
+
+export { IMathSubSuperScriptOptions }
+
+export { IMathSumOptions }
+
+export { IMathSuperScriptOptions }
+
+/**
+ * Turns LaTeX math into docx's math, to go in a `Math`, as Word's own equations, which it shows and edits as it does
+ * those typed into it.
+ *
+ * It reads the math that LaTeX, MathJax and KaTeX write: fractions, scripts, roots, sums, integrals and other large
+ * operators, functions such as sin and lim, brackets that grow with `\left` and `\right`, accents, braces, boxes,
+ * fonts such as `\mathbb` and `\mathrm`, `\text`, Greek letters and symbols, and the environments for matrices,
+ * cases and aligned equations, with `\tag` for their numbers. The math can be given in `$…$`, `$$…$$`, `\(…\)` or
+ * `\[…\]`, which are left out.
+ *
+ * Colours, sizes and spacing that Word works out for itself are left out.
+ *
+ * @param latex - The LaTeX, such as `"\\frac{-b \\pm \\sqrt{b^2-4ac}}{2a}"`
+ * @returns The math, to be the children of a `Math`, or to go among other math components
+ * @throws If the LaTeX has a command or an environment it doesn't know, or isn't well formed, such as a `{` with no
+ * `}`. The error says where
+ *
+ * @example
+ * ```typescript
+ * new Math({ children: latexToMath("x = \\frac{-b \\pm \\sqrt{b^2-4ac}}{2a}") });
+ * ```
+ */
+export declare const latexToMath: (latex: string) => readonly MathComponent[];
+
+export { Math_2 as Math }
+
+/**
+ * An accent over math (`m:acc`), such as a hat, a tilde, dots or a vector's arrow, as LaTeX's `\hat`, `\tilde`,
+ * `\dot` and `\vec`. Word stretches the accent over what it goes over.
+ *
+ * For a line over or under math, as LaTeX's `\overline` and `\underline`, use a `MathBar`.
+ *
+ * @example
+ * ```typescript
+ * new MathAccent({ accent: "rightArrow", children: [new MathRun("v")] });
+ * ```
+ */
+export declare class MathAccent extends BuilderElement {
+    constructor({ accent, children }: MathAccentOptions);
+}
+
+/**
+ * An accent over math, as LaTeX writes it:
+ *
+ * - `"hat"`: x̂, `\hat` and `\widehat`;
+ * - `"check"`: x̌, `\check`;
+ * - `"tilde"`: x̃, `\tilde` and `\widetilde`;
+ * - `"acute"`: x́, `\acute`;
+ * - `"grave"`: x̀, `\grave`;
+ * - `"dot"`: ẋ, `\dot`;
+ * - `"doubleDot"`: ẍ, `\ddot`;
+ * - `"tripleDot"`: x⃛, `\dddot`;
+ * - `"breve"`: x̆, `\breve`;
+ * - `"bar"`: x̅, `\bar`;
+ * - `"ring"`: x̊, `\mathring`;
+ * - `"rightArrow"`: x⃗, `\vec` and `\overrightarrow`;
+ * - `"leftArrow"`: x⃖, `\overleftarrow`;
+ * - `"leftRightArrow"`: x⃡, `\overleftrightarrow`;
+ * - `"rightHarpoon"`: x⃑, `\overrightharpoon`;
+ * - `"leftHarpoon"`: x⃐, `\overleftharpoon`.
+ */
+export declare type MathAccentName = "hat" | "check" | "tilde" | "acute" | "grave" | "dot" | "doubleDot" | "tripleDot" | "breve" | "bar" | "ring" | "rightArrow" | "leftArrow" | "leftRightArrow" | "rightHarpoon" | "leftHarpoon";
+
+/**
+ * Options for {@link MathAccent}.
+ */
+export declare type MathAccentOptions = {
+    /**
+     * The accent.
+     * @default "hat"
+     */
+    readonly accent?: MathAccentName;
+    /** What the accent goes over */
+    readonly children: readonly MathComponent[];
+};
+
+export { MathAngledBrackets }
+
+/**
+ * A line over or under math (`m:bar`), as LaTeX's `\overline` and `\underline`, as long as what it goes over.
+ *
+ * @example
+ * ```typescript
+ * new MathBar({ children: [new MathRun("AB")] });
+ * new MathBar({ position: "below", children: [new MathRun("x")] });
+ * ```
+ */
+export declare class MathBar extends BuilderElement {
+    constructor({ position, children }: MathBarOptions);
+}
+
+/**
+ * Options for {@link MathBar}.
+ */
+export declare type MathBarOptions = {
+    /**
+     * Whether the line goes above or below.
+     * @default "above"
+     */
+    readonly position?: MathPosition;
+    /** What the line goes over or under */
+    readonly children: readonly MathComponent[];
+};
+
+/**
+ * A box around math (`m:borderBox`), as LaTeX's `\boxed`, with lines struck through it, as `\cancel`, `\bcancel` and
+ * `\xcancel`. Any of its sides can be left out.
+ *
+ * @example
+ * ```typescript
+ * new MathBox({ children: [new MathRun("E=mc²")] });
+ * new MathBox({ borders: [], strikes: ["diagonalUp"], children: [new MathRun("x")] });
+ * ```
+ */
+export declare class MathBox extends BuilderElement {
+    constructor({ children, borders, strikes }: MathBoxOptions);
+}
+
+/**
+ * Options for {@link MathBox}.
+ */
+export declare type MathBoxOptions = {
+    /** What goes in the box */
+    readonly children: readonly MathComponent[];
+    /**
+     * The sides of the box that are drawn. `[]` draws none, for lines struck through math with no box.
+     * @default ["top", "bottom", "left", "right"]
+     */
+    readonly borders?: readonly MathBoxSide[];
+    /**
+     * Lines struck through the box, such as `["diagonalUp"]` to cancel a term.
+     * @default []
+     */
+    readonly strikes?: readonly MathBoxStrike[];
+};
+
+/** A side of a box */
+export declare type MathBoxSide = "top" | "bottom" | "left" | "right";
+
+/**
+ * A line struck through a box:
+ *
+ * - `"horizontal"`: across its middle;
+ * - `"vertical"`: down its middle;
+ * - `"diagonalUp"`: from its bottom left corner to its top right, as LaTeX's `\cancel`;
+ * - `"diagonalDown"`: from its top left corner to its bottom right, as `\bcancel`.
+ */
+export declare type MathBoxStrike = "horizontal" | "vertical" | "diagonalUp" | "diagonalDown";
+
+/**
+ * A brace over or under math (`m:groupChr`), as long as what it goes over, as LaTeX's `\overbrace` and
+ * `\underbrace`. A label goes on the brace's other side, as Word writes it: in a limit above (`m:limUpp`) or below
+ * (`m:limLow`).
+ *
+ * @example
+ * ```typescript
+ * new MathBrace({
+ *   position: "below",
+ *   children: [new MathRun("1+2+⋯+n")],
+ *   label: [new MathRun("n terms")],
+ * });
+ * ```
+ */
+export declare class MathBrace extends BuilderElement {
+    constructor({ position, brace, children, label }: MathBraceOptions);
+}
+
+/**
+ * Options for {@link MathBrace}.
+ */
+export declare type MathBraceOptions = {
+    /**
+     * Whether the brace goes above or below.
+     * @default "above"
+     */
+    readonly position?: MathPosition;
+    /**
+     * The shape of the brace.
+     * @default "curly"
+     */
+    readonly brace?: MathBraceShape;
+    /** What the brace goes over or under */
+    readonly children: readonly MathComponent[];
+    /** A label on the brace's other side, such as `n times` */
+    readonly label?: readonly MathComponent[];
+};
+
+/**
+ * The shape of a brace:
+ *
+ * - `"curly"`: ⏞ and ⏟, as LaTeX's `\overbrace` and `\underbrace`;
+ * - `"square"`: ⎴ and ⎵, as `\overbracket` and `\underbracket`;
+ * - `"round"`: ⏜ and ⏝, as `\overparen` and `\underparen`.
+ */
+export declare type MathBraceShape = "curly" | "square" | "round";
+
+/**
+ * Brackets of any characters around math (`m:d`), such as |x|, ‖v‖, ⟨a|b⟩ or a brace on one side only. They grow
+ * with what they hold.
+ *
+ * `MathRoundBrackets`, `MathSquareBrackets`, `MathCurlyBrackets` and `MathAngledBrackets` are fixed pairs of these.
+ *
+ * @example
+ * ```typescript
+ * new MathBrackets({ open: "|", close: "|", children: [new MathRun("x")] });
+ * new MathBrackets({ open: "⟨", close: "⟩", items: [[new MathRun("a")], [new MathRun("b")]] });
+ * new MathBrackets({ open: "{", close: "", children: [new MathRun("x")] });
+ * ```
+ */
+export declare class MathBrackets extends BuilderElement {
+    constructor(options: MathBracketsOptions);
+}
+
+/**
+ * Options for {@link MathBrackets}: the brackets, and what goes between them.
+ */
+export declare type MathBracketsOptions = {
+    /**
+     * The opening bracket: one character, such as `"|"` or `"⟨"`, or `""` for none (`m:begChr`).
+     * @default "("
+     */
+    readonly open?: string;
+    /**
+     * The closing bracket: one character, or `""` for none (`m:endChr`).
+     * @default ")"
+     */
+    readonly close?: string;
+    /**
+     * The character between `items`, such as `","` (`m:sepChr`).
+     * @default "|"
+     */
+    readonly separator?: string;
+    /**
+     * Whether the brackets grow to the height of what they hold (`m:grow`). LibreOffice and Pages always grow them.
+     * @default true
+     */
+    readonly grow?: boolean;
+} & ({
+    /** What goes between the brackets */
+    readonly children: readonly MathComponent[];
+    readonly items?: never;
+} | {
+    /** Several things between the brackets, with `separator` between them, such as ⟨a|b⟩ */
+    readonly items: readonly (readonly MathComponent[])[];
+    readonly children?: never;
+});
+
+/**
+ * One case: a value, and the condition it holds under.
+ */
+export declare type MathCase = {
+    /** The value, such as `−x,` */
+    readonly value: readonly MathComponent[];
+    /**
+     * The condition, such as `if x < 0`. Words such as "if" and "otherwise" read best as normal text:
+     * `new MathRun({ text: "if ", normalText: true })`.
+     */
+    readonly condition?: readonly MathComponent[];
+};
+
+/**
+ * Cases, as LaTeX's `cases`: values, each with its condition, one to a line, in a brace on the left. The values and
+ * the conditions each line up on the left.
+ *
+ * They are written as pandoc writes them: a matrix of two columns in a brace with no closing bracket. Word's own
+ * equation editor lines the conditions up with an `&` instead, which LibreOffice draws.
+ *
+ * @example
+ * ```typescript
+ * new MathCases({
+ *   cases: [
+ *     { value: [new MathRun("x,")], condition: [new MathRun({ text: "if ", normalText: true }), new MathRun("x≥0")] },
+ *     { value: [new MathRun("−x,")], condition: [new MathRun({ text: "otherwise", normalText: true })] },
+ *   ],
+ * });
+ * ```
+ */
+export declare class MathCases extends BuilderElement {
+    constructor({ cases }: MathCasesOptions);
+}
+
+/**
+ * Options for {@link MathCases}.
+ */
+export declare type MathCasesOptions = {
+    /** The cases, one to a line. Word allows at most 256 */
+    readonly cases: readonly MathCase[];
+};
+
+/** Where the cells of a column go across it (`m:mcJc`). LibreOffice and Pages centre them all */
+export declare type MathColumnAlignment = "left" | "center" | "right";
+
+export { MathComponent }
+
+export { MathCurlyBrackets }
+
+export { MathDegree }
+
+export { MathDenominator }
+
+/**
+ * An equation array (`m:eqArr`): rows of math, one to a line, lined up at the points between their parts, as LaTeX's
+ * `align` and `aligned`, with an equation number at the end of any row.
+ *
+ * Word marks the points with an `&`, and the number with a `#`, in the text. So an `&` or a `#` in a `MathRun` in the
+ * array is taken as one too. LibreOffice shows the `&` and `#`, and centres the rows; Pages lines them up, but shows
+ * the `#`.
+ *
+ * @example
+ * ```typescript
+ * new MathEquationArray({
+ *   rows: [
+ *     { parts: [[new MathRun("y")], [new MathRun("=mx+b")]], equationNumber: "(1)" },
+ *     { parts: [[new MathRun("y′")], [new MathRun("=m")]], equationNumber: "(2)" },
+ *   ],
+ * });
+ * ```
+ */
+export declare class MathEquationArray extends BuilderElement {
+    constructor({ rows, verticalAlignment }: MathEquationArrayOptions);
+}
+
+/**
+ * Options for {@link MathEquationArray}.
+ */
+export declare type MathEquationArrayOptions = {
+    /** The rows, one to a line. Word allows at most 64 */
+    readonly rows: readonly MathEquationArrayRow[];
+    /**
+     * Where the array sits on its line.
+     * @default "center"
+     */
+    readonly verticalAlignment?: MathVerticalAlignment;
+};
+
+/**
+ * One row of an equation array.
+ */
+export declare type MathEquationArrayRow = {
+    /**
+     * The row's parts. Word lines up the points between them with the same points in the other rows, as LaTeX's `&`
+     * does: the first, third and every other point line up (such as at an `=`), and the space goes at the others, as
+     * between the columns of `align`. A part can be empty, such as the first part of a row that goes on from the row
+     * before.
+     */
+    readonly parts: readonly (readonly MathComponent[])[];
+    /**
+     * The row's equation number, such as `"(1)"`, which Word 2016 and later put at the right margin. Word 2013 and
+     * older, LibreOffice and Pages show it after a `#`.
+     */
+    readonly equationNumber?: string;
+};
+
+export { MathFraction }
+
+export { MathFractionType }
+
+export { MathFunction }
+
+export { MathFunctionName }
+
+export { MathFunctionProperties }
+
+export { MathIntegral }
+
+/**
+ * A large operator with limits (`m:nary`), such as ∏, ⋃ or ∮, as LaTeX's `\prod`, `\bigcup` and `\oint`, over what
+ * it applies to. `MathSum` and `MathIntegral` are two of these.
+ *
+ * @example
+ * ```typescript
+ * new MathLargeOperator({
+ *   operator: "product",
+ *   subScript: [new MathRun("i=1")],
+ *   superScript: [new MathRun("n")],
+ *   children: [new MathRun("i")],
+ * });
+ * ```
+ */
+export declare class MathLargeOperator extends BuilderElement {
+    constructor({ operator, children, subScript, superScript, limits }: MathLargeOperatorOptions);
+}
+
+/**
+ * A large operator, as LaTeX writes it:
+ *
+ * - `"sum"`: ∑, `\sum`;
+ * - `"product"`: ∏, `\prod`;
+ * - `"coproduct"`: ∐, `\coprod`;
+ * - `"union"`: ⋃, `\bigcup`;
+ * - `"intersection"`: ⋂, `\bigcap`;
+ * - `"squareUnion"`: ⨆, `\bigsqcup`;
+ * - `"multisetUnion"`: ⨄, `\biguplus`;
+ * - `"logicalOr"`: ⋁, `\bigvee`;
+ * - `"logicalAnd"`: ⋀, `\bigwedge`;
+ * - `"directSum"`: ⨁, `\bigoplus`;
+ * - `"tensorProduct"`: ⨂, `\bigotimes`;
+ * - `"circledDot"`: ⨀, `\bigodot`;
+ * - `"integral"`: ∫, `\int`;
+ * - `"doubleIntegral"`: ∬, `\iint`;
+ * - `"tripleIntegral"`: ∭, `\iiint`;
+ * - `"quadrupleIntegral"`: ⨌, `\iiiint`;
+ * - `"contourIntegral"`: ∮, `\oint`;
+ * - `"surfaceIntegral"`: ∯, `\oiint`;
+ * - `"volumeIntegral"`: ∰, `\oiiint`.
+ */
+export declare type MathLargeOperatorName = "sum" | "product" | "coproduct" | "union" | "intersection" | "squareUnion" | "multisetUnion" | "logicalOr" | "logicalAnd" | "directSum" | "tensorProduct" | "circledDot" | "integral" | "doubleIntegral" | "tripleIntegral" | "quadrupleIntegral" | "contourIntegral" | "surfaceIntegral" | "volumeIntegral";
+
+/**
+ * Options for {@link MathLargeOperator}.
+ */
+export declare type MathLargeOperatorOptions = {
+    /** The operator */
+    readonly operator: MathLargeOperatorName;
+    /** What the operator applies to, such as the terms of a sum */
+    readonly children: readonly MathComponent[];
+    /** The lower limit, such as `i=1` */
+    readonly subScript?: readonly MathComponent[];
+    /** The upper limit, such as `n` */
+    readonly superScript?: readonly MathComponent[];
+    /**
+     * Where the limits go: above and below the operator, or to its right.
+     * @default "side" for integrals, and "aboveBelow" for the others, as Word puts them
+     */
+    readonly limits?: MathLimitsPosition;
+};
+
+export { MathLimit }
+
+export { MathLimitLower }
+
+export { MathLimitsPosition }
+
+export { MathLimitUpper }
+
+/**
+ * A matrix (`m:m`), in brackets or none (`m:d`): LaTeX's `matrix`, `pmatrix`, `bmatrix`, `Bmatrix`, `vmatrix` and
+ * `Vmatrix`.
+ *
+ * Word lines up each column's cells as `columnAlignment` says, and hides the placeholders of empty cells. LibreOffice
+ * and Pages centre every column.
+ *
+ * @example
+ * ```typescript
+ * new MathMatrix({
+ *   brackets: "round",
+ *   rows: [
+ *     [[new MathRun("1")], [new MathRun("2")]],
+ *     [[new MathRun("3")], [new MathRun("4")]],
+ *   ],
+ * });
+ * ```
+ */
+export declare class MathMatrix extends BuilderElement {
+    constructor({ brackets, ...options }: MathMatrixOptions);
+}
+
+/**
+ * The brackets around a matrix:
+ *
+ * - `"none"`: none, as LaTeX's `matrix`;
+ * - `"round"`: ( ), as `pmatrix`;
+ * - `"square"`: [ ], as `bmatrix`;
+ * - `"curly"`: { }, as `Bmatrix`;
+ * - `"angled"`: ⟨ ⟩;
+ * - `"verticalBars"`: | |, as `vmatrix`, for determinants;
+ * - `"doubleVerticalBars"`: ‖ ‖, as `Vmatrix`, for norms.
+ */
+export declare type MathMatrixBrackets = "none" | "round" | "square" | "curly" | "angled" | "verticalBars" | "doubleVerticalBars";
+
+/**
+ * Options for {@link MathMatrix}.
+ */
+export declare type MathMatrixOptions = {
+    /**
+     * The rows, each a list of cells, and each cell the math in it (`m:mr`, `m:e`). A row shorter than the longest gets
+     * empty cells at its end. Word allows at most 256 rows and 64 cells in a row.
+     */
+    readonly rows: readonly (readonly (readonly MathComponent[])[])[];
+    /**
+     * The brackets around the matrix.
+     * @default "none"
+     */
+    readonly brackets?: MathMatrixBrackets;
+    /**
+     * Where the cells go across their columns: one alignment for every column, or one for each column.
+     * @default "center"
+     */
+    readonly columnAlignment?: MathColumnAlignment | readonly MathColumnAlignment[];
+    /**
+     * Where the matrix sits on its line.
+     * @default "center"
+     */
+    readonly verticalAlignment?: MathVerticalAlignment;
+};
+
+export { MathNumerator }
+
+/**
+ * A phantom (`m:phant`): math that takes up room without being seen, as LaTeX's `\phantom`, to leave space for it or
+ * line things up with it. Or math that is seen but takes up no room, or less, as `\smash`.
+ *
+ * @example
+ * ```typescript
+ * // As much space as "x+y" takes up
+ * new MathPhantom({ children: [new MathRun("x+y")] });
+ *
+ * // A tall fraction that doesn't push its line apart
+ * new MathPhantom({ visible: true, height: false, depth: false, children: [fraction] });
+ * ```
+ */
+export declare class MathPhantom extends BuilderElement {
+    constructor({ children, visible, width, height, depth }: MathPhantomOptions);
+}
+
+/**
+ * Options for {@link MathPhantom}.
+ */
+export declare type MathPhantomOptions = {
+    /** The math */
+    readonly children: readonly MathComponent[];
+    /**
+     * Whether the math is seen (`m:show`).
+     * @default false
+     */
+    readonly visible?: boolean;
+    /**
+     * Whether it takes up its width. False gives it none (`m:zeroWid`), as LaTeX's `\vphantom`.
+     * @default true
+     */
+    readonly width?: boolean;
+    /**
+     * Whether it takes up its height above the line. False gives it none (`m:zeroAsc`), as LaTeX's `\hphantom` and
+     * `\smash`.
+     * @default true
+     */
+    readonly height?: boolean;
+    /**
+     * Whether it takes up its depth below the line. False gives it none (`m:zeroDesc`), as LaTeX's `\hphantom` and
+     * `\smash`.
+     * @default true
+     */
+    readonly depth?: boolean;
+};
+
+/** Whether something goes above or below the math it is on */
+export declare type MathPosition = "above" | "below";
+
+export { MathPreSubSuperScript }
+
+export { MathRadical }
+
+export { MathRadicalProperties }
+
+export { MathRoundBrackets }
+
+export { MathRun }
+
+export { MathRunOptions }
+
+export { MathRunScript }
+
+export { MathRunStyle }
+
+export { MathSquareBrackets }
+
+export { MathSubScript }
+
+export { MathSubSuperScript }
+
+export { MathSum }
+
+export { MathSuperScript }
+
+/** Where a matrix or equation array sits on its line (`m:baseJc`): its top, its middle or its bottom on the line */
+export declare type MathVerticalAlignment = "top" | "center" | "bottom";
+
+export { }