@rse/ase 0.0.30 → 0.0.32

package/plugin/node_modules/katex/src/buildMathML.ts

@@ -0,0 +1,332 @@
+/**
+ * This file converts a parse tree into a corresponding MathML tree. The main
+ * entry point is the `buildMathML` function, which takes a parse tree from the
+ * parser.
+ */
+
+import {fontMap, makeSpan} from "./buildCommon";
+import {getCharacterMetrics} from "./fontMetrics";
+import ParseError from "./ParseError";
+import symbols, {ligatures} from "./symbols";
+import {_mathmlGroupBuilders as groupBuilders} from "./defineFunction";
+import {MathNode, TextNode} from "./mathMLTree";
+
+import type Options from "./Options";
+import type {AnyParseNode, SymbolParseNode} from "./parseNode";
+import type {DomSpan, HtmlDomNode} from "./domTree";
+import type {MathDomNode} from "./mathMLTree";
+import type {Mode} from "./types";
+import type {FontVariant, MathFont} from "./types/fonts";
+
+const noVariantSymbols = new Set(["\\imath", "\\jmath"]);
+const rowLikeTypes = new Set(["mrow", "mtable"]);
+
+/**
+ * Takes a symbol and converts it into a MathML text node after performing
+ * optional replacement from symbols.js.
+ */
+export const makeText = function(
+    text: string,
+    mode: Mode,
+    options?: Options,
+): TextNode {
+    if (symbols[mode][text] && symbols[mode][text].replace &&
+        text.charCodeAt(0) !== 0xD835 &&
+        !(ligatures.hasOwnProperty(text) && options &&
+          ((options.fontFamily && options.fontFamily.slice(4, 6) === "tt") ||
+           (options.font && options.font.slice(4, 6) === "tt")))) {
+        text = symbols[mode][text].replace!;
+    }
+
+    return new TextNode(text);
+};
+
+/**
+ * Wrap the given array of nodes in an <mrow> node if needed, i.e.,
+ * unless the array has length 1.  Always returns a single node.
+ */
+export const makeRow = function(body: MathDomNode[]): MathDomNode {
+    if (body.length === 1) {
+        return body[0];
+    } else {
+        return new MathNode("mrow", body);
+    }
+};
+
+const mathFontVariants: Partial<
+    Record<MathFont, FontVariant | ((group: SymbolParseNode) => FontVariant)>
+> = {
+    mathit: "italic",
+    boldsymbol: (group) => (group.type === "textord" ? "bold" : "bold-italic"),
+    mathbf: "bold",
+    mathbb: "double-struck",
+    mathsfit: "sans-serif-italic",
+    mathfrak: "fraktur",
+    mathscr: "script",
+    mathcal: "script",
+    mathsf: "sans-serif",
+    mathtt: "monospace",
+};
+
+/**
+ * Returns the math variant as a string or null if none is required.
+ */
+export const getVariant = (
+    group: SymbolParseNode,
+    options: Options,
+): FontVariant | null | undefined => {
+    // Handle \text... font specifiers as best we can.
+    // MathML has a limited list of allowable mathvariant specifiers; see
+    // https://www.w3.org/TR/MathML3/chapter3.html#presm.commatt
+    if (group.mode === "text") {
+        if (options.fontFamily === "texttt") {
+            return "monospace";
+        } else if (options.fontFamily === "textsf") {
+            if (options.fontShape === "textit" &&
+                options.fontWeight === "textbf") {
+                return "sans-serif-bold-italic";
+            } else if (options.fontShape === "textit") {
+                return "sans-serif-italic";
+            } else if (options.fontWeight === "textbf") {
+                return "bold-sans-serif";
+            } else {
+                return "sans-serif";
+            }
+        } else if (options.fontShape === "textit" &&
+                   options.fontWeight === "textbf") {
+            return "bold-italic";
+        } else if (options.fontShape === "textit") {
+            return "italic";
+        } else if (options.fontWeight === "textbf") {
+            return "bold";
+        }
+    }
+
+    const font = options.font;
+    if (!font || font === "mathnormal") {
+        return null;
+    }
+
+    const mode = group.mode;
+    const mathVariant = mathFontVariants[font];
+
+    if (mathVariant) {
+        return typeof mathVariant === "function"
+            ? mathVariant(group)
+            : mathVariant;
+    }
+
+    let text = group.text;
+    if (noVariantSymbols.has(text)) {
+        return null;
+    }
+
+    if (symbols[mode][text]) {
+        const replacement = symbols[mode][text].replace;
+        if (replacement) {
+            text = replacement;
+        }
+    }
+
+    const fontName = fontMap[font].fontName;
+    if (getCharacterMetrics(text, fontName, mode)) {
+        return fontMap[font].variant;
+    }
+
+    return null;
+};
+
+/**
+ * Check for <mi>.</mi> which is how a dot renders in MathML,
+ * or <mo separator="true" lspace="0em" rspace="0em">,</mo>
+ * which is how a braced comma {,} renders in MathML
+ */
+function isNumberPunctuation(group: MathNode | null | undefined): boolean {
+    if (!group) {
+        return false;
+    }
+    if (group.type === 'mi' && group.children.length === 1) {
+        const child = group.children[0];
+        return child instanceof TextNode && child.text === '.';
+    } else if (group.type === 'mo' && group.children.length === 1 &&
+        group.getAttribute('separator') === 'true' &&
+        group.getAttribute('lspace') === '0em' &&
+        group.getAttribute('rspace') === '0em'
+    ) {
+        const child = group.children[0];
+        return child instanceof TextNode && child.text === ',';
+    } else {
+        return false;
+    }
+}
+
+/**
+ * Takes a list of nodes, builds them, and returns a list of the generated
+ * MathML nodes.  Also combine consecutive <mtext> outputs into a single
+ * <mtext> tag.
+ */
+export const buildExpression = function(
+    expression: AnyParseNode[],
+    options: Options,
+    isOrdgroup?: boolean,
+): MathNode[] {
+    if (expression.length === 1) {
+        const group = buildGroup(expression[0], options);
+        if (isOrdgroup && group instanceof MathNode && group.type === "mo") {
+            // When TeX writers want to suppress spacing on an operator,
+            // they often put the operator by itself inside braces.
+            group.setAttribute("lspace", "0em");
+            group.setAttribute("rspace", "0em");
+        }
+        return [group];
+    }
+
+    const groups = [];
+    let lastGroup;
+    for (let i = 0; i < expression.length; i++) {
+        const group = buildGroup(expression[i], options);
+        if (group instanceof MathNode && lastGroup instanceof MathNode) {
+            // Concatenate adjacent <mtext>s
+            if (group.type === 'mtext' && lastGroup.type === 'mtext'
+                && group.getAttribute('mathvariant') ===
+                   lastGroup.getAttribute('mathvariant')) {
+                lastGroup.children.push(...group.children);
+                continue;
+            // Concatenate adjacent <mn>s
+            } else if (group.type === 'mn' && lastGroup.type === 'mn') {
+                lastGroup.children.push(...group.children);
+                continue;
+            // Concatenate <mn>...</mn> followed by <mi>.</mi>
+            } else if (isNumberPunctuation(group) && lastGroup.type === 'mn') {
+                lastGroup.children.push(...group.children);
+                continue;
+            // Concatenate <mi>.</mi> followed by <mn>...</mn>
+            } else if (group.type === 'mn' && isNumberPunctuation(lastGroup)) {
+                group.children = [...lastGroup.children, ...group.children];
+                groups.pop();
+            // Put preceding <mn>...</mn> or <mi>.</mi> inside base of
+            // <msup><mn>...base...</mn>...exponent...</msup> (or <msub>)
+            } else if ((group.type === 'msup' || group.type === 'msub') &&
+                group.children.length >= 1 &&
+                (lastGroup.type === 'mn' || isNumberPunctuation(lastGroup))
+            ) {
+                const base = group.children[0];
+                if (base instanceof MathNode && base.type === 'mn') {
+                    base.children = [...lastGroup.children, ...base.children];
+                    groups.pop();
+                }
+            // \not
+            } else if (lastGroup.type === 'mi' && lastGroup.children.length === 1) {
+                const lastChild = lastGroup.children[0];
+                if (lastChild instanceof TextNode && lastChild.text === '\u0338' &&
+                    (group.type === 'mo' || group.type === 'mi' ||
+                        group.type === 'mn')) {
+                    const child = group.children[0];
+                    if (child instanceof TextNode && child.text.length > 0) {
+                        // Overlay with combining character long solidus
+                        child.text = child.text.slice(0, 1) + "\u0338" +
+                            child.text.slice(1);
+                        groups.pop();
+                    }
+                }
+            }
+        }
+        groups.push(group);
+        lastGroup = group;
+    }
+    return groups;
+};
+
+/**
+ * Equivalent to buildExpression, but wraps the elements in an <mrow>
+ * if there's more than one.  Returns a single node instead of an array.
+ */
+export const buildExpressionRow = function(
+    expression: AnyParseNode[],
+    options: Options,
+    isOrdgroup?: boolean,
+): MathDomNode {
+    return makeRow(buildExpression(expression, options, isOrdgroup));
+};
+
+/**
+ * Takes a group from the parser and calls the appropriate groupBuilders function
+ * on it to produce a MathML node.
+ */
+export const buildGroup = function(
+    group: AnyParseNode | null | undefined,
+    options: Options,
+): MathNode {
+    if (!group) {
+        return new MathNode("mrow");
+    }
+
+    if (groupBuilders[group.type]) {
+        // TODO(ts): MathMLBuilder returns MathDomNode but all concrete
+        // builders return MathNode. Widening the return type here would
+        // require updating all callers that assume MathNode.
+        return groupBuilders[group.type](group, options) as MathNode;
+    } else {
+        throw new ParseError(
+            "Got group of unknown type: '" + group.type + "'");
+    }
+};
+
+/**
+ * Takes a full parse tree and settings and builds a MathML representation of
+ * it. In particular, we put the elements from building the parse tree into a
+ * <semantics> tag so we can also include that TeX source as an annotation.
+ *
+ * Note that we actually return a domTree element with a `<math>` inside it so
+ * we can do appropriate styling.
+ */
+export default function buildMathML(
+    tree: AnyParseNode[],
+    texExpression: string,
+    options: Options,
+    isDisplayMode: boolean,
+    forMathmlOnly: boolean,
+): DomSpan {
+    const expression = buildExpression(tree, options);
+
+    // TODO: Make a pass thru the MathML similar to buildHTML.traverseNonSpaceNodes
+    // and add spacing nodes. This is necessary only adjacent to math operators
+    // like \sin or \lim or to subsup elements that contain math operators.
+    // MathML takes care of the other spacing issues.
+
+    // Wrap up the expression in an mrow so it is presented in the semantics
+    // tag correctly, unless it's a single <mrow> or <mtable>.
+    let wrapper;
+    if (expression.length === 1 && expression[0] instanceof MathNode &&
+        rowLikeTypes.has(expression[0].type)) {
+        wrapper = expression[0];
+    } else {
+        wrapper = new MathNode("mrow", expression);
+    }
+
+    // Build a TeX annotation of the source
+    const annotation = new MathNode(
+        "annotation", [new TextNode(texExpression)]);
+
+    annotation.setAttribute("encoding", "application/x-tex");
+
+    const semantics = new MathNode(
+        "semantics", [wrapper, annotation]);
+
+    const math = new MathNode("math", [semantics]);
+    math.setAttribute("xmlns", "http://www.w3.org/1998/Math/MathML");
+    if (isDisplayMode) {
+        math.setAttribute("display", "block");
+    }
+
+    // You can't style <math> nodes, so we wrap the node in a span.
+    // NOTE: The span class is not typed to have <math> nodes as children, and
+    // we don't want to make the children type more generic since the children
+    // of span are expected to have more fields in `buildHtml` contexts.
+    // The MathNode implements VirtualNode (toNode/toMarkup) which is all that
+    // Span needs from its children for rendering.
+    // TODO(ts): Span's child type is HtmlDomNode, but MathNode only implements
+    // VirtualNode. The double-cast acknowledges this architectural limitation.
+    const wrapperClass = forMathmlOnly ? "katex" : "katex-mathml";
+    return makeSpan([wrapperClass], [math as unknown as HtmlDomNode]);
+}

package/plugin/node_modules/katex/src/buildTree.ts

@@ -0,0 +1,66 @@
+import buildHTML from "./buildHTML";
+import buildMathML from "./buildMathML";
+import {makeSpan} from "./buildCommon";
+import Options from "./Options";
+import Settings from "./Settings";
+import Style from "./Style";
+
+import type {AnyParseNode} from "./parseNode";
+import type {DomSpan} from "./domTree";
+
+const optionsFromSettings = function(settings: Settings) {
+    return new Options({
+        style: (settings.displayMode ? Style.DISPLAY : Style.TEXT),
+        maxSize: settings.maxSize,
+        minRuleThickness: settings.minRuleThickness,
+    });
+};
+
+const displayWrap = function(node: DomSpan, settings: Settings): DomSpan {
+    if (settings.displayMode) {
+        const classes = ["katex-display"];
+        if (settings.leqno) {
+            classes.push("leqno");
+        }
+        if (settings.fleqn) {
+            classes.push("fleqn");
+        }
+        node = makeSpan(classes, [node]);
+    }
+    return node;
+};
+
+export const buildTree = function(
+    tree: AnyParseNode[],
+    expression: string,
+    settings: Settings,
+): DomSpan {
+    const options = optionsFromSettings(settings);
+    let katexNode;
+    if (settings.output === "mathml") {
+        return buildMathML(tree, expression, options, settings.displayMode, true);
+    } else if (settings.output === "html") {
+        const htmlNode = buildHTML(tree, options);
+        katexNode = makeSpan(["katex"], [htmlNode]);
+    } else {
+        const mathMLNode = buildMathML(tree, expression, options,
+            settings.displayMode, false);
+        const htmlNode = buildHTML(tree, options);
+        katexNode = makeSpan(["katex"], [mathMLNode, htmlNode]);
+    }
+
+    return displayWrap(katexNode, settings);
+};
+
+export const buildHTMLTree = function(
+    tree: AnyParseNode[],
+    expression: string,
+    settings: Settings,
+): DomSpan {
+    const options = optionsFromSettings(settings);
+    const htmlNode = buildHTML(tree, options);
+    const katexNode = makeSpan(["katex"], [htmlNode]);
+    return displayWrap(katexNode, settings);
+};
+
+export default buildTree;

package/plugin/node_modules/katex/src/defineEnvironment.ts

@@ -0,0 +1,116 @@
+import {_htmlGroupBuilders, _mathmlGroupBuilders} from "./defineFunction";
+
+import type Parser from "./Parser";
+import type {AnyParseNode} from "./parseNode";
+import type {ArgType, Mode} from "./types";
+import type {NodeType} from "./parseNode";
+import type {HtmlBuilder, MathMLBuilder} from "./defineFunction";
+
+/**
+ * The context contains the following properties:
+ *  - mode: current parsing mode.
+ *  - envName: the name of the environment, one of the listed names.
+ *  - parser: the parser object.
+ */
+type EnvContext = {
+    mode: Mode;
+    envName: string;
+    parser: Parser;
+};
+
+/**
+ *  - context: information and references provided by the parser
+ *  - args: an array of arguments passed to \begin{name}
+ *  - optArgs: an array of optional arguments passed to \begin{name}
+ */
+type EnvHandler = (
+    context: EnvContext,
+    args: AnyParseNode[],
+    optArgs: (AnyParseNode | null | undefined)[],
+) => AnyParseNode;
+
+/**
+ *  - numArgs: (default 0) The number of arguments after the \begin{name} function.
+ *  - argTypes: (optional) Just like for a function
+ *  - allowedInText: (default false) Whether or not the environment is allowed
+ *                   inside text mode (not enforced yet).
+ *  - numOptionalArgs: (default 0) Just like for a function
+ */
+type EnvProps = {
+    numArgs: number;
+};
+
+/**
+ * Final environment spec for use at parse time.
+ * This is almost identical to `EnvDefSpec`, except it
+ * 1. includes the function handler
+ * 2. requires all arguments except argType
+ * It is generated by `defineEnvironment()` below.
+ */
+export type EnvSpec<NODETYPE extends NodeType> = {
+    type: NODETYPE;
+    // Need to use the type to avoid error. See NOTES below.
+    numArgs: number;
+    argTypes?: ArgType[];
+    allowedInText: boolean;
+    numOptionalArgs: number;
+    handler: EnvHandler;
+};
+
+/**
+ * All registered environments.
+ * `environments.js` exports this same dictionary again and makes it public.
+ * `Parser.js` requires this dictionary via `environments.js`.
+ */
+export const _environments: Record<string, EnvSpec<NodeType>> = {};
+
+type EnvDefSpec<NODETYPE extends NodeType> = {
+    // Unique string to differentiate parse nodes.
+    type: NODETYPE;
+
+    // List of functions which use the give handler, htmlBuilder,
+    // and mathmlBuilder.
+    names: Array<string>;
+
+    // Properties that control how the environments are parsed.
+    props: EnvProps;
+    handler: EnvHandler;
+
+    // This function returns an object representing the DOM structure to be
+    // created when rendering the defined LaTeX function.
+    htmlBuilder: HtmlBuilder<NODETYPE>;
+
+    // This function returns an object representing the MathML structure to be
+    // created when rendering the defined LaTeX function.
+    mathmlBuilder: MathMLBuilder<NODETYPE>;
+};
+
+export default function defineEnvironment<NODETYPE extends NodeType>({
+    type,
+    names,
+    props,
+    handler,
+    htmlBuilder,
+    mathmlBuilder,
+}: EnvDefSpec<NODETYPE>) {
+    // Set default values of environments.
+    const data = {
+        type,
+        numArgs: props.numArgs || 0,
+        allowedInText: false,
+        numOptionalArgs: 0,
+        handler,
+    };
+    for (let i = 0; i < names.length; ++i) {
+        // TODO: The value type of _environments should be a type union of all
+        // possible `EnvSpec<>` possibilities instead of `EnvSpec<*>`, which is
+        // an existential type.
+        _environments[names[i]] = data;
+    }
+    if (htmlBuilder) {
+        _htmlGroupBuilders[type] = htmlBuilder;
+    }
+    if (mathmlBuilder) {
+        _mathmlGroupBuilders[type] = mathmlBuilder;
+    }
+}