@rse/ase 0.0.41 → 0.0.43

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

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

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

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

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

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

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

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