Method parseAtom

src/Parser.ts:338–456

* Parses a group with optional super/subscripts.

(breakOnTokenText?: BreakToken)

     * Parses a group with optional super/subscripts.
     */
    parseAtom(breakOnTokenText?: BreakToken): AnyParseNode | null {
        // The body of an atom is an implicit group, so that things like
        // \left(x\right)^2 work correctly.
        const base = this.parseGroup("atom", breakOnTokenText);

        // Internal nodes (e.g. \relax) cannot support super/subscripts.
        // Instead, we will pick up super/subscripts with blank base next round.
        if (base?.type === "internal") {
            return base;
        }

        // In text mode, we don't have superscripts or subscripts
        if (this.mode === "text") {
            return base;
        }

        let superscript: AnyParseNode | undefined;
        let subscript: AnyParseNode | undefined;
        while (true) {
            // Guaranteed in math mode, so eat any spaces first.
            this.consumeSpaces();

            // Lex the first token
            const lex = this.fetch();

            if (lex.text === "\\limits" || lex.text === "\\nolimits") {
                // We got a limit control
                if (base && base.type === "op") {
                    base.limits = lex.text === "\\limits";
                    base.alwaysHandleSupSub = true;
                } else if (base && base.type === "operatorname") {
                    if (base.alwaysHandleSupSub) {
                        base.limits = lex.text === "\\limits";
                    }
                } else {
                    throw new ParseError(
                        "Limit controls must follow a math operator",
                        lex);
                }
                this.consume();
            } else if (lex.text === "^") {
                // We got a superscript start
                if (superscript) {
                    throw new ParseError("Double superscript", lex);
                }
                superscript = this.handleSupSubscript("superscript");
            } else if (lex.text === "_") {
                // We got a subscript start
                if (subscript) {
                    throw new ParseError("Double subscript", lex);
                }
                subscript = this.handleSupSubscript("subscript");
            } else if (lex.text === "'") {
                // We got a prime
                if (superscript) {
                    throw new ParseError("Double superscript", lex);
                }