@rse/ase 0.0.42 → 0.0.44

package/plugin/node_modules/katex/src/environments/cd.ts

@@ -1,318 +0,0 @@
-import {wrapFragment} from "../buildCommon";
-import defineFunction from "../defineFunction";
-import {MathNode} from "../mathMLTree";
-import * as html from "../buildHTML";
-import * as mml from "../buildMathML";
-import {assertSymbolNodeType} from "../parseNode";
-import ParseError from "../ParseError";
-import {makeEm} from "../units";
-
-import type Parser from "../Parser";
-import type {ParseNode, AnyParseNode} from "../parseNode";
-
-const cdArrowFunctionName: Record<string, string> = {
-    ">": "\\\\cdrightarrow",
-    "<": "\\\\cdleftarrow",
-    "=": "\\\\cdlongequal",
-    "A": "\\uparrow",
-    "V": "\\downarrow",
-    "|": "\\Vert",
-    ".": "no arrow",
-};
-
-const newCell = (): ParseNode<"styling"> => {
-    // Create an empty cell, to be filled below with parse nodes.
-    // The parseTree from this module must be constructed like the
-    // one created by parseArray(), so an empty CD cell must
-    // be a ParseNode<"styling">. And CD is always displaystyle.
-    return {
-        type: "styling",
-        body: [],
-        mode: "math",
-        style: "display",
-        resetFont: true,
-    };
-};
-
-const isStartOfArrow = (node: AnyParseNode) => {
-    return (node.type === "textord" && node.text === "@");
-};
-
-const isLabelEnd = (node: AnyParseNode, endChar: string): boolean => {
-    return ((node.type === "mathord" || node.type === "atom") &&
-        node.text === endChar);
-};
-
-function cdArrow(
-    arrowChar: string,
-    labels: ParseNode<"ordgroup">[],
-    parser: Parser
-): AnyParseNode {
-    // Return a parse tree of an arrow and its labels.
-    // This acts in a way similar to a macro expansion.
-    const funcName = cdArrowFunctionName[arrowChar];
-    switch (funcName) {
-        case "\\\\cdrightarrow":
-        case "\\\\cdleftarrow":
-            return parser.callFunction(
-                funcName, [labels[0]], [labels[1]]
-            );
-        case "\\uparrow":
-        case "\\downarrow": {
-            const leftLabel = parser.callFunction(
-                "\\\\cdleft", [labels[0]], []
-            );
-            const bareArrow: ParseNode<"atom"> = {
-                type: "atom",
-                text: funcName,
-                mode: "math",
-                family: "rel",
-            };
-            const sizedArrow = parser.callFunction("\\Big", [bareArrow], []);
-            const rightLabel = parser.callFunction(
-                "\\\\cdright", [labels[1]], []
-            );
-            const arrowGroup: ParseNode<"ordgroup"> = {
-                type: "ordgroup",
-                mode: "math",
-                body: [leftLabel, sizedArrow, rightLabel],
-            };
-            return parser.callFunction("\\\\cdparent", [arrowGroup], []);
-        }
-        case "\\\\cdlongequal":
-            return parser.callFunction("\\\\cdlongequal", [], []);
-        case "\\Vert": {
-            const arrow: ParseNode<"textord"> = {type: "textord", text: "\\Vert", mode: "math"};
-            return parser.callFunction("\\Big", [arrow], []);
-        }
-        default:
-            return {type: "textord", text: " ", mode: "math"};
-    }
-}
-
-export function parseCD(parser: Parser): ParseNode<"array"> {
-    // Get the array's parse nodes with \\ temporarily mapped to \cr.
-    const parsedRows: AnyParseNode[][] = [];
-    parser.gullet.beginGroup();
-    parser.gullet.macros.set("\\cr", "\\\\\\relax");
-    parser.gullet.beginGroup();
-    while (true) {
-        // Get the parse nodes for the next row.
-        parsedRows.push(parser.parseExpression(false, "\\\\"));
-        parser.gullet.endGroup();
-        parser.gullet.beginGroup();
-        const next = parser.fetch().text;
-        if (next === "&" || next === "\\\\") {
-            parser.consume();
-        } else if (next === "\\end") {
-            if (parsedRows[parsedRows.length - 1].length === 0) {
-                parsedRows.pop(); // final row ended in \\
-            }
-            break;
-        } else {
-            throw new ParseError("Expected \\\\ or \\cr or \\end",
-                                 parser.nextToken);
-        }
-    }
-
-    let row: ParseNode<"styling">[] = [];
-    const body: ParseNode<"styling">[][] = [row];
-
-    // Loop thru the parse nodes. Collect them into cells and arrows.
-    for (let i = 0; i < parsedRows.length; i++) {
-        // Start a new row.
-        const rowNodes = parsedRows[i];
-        // Create the first cell.
-        let cell = newCell();
-
-        for (let j = 0; j < rowNodes.length; j++) {
-            if (!isStartOfArrow(rowNodes[j])) {
-                // If a parseNode is not an arrow, it goes into a cell.
-                cell.body.push(rowNodes[j]);
-            } else {
-                // Parse node j is an "@", the start of an arrow.
-                // Before starting on the arrow, push the cell into `row`.
-                row.push(cell);
-
-                // Now collect parseNodes into an arrow.
-                // The character after "@" defines the arrow type.
-                j += 1;
-                const arrowChar = assertSymbolNodeType(rowNodes[j]).text;
-
-                // Create two empty label nodes. We may or may not use them.
-                const labels: ParseNode<"ordgroup">[] = new Array(2);
-                labels[0] = {type: "ordgroup", mode: "math", body: []};
-                labels[1] = {type: "ordgroup", mode: "math", body: []};
-
-                // Process the arrow.
-                if ("=|.".includes(arrowChar)) {
-                    // Three "arrows", ``@=`, `@|`, and `@.`, do not take labels.
-                    // Do nothing here.
-                } else if ("<>AV".includes(arrowChar)) {
-                    // Four arrows, `@>>>`, `@<<<`, `@AAA`, and `@VVV`, each take
-                    // two optional labels. E.g. the right-point arrow syntax is
-                    // really:  @>{optional label}>{optional label}>
-                    // Collect parseNodes into labels.
-                    for (let labelNum = 0; labelNum < 2; labelNum++) {
-                        let inLabel = true;
-                        for (let k = j + 1; k < rowNodes.length; k++) {
-                            if (isLabelEnd(rowNodes[k], arrowChar)) {
-                                inLabel = false;
-                                j = k;
-                                break;
-                            }
-                            if (isStartOfArrow(rowNodes[k])) {
-                                throw new ParseError("Missing a " + arrowChar +
-                                " character to complete a CD arrow.", rowNodes[k]);
-                            }
-
-                            labels[labelNum].body.push(rowNodes[k]);
-                        }
-                        if (inLabel) {
-                            // isLabelEnd never returned a true.
-                            throw new ParseError("Missing a " + arrowChar +
-                                " character to complete a CD arrow.", rowNodes[j]);
-                        }
-                    }
-                } else {
-                    throw new ParseError(`Expected one of "<>AV=|." after @`,
-                        rowNodes[j]);
-                }
-
-                // Now join the arrow to its labels.
-                const arrow: AnyParseNode = cdArrow(arrowChar, labels, parser);
-
-                // Wrap the arrow in  ParseNode<"styling">.
-                // This is done to match parseArray() behavior.
-                const wrappedArrow: ParseNode<"styling"> = {
-                    type: "styling",
-                    body: [arrow],
-                    mode: "math",
-                    style: "display", // CD is always displaystyle.
-                    resetFont: true,
-                };
-                row.push(wrappedArrow);
-                // In CD's syntax, cells are implicit. That is, everything that
-                // is not an arrow gets collected into a cell. So create an empty
-                // cell now. It will collect upcoming parseNodes.
-                cell = newCell();
-            }
-        }
-        if (i % 2 === 0) {
-            // Even-numbered rows consist of: cell, arrow, cell, arrow, ... cell
-            // The last cell is not yet pushed into `row`, so:
-            row.push(cell);
-        } else {
-            // Odd-numbered rows consist of: vert arrow, empty cell, ... vert arrow
-            // Remove the empty cell that was placed at the beginning of `row`.
-            row.shift();
-        }
-        row = [];
-        body.push(row);
-    }
-
-    // End row group
-    parser.gullet.endGroup();
-    // End array group defining \\
-    parser.gullet.endGroup();
-
-    // define column separation.
-    const cols = new Array(body[0].length).fill({
-        type: "align",
-        align: "c",
-        pregap: 0.25,  // CD package sets \enskip between columns.
-        postgap: 0.25, // So pre and post each get half an \enskip, i.e. 0.25em.
-    });
-
-    return {
-        type: "array",
-        mode: "math",
-        body,
-        arraystretch: 1,
-        addJot: true,
-        rowGaps: [null],
-        cols,
-        colSeparationType: "CD",
-        hLinesBeforeRow: new Array(body.length + 1).fill([]),
-    };
-}
-
-// The functions below are not available for general use.
-// They are here only for internal use by the {CD} environment in placing labels
-// next to vertical arrows.
-
-// We don't need any such functions for horizontal arrows because we can reuse
-// the functionality that already exists for extensible arrows.
-
-defineFunction({
-    type: "cdlabel",
-    names: ["\\\\cdleft", "\\\\cdright"],
-    props: {
-        numArgs: 1,
-    },
-    handler({parser, funcName}, args) {
-        return {
-            type: "cdlabel",
-            mode: parser.mode,
-            side: funcName.slice(4),
-            label: args[0],
-        };
-    },
-    htmlBuilder(group, options) {
-        const newOptions = options.havingStyle(options.style.sup());
-        const label = wrapFragment(
-            html.buildGroup(group.label, newOptions, options), options);
-        label.classes.push("cd-label-" + group.side);
-        label.style.bottom = makeEm(0.8 - label.depth);
-        // Zero out label height & depth, so vertical align of arrow is set
-        // by the arrow height, not by the label.
-        label.height = 0;
-        label.depth = 0;
-        return label;
-    },
-    mathmlBuilder(group, options) {
-        let label = new MathNode("mrow",
-            [mml.buildGroup(group.label, options)]);
-        label = new MathNode("mpadded", [label]);
-        label.setAttribute("width", "0");
-        if (group.side === "left") {
-            label.setAttribute("lspace", "-1width");
-        }
-        // We have to guess at vertical alignment. We know the arrow is 1.8em tall,
-        // But we don't know the height or depth of the label.
-        label.setAttribute("voffset", "0.7em");
-        label = new MathNode("mstyle", [label]);
-        label.setAttribute("displaystyle", "false");
-        label.setAttribute("scriptlevel", "1");
-        return label;
-    },
-});
-
-defineFunction({
-    type: "cdlabelparent",
-    names: ["\\\\cdparent"],
-    props: {
-        numArgs: 1,
-    },
-    handler({parser}, args) {
-        return {
-            type: "cdlabelparent",
-            mode: parser.mode,
-            fragment: args[0],
-        };
-    },
-    htmlBuilder(group, options) {
-        // Wrap the vertical arrow and its labels.
-        // The parent gets position: relative. The child gets position: absolute.
-        // So CSS can locate the label correctly.
-        const parent = wrapFragment(
-            html.buildGroup(group.fragment, options), options
-        );
-        parent.classes.push("cd-vert-arrow");
-        return parent;
-    },
-    mathmlBuilder(group, options) {
-        return new MathNode("mrow",
-            [mml.buildGroup(group.fragment, options)]);
-    },
-});

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

@@ -1,8 +0,0 @@
-import {_environments} from "./defineEnvironment";
-
-const environments = _environments;
-
-export default environments;
-
-// All environment definitions should be imported below
-import "./environments/array";

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

@@ -1,267 +0,0 @@
-import {supportedCodepoint} from "./unicodeScripts";
-
-import type {Mode} from "./types";
-import type {CharacterMetrics, CharacterMetricsTuple, FontMetrics} from "./types/fonts";
-// This map contains a mapping from font name and character code to character
-// metrics, including height, depth, italic correction, and skew (kern from the
-// character to the corresponding \skewchar)
-// This map is generated via `make metrics`. It should not be changed manually.
-import metricMap from "./fontMetricsData";
-
-/**
- * This file contains metrics regarding fonts and individual symbols. The sigma
- * and xi variables, as well as the metricMap map contain data extracted from
- * TeX, TeX font metrics, and the TTF files. These data are then exposed via the
- * `metrics` variable and the getCharacterMetrics function.
- */
-
-// In TeX, there are actually three sets of dimensions, one for each of
-// textstyle (size index 5 and higher: >=9pt), scriptstyle (size index 3 and 4:
-// 7-8pt), and scriptscriptstyle (size index 1 and 2: 5-6pt).  These are
-// provided in the arrays below, in that order.
-//
-// The font metrics are stored in fonts cmsy10, cmsy7, and cmsy5 respectively.
-// This was determined by running the following script:
-//
-//     latex -interaction=nonstopmode \
-//     '\documentclass{article}\usepackage{amsmath}\begin{document}' \
-//     '$a$ \expandafter\show\the\textfont2' \
-//     '\expandafter\show\the\scriptfont2' \
-//     '\expandafter\show\the\scriptscriptfont2' \
-//     '\stop'
-//
-// The metrics themselves were retrieved using the following commands:
-//
-//     tftopl cmsy10
-//     tftopl cmsy7
-//     tftopl cmsy5
-//
-// The output of each of these commands is quite lengthy.  The only part we
-// care about is the FONTDIMEN section. Each value is measured in EMs.
-const sigmasAndXis: Record<string, [number, number, number]> = {
-    slant: [0.250, 0.250, 0.250],       // sigma1
-    space: [0.000, 0.000, 0.000],       // sigma2
-    stretch: [0.000, 0.000, 0.000],     // sigma3
-    shrink: [0.000, 0.000, 0.000],      // sigma4
-    xHeight: [0.431, 0.431, 0.431],     // sigma5
-    quad: [1.000, 1.171, 1.472],        // sigma6
-    extraSpace: [0.000, 0.000, 0.000],  // sigma7
-    num1: [0.677, 0.732, 0.925],        // sigma8
-    num2: [0.394, 0.384, 0.387],        // sigma9
-    num3: [0.444, 0.471, 0.504],        // sigma10
-    denom1: [0.686, 0.752, 1.025],      // sigma11
-    denom2: [0.345, 0.344, 0.532],      // sigma12
-    sup1: [0.413, 0.503, 0.504],        // sigma13
-    sup2: [0.363, 0.431, 0.404],        // sigma14
-    sup3: [0.289, 0.286, 0.294],        // sigma15
-    sub1: [0.150, 0.143, 0.200],        // sigma16
-    sub2: [0.247, 0.286, 0.400],        // sigma17
-    supDrop: [0.386, 0.353, 0.494],     // sigma18
-    subDrop: [0.050, 0.071, 0.100],     // sigma19
-    delim1: [2.390, 1.700, 1.980],      // sigma20
-    delim2: [1.010, 1.157, 1.420],      // sigma21
-    axisHeight: [0.250, 0.250, 0.250],  // sigma22
-
-    // These font metrics are extracted from TeX by using tftopl on cmex10.tfm;
-    // they correspond to the font parameters of the extension fonts (family 3).
-    // See the TeXbook, page 441. In AMSTeX, the extension fonts scale; to
-    // match cmex7, we'd use cmex7.tfm values for script and scriptscript
-    // values.
-    defaultRuleThickness: [0.04, 0.049, 0.049], // xi8; cmex7: 0.049
-    bigOpSpacing1: [0.111, 0.111, 0.111],       // xi9
-    bigOpSpacing2: [0.166, 0.166, 0.166],       // xi10
-    bigOpSpacing3: [0.2, 0.2, 0.2],             // xi11
-    bigOpSpacing4: [0.6, 0.611, 0.611],         // xi12; cmex7: 0.611
-    bigOpSpacing5: [0.1, 0.143, 0.143],         // xi13; cmex7: 0.143
-
-    // The \sqrt rule width is taken from the height of the surd character.
-    // Since we use the same font at all sizes, this thickness doesn't scale.
-    sqrtRuleThickness: [0.04, 0.04, 0.04],
-
-    // This value determines how large a pt is, for metrics which are defined
-    // in terms of pts.
-    // This value is also used in katex.scss; if you change it make sure the
-    // values match.
-    ptPerEm: [10.0, 10.0, 10.0],
-
-    // The space between adjacent `|` columns in an array definition. From
-    // `\showthe\doublerulesep` in LaTeX. Equals 2.0 / ptPerEm.
-    doubleRuleSep: [0.2, 0.2, 0.2],
-
-    // The width of separator lines in {array} environments. From
-    // `\showthe\arrayrulewidth` in LaTeX. Equals 0.4 / ptPerEm.
-    arrayRuleWidth: [0.04, 0.04, 0.04],
-
-    // Two values from LaTeX source2e:
-    fboxsep: [0.3, 0.3, 0.3], //        3 pt / ptPerEm
-    fboxrule: [0.04, 0.04, 0.04], // 0.4 pt / ptPerEm
-};
-
-// These are very rough approximations.  We default to Times New Roman which
-// should have Latin-1 and Cyrillic characters, but may not depending on the
-// operating system.  The metrics do not account for extra height from the
-// accents.  In the case of Cyrillic characters which have both ascenders and
-// descenders we prefer approximations with ascenders, primarily to prevent
-// the fraction bar or root line from intersecting the glyph.
-// TODO(kevinb) allow union of multiple glyph metrics for better accuracy.
-const extraCharacterMap: Record<string, string> = {
-    // Latin-1
-    'Å': 'A',
-    'Ð': 'D',
-    'Þ': 'o',
-    'å': 'a',
-    'ð': 'd',
-    'þ': 'o',
-
-    // Cyrillic
-    'А': 'A',
-    'Б': 'B',
-    'В': 'B',
-    'Г': 'F',
-    'Д': 'A',
-    'Е': 'E',
-    'Ж': 'K',
-    'З': '3',
-    'И': 'N',
-    'Й': 'N',
-    'К': 'K',
-    'Л': 'N',
-    'М': 'M',
-    'Н': 'H',
-    'О': 'O',
-    'П': 'N',
-    'Р': 'P',
-    'С': 'C',
-    'Т': 'T',
-    'У': 'y',
-    'Ф': 'O',
-    'Х': 'X',
-    'Ц': 'U',
-    'Ч': 'h',
-    'Ш': 'W',
-    'Щ': 'W',
-    'Ъ': 'B',
-    'Ы': 'X',
-    'Ь': 'B',
-    'Э': '3',
-    'Ю': 'X',
-    'Я': 'R',
-    'а': 'a',
-    'б': 'b',
-    'в': 'a',
-    'г': 'r',
-    'д': 'y',
-    'е': 'e',
-    'ж': 'm',
-    'з': 'e',
-    'и': 'n',
-    'й': 'n',
-    'к': 'n',
-    'л': 'n',
-    'м': 'm',
-    'н': 'n',
-    'о': 'o',
-    'п': 'n',
-    'р': 'p',
-    'с': 'c',
-    'т': 'o',
-    'у': 'y',
-    'ф': 'b',
-    'х': 'x',
-    'ц': 'n',
-    'ч': 'n',
-    'ш': 'w',
-    'щ': 'w',
-    'ъ': 'a',
-    'ы': 'm',
-    'ь': 'a',
-    'э': 'e',
-    'ю': 'm',
-    'я': 'r',
-};
-
-/**
- * This function adds new font metrics to default metricMap
- * It can also override existing metrics
- */
-export function setFontMetrics(
-    fontName: string,
-    metrics: {[key: string]: CharacterMetricsTuple}
-) {
-    metricMap[fontName] = metrics;
-}
-
-/**
- * This function is a convenience function for looking up information in the
- * metricMap table. It takes a character as a string, and a font.
- *
- * Note: the `width` property may be undefined if fontMetricsData.js wasn't
- * built using `Make extended_metrics`.
- */
-export function getCharacterMetrics(
-    character: string,
-    font: string,
-    mode: Mode,
-): CharacterMetrics | null | undefined {
-    if (!metricMap[font]) {
-        throw new Error(`Font metrics not found for font: ${font}.`);
-    }
-    let ch = character.charCodeAt(0);
-    let metrics = metricMap[font][ch];
-    if (!metrics && character[0] in extraCharacterMap) {
-        ch = extraCharacterMap[character[0]].charCodeAt(0);
-        metrics = metricMap[font][ch];
-    }
-
-    if (!metrics && mode === 'text') {
-        // We don't typically have font metrics for Asian scripts.
-        // But since we support them in text mode, we need to return
-        // some sort of metrics.
-        // So if the character is in a script we support but we
-        // don't have metrics for it, just use the metrics for
-        // the Latin capital letter M. This is close enough because
-        // we (currently) only care about the height of the glyph
-        // not its width.
-        if (supportedCodepoint(ch)) {
-            metrics = metricMap[font][77]; // 77 is the charcode for 'M'
-        }
-    }
-
-    if (metrics) {
-        return {
-            depth: metrics[0],
-            height: metrics[1],
-            italic: metrics[2],
-            skew: metrics[3],
-            width: metrics[4],
-        };
-    }
-}
-
-type FontSizeIndex = 0 | 1 | 2;
-const fontMetricsBySizeIndex: Partial<Record<FontSizeIndex, FontMetrics>> = {};
-
-/**
- * Get the font metrics for a given size.
- */
-export function getGlobalMetrics(size: number): FontMetrics {
-    let sizeIndex: FontSizeIndex;
-    if (size >= 5) {
-        sizeIndex = 0;
-    } else if (size >= 3) {
-        sizeIndex = 1;
-    } else {
-        sizeIndex = 2;
-    }
-    if (!fontMetricsBySizeIndex[sizeIndex]) {
-        const metrics: FontMetrics = fontMetricsBySizeIndex[sizeIndex] = {
-            cssEmPerMu: sigmasAndXis.quad[sizeIndex] / 18,
-        };
-        for (const key in sigmasAndXis) {
-            if (sigmasAndXis.hasOwnProperty(key)) {
-                metrics[key] = sigmasAndXis[key][sizeIndex];
-            }
-        }
-    }
-    return fontMetricsBySizeIndex[sizeIndex]!;
-}

package/plugin/node_modules/katex/src/fontMetricsData.d.ts

@@ -1,8 +0,0 @@
-import type {CharacterMetricsTuple, FontName} from "./types/fonts";
-
-type FontMetrics = Record<number, CharacterMetricsTuple>;
-
-declare const fontMetricsData: Record<FontName, FontMetrics> &
-    Record<string, FontMetrics>;
-
-export default fontMetricsData;