import React from 'react';
import PropTypes from 'prop-types';

interface MathJaxConfig$1 {
    [name: string]: any;
}
interface MathJaxLibrary {
    [name: string]: any;
}
interface MathJaxObject$1 {
    version: string;
    _: MathJaxLibrary;
    config: MathJaxConfig$1;
}

declare type OptionList = {
    [name: string]: any;
};

interface FactoryNode {
    readonly kind: string;
}
interface FactoryNodeClass<N extends FactoryNode> {
    new (factory: Factory<N, FactoryNodeClass<N>>, ...args: any[]): N;
}
interface Factory<N extends FactoryNode, C extends FactoryNodeClass<N>> {
    create(kind: string): N;
    setNodeClass(kind: string, nodeClass: C): void;
    getNodeClass(kind: string): C;
    deleteNodeClass(kind: string): void;
    nodeIsKind(node: N, kind: string): boolean;
    getKinds(): string[];
}
declare abstract class AbstractFactory<N extends FactoryNode, C extends FactoryNodeClass<N>> implements Factory<N, C> {
    static defaultNodes: {};
    defaultKind: string;
    protected nodeMap: Map<string, C>;
    protected node: {
        [kind: string]: (...args: any[]) => N;
    };
    constructor(nodes?: {
        [kind: string]: C;
    });
    create(kind: string, ...args: any[]): N;
    setNodeClass(kind: string, nodeClass: C): void;
    getNodeClass(kind: string): C;
    deleteNodeClass(kind: string): void;
    nodeIsKind(node: N, kind: string): boolean;
    getKinds(): string[];
}

interface NodeFactory<N extends Node, C extends FactoryNodeClass<N>> extends Factory<N, C> {
    create(kind: string, properties?: PropertyList, children?: N[]): N;
}
declare abstract class AbstractNodeFactory<N extends Node, C extends FactoryNodeClass<N>> extends AbstractFactory<N, C> {
    create(kind: string, properties?: PropertyList, children?: N[]): N;
}

declare type Property = string | number | boolean;
declare type PropertyList = {
    [key: string]: Property;
};
interface Node {
    readonly kind: string;
    readonly factory: NodeFactory<Node, NodeClass>;
    parent: Node;
    childNodes: Node[];
    setProperty(name: string, value: Property): void;
    getProperty(name: string): Property;
    getPropertyNames(): string[];
    getAllProperties(): PropertyList;
    removeProperty(...names: string[]): void;
    isKind(kind: string): boolean;
    setChildren(children: Node[]): void;
    appendChild(child: Node): Node;
    replaceChild(newChild: Node, oldChild: Node): Node;
    removeChild(child: Node): Node;
    childIndex(child: Node): number;
    copy(): Node;
    findNodes(kind: string): Node[];
    walkTree(func: (node: Node, data?: any) => void, data?: any): void;
}
interface NodeClass {
    new (factory: NodeFactory<Node, NodeClass>, properties?: PropertyList, children?: Node[]): Node;
}

declare class Attributes {
    protected attributes: PropertyList;
    protected inherited: PropertyList;
    protected defaults: PropertyList;
    protected global: PropertyList;
    constructor(defaults: PropertyList, global: PropertyList);
    set(name: string, value: Property): void;
    setList(list: PropertyList): void;
    get(name: string): Property;
    getExplicit(name: string): Property;
    getList(...names: string[]): PropertyList;
    setInherited(name: string, value: Property): void;
    getInherited(name: string): Property;
    getDefault(name: string): Property;
    isSet(name: string): boolean;
    hasDefault(name: string): boolean;
    getExplicitNames(): string[];
    getInheritedNames(): string[];
    getDefaultNames(): string[];
    getGlobalNames(): string[];
    getAllAttributes(): PropertyList;
    getAllInherited(): PropertyList;
    getAllDefaults(): PropertyList;
    getAllGlobals(): PropertyList;
}

declare class MmlFactory extends AbstractNodeFactory<MmlNode, MmlNodeClass> {
    static defaultNodes: {
        [kind: string]: MmlNodeClass;
    };
    get MML(): Object;
}

declare type AttributeData = {
    name: string;
    value: string;
};
declare type PageBBox = {
    left: number;
    right: number;
    top: number;
    bottom: number;
};
interface DOMAdaptor<N, T, D> {
    document: D;
    parse(text: string, format?: string): D;
    node(kind: string, def?: OptionList, children?: (N | T)[], ns?: string): N;
    text(text: string): T;
    head(doc: D): N;
    body(doc: D): N;
    root(doc: D): N;
    doctype(doc: D): string;
    tags(node: N, name: string, ns?: string): N[];
    getElements(nodes: (string | N | N[])[], document: D): N[];
    contains(container: N, node: N | T): boolean;
    parent(node: N | T): N;
    append(node: N, child: N | T): N | T;
    insert(nchild: N | T, ochild: N | T): void;
    remove(child: N | T): N | T;
    replace(nnode: N | T, onode: N | T): N | T;
    clone(node: N): N;
    split(node: T, n: number): T;
    next(node: N | T): N | T;
    previous(node: N | T): N | T;
    firstChild(node: N): N | T;
    lastChild(node: N): N | T;
    childNodes(node: N): (N | T)[];
    childNode(node: N, i: number): N | T;
    kind(node: N | T): string;
    value(node: N | T): string;
    textContent(node: N): string;
    innerHTML(node: N): string;
    outerHTML(node: N): string;
    serializeXML(node: N): string;
    setAttribute(node: N, name: string, value: string | number, ns?: string): void;
    setAttributes(node: N, def: OptionList): void;
    getAttribute(node: N, name: string): string;
    removeAttribute(node: N, name: string): void;
    hasAttribute(node: N, name: string): boolean;
    allAttributes(node: N): AttributeData[];
    addClass(node: N, name: string): void;
    removeClass(node: N, name: string): void;
    hasClass(node: N, name: string): boolean;
    allClasses(node: N): string[];
    setStyle(node: N, name: string, value: string): void;
    getStyle(node: N, name: string): string;
    allStyles(node: N): string;
    insertRules(node: N, rules: string[]): void;
    fontSize(node: N): number;
    fontFamily(node: N): string;
    nodeSize(node: N, em?: number, local?: boolean): [number, number];
    nodeBBox(node: N): PageBBox;
}

declare type AttributeList = {
    [attribute: string]: [string, Property];
};
interface MmlNode extends Node {
    readonly isToken: boolean;
    readonly isEmbellished: boolean;
    readonly isSpacelike: boolean;
    readonly linebreakContainer: boolean;
    readonly hasNewLine: boolean;
    readonly arity: number;
    readonly isInferred: boolean;
    readonly Parent: MmlNode;
    readonly notParent: boolean;
    parent: MmlNode;
    texClass: number;
    prevClass: number;
    prevLevel: number;
    attributes: Attributes;
    core(): MmlNode;
    coreMO(): MmlNode;
    coreIndex(): number;
    childPosition(): number;
    setTeXclass(prev: MmlNode): MmlNode;
    texSpacing(): string;
    hasSpacingAttributes(): boolean;
    setInheritedAttributes(attributes: AttributeList, display: boolean, level: number, prime: boolean): void;
    inheritAttributesFrom(node: MmlNode): void;
    mError(message: string, options: PropertyList, short?: boolean): MmlNode;
    verifyTree(options?: PropertyList): void;
}
interface MmlNodeClass extends NodeClass {
    defaults?: PropertyList;
    new (factory: MmlFactory, attributes?: PropertyList, children?: MmlNode[]): MmlNode;
}

declare type Location<N, T> = {
    i?: number;
    n?: number;
    delim?: string;
    node?: N | T;
};
declare type Metrics = {
    em: number;
    ex: number;
    containerWidth: number;
    lineWidth: number;
    scale: number;
};
interface MathItem<N, T, D> {
    math: string;
    inputJax: InputJax<N, T, D>;
    display: boolean;
    isEscaped: boolean;
    start: Location<N, T>;
    end: Location<N, T>;
    root: MmlNode;
    typesetRoot: N;
    metrics: Metrics;
    inputData: OptionList;
    outputData: OptionList;
    render(document: MathDocument<N, T, D>): void;
    rerender(document: MathDocument<N, T, D>, start?: number): void;
    convert(document: MathDocument<N, T, D>, end?: number): void;
    compile(document: MathDocument<N, T, D>): void;
    typeset(document: MathDocument<N, T, D>): void;
    updateDocument(document: MathDocument<N, T, D>): void;
    removeFromDocument(restore: boolean): void;
    setMetrics(em: number, ex: number, cwidth: number, lwidth: number, scale: number): void;
    state(state?: number, restore?: boolean): number;
    reset(restore?: boolean): void;
}
declare type ProtoItem<N, T> = {
    math: string;
    start: Location<N, T>;
    end: Location<N, T>;
    open?: string;
    close?: string;
    n?: number;
    display: boolean;
};

interface PrioritizedListItem<DataClass> {
    priority: number;
    item: DataClass;
}
declare class PrioritizedList<DataClass> {
    static DEFAULTPRIORITY: number;
    protected items: PrioritizedListItem<DataClass>[];
    constructor();
    [Symbol.iterator](): Iterator<PrioritizedListItem<DataClass>>;
    add(item: DataClass, priority?: number): DataClass;
    remove(item: DataClass): void;
}

declare class FunctionList extends PrioritizedList<Function> {
    execute(...data: any[]): boolean;
    asyncExecute(...data: any[]): Promise<void>;
}

interface InputJax<N, T, D> {
    name: string;
    processStrings: boolean;
    options: OptionList;
    preFilters: FunctionList;
    postFilters: FunctionList;
    adaptor: DOMAdaptor<N, T, D>;
    mmlFactory: MmlFactory;
    setAdaptor(adaptor: DOMAdaptor<N, T, D>): void;
    setMmlFactory(mmlFactory: MmlFactory): void;
    initialize(): void;
    reset(...args: any[]): void;
    findMath(which: N | string[], options?: OptionList): ProtoItem<N, T>[];
    compile(math: MathItem<N, T, D>, document: MathDocument<N, T, D>): MmlNode;
}

interface OutputJax<N, T, D> {
    name: string;
    options: OptionList;
    postFilters: FunctionList;
    adaptor: DOMAdaptor<N, T, D>;
    setAdaptor(adaptor: DOMAdaptor<N, T, D>): void;
    initialize(): void;
    reset(...args: any[]): void;
    typeset(math: MathItem<N, T, D>, document?: MathDocument<N, T, D>): N;
    escaped(math: MathItem<N, T, D>, document?: MathDocument<N, T, D>): N;
    getMetrics(document: MathDocument<N, T, D>): void;
    styleSheet(document: MathDocument<N, T, D>): N;
    pageElements(document: MathDocument<N, T, D>): N;
}

declare type SortFn<DataClass> = (a: DataClass, b: DataClass) => boolean;
declare class ListItem<DataClass> {
    data: DataClass | symbol;
    next: ListItem<DataClass>;
    prev: ListItem<DataClass>;
    constructor(data?: any);
}
declare class LinkedList<DataClass> {
    protected list: ListItem<DataClass>;
    constructor(...args: DataClass[]);
    isBefore(a: DataClass, b: DataClass): boolean;
    push(...args: DataClass[]): LinkedList<DataClass>;
    pop(): DataClass;
    unshift(...args: DataClass[]): LinkedList<DataClass>;
    shift(): DataClass;
    remove(...items: DataClass[]): void;
    clear(): LinkedList<DataClass>;
    [Symbol.iterator](): IterableIterator<DataClass>;
    reversed(): IterableIterator<DataClass>;
    insert(data: DataClass, isBefore?: SortFn<DataClass>): this;
    sort(isBefore?: SortFn<DataClass>): LinkedList<DataClass>;
    merge(list: LinkedList<DataClass>, isBefore?: SortFn<DataClass>): LinkedList<DataClass>;
}

interface MathList<N, T, D> extends LinkedList<MathItem<N, T, D>> {
    isBefore(a: MathItem<N, T, D>, b: MathItem<N, T, D>): boolean;
}

declare class BitField {
    protected static MAXBIT: number;
    protected static next: number;
    protected static names: Map<string, number>;
    protected bits: number;
    static allocate(...names: string[]): void;
    static has(name: string): boolean;
    set(name: string): void;
    clear(name: string): void;
    isSet(name: string): boolean;
    reset(): void;
    protected getBit(name: string): number;
}

declare type RenderDoc<N, T, D> = (document: MathDocument<N, T, D>) => boolean;
declare type RenderMath<N, T, D> = (math: MathItem<N, T, D>, document: MathDocument<N, T, D>) => boolean;
declare type RenderData<N, T, D> = {
    id: string;
    renderDoc: RenderDoc<N, T, D>;
    renderMath: RenderMath<N, T, D>;
    convert: boolean;
};
declare type RenderAction<N, T, D> = [
    number
] | [
    number,
    string
] | [
    number,
    string,
    string
] | [
    number,
    RenderDoc<N, T, D>,
    RenderMath<N, T, D>
] | [
    number,
    boolean
] | [
    number,
    string,
    boolean
] | [
    number,
    string,
    string,
    boolean
] | [
    number,
    RenderDoc<N, T, D>,
    RenderMath<N, T, D>,
    boolean
];
declare type RenderActions<N, T, D> = {
    [id: string]: RenderAction<N, T, D>;
};
declare class RenderList<N, T, D> extends PrioritizedList<RenderData<N, T, D>> {
    static create<N, T, D>(actions: RenderActions<N, T, D>): RenderList<N, T, D>;
    static action<N, T, D>(id: string, action: RenderAction<N, T, D>): [RenderData<N, T, D>, number];
    protected static methodActions(method1: string, method2?: string): ((math: any, document: any) => boolean)[];
    renderDoc(document: MathDocument<N, T, D>, start?: number): void;
    renderMath(math: MathItem<N, T, D>, document: MathDocument<N, T, D>, start?: number): void;
    renderConvert(math: MathItem<N, T, D>, document: MathDocument<N, T, D>, end?: number): void;
    findID(id: string): RenderData<N, T, D> | null;
}
declare type ContainerList<N> = string | N | (string | N | N[])[];
declare type ResetList = {
    all?: boolean;
    processed?: boolean;
    inputJax?: any[];
    outputJax?: any[];
};
interface MathDocument<N, T, D> {
    document: D;
    kind: string;
    options: OptionList;
    math: MathList<N, T, D>;
    renderActions: RenderList<N, T, D>;
    processed: BitField;
    inputJax: InputJax<N, T, D>[];
    outputJax: OutputJax<N, T, D>;
    adaptor: DOMAdaptor<N, T, D>;
    mmlFactory: MmlFactory;
    addRenderAction(id: string, ...action: any[]): void;
    removeRenderAction(id: string): void;
    render(): MathDocument<N, T, D>;
    rerender(start?: number): MathDocument<N, T, D>;
    convert(math: string, options?: OptionList): MmlNode | N;
    findMath(options?: OptionList): MathDocument<N, T, D>;
    compile(): MathDocument<N, T, D>;
    getMetrics(): MathDocument<N, T, D>;
    typeset(): MathDocument<N, T, D>;
    updateDocument(): MathDocument<N, T, D>;
    removeFromDocument(restore?: boolean): MathDocument<N, T, D>;
    state(state: number, restore?: boolean): MathDocument<N, T, D>;
    reset(options?: ResetList): MathDocument<N, T, D>;
    clear(): MathDocument<N, T, D>;
    concat(list: MathList<N, T, D>): MathDocument<N, T, D>;
    clearMathItemsWithin(containers: ContainerList<N>): MathItem<N, T, D>[];
    getMathItemsWithin(elements: ContainerList<N>): MathItem<N, T, D>[];
}
declare abstract class AbstractMathDocument<N, T, D> implements MathDocument<N, T, D> {
    static KIND: string;
    static OPTIONS: OptionList;
    static ProcessBits: typeof BitField;
    document: D;
    options: OptionList;
    math: MathList<N, T, D>;
    renderActions: RenderList<N, T, D>;
    processed: BitField;
    inputJax: InputJax<N, T, D>[];
    outputJax: OutputJax<N, T, D>;
    adaptor: DOMAdaptor<N, T, D>;
    mmlFactory: MmlFactory;
    constructor(document: D, adaptor: DOMAdaptor<N, T, D>, options: OptionList);
    get kind(): string;
    addRenderAction(id: string, ...action: any[]): void;
    removeRenderAction(id: string): void;
    render(): this;
    rerender(start?: number): this;
    convert(math: string, options?: OptionList): any;
    findMath(_options?: OptionList): this;
    compile(): this;
    protected compileMath(math: MathItem<N, T, D>): void;
    compileError(math: MathItem<N, T, D>, err: Error): void;
    typeset(): this;
    typesetError(math: MathItem<N, T, D>, err: Error): void;
    getMetrics(): this;
    updateDocument(): this;
    removeFromDocument(_restore?: boolean): this;
    state(state: number, restore?: boolean): this;
    reset(options?: ResetList): this;
    clear(): this;
    concat(list: MathList<N, T, D>): this;
    clearMathItemsWithin(containers: ContainerList<N>): MathItem<N, T, D>[];
    getMathItemsWithin(elements: ContainerList<N>): MathItem<N, T, D>[];
}
interface MathDocumentConstructor<D extends MathDocument<any, any, any>> {
    KIND: string;
    OPTIONS: OptionList;
    ProcessBits: typeof BitField;
    new (...args: any[]): D;
}

interface Handler<N, T, D> {
    name: string;
    adaptor: DOMAdaptor<N, T, D>;
    priority: number;
    documentClass: MathDocumentConstructor<AbstractMathDocument<N, T, D>>;
    handlesDocument(document: any): boolean;
    create(document: any, options: OptionList): MathDocument<N, T, D>;
}

interface MathJaxConfig extends MathJaxConfig$1 {
    startup?: {
        input?: string[];
        output?: string;
        handler?: string;
        adaptor?: string;
        document?: any;
        elements?: any[];
        typeset?: boolean;
        ready?: () => void;
        pageReady?: () => void;
        invalidOption?: 'fatal' | 'warn';
        optionError?: (message: string, key: string) => void;
        [name: string]: any;
    };
}
declare type MATHDOCUMENT = MathDocument<any, any, any>;
declare type HANDLER = Handler<any, any, any>;
declare type DOMADAPTOR = DOMAdaptor<any, any, any>;
declare type INPUTJAX = InputJax<any, any, any>;
declare type OUTPUTJAX = OutputJax<any, any, any>;
declare type HandlerExtension = (handler: HANDLER) => HANDLER;
interface MathJaxObject extends MathJaxObject$1 {
    config: MathJaxConfig;
    startup: {
        constructors: {
            [name: string]: any;
        };
        input: INPUTJAX[];
        output: OUTPUTJAX;
        handler: HANDLER;
        adaptor: DOMADAPTOR;
        elements: any[];
        document: MATHDOCUMENT;
        promise: Promise<void>;
        registerConstructor(name: string, constructor: any): void;
        useHandler(name: string, force?: boolean): void;
        useAdaptor(name: string, force?: boolean): void;
        useOutput(name: string, force?: boolean): void;
        useInput(name: string, force?: boolean): void;
        extendHandler(extend: HandlerExtension): void;
        toMML(node: MmlNode): string;
        defaultReady(): void;
        defaultPageReady(): Promise<void>;
        getComponents(): void;
        makeMethods(): void;
        makeTypesetMethods(): void;
        makeOutputMethods(iname: string, oname: string, input: INPUTJAX): void;
        makeMmlMethods(name: string, input: INPUTJAX): void;
        makeResetMethod(name: string, input: INPUTJAX): void;
        getInputJax(): INPUTJAX[];
        getOutputJax(): OUTPUTJAX;
        getAdaptor(): DOMADAPTOR;
        getHandler(): HANDLER;
    };
    [name: string]: any;
}

declare enum TexLang {
    MML = "MathML",
    TEX = "TeX"
}

interface IMathJaxContext {
    MathJax3: MathJaxObject | null;
    language: TexLang;
}

declare const initialMathJaxContext: IMathJaxContext;
declare const MathJaxContextType: React.Context<IMathJaxContext>;

interface IProps$2 {
    /**
     * Formula language.
     */
    readonly lang: TexLang;
    /**
     * The literal formula string.
     */
    readonly formula: string;
    /**
     * Whether to render the formulas in inline mode.
     */
    readonly inline: boolean;
    /**
     * Mathjax render settings.
     */
    readonly error: string;
}
declare class MathError extends React.PureComponent<IProps$2> {
    static readonly displayName = "MathError";
    static readonly propTypes: {
        lang: PropTypes.Validator<TexLang>;
        formula: PropTypes.Validator<string>;
        inline: PropTypes.Validator<boolean>;
        error: PropTypes.Validator<any>;
    };
    render(): React.ReactElement;
}

interface IMathJaxNodeProps {
    /**
     * The literal formula string.
     */
    formula: string;
    /**
     * Whether to render the formulas in inline mode.
     * @default false
     */
    inline?: boolean;
    /**
     * CSS class name.
     */
    className?: string;
    /**
     * CSS style properties
     */
    style?: React.CSSProperties;
}
declare const MathJaxNode: React.FC<IMathJaxNodeProps>;

interface IMathErrorProps {
    lang: TexLang;
    formula: string;
    inline: boolean;
    error: string;
}
interface IProps$1 {
    MathJax3: MathJaxObject;
    language: TexLang;
    formula: string;
    inline: boolean;
    className?: string;
    style?: React.CSSProperties;
    MathErrorRenderer?: React.ComponentType<IMathErrorProps>;
}
interface IState$1 {
    error: string | undefined;
}
declare class MathJaxNodeWithoutContext extends React.Component<IProps$1, IState$1> {
    static readonly displayName = "MathJaxNodeWithoutContext";
    static readonly propTypes: {
        MathJax3: PropTypes.Validator<object>;
        language: PropTypes.Validator<string>;
        formula: PropTypes.Validator<NonNullable<PropTypes.ReactNodeLike>>;
        inline: PropTypes.Validator<boolean>;
        className: PropTypes.Requireable<string>;
        style: PropTypes.Requireable<object>;
        MathErrorRenderer: PropTypes.Requireable<PropTypes.ReactComponentLike>;
    };
    protected readonly _nodeRef: React.RefObject<HTMLDivElement>;
    protected readonly _typesettingRef: React.MutableRefObject<boolean>;
    constructor(props: IProps$1);
    shouldComponentUpdate(nextProps: Readonly<IProps$1>, nextState: Readonly<IState$1>): boolean;
    render(): React.ReactElement;
    componentDidMount(): void;
    componentDidUpdate(prevProps: Readonly<IProps$1>): void;
    componentWillUnmount(): void;
    /**
     * Update math in the node
     * @param isForceUpdate
     */
    protected _typeset(): void | never;
    protected _onTypesetDone(): void;
}

interface IProps {
    /**
     * http / https url for loading mathjax.
     * @default 'https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.4/MathJax3.js?config=TeX-MML-AM_CHTML'
     */
    mathjaxSrc?: string;
    /**
     * MathJax3 config
     */
    mathjaxConfig?: MathJaxConfig;
    /**
     * Contents / Animation displayed at waiting MathJax3 loading.
     * @default null
     */
    loading?: React.ReactNode;
    /**
     * Sub components.
     */
    children?: React.ReactNode;
    /**
     * Triggered on mathjax loaded.
     * @param MathJax3
     */
    onLoad?(MathJax3: MathJaxObject): void;
    /**
     * Triggered on mathjax thrown an error.
     *
     * @param MathJax3
     * @param error
     */
    onError?(MathJax3: MathJaxObject, error: any): void;
}
interface IState {
    loaded: boolean;
    context: IMathJaxContext;
}
declare class MathJaxProvider extends React.Component<IProps, IState> {
    static readonly displayName = "MathJaxProvider";
    static readonly propTypes: {
        mathjaxSrc: PropTypes.Requireable<string>;
        mathjaxConfig: PropTypes.Requireable<object>;
        loading: PropTypes.Requireable<PropTypes.ReactNodeLike>;
        children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
        onLoad: PropTypes.Requireable<(...args: any[]) => any>;
        onError: PropTypes.Requireable<(...args: any[]) => any>;
    };
    protected _cancelLoad: (() => Promise<void>) | undefined;
    constructor(props: IProps);
    shouldComponentUpdate(nextProps: Readonly<IProps>, nextState: Readonly<IState>): boolean;
    render(): React.ReactElement;
    componentDidMount(): void;
    componentDidUpdate(prevProps: Readonly<IProps>): void;
    componentWillUnmount(): void;
    protected load(): Promise<void>;
    protected clear(): Promise<void>;
    protected readonly onLoad: (MathJax3: MathJaxObject) => void;
    protected readonly onError: (MathJax3: MathJaxObject, error: unknown) => void;
}

declare function loadMathJax3(mathjax3Src: string, mathjax3Config: MathJaxConfig | undefined): Promise<MathJaxObject | null>;

export { MathError, MathJaxContextType, MathJaxNode, MathJaxNodeWithoutContext, MathJaxProvider, TexLang, initialMathJaxContext, loadMathJax3 };
export type { MathJaxObject as IMathJax3, MathJaxConfig as IMathJaxConfig3, IMathJaxContext };