@rse/ase 0.0.42 → 0.0.43

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

@@ -1,470 +0,0 @@
-import defineFunction, {normalizeArgument} from "../defineFunction";
-import {makeLineSpan, makeSpan, makeVList} from "../buildCommon";
-import {makeCustomSizedDelim} from "../delimiter";
-import {MathNode, TextNode} from "../mathMLTree";
-import type {ParseNode} from "../parseNode";
-import Style from "../Style";
-import {assertNodeType} from "../parseNode";
-import * as html from "../buildHTML";
-import * as mml from "../buildMathML";
-import {calculateSize, makeEm} from "../units";
-import type {StyleStr} from "../types";
-import type {HtmlBuilder, MathMLBuilder} from "../defineFunction";
-
-const htmlBuilder: HtmlBuilder<"genfrac"> = (group, options) => {
-    // Fractions are handled in the TeXbook on pages 444-445, rules 15(a-e).
-    const style = options.style;
-
-    const nstyle = style.fracNum();
-    const dstyle = style.fracDen();
-    let newOptions;
-
-    newOptions = options.havingStyle(nstyle);
-    const numerm = html.buildGroup(group.numer, newOptions, options);
-
-    if (group.continued) {
-        // \cfrac inserts a \strut into the numerator.
-        // Get \strut dimensions from TeXbook page 353.
-        const hStrut = 8.5 / options.fontMetrics().ptPerEm;
-        const dStrut = 3.5 / options.fontMetrics().ptPerEm;
-        numerm.height = numerm.height < hStrut ? hStrut : numerm.height;
-        numerm.depth = numerm.depth < dStrut ? dStrut : numerm.depth;
-    }
-
-    newOptions = options.havingStyle(dstyle);
-    const denomm = html.buildGroup(group.denom, newOptions, options);
-
-    let rule;
-    let ruleWidth;
-    let ruleSpacing;
-    if (group.hasBarLine) {
-        if (group.barSize) {
-            ruleWidth = calculateSize(group.barSize, options);
-            rule = makeLineSpan("frac-line", options, ruleWidth);
-        } else {
-            rule = makeLineSpan("frac-line", options);
-        }
-        ruleWidth = rule.height;
-        ruleSpacing = rule.height;
-    } else {
-        rule = null;
-        ruleWidth = 0;
-        ruleSpacing = options.fontMetrics().defaultRuleThickness;
-    }
-
-    // Rule 15b
-    let numShift;
-    let clearance;
-    let denomShift;
-    if (style.size === Style.DISPLAY.size) {
-        numShift = options.fontMetrics().num1;
-        if (ruleWidth > 0) {
-            clearance = 3 * ruleSpacing;
-        } else {
-            clearance = 7 * ruleSpacing;
-        }
-        denomShift = options.fontMetrics().denom1;
-    } else {
-        if (ruleWidth > 0) {
-            numShift = options.fontMetrics().num2;
-            clearance = ruleSpacing;
-        } else {
-            numShift = options.fontMetrics().num3;
-            clearance = 3 * ruleSpacing;
-        }
-        denomShift = options.fontMetrics().denom2;
-    }
-
-    let frac;
-    if (!rule) {
-        // Rule 15c
-        const candidateClearance =
-            (numShift - numerm.depth) - (denomm.height - denomShift);
-        if (candidateClearance < clearance) {
-            numShift += 0.5 * (clearance - candidateClearance);
-            denomShift += 0.5 * (clearance - candidateClearance);
-        }
-
-        frac = makeVList({
-            positionType: "individualShift",
-            children: [
-                {type: "elem", elem: denomm, shift: denomShift},
-                {type: "elem", elem: numerm, shift: -numShift},
-            ],
-        }, options);
-    } else {
-        // Rule 15d
-        const axisHeight = options.fontMetrics().axisHeight;
-
-        if ((numShift - numerm.depth) - (axisHeight + 0.5 * ruleWidth) <
-                clearance) {
-            numShift +=
-                clearance - ((numShift - numerm.depth) -
-                            (axisHeight + 0.5 * ruleWidth));
-        }
-
-        if ((axisHeight - 0.5 * ruleWidth) - (denomm.height - denomShift) <
-                clearance) {
-            denomShift +=
-                clearance - ((axisHeight - 0.5 * ruleWidth) -
-                            (denomm.height - denomShift));
-        }
-
-        const midShift = -(axisHeight - 0.5 * ruleWidth);
-
-        frac = makeVList({
-            positionType: "individualShift",
-            children: [
-                {type: "elem", elem: denomm, shift: denomShift},
-                {type: "elem", elem: rule,   shift: midShift},
-                {type: "elem", elem: numerm, shift: -numShift},
-            ],
-        }, options);
-    }
-
-    // Since we manually change the style sometimes (with \dfrac or \tfrac),
-    // account for the possible size change here.
-    newOptions = options.havingStyle(style);
-    frac.height *= newOptions.sizeMultiplier / options.sizeMultiplier;
-    frac.depth *= newOptions.sizeMultiplier / options.sizeMultiplier;
-
-    // Rule 15e
-    let delimSize;
-    if (style.size === Style.DISPLAY.size) {
-        delimSize = options.fontMetrics().delim1;
-    } else if (style.size === Style.SCRIPTSCRIPT.size) {
-        delimSize = options.havingStyle(Style.SCRIPT).fontMetrics().delim2;
-    } else {
-        delimSize = options.fontMetrics().delim2;
-    }
-
-    let leftDelim;
-    let rightDelim;
-    if (group.leftDelim == null) {
-        leftDelim = html.makeNullDelimiter(options, ["mopen"]);
-    } else {
-        leftDelim = makeCustomSizedDelim(
-            group.leftDelim, delimSize, true,
-            options.havingStyle(style), group.mode, ["mopen"]);
-    }
-
-    if (group.continued) {
-        rightDelim = makeSpan([]); // zero width for \cfrac
-    } else if (group.rightDelim == null) {
-        rightDelim = html.makeNullDelimiter(options, ["mclose"]);
-    } else {
-        rightDelim = makeCustomSizedDelim(
-            group.rightDelim, delimSize, true,
-            options.havingStyle(style), group.mode, ["mclose"]);
-    }
-
-    return makeSpan(
-        ["mord"].concat(newOptions.sizingClasses(options)),
-        [leftDelim, makeSpan(["mfrac"], [frac]), rightDelim],
-        options);
-};
-
-const mathmlBuilder: MathMLBuilder<"genfrac"> = (group, options) => {
-    const node = new MathNode(
-        "mfrac",
-        [
-            mml.buildGroup(group.numer, options),
-            mml.buildGroup(group.denom, options),
-        ]);
-
-    if (!group.hasBarLine) {
-        node.setAttribute("linethickness", "0px");
-    } else if (group.barSize) {
-        const ruleWidth = calculateSize(group.barSize, options);
-        node.setAttribute("linethickness", makeEm(ruleWidth));
-    }
-
-    if (group.leftDelim != null || group.rightDelim != null) {
-        const withDelims = [];
-
-        if (group.leftDelim != null) {
-            const leftOp = new MathNode(
-                "mo",
-                [new TextNode(group.leftDelim.replace("\\", ""))]
-            );
-
-            leftOp.setAttribute("fence", "true");
-
-            withDelims.push(leftOp);
-        }
-
-        withDelims.push(node);
-
-        if (group.rightDelim != null) {
-            const rightOp = new MathNode(
-                "mo",
-                [new TextNode(group.rightDelim.replace("\\", ""))]
-            );
-
-            rightOp.setAttribute("fence", "true");
-
-            withDelims.push(rightOp);
-        }
-
-        return mml.makeRow(withDelims);
-    }
-
-    return node;
-};
-
-const wrapWithStyle = (
-    frac: ParseNode<"genfrac">,
-    style?: StyleStr | null,
-): ParseNode<"genfrac"> => {
-    if (!style) {
-        return frac;
-    }
-
-    const wrapper: ParseNode<"styling"> = {
-        type: "styling",
-        mode: frac.mode,
-        style,
-        body: [frac],
-    };
-
-    // @ts-ignore defineFunction handler needs to return ParseNode<"genfrac">
-    return wrapper;
-};
-
-defineFunction({
-    type: "genfrac",
-    names: [
-        "\\cfrac", "\\dfrac", "\\frac", "\\tfrac",
-        "\\dbinom", "\\binom", "\\tbinom",
-        "\\\\atopfrac", // can’t be entered directly
-        "\\\\bracefrac", "\\\\brackfrac",   // ditto
-    ],
-    props: {
-        numArgs: 2,
-        allowedInArgument: true,
-    },
-    handler: ({parser, funcName}, args) => {
-        const numer = args[0];
-        const denom = args[1];
-        let hasBarLine: boolean;
-        let leftDelim: string | null = null;
-        let rightDelim: string | null = null;
-
-        switch (funcName) {
-            case "\\cfrac":
-            case "\\dfrac":
-            case "\\frac":
-            case "\\tfrac":
-                hasBarLine = true;
-                break;
-            case "\\\\atopfrac":
-                hasBarLine = false;
-                break;
-            case "\\dbinom":
-            case "\\binom":
-            case "\\tbinom":
-                hasBarLine = false;
-                leftDelim = "(";
-                rightDelim = ")";
-                break;
-            case "\\\\bracefrac":
-                hasBarLine = false;
-                leftDelim = "\\{";
-                rightDelim = "\\}";
-                break;
-            case "\\\\brackfrac":
-                hasBarLine = false;
-                leftDelim = "[";
-                rightDelim = "]";
-                break;
-            default:
-                throw new Error("Unrecognized genfrac command");
-        }
-
-        const continued = funcName === "\\cfrac";
-        let style = null;
-        if (continued || funcName.startsWith("\\d")) {
-            style = "display" as StyleStr;
-        } else if (funcName.startsWith("\\t")) {
-            style = "text" as StyleStr;
-        }
-
-        return wrapWithStyle({
-            type: "genfrac",
-            mode: parser.mode,
-            numer,
-            denom,
-            continued,
-            hasBarLine,
-            leftDelim,
-            rightDelim,
-            barSize: null,
-        }, style);
-    },
-
-    htmlBuilder,
-    mathmlBuilder,
-});
-
-// Infix generalized fractions -- these are not rendered directly, but replaced
-// immediately by one of the variants above.
-defineFunction({
-    type: "infix",
-    names: ["\\over", "\\choose", "\\atop", "\\brace", "\\brack"],
-    props: {
-        numArgs: 0,
-        infix: true,
-    },
-    handler({parser, funcName, token}) {
-        let replaceWith;
-        switch (funcName) {
-            case "\\over":
-                replaceWith = "\\frac";
-                break;
-            case "\\choose":
-                replaceWith = "\\binom";
-                break;
-            case "\\atop":
-                replaceWith = "\\\\atopfrac";
-                break;
-            case "\\brace":
-                replaceWith = "\\\\bracefrac";
-                break;
-            case "\\brack":
-                replaceWith = "\\\\brackfrac";
-                break;
-            default:
-                throw new Error("Unrecognized infix genfrac command");
-        }
-        return {
-            type: "infix",
-            mode: parser.mode,
-            replaceWith,
-            token,
-        };
-    },
-});
-
-const stylArray: StyleStr[] = ["display", "text", "script", "scriptscript"];
-
-const delimFromValue = function(delimString: string): string | null {
-    let delim = null;
-    if (delimString.length > 0) {
-        delim = delimString;
-        delim = delim === "." ? null : delim;
-    }
-    return delim;
-};
-
-defineFunction({
-    type: "genfrac",
-    names: ["\\genfrac"],
-    props: {
-        numArgs: 6,
-        allowedInArgument: true,
-        argTypes: ["math", "math", "size", "text", "math", "math"],
-    },
-    handler({parser}, args) {
-        const numer = args[4];
-        const denom = args[5];
-
-        // Look into the parse nodes to get the desired delimiters.
-        const leftNode = normalizeArgument(args[0]);
-        const leftDelim = leftNode.type === "atom" && leftNode.family === "open"
-            ? delimFromValue(leftNode.text) : null;
-        const rightNode = normalizeArgument(args[1]);
-        const rightDelim = rightNode.type === "atom" && rightNode.family === "close"
-            ? delimFromValue(rightNode.text) : null;
-
-        const barNode = assertNodeType(args[2], "size");
-        let hasBarLine: boolean;
-        let barSize = null;
-        if (barNode.isBlank) {
-            // \genfrac acts differently than \above.
-            // \genfrac treats an empty size group as a signal to use a
-            // standard bar size. \above would see size = 0 and omit the bar.
-            hasBarLine = true;
-        } else {
-            barSize = barNode.value;
-            hasBarLine = barSize.number > 0;
-        }
-
-        // Find out if we want displaystyle, textstyle, etc.
-        let size = null;
-        let styl = args[3];
-        if (styl.type === "ordgroup") {
-            if (styl.body.length > 0) {
-                const textOrd = assertNodeType(styl.body[0], "textord");
-                size = stylArray[Number(textOrd.text)] as StyleStr;
-            }
-        } else {
-            styl = assertNodeType(styl, "textord");
-            size = stylArray[Number(styl.text)] as StyleStr;
-        }
-
-        return wrapWithStyle({
-            type: "genfrac",
-            mode: parser.mode,
-            numer,
-            denom,
-            continued: false,
-            hasBarLine,
-            barSize,
-            leftDelim,
-            rightDelim,
-        }, size);
-    },
-});
-
-// \above is an infix fraction that also defines a fraction bar size.
-defineFunction({
-    type: "infix",
-    names: ["\\above"],
-    props: {
-        numArgs: 1,
-        argTypes: ["size"],
-        infix: true,
-    },
-    handler({parser, funcName, token}, args) {
-        return {
-            type: "infix",
-            mode: parser.mode,
-            replaceWith: "\\\\abovefrac",
-            size: assertNodeType(args[0], "size").value,
-            token,
-        };
-    },
-});
-
-defineFunction({
-    type: "genfrac",
-    names: ["\\\\abovefrac"],
-    props: {
-        numArgs: 3,
-        argTypes: ["math", "size", "math"],
-    },
-    handler: ({parser, funcName}, args) => {
-        const numer = args[0];
-        const barSize = assertNodeType(args[1], "infix").size;
-
-        if (!barSize) {
-            throw new Error(
-                `\\\\abovefrac expected size, but got ${String(barSize)}`);
-        }
-
-        const denom = args[2];
-
-        const hasBarLine = barSize.number > 0;
-        return {
-            type: "genfrac",
-            mode: parser.mode,
-            numer,
-            denom,
-            continued: false,
-            hasBarLine,
-            barSize,
-            leftDelim: null,
-            rightDelim: null,
-        };
-    },
-});

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

@@ -1,38 +0,0 @@
-import defineFunction, {ordargument} from "../defineFunction";
-import {makeFragment} from "../buildCommon";
-import {MathNode} from "../mathMLTree";
-
-import * as html from "../buildHTML";
-import * as mml from "../buildMathML";
-
-// \hbox is provided for compatibility with LaTeX \vcenter.
-// In LaTeX, \vcenter can act only on a box, as in
-// \vcenter{\hbox{$\frac{a+b}{\dfrac{c}{d}}$}}
-// This function by itself doesn't do anything but prevent a soft line break.
-
-defineFunction({
-    type: "hbox",
-    names: ["\\hbox"],
-    props: {
-        numArgs: 1,
-        argTypes: ["text"],
-        allowedInText: true,
-        primitive: true,
-    },
-    handler({parser}, args) {
-        return {
-            type: "hbox",
-            mode: parser.mode,
-            body: ordargument(args[0]),
-        };
-    },
-    htmlBuilder(group, options) {
-        const elements = html.buildExpression(group.body, options.withFont(''), false);
-        return makeFragment(elements);
-    },
-    mathmlBuilder(group, options) {
-        return new MathNode(
-          "mrow", mml.buildExpression(group.body, options.withFont(''))
-        );
-    },
-});

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

@@ -1,134 +0,0 @@
-import defineFunction from "../defineFunction";
-import {makeSpan, makeVList} from "../buildCommon";
-import {MathNode} from "../mathMLTree";
-import {stretchyMathML, stretchySvg} from "../stretchy";
-import Style from "../Style";
-import {assertNodeType} from "../parseNode";
-
-import * as html from "../buildHTML";
-import * as mml from "../buildMathML";
-
-import type {HtmlBuilderSupSub, MathMLBuilder} from "../defineFunction";
-import type {ParseNode} from "../parseNode";
-
-// NOTE: Unlike most `htmlBuilder`s, this one handles not only "horizBrace", but
-// also "supsub" since an over/underbrace can affect super/subscripting.
-export const htmlBuilder: HtmlBuilderSupSub<"horizBrace"> = (grp, options) => {
-    const style = options.style;
-
-    // Pull out the `ParseNode<"horizBrace">` if `grp` is a "supsub" node.
-    let supSubGroup;
-    let group: ParseNode<"horizBrace">;
-    if (grp.type === "supsub") {
-        // Ref: LaTeX source2e: }}}}\limits}
-        // i.e. LaTeX treats the brace similar to an op and passes it
-        // with \limits, so we need to assign supsub style.
-        supSubGroup = grp.sup ?
-            html.buildGroup(grp.sup, options.havingStyle(style.sup()), options) :
-            html.buildGroup(grp.sub, options.havingStyle(style.sub()), options);
-        group = assertNodeType(grp.base, "horizBrace");
-    } else {
-        group = assertNodeType(grp, "horizBrace");
-    }
-
-    // Build the base group
-    const body = html.buildGroup(
-        group.base, options.havingBaseStyle(Style.DISPLAY));
-
-    // Create the stretchy element
-    const braceBody = stretchySvg(group, options);
-
-    // Generate the vlist, with the appropriate kerns        ┏━━━━━━━━┓
-    // This first vlist contains the content and the brace:   equation
-    let vlist;
-    if (group.isOver) {
-        vlist = makeVList({
-            positionType: "firstBaseline",
-            children: [
-                {type: "elem", elem: body},
-                {type: "kern", size: 0.1},
-                {type: "elem", elem: braceBody,
-                    wrapperClasses: ["svg-align"]},
-            ],
-        }, options);
-    } else {
-        vlist = makeVList({
-            positionType: "bottom",
-            positionData: body.depth + 0.1 + braceBody.height,
-            children: [
-                {type: "elem", elem: braceBody,
-                    wrapperClasses: ["svg-align"]},
-                {type: "kern", size: 0.1},
-                {type: "elem", elem: body},
-            ],
-        }, options);
-    }
-
-    if (supSubGroup) {
-        // To write the supsub, wrap the first vlist in another vlist:
-        // They can't all go in the same vlist, because the note might be
-        // wider than the equation. We want the equation to control the
-        // brace width.
-
-        //      note          long note           long note
-        //   ┏━━━━━━━━┓   or    ┏━━━┓     not    ┏━━━━━━━━━┓
-        //    equation           eqn                 eqn
-
-        const vSpan = makeSpan(
-            ["minner", (group.isOver ? "mover" : "munder")],
-            [vlist], options);
-
-        if (group.isOver) {
-            vlist = makeVList({
-                positionType: "firstBaseline",
-                children: [
-                    {type: "elem", elem: vSpan},
-                    {type: "kern", size: 0.2},
-                    {type: "elem", elem: supSubGroup},
-                ],
-            }, options);
-        } else {
-            vlist = makeVList({
-                positionType: "bottom",
-                positionData: vSpan.depth + 0.2 + supSubGroup.height +
-                    supSubGroup.depth,
-                children: [
-                    {type: "elem", elem: supSubGroup},
-                    {type: "kern", size: 0.2},
-                    {type: "elem", elem: vSpan},
-                ],
-            }, options);
-        }
-    }
-
-    return makeSpan(
-        ["minner", (group.isOver ? "mover" : "munder")], [vlist], options);
-};
-
-const mathmlBuilder: MathMLBuilder<"horizBrace"> = (group, options) => {
-    const accentNode = stretchyMathML(group.label);
-    return new MathNode(
-        (group.isOver ? "mover" : "munder"),
-        [mml.buildGroup(group.base, options), accentNode]
-    );
-};
-
-// Horizontal stretchy braces
-defineFunction({
-    type: "horizBrace",
-    names: ["\\overbrace", "\\underbrace", "\\overbracket", "\\underbracket"],
-    props: {
-        numArgs: 1,
-    },
-    handler({parser, funcName}, args) {
-        return {
-            type: "horizBrace",
-            mode: parser.mode,
-            label: funcName,
-            isOver: funcName.includes("\\over"),
-            base: args[0],
-        };
-    },
-    htmlBuilder,
-    mathmlBuilder,
-});