@rse/ase 0.0.41 → 0.0.43

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

@@ -1,259 +0,0 @@
-/**
- * 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

@@ -1,23 +0,0 @@
-### 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

@@ -1,114 +0,0 @@
-#!/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

@@ -1,122 +0,0 @@
-#!/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

@@ -1,28 +0,0 @@
-#!/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")