@rse/ase 0.0.30 → 0.0.32

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

@@ -0,0 +1,85 @@
+import defineFunction from "../defineFunction";
+import {MathNode} from "../mathMLTree";
+import Style from "../Style";
+import {sizingGroup} from "./sizing";
+
+import * as mml from "../buildMathML";
+import type {StyleStr} from "../types";
+
+const styleMap: Record<StyleStr, typeof Style.DISPLAY> = {
+    "display": Style.DISPLAY,
+    "text": Style.TEXT,
+    "script": Style.SCRIPT,
+    "scriptscript": Style.SCRIPTSCRIPT,
+};
+
+function isStyleStr(s: string): s is StyleStr {
+    return s in styleMap;
+}
+
+defineFunction({
+    type: "styling",
+    names: [
+        "\\displaystyle", "\\textstyle", "\\scriptstyle",
+        "\\scriptscriptstyle",
+    ],
+    props: {
+        numArgs: 0,
+        allowedInText: true,
+        primitive: true,
+    },
+    handler({breakOnTokenText, funcName, parser}, args) {
+        // parse out the implicit body
+        const body = parser.parseExpression(true, breakOnTokenText);
+
+        // TODO: Refactor to avoid duplicating styleMap in multiple places (e.g.
+        // here and in buildHTML and de-dupe the enumeration of all the styles).
+        const style = funcName.slice(1, funcName.length - 5);
+        if (!isStyleStr(style)) {
+            throw new Error(`Unknown style: ${style}`);
+        }
+        return {
+            type: "styling",
+            mode: parser.mode,
+            // Figure out what style to use by pulling out the style from
+            // the function name
+            style,
+            body,
+        };
+    },
+    htmlBuilder(group, options) {
+        // Style changes are handled in the TeXbook on pg. 442, Rule 3.
+        const newStyle = styleMap[group.style];
+        let newOptions = options.havingStyle(newStyle);
+        if (group.resetFont) {
+            newOptions = newOptions.withFont('');
+        }
+        return sizingGroup(group.body, newOptions, options);
+    },
+    mathmlBuilder(group, options) {
+        // Figure out what style we're changing to.
+        const newStyle = styleMap[group.style];
+        let newOptions = options.havingStyle(newStyle);
+        if (group.resetFont) {
+            newOptions = newOptions.withFont('');
+        }
+
+        const inner = mml.buildExpression(group.body, newOptions);
+
+        const node = new MathNode("mstyle", inner);
+
+        const styleAttributes = {
+            "display": ["0", "true"],
+            "text": ["0", "false"],
+            "script": ["1", "false"],
+            "scriptscript": ["2", "false"],
+        };
+
+        const attr = styleAttributes[group.style];
+
+        node.setAttribute("scriptlevel", attr[0]);
+        node.setAttribute("displaystyle", attr[1]);
+
+        return node;
+    },
+});

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

@@ -0,0 +1,268 @@
+import {defineFunctionBuilders} from "../defineFunction";
+import {makeSpan, makeVList} from "../buildCommon";
+import {Span, SymbolNode, type HtmlDomNode} from "../domTree";
+import {isCharacterBox} from "../utils";
+import {MathNode} from "../mathMLTree";
+import {makeEm} from "../units";
+import Style from "../Style";
+
+import * as html from "../buildHTML";
+import * as mml from "../buildMathML";
+import * as accent from "./accent";
+import * as horizBrace from "./horizBrace";
+import * as op from "./op";
+import * as operatorname from "./operatorname";
+
+import type Options from "../Options";
+import type {ParseNode} from "../parseNode";
+import type {HtmlBuilder} from "../defineFunction";
+import type {MathNodeType} from "../mathMLTree";
+
+/**
+ * Sometimes, groups perform special rules when they have superscripts or
+ * subscripts attached to them. This function lets the `supsub` group know that
+ * Sometimes, groups perform special rules when they have superscripts or
+ * its inner element should handle the superscripts and subscripts instead of
+ * handling them itself.
+ */
+const htmlBuilderDelegate = function(
+    group: ParseNode<"supsub">,
+    options: Options,
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+): HtmlBuilder<any> | null | undefined {
+    const base = group.base;
+    if (!base) {
+        return null;
+    } else if (base.type === "op") {
+        // Operators handle supsubs differently when they have limits
+        // (e.g. `\displaystyle\sum_2^3`)
+        const delegate = base.limits &&
+            (options.style.size === Style.DISPLAY.size ||
+            base.alwaysHandleSupSub);
+        return delegate ? op.htmlBuilder : null;
+    } else if (base.type === "operatorname") {
+        const delegate = base.alwaysHandleSupSub &&
+            (options.style.size === Style.DISPLAY.size || base.limits);
+        return delegate ? operatorname.htmlBuilder : null;
+    } else if (base.type === "accent") {
+        return isCharacterBox(base.base) ? accent.htmlBuilder : null;
+    } else if (base.type === "horizBrace") {
+        const isSup = !group.sub;
+        return isSup === base.isOver ? horizBrace.htmlBuilder : null;
+    } else {
+        return null;
+    }
+};
+
+// Super scripts and subscripts, whose precise placement can depend on other
+// functions that precede them.
+defineFunctionBuilders({
+    type: "supsub",
+    htmlBuilder(group, options) {
+        // Superscript and subscripts are handled in the TeXbook on page
+        // 445-446, rules 18(a-f).
+
+        // Here is where we defer to the inner group if it should handle
+        // superscripts and subscripts itself.
+        const builderDelegate = htmlBuilderDelegate(group, options);
+        if (builderDelegate) {
+            return builderDelegate(group, options);
+        }
+
+        const {base: valueBase, sup: valueSup, sub: valueSub} = group;
+        const base = html.buildGroup(valueBase, options);
+        let supm;
+        let subm;
+
+        const metrics = options.fontMetrics();
+
+        // Rule 18a
+        let supShift = 0;
+        let subShift = 0;
+
+        const isCharBox = valueBase && isCharacterBox(valueBase);
+        if (valueSup) {
+            const newOptions = options.havingStyle(options.style.sup());
+            supm = html.buildGroup(valueSup, newOptions, options);
+            if (!isCharBox) {
+                supShift = base.height - newOptions.fontMetrics().supDrop
+                    * newOptions.sizeMultiplier / options.sizeMultiplier;
+            }
+        }
+
+        if (valueSub) {
+            const newOptions = options.havingStyle(options.style.sub());
+            subm = html.buildGroup(valueSub, newOptions, options);
+            if (!isCharBox) {
+                subShift = base.depth + newOptions.fontMetrics().subDrop
+                    * newOptions.sizeMultiplier / options.sizeMultiplier;
+            }
+        }
+
+        // Rule 18c
+        let minSupShift;
+        if (options.style === Style.DISPLAY) {
+            minSupShift = metrics.sup1;
+        } else if (options.style.cramped) {
+            minSupShift = metrics.sup3;
+        } else {
+            minSupShift = metrics.sup2;
+        }
+
+        // scriptspace is a font-size-independent size, so scale it
+        // appropriately for use as the marginRight.
+        const multiplier = options.sizeMultiplier;
+        const marginRight = makeEm((0.5 / metrics.ptPerEm) / multiplier);
+
+        let marginLeft = null;
+        if (subm) {
+            // Subscripts shouldn't be shifted by the base's italic correction.
+            // Account for that by shifting the subscript back the appropriate
+            // amount. Note we only do this when the base is a single symbol.
+            const isOiint =
+                group.base && group.base.type === "op" && group.base.name &&
+                (group.base.name === "\\oiint" || group.base.name === "\\oiiint");
+            if (base instanceof SymbolNode || isOiint) {
+                // SymbolNode has .italic natively; for \oiint/\oiiint the
+                // op builder stores .italic on the wrapping Span.
+                marginLeft = makeEm(
+                    -((base as SymbolNode | Span<HtmlDomNode>).italic ?? 0));
+            }
+        }
+
+        let supsub;
+        if (supm && subm) {
+            supShift = Math.max(
+                supShift, minSupShift, supm.depth + 0.25 * metrics.xHeight);
+            subShift = Math.max(subShift, metrics.sub2);
+
+            const ruleWidth = metrics.defaultRuleThickness;
+
+            // Rule 18e
+            const maxWidth = 4 * ruleWidth;
+            if ((supShift - supm.depth) - (subm.height - subShift) < maxWidth) {
+                subShift = maxWidth - (supShift - supm.depth) + subm.height;
+                const psi = 0.8 * metrics.xHeight - (supShift - supm.depth);
+                if (psi > 0) {
+                    supShift += psi;
+                    subShift -= psi;
+                }
+            }
+
+            const vlistElem = [
+                {type: "elem" as const, elem: subm, shift: subShift, marginRight,
+                    marginLeft},
+                {type: "elem" as const, elem: supm, shift: -supShift, marginRight},
+            ];
+
+            supsub = makeVList({
+                positionType: "individualShift",
+                children: vlistElem,
+            }, options);
+        } else if (subm) {
+            // Rule 18b
+            subShift = Math.max(
+                subShift, metrics.sub1,
+                subm.height - 0.8 * metrics.xHeight);
+
+            const vlistElem =
+                [{type: "elem" as const, elem: subm, marginLeft, marginRight}];
+
+            supsub = makeVList({
+                positionType: "shift",
+                positionData: subShift,
+                children: vlistElem,
+            }, options);
+        } else if (supm) {
+            // Rule 18c, d
+            supShift = Math.max(supShift, minSupShift,
+                supm.depth + 0.25 * metrics.xHeight);
+
+            supsub = makeVList({
+                positionType: "shift",
+                positionData: -supShift,
+                children: [{type: "elem" as const, elem: supm, marginRight}],
+            }, options);
+        } else {
+            throw new Error("supsub must have either sup or sub.");
+        }
+
+        // Wrap the supsub vlist in a span.msupsub to reset text-align.
+        const mclass = html.getTypeOfDomTree(base, "right") || "mord";
+        return makeSpan([mclass],
+            [base, makeSpan(["msupsub"], [supsub])],
+            options);
+    },
+    mathmlBuilder(group, options) {
+        // Is the inner group a relevant horizontal brace?
+        let isBrace = false;
+        let isOver;
+        let isSup;
+
+        if (group.base && group.base.type === "horizBrace") {
+            isSup = !!group.sup;
+            if (isSup === group.base.isOver) {
+                isBrace = true;
+                isOver = group.base.isOver;
+            }
+        }
+
+        if (group.base &&
+            (group.base.type === "op" || group.base.type === "operatorname")) {
+            group.base.parentIsSupSub = true;
+        }
+
+        const children = [mml.buildGroup(group.base, options)];
+
+        if (group.sub) {
+            children.push(mml.buildGroup(group.sub, options));
+        }
+
+        if (group.sup) {
+            children.push(mml.buildGroup(group.sup, options));
+        }
+
+        let nodeType: MathNodeType;
+        if (isBrace) {
+            nodeType = (isOver ? "mover" : "munder");
+        } else if (!group.sub) {
+            const base = group.base;
+            if (base && base.type === "op" && base.limits &&
+                (options.style === Style.DISPLAY || base.alwaysHandleSupSub)) {
+                nodeType = "mover";
+            } else if (base && base.type === "operatorname" &&
+                base.alwaysHandleSupSub &&
+                (base.limits || options.style === Style.DISPLAY)) {
+                nodeType = "mover";
+            } else {
+                nodeType = "msup";
+            }
+        } else if (!group.sup) {
+            const base = group.base;
+            if (base && base.type === "op" && base.limits &&
+                (options.style === Style.DISPLAY || base.alwaysHandleSupSub)) {
+                nodeType = "munder";
+            } else if (base && base.type === "operatorname" &&
+                base.alwaysHandleSupSub &&
+                (base.limits || options.style === Style.DISPLAY)) {
+                nodeType = "munder";
+            } else {
+                nodeType = "msub";
+            }
+        } else {
+            const base = group.base;
+            if (base && base.type === "op" && base.limits &&
+                options.style === Style.DISPLAY) {
+                nodeType = "munderover";
+            } else if (base && base.type === "operatorname" &&
+                base.alwaysHandleSupSub &&
+                (options.style === Style.DISPLAY || base.limits)) {
+                nodeType = "munderover";
+            } else {
+                nodeType = "msubsup";
+            }
+        }
+
+        return new MathNode(nodeType, children);
+    },
+});

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

@@ -0,0 +1,32 @@
+import {defineFunctionBuilders} from "../defineFunction";
+import {mathsym} from "../buildCommon";
+import {MathNode} from "../mathMLTree";
+
+import * as mml from "../buildMathML";
+
+// Operator ParseNodes created in Parser.js from symbol Groups in src/symbols.js.
+
+defineFunctionBuilders({
+    type: "atom",
+    htmlBuilder(group, options) {
+        return mathsym(
+            group.text, group.mode, options, ["m" + group.family]);
+    },
+    mathmlBuilder(group, options) {
+        const node = new MathNode(
+            "mo", [mml.makeText(group.text, group.mode)]);
+        if (group.family === "bin") {
+            const variant = mml.getVariant(group, options);
+            if (variant === "bold-italic") {
+                node.setAttribute("mathvariant", variant);
+            }
+        } else if (group.family === "punct") {
+            node.setAttribute("separator", "true");
+        } else if (group.family === "open" || group.family === "close") {
+            // Delims built here should not stretch vertically.
+            // See delimsizing.js for stretchy delims.
+            node.setAttribute("stretchy", "false");
+        }
+        return node;
+    },
+});

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

@@ -0,0 +1,61 @@
+import {defineFunctionBuilders} from "../defineFunction";
+import {makeOrd} from "../buildCommon";
+import {MathNode} from "../mathMLTree";
+
+import * as mml from "../buildMathML";
+
+import type {ParseNode} from "../parseNode";
+
+// "mathord" and "textord" ParseNodes created in Parser.js from symbol Groups in
+// src/symbols.js.
+
+const defaultVariant: Record<string, string> = {
+    "mi": "italic",
+    "mn": "normal",
+    "mtext": "normal",
+};
+
+defineFunctionBuilders({
+    type: "mathord",
+    htmlBuilder(group, options) {
+        return makeOrd(group, options, "mathord");
+    },
+    mathmlBuilder(group: ParseNode<"mathord">, options) {
+        const node = new MathNode(
+            "mi",
+            [mml.makeText(group.text, group.mode, options)]);
+
+        const variant = mml.getVariant(group, options) || "italic";
+        if (variant !== defaultVariant[node.type]) {
+            node.setAttribute("mathvariant", variant);
+        }
+        return node;
+    },
+});
+
+defineFunctionBuilders({
+    type: "textord",
+    htmlBuilder(group, options) {
+        return makeOrd(group, options, "textord");
+    },
+    mathmlBuilder(group: ParseNode<"textord">, options) {
+        const text = mml.makeText(group.text, group.mode, options);
+        const variant = mml.getVariant(group, options) || "normal";
+
+        let node;
+        if (group.mode === 'text') {
+            node = new MathNode("mtext", [text]);
+        } else if (/[0-9]/.test(group.text)) {
+            node = new MathNode("mn", [text]);
+        } else if (group.text === "\\prime") {
+            node = new MathNode("mo", [text]);
+        } else {
+            node = new MathNode("mi", [text]);
+        }
+        if (variant !== defaultVariant[node.type]) {
+            node.setAttribute("mathvariant", variant);
+        }
+
+        return node;
+    },
+});

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

@@ -0,0 +1,72 @@
+import {defineFunctionBuilders} from "../defineFunction";
+import {mathsym, makeOrd, makeSpan} from "../buildCommon";
+import {MathNode, TextNode} from "../mathMLTree";
+import ParseError from "../ParseError";
+
+// A map of CSS-based spacing functions to their CSS class.
+const cssSpace: Record<string, string> = {
+    "\\nobreak": "nobreak",
+    "\\allowbreak": "allowbreak",
+};
+
+// A lookup table to determine whether a spacing function/symbol should be
+// treated like a regular space character.  If a symbol or command is a key
+// in this table, then it should be a regular space character.  Furthermore,
+// the associated value may have a `className` specifying an extra CSS class
+// to add to the created `span`.
+const regularSpace: Record<string, {className?: string}> = {
+    " ": {},
+    "\\ ": {},
+    "~": {
+        className: "nobreak",
+    },
+    "\\space": {},
+    "\\nobreakspace": {
+        className: "nobreak",
+    },
+};
+
+// ParseNode<"spacing"> created in Parser.js from the "spacing" symbol Groups in
+// src/symbols.js.
+defineFunctionBuilders({
+    type: "spacing",
+    htmlBuilder(group, options) {
+        if (regularSpace.hasOwnProperty(group.text)) {
+            const className = regularSpace[group.text].className || "";
+            // Spaces are generated by adding an actual space. Each of these
+            // things has an entry in the symbols table, so these will be turned
+            // into appropriate outputs.
+            if (group.mode === "text") {
+                const ord = makeOrd(group, options, "textord");
+                ord.classes.push(className);
+                return ord;
+            } else {
+                return makeSpan(["mspace", className],
+                    [mathsym(group.text, group.mode, options)],
+                    options);
+            }
+        } else if (cssSpace.hasOwnProperty(group.text)) {
+            // Spaces based on just a CSS class.
+            return makeSpan(
+                ["mspace", cssSpace[group.text]],
+                [], options);
+        } else {
+            throw new ParseError(`Unknown type of space "${group.text}"`);
+        }
+    },
+    mathmlBuilder(group, options) {
+        let node;
+
+        if (regularSpace.hasOwnProperty(group.text)) {
+            node = new MathNode(
+                "mtext", [new TextNode("\u00a0")]);
+        } else if (cssSpace.hasOwnProperty(group.text)) {
+            // CSS-based MathML spaces (\nobreak, \allowbreak) are ignored
+            return new MathNode("mspace");
+        } else {
+            throw new ParseError(`Unknown type of space "${group.text}"`);
+        }
+
+        return node;
+    },
+});

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

@@ -0,0 +1,38 @@
+import {defineFunctionBuilders} from "../defineFunction";
+import {MathNode} from "../mathMLTree";
+
+import * as mml from "../buildMathML";
+
+const pad = () => {
+    const padNode = new MathNode("mtd", []);
+    padNode.setAttribute("width", "50%");
+    return padNode;
+};
+
+defineFunctionBuilders({
+    type: "tag",
+    mathmlBuilder(group, options) {
+        const table = new MathNode("mtable", [
+            new MathNode("mtr", [
+                pad(),
+                new MathNode("mtd", [
+                    mml.buildExpressionRow(group.body, options),
+                ]),
+                pad(),
+                new MathNode("mtd", [
+                    mml.buildExpressionRow(group.tag, options),
+                ]),
+            ]),
+        ]);
+        table.setAttribute("width", "100%");
+        return table;
+
+        // TODO: Left-aligned tags.
+        // Currently, the group and options passed here do not contain
+        // enough info to set tag alignment. `leqno` is in Settings but it is
+        // not passed to Options. On the HTML side, leqno is
+        // set by a CSS class applied in buildTree.js. That would have worked
+        // in MathML if browsers supported <mlabeledtr>. Since they don't, we
+        // need to rewrite the way this function is called.
+    },
+});

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

@@ -0,0 +1,81 @@
+import defineFunction, {ordargument} from "../defineFunction";
+import type {TextFont} from "../types/fonts";
+import {makeSpan} from "../buildCommon";
+
+import * as html from "../buildHTML";
+import * as mml from "../buildMathML";
+import type Options from "../Options";
+import type {ParseNode} from "../parseNode";
+
+// Non-mathy text, possibly in a font
+const textFontFamilies: Record<string, TextFont | undefined> = {
+    "\\text": undefined,
+    "\\textrm": "textrm",
+    "\\textsf": "textsf",
+    "\\texttt": "texttt",
+    "\\textnormal": "textrm",
+};
+
+const textFontWeights: Record<string, "textbf" | "textmd"> = {
+    "\\textbf": "textbf",
+    "\\textmd": "textmd",
+};
+
+const textFontShapes: Record<string, "textit" | "textup"> = {
+    "\\textit": "textit",
+    "\\textup": "textup",
+};
+
+const optionsWithFont = (group: ParseNode<"text">, options: Options): Options => {
+    const font = group.font;
+    // Checks if the argument is a font family or a font style.
+    if (!font) {
+        return options;
+    } else if (textFontFamilies[font]) {
+        return options.withTextFontFamily(textFontFamilies[font]);
+    } else if (textFontWeights[font]) {
+        return options.withTextFontWeight(textFontWeights[font]);
+    } else if (font === "\\emph") {
+        return options.fontShape === "textit" ?
+            options.withTextFontShape("textup") :
+            options.withTextFontShape("textit");
+    }
+
+    return options.withTextFontShape(textFontShapes[font] as "textit" | "textup");
+};
+
+defineFunction({
+    type: "text",
+    names: [
+        // Font families
+        "\\text", "\\textrm", "\\textsf", "\\texttt", "\\textnormal",
+        // Font weights
+        "\\textbf", "\\textmd",
+        // Font Shapes
+        "\\textit", "\\textup", "\\emph",
+    ],
+    props: {
+        numArgs: 1,
+        argTypes: ["text"],
+        allowedInArgument: true,
+        allowedInText: true,
+    },
+    handler({parser, funcName}, args) {
+        const body = args[0];
+        return {
+            type: "text",
+            mode: parser.mode,
+            body: ordargument(body),
+            font: funcName,
+        };
+    },
+    htmlBuilder(group, options) {
+        const newOptions = optionsWithFont(group, options);
+        const inner = html.buildExpression(group.body, newOptions, true);
+        return makeSpan(["mord", "text"], inner, newOptions);
+    },
+    mathmlBuilder(group, options) {
+        const newOptions = optionsWithFont(group, options);
+        return mml.buildExpressionRow(group.body, newOptions);
+    },
+});