@rse/ase 0.0.42 → 0.0.43

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

@@ -1,165 +0,0 @@
-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

@@ -1,337 +0,0 @@
-// 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

@@ -1,161 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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);
-    },
-});