@rse/ase 0.0.41 → 0.0.43

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

@@ -1,93 +0,0 @@
-import defineFunction, {ordargument} from "../defineFunction";
-import {makeAnchor} from "../buildCommon";
-import {assertNodeType} from "../parseNode";
-import {MathNode} from "../mathMLTree";
-
-import * as html from "../buildHTML";
-import * as mml from "../buildMathML";
-import type {ParseNode} from "../parseNode";
-
-defineFunction({
-    type: "href",
-    names: ["\\href"],
-    props: {
-        numArgs: 2,
-        argTypes: ["url", "original"],
-        allowedInText: true,
-    },
-    handler: ({parser}, args) => {
-        const body = args[1];
-        const href = assertNodeType(args[0], "url").url;
-
-        if (!parser.settings.isTrusted({
-            command: "\\href",
-            url: href,
-        })) {
-            return parser.formatUnsupportedCmd("\\href");
-        }
-
-        return {
-            type: "href",
-            mode: parser.mode,
-            href,
-            body: ordargument(body),
-        };
-    },
-    htmlBuilder: (group, options) => {
-        const elements = html.buildExpression(group.body, options, false);
-        return makeAnchor(group.href, [], elements, options);
-    },
-    mathmlBuilder: (group, options) => {
-        let math = mml.buildExpressionRow(group.body, options);
-        if (!(math instanceof MathNode)) {
-            math = new MathNode("mrow", [math]);
-        }
-        (math as MathNode).setAttribute("href", group.href);
-        return math;
-    },
-});
-
-defineFunction({
-    type: "href",
-    names: ["\\url"],
-    props: {
-        numArgs: 1,
-        argTypes: ["url"],
-        allowedInText: true,
-    },
-    handler: ({parser}, args) => {
-        const href = assertNodeType(args[0], "url").url;
-
-        if (!parser.settings.isTrusted({
-            command: "\\url",
-            url: href,
-        })) {
-            return parser.formatUnsupportedCmd("\\url");
-        }
-
-        const chars: ParseNode<"textord">[] = [];
-        for (let i = 0; i < href.length; i++) {
-            let c = href[i];
-            if (c === "~") {
-                c = "\\textasciitilde";
-            }
-            chars.push({
-                type: "textord",
-                mode: "text",
-                text: c,
-            });
-        }
-        const body: ParseNode<"text"> = {
-            type: "text",
-            mode: parser.mode,
-            font: "\\texttt",
-            body: chars,
-        };
-        return {
-            type: "href",
-            mode: parser.mode,
-            href,
-            body: ordargument(body),
-        };
-    },
-});

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

@@ -1,105 +0,0 @@
-import defineFunction, {ordargument} from "../defineFunction";
-import {makeSpan} from "../buildCommon";
-import {assertNodeType} from "../parseNode";
-import ParseError from "../ParseError";
-
-import * as html from "../buildHTML";
-import * as mml from "../buildMathML";
-import type {AnyTrustContext} from "../Settings";
-
-defineFunction({
-    type: "html",
-    names: ["\\htmlClass", "\\htmlId", "\\htmlStyle", "\\htmlData"],
-    props: {
-        numArgs: 2,
-        argTypes: ["raw", "original"],
-        allowedInText: true,
-    },
-    handler: ({parser, funcName, token}, args) => {
-        const value = assertNodeType(args[0], "raw").string;
-        const body = args[1];
-
-        if (parser.settings.strict) {
-            parser.settings.reportNonstrict("htmlExtension",
-                "HTML extension is disabled on strict mode");
-        }
-
-        let trustContext: AnyTrustContext;
-        const attributes: Record<string, string> = {};
-
-        switch (funcName) {
-            case "\\htmlClass":
-                attributes.class = value;
-                trustContext = {
-                    command: "\\htmlClass",
-                    class: value,
-                };
-                break;
-            case "\\htmlId":
-                attributes.id = value;
-                trustContext = {
-                    command: "\\htmlId",
-                    id: value,
-                };
-                break;
-            case "\\htmlStyle":
-                attributes.style = value;
-                trustContext = {
-                    command: "\\htmlStyle",
-                    style: value,
-                };
-                break;
-            case "\\htmlData": {
-                const data = value.split(",");
-                for (let i = 0; i < data.length; i++) {
-                    const item = data[i];
-                    const firstEquals = item.indexOf("=");
-                    if (firstEquals < 0) {
-                        throw new ParseError(`\\htmlData key/value '${item}'` +
-                            ` missing equals sign`);
-                    }
-                    const key = item.slice(0, firstEquals);
-                    const value = item.slice(firstEquals + 1);
-                    attributes["data-" + key.trim()] = value;
-                }
-
-                trustContext = {
-                    command: "\\htmlData",
-                    attributes,
-                };
-                break;
-            }
-            default:
-                throw new Error("Unrecognized html command");
-        }
-
-        if (!parser.settings.isTrusted(trustContext)) {
-            return parser.formatUnsupportedCmd(funcName);
-        }
-        return {
-            type: "html",
-            mode: parser.mode,
-            attributes,
-            body: ordargument(body),
-        };
-    },
-    htmlBuilder: (group, options) => {
-        const elements = html.buildExpression(group.body, options, false);
-
-        const classes = ["enclosing"];
-        if (group.attributes.class) {
-            classes.push(...group.attributes.class.trim().split(/\s+/));
-        }
-
-        const span = makeSpan(classes, elements, options);
-        for (const attr in group.attributes) {
-            if (attr !== "class" && group.attributes.hasOwnProperty(attr)) {
-                span.setAttribute(attr, group.attributes[attr]);
-            }
-        }
-        return span;
-    },
-    mathmlBuilder: (group, options) => {
-        return mml.buildExpressionRow(group.body, options);
-    },
-});

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

@@ -1,34 +0,0 @@
-import defineFunction, {ordargument} from "../defineFunction";
-import {makeFragment} from "../buildCommon";
-
-import * as html from "../buildHTML";
-import * as mml from "../buildMathML";
-
-defineFunction({
-    type: "htmlmathml",
-    names: ["\\html@mathml"],
-    props: {
-        numArgs: 2,
-        allowedInArgument: true,
-        allowedInText: true,
-    },
-    handler: ({parser}, args) => {
-        return {
-            type: "htmlmathml",
-            mode: parser.mode,
-            html:   ordargument(args[0]),
-            mathml: ordargument(args[1]),
-        };
-    },
-    htmlBuilder: (group, options) => {
-        const elements = html.buildExpression(
-            group.html,
-            options,
-            false
-        );
-        return makeFragment(elements);
-    },
-    mathmlBuilder: (group, options) => {
-        return mml.buildExpressionRow(group.mathml, options);
-    },
-});

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

@@ -1,150 +0,0 @@
-import defineFunction from "../defineFunction";
-import type {Measurement} from "../units";
-import {calculateSize, validUnit, makeEm} from "../units";
-import ParseError from "../ParseError";
-import {Img} from "../domTree";
-import {MathNode} from "../mathMLTree";
-import {assertNodeType} from "../parseNode";
-import type {CssStyle} from "../domTree";
-
-const sizeData = function(str: string): Measurement {
-    if (/^[-+]? *(\d+(\.\d*)?|\.\d+)$/.test(str)) {
-        // str is a number with no unit specified.
-        // default unit is bp, per graphix package.
-        return {number: +str, unit: "bp"};
-    } else {
-        const match = (/([-+]?) *(\d+(?:\.\d*)?|\.\d+) *([a-z]{2})/).exec(str);
-        if (!match) {
-            throw new ParseError("Invalid size: '" + str
-                + "' in \\includegraphics");
-        }
-        const data = {
-            number: +(match[1] + match[2]), // sign + magnitude, cast to number
-            unit: match[3],
-        };
-        if (!validUnit(data)) {
-            throw new ParseError("Invalid unit: '" + data.unit
-             + "' in \\includegraphics.");
-        }
-        return data;
-    }
-};
-
-defineFunction({
-    type: "includegraphics",
-    names: ["\\includegraphics"],
-    props: {
-        numArgs: 1,
-        numOptionalArgs: 1,
-        argTypes: ["raw", "url"],
-        allowedInText: false,
-    },
-    handler: ({parser}, args, optArgs) => {
-        let width = {number: 0, unit: "em"};
-        let height = {number: 0.9, unit: "em"};    // sorta character sized.
-        let totalheight = {number: 0, unit: "em"};
-        let alt = "";
-
-        if (optArgs[0]) {
-            const attributeStr = assertNodeType(optArgs[0], "raw").string;
-
-            // Parser.js does not parse key/value pairs. We get a string.
-            const attributes = attributeStr.split(",");
-            for (let i = 0; i < attributes.length; i++) {
-                const keyVal = attributes[i].split("=");
-                if (keyVal.length === 2) {
-                    const str = keyVal[1].trim();
-                    switch (keyVal[0].trim()) {
-                        case "alt":
-                            alt = str;
-                            break;
-                        case "width":
-                            width = sizeData(str);
-                            break;
-                        case "height":
-                            height = sizeData(str);
-                            break;
-                        case "totalheight":
-                            totalheight = sizeData(str);
-                            break;
-                        default:
-                            throw new ParseError("Invalid key: '" + keyVal[0] +
-                                "' in \\includegraphics.");
-                    }
-                }
-            }
-        }
-
-        const src = assertNodeType(args[0], "url").url;
-
-        if (alt === "") {
-            // No alt given. Use the file name. Strip away the path.
-            alt = src;
-            alt = alt.replace(/^.*[\\/]/, '');
-            alt = alt.substring(0, alt.lastIndexOf('.'));
-        }
-
-        if (!parser.settings.isTrusted({
-            command: "\\includegraphics",
-            url: src,
-        })) {
-            return parser.formatUnsupportedCmd("\\includegraphics");
-        }
-
-        return {
-            type: "includegraphics",
-            mode: parser.mode,
-            alt: alt,
-            width: width,
-            height: height,
-            totalheight: totalheight,
-            src: src,
-        };
-    },
-    htmlBuilder: (group, options) => {
-        const height = calculateSize(group.height, options);
-        let depth = 0;
-
-        if (group.totalheight.number > 0) {
-            depth = calculateSize(group.totalheight, options) - height;
-        }
-
-        let width = 0;
-        if (group.width.number > 0) {
-            width = calculateSize(group.width, options);
-        }
-
-        const style: CssStyle = {height: makeEm(height + depth)};
-        if (width > 0) {
-            style.width = makeEm(width);
-        }
-        if (depth > 0) {
-            style.verticalAlign = makeEm(-depth);
-        }
-
-        const node = new Img(group.src, group.alt, style);
-        node.height = height;
-        node.depth = depth;
-
-        return node;
-    },
-    mathmlBuilder: (group, options) => {
-        const node = new MathNode("mglyph", []);
-        node.setAttribute("alt", group.alt);
-
-        const height = calculateSize(group.height, options);
-        let depth = 0;
-        if (group.totalheight.number > 0) {
-            depth = calculateSize(group.totalheight, options) - height;
-            node.setAttribute("valign", makeEm(-depth));
-        }
-        node.setAttribute("height", makeEm(height + depth));
-
-        if (group.width.number > 0) {
-            const width = calculateSize(group.width, options);
-            node.setAttribute("width", makeEm(width));
-        }
-        node.setAttribute("src", group.src);
-        return node;
-    },
-});

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

@@ -1,55 +0,0 @@
-// Horizontal spacing commands
-
-import defineFunction from "../defineFunction";
-import {makeGlue} from "../buildCommon";
-import {SpaceNode} from "../mathMLTree";
-import {calculateSize} from "../units";
-import {assertNodeType} from "../parseNode";
-
-// TODO: \hskip and \mskip should support plus and minus in lengths
-
-defineFunction({
-    type: "kern",
-    names: ["\\kern", "\\mkern", "\\hskip", "\\mskip"],
-    props: {
-        numArgs: 1,
-        argTypes: ["size"],
-        primitive: true,
-        allowedInText: true,
-    },
-    handler({parser, funcName}, args) {
-        const size = assertNodeType(args[0], "size");
-        if (parser.settings.strict) {
-            const mathFunction = (funcName[1] === 'm');  // \mkern, \mskip
-            const muUnit = (size.value.unit === 'mu');
-            if (mathFunction) {
-                if (!muUnit) {
-                    parser.settings.reportNonstrict("mathVsTextUnits",
-                        `LaTeX's ${funcName} supports only mu units, ` +
-                        `not ${size.value.unit} units`);
-                }
-                if (parser.mode !== "math") {
-                    parser.settings.reportNonstrict("mathVsTextUnits",
-                        `LaTeX's ${funcName} works only in math mode`);
-                }
-            } else {  // !mathFunction
-                if (muUnit) {
-                    parser.settings.reportNonstrict("mathVsTextUnits",
-                        `LaTeX's ${funcName} doesn't support mu units`);
-                }
-            }
-        }
-        return {
-            type: "kern",
-            mode: parser.mode,
-            dimension: size.value,
-        };
-    },
-    htmlBuilder(group, options) {
-        return makeGlue(group.dimension, options);
-    },
-    mathmlBuilder(group, options) {
-        const dimension = calculateSize(group.dimension, options);
-        return new SpaceNode(dimension);
-    },
-});

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

@@ -1,73 +0,0 @@
-// Horizontal overlap functions
-import defineFunction from "../defineFunction";
-import {makeSpan} from "../buildCommon";
-import {MathNode} from "../mathMLTree";
-import {makeEm} from "../units";
-
-import * as html from "../buildHTML";
-import * as mml from "../buildMathML";
-
-defineFunction({
-    type: "lap",
-    names: ["\\mathllap", "\\mathrlap", "\\mathclap"],
-    props: {
-        numArgs: 1,
-        allowedInText: true,
-    },
-    handler: ({parser, funcName}, args) => {
-        const body = args[0];
-        return {
-            type: "lap",
-            mode: parser.mode,
-            alignment: funcName.slice(5),
-            body,
-        };
-    },
-    htmlBuilder: (group, options) => {
-        // mathllap, mathrlap, mathclap
-        let inner;
-        if (group.alignment === "clap") {
-            // ref: https://www.math.lsu.edu/~aperlis/publications/mathclap/
-            inner = makeSpan(
-                [], [html.buildGroup(group.body, options)]);
-            // wrap, since CSS will center a .clap > .inner > span
-            inner = makeSpan(["inner"], [inner], options);
-        } else {
-            inner = makeSpan(
-                ["inner"], [html.buildGroup(group.body, options)]);
-        }
-        const fix = makeSpan(["fix"], []);
-        let node = makeSpan(
-            [group.alignment], [inner, fix], options);
-
-        // At this point, we have correctly set horizontal alignment of the
-        // two items involved in the lap.
-        // Next, use a strut to set the height of the HTML bounding box.
-        // Otherwise, a tall argument may be misplaced.
-        // This code resolved issue #1153
-        const strut = makeSpan(["strut"]);
-        strut.style.height = makeEm(node.height + node.depth);
-        if (node.depth) {
-            strut.style.verticalAlign = makeEm(-node.depth);
-        }
-        node.children.unshift(strut);
-
-        // Next, prevent vertical misplacement when next to something tall.
-        // This code resolves issue #1234
-        node = makeSpan(["thinbox"], [node], options);
-        return makeSpan(["mord", "vbox"], [node], options);
-    },
-    mathmlBuilder: (group, options) => {
-        // mathllap, mathrlap, mathclap
-        const node = new MathNode(
-            "mpadded", [mml.buildGroup(group.body, options)]);
-
-        if (group.alignment !== "rlap")    {
-            const offset = (group.alignment === "llap" ? "-1" : "-0.5");
-            node.setAttribute("lspace", offset + "width");
-        }
-        node.setAttribute("width", "0px");
-
-        return node;
-    },
-});

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

@@ -1,42 +0,0 @@
-import defineFunction from "../defineFunction";
-import ParseError from "../ParseError";
-
-// Switching from text mode back to math mode
-defineFunction({
-    type: "styling",
-    names: ["\\(", "$"],
-    props: {
-        numArgs: 0,
-        allowedInText: true,
-        allowedInMath: false,
-    },
-    handler({funcName, parser}, args) {
-        const outerMode = parser.mode;
-        parser.switchMode("math");
-        const close = (funcName === "\\(" ? "\\)" : "$");
-        const body = parser.parseExpression(false, close);
-        parser.expect(close);
-        parser.switchMode(outerMode);
-        return {
-            type: "styling",
-            mode: parser.mode,
-            style: "text",
-            resetFont: true,
-            body,
-        };
-    },
-});
-
-// Check for extra closing math delimiters
-defineFunction({
-    type: "text", // Doesn't matter what this is.
-    names: ["\\)", "\\]"],
-    props: {
-        numArgs: 0,
-        allowedInText: true,
-        allowedInMath: false,
-    },
-    handler(context, args) {
-        throw new ParseError(`Mismatched ${context.funcName}`);
-    },
-});

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

@@ -1,51 +0,0 @@
-import defineFunction, {ordargument} from "../defineFunction";
-import {makeFragment} from "../buildCommon";
-import Style from "../Style";
-
-import * as html from "../buildHTML";
-import * as mml from "../buildMathML";
-
-import type Options from "../Options";
-import type {ParseNode} from "../parseNode";
-
-const chooseMathStyle = (group: ParseNode<"mathchoice">, options: Options) => {
-    switch (options.style.size) {
-        case Style.DISPLAY.size: return group.display;
-        case Style.TEXT.size: return group.text;
-        case Style.SCRIPT.size: return group.script;
-        case Style.SCRIPTSCRIPT.size: return group.scriptscript;
-        default: return group.text;
-    }
-};
-
-defineFunction({
-    type: "mathchoice",
-    names: ["\\mathchoice"],
-    props: {
-        numArgs: 4,
-        primitive: true,
-    },
-    handler: ({parser}, args) => {
-        return {
-            type: "mathchoice",
-            mode: parser.mode,
-            display:      ordargument(args[0]),
-            text:         ordargument(args[1]),
-            script:       ordargument(args[2]),
-            scriptscript: ordargument(args[3]),
-        };
-    },
-    htmlBuilder: (group, options) => {
-        const body = chooseMathStyle(group, options);
-        const elements = html.buildExpression(
-            body,
-            options,
-            false
-        );
-        return makeFragment(elements);
-    },
-    mathmlBuilder: (group, options) => {
-        const body = chooseMathStyle(group, options);
-        return mml.buildExpressionRow(body, options);
-    },
-});