@rse/ase 0.0.31 → 0.0.32

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

@@ -0,0 +1,259 @@
+/**
+ * These objects store data about MathML nodes. This is the MathML equivalent
+ * of the types in domTree.js. Since MathML handles its own rendering, and
+ * since we're mainly using MathML to improve accessibility, we don't manage
+ * any of the styling state that the plain DOM nodes do.
+ *
+ * The `toNode` and `toMarkup` functions work similarly to how they do in
+ * domTree.js, creating namespaced DOM nodes and HTML text markup respectively.
+ */
+
+import {escape} from "./utils";
+import {DocumentFragment} from "./tree";
+import {createClass} from "./domTree";
+import {makeEm} from "./units";
+
+import type {VirtualNode} from "./tree";
+
+/**
+ * MathML node types used in KaTeX. For a complete list of MathML nodes, see
+ * https://developer.mozilla.org/en-US/docs/Web/MathML/Element.
+ */
+export type MathNodeType =
+    "math" | "annotation" | "semantics" |
+    "mtext" | "mn" | "mo" | "mi" | "mspace" |
+    "mover" | "munder" | "munderover" | "msup" | "msub" | "msubsup" |
+    "mfrac" | "mroot" | "msqrt" |
+    "mtable" | "mtr" | "mtd" | "mlabeledtr" |
+    "mrow" | "menclose" |
+    "mstyle" | "mpadded" | "mphantom" | "mglyph";
+
+export interface MathDomNode extends VirtualNode {
+    toText(): string;
+}
+
+export type documentFragment = DocumentFragment<MathDomNode>;
+export function newDocumentFragment(
+    children: ReadonlyArray<MathDomNode>
+): documentFragment {
+    return new DocumentFragment(children);
+}
+
+/**
+ * This node represents a general purpose MathML node of any type. The
+ * constructor requires the type of node to create (for example, `"mo"` or
+ * `"mspace"`, corresponding to `<mo>` and `<mspace>` tags).
+ */
+export class MathNode implements MathDomNode {
+    type: MathNodeType;
+    attributes: Record<string, string>;
+    children: MathDomNode[];
+    classes: string[];
+
+    constructor(
+        type: MathNodeType,
+        children?: MathDomNode[],
+        classes?: string[]
+    ) {
+        this.type = type;
+        this.attributes = {};
+        this.children = children || [];
+        this.classes = classes || [];
+    }
+
+    /**
+     * Sets an attribute on a MathML node. MathML depends on attributes to convey a
+     * semantic content, so this is used heavily.
+     */
+    setAttribute(name: string, value: string) {
+        this.attributes[name] = value;
+    }
+
+    /**
+     * Gets an attribute on a MathML node.
+     */
+    getAttribute(name: string): string {
+        return this.attributes[name];
+    }
+
+    /**
+     * Converts the math node into a MathML-namespaced DOM element.
+     */
+    toNode(): Node {
+        const node = document.createElementNS(
+            "http://www.w3.org/1998/Math/MathML", this.type);
+
+        for (const attr in this.attributes) {
+            if (Object.prototype.hasOwnProperty.call(this.attributes, attr)) {
+                node.setAttribute(attr, this.attributes[attr]);
+            }
+        }
+
+        if (this.classes.length > 0) {
+            node.className = createClass(this.classes);
+        }
+
+        for (let i = 0; i < this.children.length; i++) {
+            // Combine multiple TextNodes into one TextNode, to prevent
+            // screen readers from reading each as a separate word [#3995]
+            if (this.children[i] instanceof TextNode &&
+                this.children[i + 1] instanceof TextNode) {
+                let text = this.children[i].toText() + this.children[++i].toText();
+                while (this.children[i + 1] instanceof TextNode) {
+                    text += this.children[++i].toText();
+                }
+                node.appendChild(new TextNode(text).toNode());
+            } else {
+                node.appendChild(this.children[i].toNode());
+            }
+        }
+
+        return node;
+    }
+
+    /**
+     * Converts the math node into an HTML markup string.
+     */
+    toMarkup(): string {
+        let markup = "<" + this.type;
+
+        // Add the attributes
+        for (const attr in this.attributes) {
+            if (Object.prototype.hasOwnProperty.call(this.attributes, attr)) {
+                markup += " " + attr + "=\"";
+                markup += escape(this.attributes[attr]);
+                markup += "\"";
+            }
+        }
+
+        if (this.classes.length > 0) {
+            markup += ` class ="${escape(createClass(this.classes))}"`;
+        }
+
+        markup += ">";
+
+        for (let i = 0; i < this.children.length; i++) {
+            markup += this.children[i].toMarkup();
+        }
+
+        markup += "</" + this.type + ">";
+
+        return markup;
+    }
+
+    /**
+     * Converts the math node into a string, similar to innerText, but escaped.
+     */
+    toText(): string {
+        return this.children.map(child => child.toText()).join("");
+    }
+}
+
+/**
+ * This node represents a piece of text.
+ */
+export class TextNode implements MathDomNode {
+    text: string;
+
+    constructor(text: string) {
+        this.text = text;
+    }
+
+    /**
+     * Converts the text node into a DOM text node.
+     */
+    toNode(): Node {
+        return document.createTextNode(this.text);
+    }
+
+    /**
+     * Converts the text node into escaped HTML markup
+     * (representing the text itself).
+     */
+    toMarkup(): string {
+        return escape(this.toText());
+    }
+
+    /**
+     * Converts the text node into a string
+     * (representing the text itself).
+     */
+    toText(): string {
+        return this.text;
+    }
+}
+
+/**
+ * This node represents a space, but may render as <mspace.../> or as text,
+ * depending on the width.
+ */
+export class SpaceNode implements MathDomNode {
+    width: number;
+    character: string | null | undefined;
+
+    /**
+     * Create a Space node with width given in CSS ems.
+     */
+    constructor(width: number) {
+        this.width = width;
+        // See https://www.w3.org/TR/2000/WD-MathML2-20000328/chapter6.html
+        // for a table of space-like characters.  We use Unicode
+        // representations instead of &LongNames; as it's not clear how to
+        // make the latter via document.createTextNode.
+        if (width >= 0.05555 && width <= 0.05556) {
+            this.character = "\u200a";           // &VeryThinSpace;
+        } else if (width >= 0.1666 && width <= 0.1667) {
+            this.character = "\u2009";           // &ThinSpace;
+        } else if (width >= 0.2222 && width <= 0.2223) {
+            this.character = "\u2005";           // &MediumSpace;
+        } else if (width >= 0.2777 && width <= 0.2778) {
+            this.character = "\u2005\u200a";     // &ThickSpace;
+        } else if (width >= -0.05556 && width <= -0.05555) {
+            this.character = "\u200a\u2063";     // &NegativeVeryThinSpace;
+        } else if (width >= -0.1667 && width <= -0.1666) {
+            this.character = "\u2009\u2063";     // &NegativeThinSpace;
+        } else if (width >= -0.2223 && width <= -0.2222) {
+            this.character = "\u205f\u2063";     // &NegativeMediumSpace;
+        } else if (width >= -0.2778 && width <= -0.2777) {
+            this.character = "\u2005\u2063";     // &NegativeThickSpace;
+        } else {
+            this.character = null;
+        }
+    }
+
+    /**
+     * Converts the math node into a MathML-namespaced DOM element.
+     */
+    toNode(): Node {
+        if (this.character) {
+            return document.createTextNode(this.character);
+        } else {
+            const node = document.createElementNS(
+                "http://www.w3.org/1998/Math/MathML", "mspace");
+            node.setAttribute("width", makeEm(this.width));
+            return node;
+        }
+    }
+
+    /**
+     * Converts the math node into an HTML markup string.
+     */
+    toMarkup(): string {
+        if (this.character) {
+            return `<mtext>${this.character}</mtext>`;
+        } else {
+            return `<mspace width="${makeEm(this.width)}"/>`;
+        }
+    }
+
+    /**
+     * Converts the math node into a string, similar to innerText.
+     */
+    toText(): string {
+        if (this.character) {
+            return this.character;
+        } else {
+            return " ";
+        }
+    }
+}

package/plugin/node_modules/katex/src/metrics/README.md

@@ -0,0 +1,23 @@
+### How to generate new metrics
+-------------------------------
+
+There are several requirements for generating the metrics used by KaTeX.
+
+- You need to have an installation of TeX which supports kpathsea. You can check
+  this by running `tex --version`, and seeing if it has a line that looks like
+  > kpathsea version 6.2.0
+
+- You need the Perl module `JSON`. You can install this either from CPAN
+  (e.g. using the `cpan` command line tool: `cpan install JSON`)
+  or with your package manager.
+
+- You need the Python module `fonttools`. You can install this either from PyPI
+  (using `easy_install` or `pip`: `pip install fonttools`)
+  or with your package manager.
+
+Once you have these things, run the following command from the root directory:
+
+    sh ./dockers/fonts/buildMetrics.sh
+
+which should generate new metrics and place them into `fontMetricsData.json`.
+You're done!

package/plugin/node_modules/katex/src/metrics/extract_tfms.py

@@ -0,0 +1,114 @@
+#!/usr/bin/env python3
+
+import collections
+import json
+import parse_tfm
+import subprocess
+import sys
+
+
+def find_font_path(font_name):
+    try:
+        font_path = subprocess.check_output(['kpsewhich', font_name])
+    except OSError:
+        raise RuntimeError("Couldn't find kpsewhich program, make sure you" +
+                           " have TeX installed")
+    except subprocess.CalledProcessError:
+        raise RuntimeError("Couldn't find font metrics: '%s'" % font_name)
+    return font_path.strip()
+
+
+def main():
+    mapping = json.load(sys.stdin)
+
+    fonts = [
+        'cmbsy10.tfm',
+        'cmbx10.tfm',
+        'cmbxti10.tfm',
+        'cmex10.tfm',
+        'cmmi10.tfm',
+        'cmmib10.tfm',
+        'cmr10.tfm',
+        'cmsy10.tfm',
+        'cmti10.tfm',
+        'msam10.tfm',
+        'msbm10.tfm',
+        'eufm10.tfm',
+        'cmtt10.tfm',
+        'rsfs10.tfm',
+        'cmss10.tfm',
+        'cmssbx10.tfm',
+        'cmssi10.tfm',
+    ]
+
+    # Extracted by running `\font\a=<font>` and then `\showthe\skewchar\a` in
+    # TeX, where `<font>` is the name of the font listed here. The skewchar
+    # will be printed out in the output. If it outputs `-1`, that means there
+    # is no skewchar, so we use `None` here.
+    font_skewchar = {
+        'cmbsy10': None,
+        'cmbx10': None,
+        'cmbxti10': None,
+        'cmex10': None,
+        'cmmi10': 127,
+        'cmmib10': None,
+        'cmr10': None,
+        'cmsy10': 48,
+        'cmti10': None,
+        'msam10': None,
+        'msbm10': None,
+        'eufm10': None,
+        'cmtt10': None,
+        'rsfs10': None,
+        'cmss10': None,
+        'cmssbx10': None,
+        'cmssi10': None,
+    }
+
+    font_name_to_tfm = {}
+
+    for font_name in fonts:
+        font_basename = font_name.split('.')[0]
+        font_path = find_font_path(font_name)
+        font_name_to_tfm[font_basename] = parse_tfm.read_tfm_file(font_path)
+
+    families = collections.defaultdict(dict)
+
+    for family, chars in mapping.items():
+        for char, char_data in chars.items():
+            char_num = int(char)
+
+            font = char_data['font']
+            tex_char_num = int(char_data['char'])
+            yshift = float(char_data['yshift'])
+
+            if family == "Script-Regular":
+                tfm_char = font_name_to_tfm[font].get_char_metrics(tex_char_num,
+                                                                   fix_rsfs=True)
+            else:
+                tfm_char = font_name_to_tfm[font].get_char_metrics(tex_char_num)
+
+            height = round(tfm_char.height + yshift / 1000.0, 5)
+            depth = round(tfm_char.depth - yshift / 1000.0, 5)
+            italic = round(tfm_char.italic_correction, 5)
+            width = round(tfm_char.width, 5)
+
+            skewkern = 0.0
+            if (font_skewchar[font] and
+                    font_skewchar[font] in tfm_char.kern_table):
+                skewkern = round(
+                    tfm_char.kern_table[font_skewchar[font]], 5)
+
+            families[family][char_num] = {
+                'height': height,
+                'depth': depth,
+                'italic': italic,
+                'skew': skewkern,
+                'width': width
+            }
+
+    sys.stdout.write(
+        json.dumps(families, separators=(',', ':'), sort_keys=True))
+
+if __name__ == '__main__':
+    main()

package/plugin/node_modules/katex/src/metrics/extract_ttfs.py

@@ -0,0 +1,122 @@
+#!/usr/bin/env python3
+
+from fontTools.ttLib import TTFont
+import sys
+import json
+
+# map of characters to extract
+metrics_to_extract = {
+    # Font name
+    "AMS-Regular": {
+        u"\u21e2": None,  # \dashrightarrow
+        u"\u21e0": None,  # \dashleftarrow
+    },
+    "Main-Regular": {
+        # Skew and italic metrics can't be easily parsed from the TTF. Instead,
+        # we map each character to a "base character", which is a character
+        # from the same font with correct italic and skew metrics. A character
+        # maps to None if it doesn't have a base.
+
+        #u"\u2209": None,  # \notin
+        #u"\u2260": None,  # \neq
+        u"\u2245": None,  # \cong
+        u"\u2026": None,  # \ldots
+        u"\u22ef": None,  # \cdots
+        u"\u22f1": None,  # \ddots
+        u"\u22ee": None,  # \vdots
+        u"\u22ee": None,  # \vdots
+        u"\u22a8": None,  # \models
+        u"\u22c8": None,  # \bowtie
+        u"\u2250": None,  # \doteq
+        u"\u23b0": None,  # \lmoustache
+        u"\u23b1": None,  # \rmoustache
+        u"\u27ee": None,  # \lgroup
+        u"\u27ef": None,  # \rgroup
+        u"\u27f5": None,  # \longleftarrow
+        u"\u27f8": None,  # \Longleftarrow
+        u"\u27f6": None,  # \longrightarrow
+        u"\u27f9": None,  # \Longrightarrow
+        u"\u27f7": None,  # \longleftrightarrow
+        u"\u27fa": None,  # \Longleftrightarrow
+        u"\u21a6": None,  # \mapsto
+        u"\u27fc": None,  # \longmapsto
+        u"\u21a9": None,  # \hookleftarrow
+        u"\u21aa": None,  # \hookrightarrow
+        u"\u21cc": None,  # \rightleftharpoons
+    },
+    "Main-Bold": {
+        u"\u2245": None,  # \cong
+    },
+    "Size1-Regular": {
+        u"\u222c": u"\u222b",  # \iint, based on \int
+        u"\u222d": u"\u222b",  # \iiint, based on \int
+    },
+    "Size2-Regular": {
+        u"\u222c": u"\u222b",  # \iint, based on \int
+        u"\u222d": u"\u222b",  # \iiint, based on \int
+    },
+}
+
+
+def main():
+    start_json = json.load(sys.stdin)
+
+    for font in start_json:
+        fontInfo = TTFont("../../fonts/KaTeX_" + font + ".ttf")
+        glyf = fontInfo["glyf"]
+        widths = fontInfo.getGlyphSet()
+        unitsPerEm = float(fontInfo["head"].unitsPerEm)
+
+        # We keep ALL Unicode cmaps, not just fontInfo["cmap"].getcmap(3, 1).
+        # This is playing it extra safe, since it reports inconsistencies.
+        # Platform 0 is Unicode, platform 3 is Windows. For platform 3,
+        # encoding 1 is UCS-2 and encoding 10 is UCS-4.
+        cmap = [t.cmap for t in fontInfo["cmap"].tables
+                if (t.platformID == 0)
+                or (t.platformID == 3 and t.platEncID in (1, 10))]
+
+        chars = metrics_to_extract.get(font, {})
+        chars[u"\u0020"] = None  # space
+        chars[u"\u00a0"] = None  # nbsp
+
+        for char, base_char in chars.items():
+            code = ord(char)
+            names = set(t.get(code) for t in cmap)
+            if not names:
+                sys.stderr.write(
+                    "Codepoint {} of font {} maps to no name\n"
+                    .format(code, font))
+                continue
+            if len(names) != 1:
+                sys.stderr.write(
+                    "Codepoint {} of font {} maps to multiple names: {}\n"
+                    .format(code, font, ", ".join(sorted(names))))
+                continue
+            name = names.pop()
+
+            height = depth = italic = skew = width = 0
+            glyph = glyf[name]
+            if glyph.numberOfContours:
+                height = glyph.yMax / unitsPerEm
+                depth = -glyph.yMin / unitsPerEm
+            width = widths[name].width / unitsPerEm
+            if base_char:
+                base_char_str = str(ord(base_char))
+                base_metrics = start_json[font][base_char_str]
+                italic = base_metrics["italic"]
+                skew = base_metrics["skew"]
+                width = base_metrics["width"]
+
+            start_json[font][str(code)] = {
+                "height": height,
+                "depth": depth,
+                "italic": italic,
+                "skew": skew,
+                "width": width
+            }
+
+    sys.stdout.write(
+        json.dumps(start_json, separators=(',', ':'), sort_keys=True))
+
+if __name__ == "__main__":
+    main()

package/plugin/node_modules/katex/src/metrics/format_json.py

@@ -0,0 +1,28 @@
+#!/usr/bin/env python3
+
+import sys
+import json
+
+props = ['depth', 'height', 'italic', 'skew']
+
+if len(sys.argv) > 1:
+    if sys.argv[1] == '--width':
+        props.append('width')
+
+data = json.load(sys.stdin)
+sys.stdout.write(
+  "// This file is GENERATED by buildMetrics.sh. DO NOT MODIFY.\n")
+sep = "export default {\n    "
+for font in sorted(data):
+    sys.stdout.write(sep + json.dumps(font))
+    sep = ": {\n        "
+    for glyph in sorted(data[font], key=int):
+        sys.stdout.write(sep + json.dumps(glyph) + ": ")
+
+        values = [value if value != 0.0 else 0 for value in
+                  [data[font][glyph][key] for key in props]]
+
+        sys.stdout.write(json.dumps(values))
+        sep = ",\n        "
+    sep = ",\n    },\n    "
+sys.stdout.write(",\n    },\n};\n")