@rse/ase 0.0.31 → 0.0.32

package/plugin/node_modules/katex/src/functions/mclass.ts

@@ -0,0 +1,165 @@
+import defineFunction, {ordargument} from "../defineFunction";
+import {makeSpan} from "../buildCommon";
+import {isCharacterBox} from "../utils";
+import {MathNode} from "../mathMLTree";
+import type {AnyParseNode} from "../parseNode";
+
+import * as html from "../buildHTML";
+import * as mml from "../buildMathML";
+
+import type Options from "../Options";
+import type {ParseNode} from "../parseNode";
+
+function htmlBuilder(group: ParseNode<"mclass">, options: Options) {
+    const elements = html.buildExpression(group.body, options, true);
+    return makeSpan([group.mclass], elements, options);
+}
+
+function mathmlBuilder(group: ParseNode<"mclass">, options: Options) {
+    let node: MathNode;
+    const inner = mml.buildExpression(group.body, options);
+
+    if (group.mclass === "minner") {
+        node = new MathNode("mpadded", inner);
+    } else if (group.mclass === "mord") {
+        if (group.isCharacterBox) {
+            node = inner[0];
+            node.type = "mi";
+        } else {
+            node = new MathNode("mi", inner);
+        }
+    } else {
+        if (group.isCharacterBox) {
+            node = inner[0];
+            node.type = "mo";
+        } else {
+            node = new MathNode("mo", inner);
+        }
+
+        // Set spacing based on what is the most likely adjacent atom type.
+        // See TeXbook p170.
+        if (group.mclass === "mbin") {
+            node.attributes.lspace = "0.22em"; // medium space
+            node.attributes.rspace = "0.22em";
+        } else if (group.mclass === "mpunct") {
+            node.attributes.lspace = "0em";
+            node.attributes.rspace = "0.17em"; // thinspace
+        } else if (group.mclass === "mopen" || group.mclass === "mclose") {
+            node.attributes.lspace = "0em";
+            node.attributes.rspace = "0em";
+        } else if (group.mclass === "minner") {
+            node.attributes.lspace = "0.0556em"; // 1 mu is the most likely option
+            node.attributes.width = "+0.1111em";
+        }
+        // MathML <mo> default space is 5/18 em, so <mrel> needs no action.
+        // Ref: https://developer.mozilla.org/en-US/docs/Web/MathML/Element/mo
+    }
+    return node;
+}
+
+// Math class commands except \mathop
+defineFunction({
+    type: "mclass",
+    names: [
+        "\\mathord", "\\mathbin", "\\mathrel", "\\mathopen",
+        "\\mathclose", "\\mathpunct", "\\mathinner",
+    ],
+    props: {
+        numArgs: 1,
+        primitive: true,
+    },
+    handler({parser, funcName}, args) {
+        const body = args[0];
+        return {
+            type: "mclass",
+            mode: parser.mode,
+            mclass: "m" + funcName.slice(5), // TODO(kevinb): don't prefix with 'm'
+            body: ordargument(body),
+            isCharacterBox: isCharacterBox(body),
+        };
+    },
+    htmlBuilder,
+    mathmlBuilder,
+});
+
+export const binrelClass = (arg: AnyParseNode): string => {
+    // \binrel@ spacing varies with (bin|rel|ord) of the atom in the argument.
+    // (by rendering separately and with {}s before and after, and measuring
+    // the change in spacing).  We'll do roughly the same by detecting the
+    // atom type directly.
+    const atom = (arg.type === "ordgroup" && arg.body.length ? arg.body[0] : arg);
+    if (atom.type === "atom" && (atom.family === "bin" || atom.family === "rel")) {
+        return "m" + atom.family;
+    } else {
+        return "mord";
+    }
+};
+
+// \@binrel{x}{y} renders like y but as mbin/mrel/mord if x is mbin/mrel/mord.
+// This is equivalent to \binrel@{x}\binrel@@{y} in AMSTeX.
+defineFunction({
+    type: "mclass",
+    names: ["\\@binrel"],
+    props: {
+        numArgs: 2,
+    },
+    handler({parser}, args) {
+        return {
+            type: "mclass",
+            mode: parser.mode,
+            mclass: binrelClass(args[0]),
+            body: ordargument(args[1]),
+            isCharacterBox: isCharacterBox(args[1]),
+        };
+    },
+});
+
+// Build a relation or stacked op by placing one symbol on top of another
+defineFunction({
+    type: "mclass",
+    names: ["\\stackrel", "\\overset", "\\underset"],
+    props: {
+        numArgs: 2,
+    },
+    handler({parser, funcName}, args) {
+        const baseArg = args[1];
+        const shiftedArg = args[0];
+
+        let mclass;
+        if (funcName !== "\\stackrel") {
+            // LaTeX applies \binrel spacing to \overset and \underset.
+            mclass = binrelClass(baseArg);
+        } else {
+            mclass = "mrel";  // for \stackrel
+        }
+
+        const baseOp: ParseNode<"op"> = {
+            type: "op",
+            mode: baseArg.mode,
+            limits: true,
+            alwaysHandleSupSub: true,
+            parentIsSupSub: false,
+            symbol: false,
+            suppressBaseShift: funcName !== "\\stackrel",
+            body: ordargument(baseArg),
+        };
+
+        const supsub: ParseNode<"supsub"> = {
+            type: "supsub",
+            mode: shiftedArg.mode,
+            base: baseOp,
+            sup: funcName === "\\underset" ? null : shiftedArg,
+            sub: funcName === "\\underset" ? shiftedArg : null,
+        };
+
+        return {
+            type: "mclass",
+            mode: parser.mode,
+            mclass,
+            body: [supsub],
+            isCharacterBox: isCharacterBox(supsub),
+        };
+    },
+    htmlBuilder,
+    mathmlBuilder,
+});

package/plugin/node_modules/katex/src/functions/op.ts

@@ -0,0 +1,337 @@
+// Limits, symbols
+import defineFunction, {ordargument} from "../defineFunction";
+import {mathsym, makeSpan, makeSymbol, makeVList, staticSvg} from "../buildCommon";
+import {SymbolNode} from "../domTree";
+import {MathNode, newDocumentFragment, TextNode} from "../mathMLTree";
+import Style from "../Style";
+import {assembleSupSub} from "./utils/assembleSupSub";
+import {assertNodeType} from "../parseNode";
+import {makeEm} from "../units";
+
+import * as html from "../buildHTML";
+import * as mml from "../buildMathML";
+
+import type {HtmlBuilderSupSub, MathMLBuilder} from "../defineFunction";
+import type {ParseNode} from "../parseNode";
+
+// Most operators have a large successor symbol, but these don't.
+const noSuccessor = new Set([
+    "\\smallint",
+]);
+
+// NOTE: Unlike most `htmlBuilder`s, this one handles not only "op", but also
+// "supsub" since some of them (like \int) can affect super/subscripting.
+export const htmlBuilder: HtmlBuilderSupSub<"op"> = (grp, options) => {
+    // Operators are handled in the TeXbook pg. 443-444, rule 13(a).
+    let supGroup;
+    let subGroup;
+    let hasLimits = false;
+    let group: ParseNode<"op">;
+    if (grp.type === "supsub") {
+        // If we have limits, supsub will pass us its group to handle. Pull
+        // out the superscript and subscript and set the group to the op in
+        // its base.
+        supGroup = grp.sup;
+        subGroup = grp.sub;
+        group = assertNodeType(grp.base, "op");
+        hasLimits = true;
+    } else {
+        group = assertNodeType(grp, "op");
+    }
+
+    const style = options.style;
+
+    let large = false;
+    if (style.size === Style.DISPLAY.size &&
+        group.symbol &&
+        !noSuccessor.has(group.name)) {
+
+        // Most symbol operators get larger in displaystyle (rule 13)
+        large = true;
+    }
+
+    let base;
+    // Italic correction from the symbol glyph, captured before the symbol
+    // may be wrapped in a vlist (for \oiint/\oiiint).  Stays 0 for non-symbol ops.
+    let symbolItalic;
+    if (group.symbol) {
+        // If this is a symbol, create the symbol.
+        const fontName = large ? "Size2-Regular" : "Size1-Regular";
+
+        let stash = "";
+        if (group.name === "\\oiint" || group.name === "\\oiiint") {
+            // No font glyphs yet, so use a glyph w/o the oval.
+            // TODO: When font glyphs are available, delete this code.
+            stash = group.name.slice(1);
+            group.name = stash === "oiint" ? "\\iint" : "\\iiint";
+        }
+
+        base = makeSymbol(
+            group.name, fontName, "math", options,
+            ["mop", "op-symbol", large ? "large-op" : "small-op"]);
+        symbolItalic = base.italic;
+
+        if (stash.length > 0) {
+            // We're in \oiint or \oiiint. Overlay the oval.
+            // TODO: When font glyphs are available, delete this code.
+            const oval = staticSvg(stash + "Size"
+                + (large ? "2" : "1"), options);
+            base = makeVList({
+                positionType: "individualShift",
+                children: [
+                    {type: "elem", elem: base, shift: 0},
+                    {type: "elem", elem: oval, shift: large ? 0.08 : 0},
+                ],
+            }, options);
+            group.name = "\\" + stash;
+            base.classes.unshift("mop");
+            // Carry the italic correction from the original symbol to the
+            // vlist wrapper so supsub can use it for subscript positioning.
+            base.italic = symbolItalic;
+        }
+    } else if (group.body) {
+        // If this is a list, compose that list.
+        const inner = html.buildExpression(group.body, options, true);
+        if (inner.length === 1 && inner[0] instanceof SymbolNode) {
+            base = inner[0];
+            base.classes[0] = "mop"; // replace old mclass
+        } else {
+            base = makeSpan(["mop"], inner, options);
+        }
+    } else {
+        // Otherwise, this is a text operator. Build the text from the
+        // operator's name.
+        const output = [];
+        for (let i = 1; i < group.name!.length; i++) {
+            output.push(mathsym(group.name![i], group.mode, options));
+        }
+        base = makeSpan(["mop"], output, options);
+    }
+
+    // If content of op is a single symbol, shift it vertically.
+    let baseShift = 0;
+    let slant = 0;
+    if ((base instanceof SymbolNode
+        || group.name === "\\oiint" || group.name === "\\oiiint")
+        && !group.suppressBaseShift) {
+        // We suppress the shift of the base of \overset and \underset. Otherwise,
+        // shift the symbol so its center lies on the axis (rule 13). It
+        // appears that our fonts have the centers of the symbols already
+        // almost on the axis, so these numbers are very small. Note we
+        // don't actually apply this here, but instead it is used either in
+        // the vlist creation or separately when there are no limits.
+        baseShift = (base.height - base.depth) / 2 -
+            options.fontMetrics().axisHeight;
+
+        // The slant of the symbol is just its italic correction.
+        // SymbolNode carries .italic natively; Span (for \oiint/\oiiint)
+        // only has it set when nonzero, so default to 0.
+        slant = base.italic ?? 0;
+    }
+
+    if (hasLimits) {
+        return assembleSupSub(base, supGroup, subGroup, options,
+            style, slant, baseShift);
+
+    } else {
+        if (baseShift) {
+            base.style.position = "relative";
+            base.style.top = makeEm(baseShift);
+        }
+
+        return base;
+    }
+};
+
+const mathmlBuilder: MathMLBuilder<"op"> = (group, options) => {
+    let node;
+
+    if (group.symbol) {
+        // This is a symbol. Just add the symbol.
+        node = new MathNode(
+            "mo", [mml.makeText(group.name, group.mode)]);
+        if (noSuccessor.has(group.name)) {
+            node.setAttribute("largeop", "false");
+        }
+    } else if (group.body) {
+        // This is an operator with children. Add them.
+        node = new MathNode(
+            "mo", mml.buildExpression(group.body, options));
+    } else {
+        // This is a text operator. Add all the characters from the
+        // operator's name.
+        node = new MathNode(
+            "mi", [new TextNode(group.name!.slice(1))]);
+        // Append an <mo>&ApplyFunction;</mo>.
+        // ref: https://www.w3.org/TR/REC-MathML/chap3_2.html#sec3.2.4
+        const operator = new MathNode("mo",
+            [mml.makeText("\u2061", "text")]);
+        if (group.parentIsSupSub) {
+            node = new MathNode("mrow", [node, operator]);
+        } else {
+            node = newDocumentFragment([node, operator]);
+        }
+    }
+
+    return node;
+};
+
+const singleCharBigOps: Record<string, string> = {
+    "\u220F": "\\prod",
+    "\u2210": "\\coprod",
+    "\u2211": "\\sum",
+    "\u22c0": "\\bigwedge",
+    "\u22c1": "\\bigvee",
+    "\u22c2": "\\bigcap",
+    "\u22c3": "\\bigcup",
+    "\u2a00": "\\bigodot",
+    "\u2a01": "\\bigoplus",
+    "\u2a02": "\\bigotimes",
+    "\u2a04": "\\biguplus",
+    "\u2a06": "\\bigsqcup",
+};
+
+defineFunction({
+    type: "op",
+    names: [
+        "\\coprod", "\\bigvee", "\\bigwedge", "\\biguplus", "\\bigcap",
+        "\\bigcup", "\\intop", "\\prod", "\\sum", "\\bigotimes",
+        "\\bigoplus", "\\bigodot", "\\bigsqcup", "\\smallint", "\u220F",
+        "\u2210", "\u2211", "\u22c0", "\u22c1", "\u22c2", "\u22c3", "\u2a00",
+        "\u2a01", "\u2a02", "\u2a04", "\u2a06",
+    ],
+    props: {
+        numArgs: 0,
+    },
+    handler: ({parser, funcName}, args) => {
+        let fName = funcName;
+        if (fName.length === 1) {
+            fName = singleCharBigOps[fName];
+        }
+        return {
+            type: "op",
+            mode: parser.mode,
+            limits: true,
+            parentIsSupSub: false,
+            symbol: true,
+            name: fName,
+        };
+    },
+    htmlBuilder,
+    mathmlBuilder,
+});
+
+// Note: calling defineFunction with a type that's already been defined only
+// works because the same htmlBuilder and mathmlBuilder are being used.
+defineFunction({
+    type: "op",
+    names: ["\\mathop"],
+    props: {
+        numArgs: 1,
+        primitive: true,
+    },
+    handler: ({parser}, args) => {
+        const body = args[0];
+        return {
+            type: "op",
+            mode: parser.mode,
+            limits: false,
+            parentIsSupSub: false,
+            symbol: false,
+            body: ordargument(body),
+        };
+    },
+    htmlBuilder,
+    mathmlBuilder,
+});
+
+// There are 2 flags for operators; whether they produce limits in
+// displaystyle, and whether they are symbols and should grow in
+// displaystyle. These four groups cover the four possible choices.
+const singleCharIntegrals: Record<string, string> = {
+    "\u222b": "\\int",
+    "\u222c": "\\iint",
+    "\u222d": "\\iiint",
+    "\u222e": "\\oint",
+    "\u222f": "\\oiint",
+    "\u2230": "\\oiiint",
+};
+
+// No limits, not symbols
+defineFunction({
+    type: "op",
+    names: [
+        "\\arcsin", "\\arccos", "\\arctan", "\\arctg", "\\arcctg",
+        "\\arg", "\\ch", "\\cos", "\\cosec", "\\cosh", "\\cot", "\\cotg",
+        "\\coth", "\\csc", "\\ctg", "\\cth", "\\deg", "\\dim", "\\exp",
+        "\\hom", "\\ker", "\\lg", "\\ln", "\\log", "\\sec", "\\sin",
+        "\\sinh", "\\sh", "\\tan", "\\tanh", "\\tg", "\\th",
+    ],
+    props: {
+        numArgs: 0,
+    },
+    handler({parser, funcName}) {
+        return {
+            type: "op",
+            mode: parser.mode,
+            limits: false,
+            parentIsSupSub: false,
+            symbol: false,
+            name: funcName,
+        };
+    },
+    htmlBuilder,
+    mathmlBuilder,
+});
+
+// Limits, not symbols
+defineFunction({
+    type: "op",
+    names: [
+        "\\det", "\\gcd", "\\inf", "\\lim", "\\max", "\\min", "\\Pr", "\\sup",
+    ],
+    props: {
+        numArgs: 0,
+    },
+    handler({parser, funcName}) {
+        return {
+            type: "op",
+            mode: parser.mode,
+            limits: true,
+            parentIsSupSub: false,
+            symbol: false,
+            name: funcName,
+        };
+    },
+    htmlBuilder,
+    mathmlBuilder,
+});
+
+// No limits, symbols
+defineFunction({
+    type: "op",
+    names: [
+        "\\int", "\\iint", "\\iiint", "\\oint", "\\oiint", "\\oiiint",
+        "\u222b", "\u222c", "\u222d", "\u222e", "\u222f", "\u2230",
+    ],
+    props: {
+        numArgs: 0,
+        allowedInArgument: true,
+    },
+    handler({parser, funcName}) {
+        let fName = funcName;
+        if (fName.length === 1) {
+            fName = singleCharIntegrals[fName];
+        }
+        return {
+            type: "op",
+            mode: parser.mode,
+            limits: false,
+            parentIsSupSub: false,
+            symbol: true,
+            name: fName,
+        };
+    },
+    htmlBuilder,
+    mathmlBuilder,
+});

package/plugin/node_modules/katex/src/functions/operatorname.ts

@@ -0,0 +1,161 @@
+import defineFunction, {ordargument} from "../defineFunction";
+import defineMacro from "../defineMacro";
+import {makeSpan} from "../buildCommon";
+import {MathNode, newDocumentFragment, SpaceNode, TextNode} from "../mathMLTree";
+import {SymbolNode} from "../domTree";
+import {assembleSupSub} from "./utils/assembleSupSub";
+import {assertNodeType} from "../parseNode";
+
+import * as html from "../buildHTML";
+import * as mml from "../buildMathML";
+
+import type {HtmlBuilderSupSub, MathMLBuilder} from "../defineFunction";
+import type {AnyParseNode, ParseNode} from "../parseNode";
+
+// NOTE: Unlike most `htmlBuilder`s, this one handles not only
+// "operatorname", but also  "supsub" since \operatorname* can
+// affect super/subscripting.
+export const htmlBuilder: HtmlBuilderSupSub<"operatorname"> = (grp, options) => {
+    // Operators are handled in the TeXbook pg. 443-444, rule 13(a).
+    let supGroup;
+    let subGroup;
+    let hasLimits = false;
+    let group: ParseNode<"operatorname">;
+    if (grp.type === "supsub") {
+        // If we have limits, supsub will pass us its group to handle. Pull
+        // out the superscript and subscript and set the group to the op in
+        // its base.
+        supGroup = grp.sup;
+        subGroup = grp.sub;
+        group = assertNodeType(grp.base, "operatorname");
+        hasLimits = true;
+    } else {
+        group = assertNodeType(grp, "operatorname");
+    }
+
+    let base;
+    if (group.body.length > 0) {
+        const body = group.body.map((child): AnyParseNode => {
+            const childText = "text" in child ? child.text : undefined;
+            if (typeof childText === "string") {
+                return {
+                    type: "textord",
+                    mode: child.mode,
+                    text: childText,
+                };
+            } else {
+                return child;
+            }
+        });
+
+        // Consolidate function names into symbol characters.
+        const expression = html.buildExpression(
+            body, options.withFont("mathrm"), true);
+
+        for (let i = 0; i < expression.length; i++) {
+            const child = expression[i];
+            if (child instanceof SymbolNode) {
+                // Per amsopn package,
+                // change minus to hyphen and \ast to asterisk
+                child.text = child.text.replace(/\u2212/, "-")
+                    .replace(/\u2217/, "*");
+            }
+        }
+        base = makeSpan(["mop"], expression, options);
+    } else {
+        base = makeSpan(["mop"], [], options);
+    }
+
+    if (hasLimits) {
+        return assembleSupSub(base, supGroup, subGroup, options,
+            options.style, 0, 0);
+
+    } else {
+        return base;
+    }
+};
+
+const mathmlBuilder: MathMLBuilder<"operatorname"> = (group, options) => {
+    // The steps taken here are similar to the html version.
+    let expression: Array<MathNode | TextNode> = mml.buildExpression(
+        group.body, options.withFont("mathrm"));
+
+    // Is expression a string or has it something like a fraction?
+    let isAllString = true;  // default
+    for (let i = 0; i < expression.length; i++) {
+        const node = expression[i];
+        if (node instanceof SpaceNode) {
+            // Do nothing
+        } else if (node instanceof MathNode) {
+            switch (node.type) {
+                case "mi":
+                case "mn":
+                case "mspace":
+                case "mtext":
+                    break;  // Do nothing yet.
+                case "mo": {
+                    const child = node.children[0];
+                    if (node.children.length === 1 &&
+                        child instanceof TextNode) {
+                        child.text =
+                            child.text.replace(/\u2212/, "-")
+                                .replace(/\u2217/, "*");
+                    } else {
+                        isAllString = false;
+                    }
+                    break;
+                }
+                default:
+                    isAllString = false;
+            }
+        } else {
+            isAllString = false;
+        }
+    }
+
+    if (isAllString) {
+        // Write a single TextNode instead of multiple nested tags.
+        const word = expression.map(node => node.toText()).join("");
+        expression = [new TextNode(word)];
+    }
+
+    const identifier = new MathNode("mi", expression);
+    identifier.setAttribute("mathvariant", "normal");
+
+    // \u2061 is the same as &ApplyFunction;
+    // ref: https://www.w3schools.com/charsets/ref_html_entities_a.asp
+    const operator = new MathNode("mo",
+        [mml.makeText("\u2061", "text")]);
+
+    if (group.parentIsSupSub) {
+        return new MathNode("mrow", [identifier, operator]);
+    } else {
+        return newDocumentFragment([identifier, operator]);
+    }
+};
+
+// \operatorname
+// amsopn.dtx: \mathop{#1\kern\z@\operator@font#3}\newmcodes@
+defineFunction({
+    type: "operatorname",
+    names: ["\\operatorname@", "\\operatornamewithlimits"],
+    props: {
+        numArgs: 1,
+    },
+    handler: ({parser, funcName}, args) => {
+        const body = args[0];
+        return {
+            type: "operatorname",
+            mode: parser.mode,
+            body: ordargument(body),
+            alwaysHandleSupSub: (funcName === "\\operatornamewithlimits"),
+            limits: false,
+            parentIsSupSub: false,
+        };
+    },
+    htmlBuilder,
+    mathmlBuilder,
+});
+
+defineMacro("\\operatorname",
+  "\\@ifstar\\operatornamewithlimits\\operatorname@");

package/plugin/node_modules/katex/src/functions/ordgroup.ts

@@ -0,0 +1,20 @@
+import {defineFunctionBuilders} from "../defineFunction";
+import {makeFragment, makeSpan} from "../buildCommon";
+
+import * as html from "../buildHTML";
+import * as mml from "../buildMathML";
+
+defineFunctionBuilders({
+    type: "ordgroup",
+    htmlBuilder(group, options) {
+        if (group.semisimple) {
+            return makeFragment(
+                html.buildExpression(group.body, options, false));
+        }
+        return makeSpan(
+            ["mord"], html.buildExpression(group.body, options, true), options);
+    },
+    mathmlBuilder(group, options) {
+        return mml.buildExpressionRow(group.body, options, true);
+    },
+});