katex 0.12.0 → 0.13.3

package/src/katex.less

@@ -1,8 +1,8 @@
 /* stylelint-disable font-family-no-missing-generic-family-keyword */
-@import "../submodules/katex-fonts/fonts.less";
+@import "fonts.less";
 
 // The mu unit is defined as 1/18 em
-@mu: 1/18em;
+@mu: (1em / 18);
 
 // The version is dynamically set from package.json via webpack.common.js
 @version: "";
@@ -17,20 +17,22 @@
     // Prevent a rendering bug that misplaces \vec in Chrome.
     text-rendering: auto;
 
-    // Insulate fraction bars and rules from CSS that sets border-color.
-    border-color: currentColor;
+    * {
+        // Prevent background resetting on elements in Windows's high-contrast
+        // mode, while still allowing background/foreground setting on root .katex
+        -ms-high-contrast-adjust: none !important;
 
-    // Prevent background resetting on elements in Windows's high-contrast
-    // mode, while still allowing background/foreground setting on root .katex
-    * { -ms-high-contrast-adjust: none !important; }
+        // Insulate fraction bars and rules from CSS that sets border-color.
+        border-color: currentColor;
+    }
 
     .katex-version::after {
         content: @version;
     }
 
     .katex-mathml {
-        // Accessibility hack to only show to screen readers
-        // Found at: http://a11yproject.com/posts/how-to-hide-content/
+        /* Accessibility hack to only show to screen readers
+         Found at: http://a11yproject.com/posts/how-to-hide-content/ */
         position: absolute;
         clip: rect(1px, 1px, 1px, 1px);
         padding: 0;
@@ -161,7 +163,7 @@
     // This value is also used in fontMetrics.js, if you change it make sure the
     // values match.
     @ptperem: 10;
-    @nulldelimiterspace: 1.2em / @ptperem;
+    @nulldelimiterspace: (1.2em / @ptperem);
 
     @muspace: 0.055556em;       // 1mu
     @thinspace: 0.16667em;      // 3mu
@@ -219,17 +221,13 @@
     }
 
     .vbox {
-        display: -ms-inline-flexbox;
         display: inline-flex;
-        -ms-flex-direction: column;
         flex-direction: column;
         align-items: baseline;
     }
 
     .hbox {
-        display: -ms-inline-flexbox;
         display: inline-flex;
-        -ms-flex-direction: row;
         flex-direction: row;
         width: 100%;
     }
@@ -322,8 +320,8 @@
 
     .sqrt {
         > .root {
-            // These values are taken from the definition of `\r@@t`,
-            // `\mkern 5mu` and `\mkern -10mu`.
+            /* These values are taken from the definition of `\r@@t`,
+             `\mkern 5mu` and `\mkern -10mu`. */
             margin-left: 5*@mu;
             margin-right: -10*@mu;
         }
@@ -559,6 +557,10 @@
         padding: 0 0.5em;
     }
 
+    .cd-arrow-pad {
+        padding: 0 0.55556em 0 0.27778em;  // \;{#1}\;\;
+    }
+
     .x-arrow,
     .mover,
     .munder {
@@ -588,6 +590,51 @@
         border-bottom-style: solid;
         border-bottom-width: 0.08em;
     }
+
+    .angl {
+        // from package actuarialangle, which is always used in a subscript.
+        box-sizing: border-content;
+        border-top: 0.049em solid;        // defaultRuleThickness in scriptstyle
+        border-right: 0.049em solid;      // ditto
+        margin-right: 0.03889em;          // 1 mu
+    }
+
+    .anglpad {
+        padding: 0 0.03889em 0 0.03889em; // pad 1mu left and right (in scriptstyle)
+    }
+
+    .eqn-num::before {
+        counter-increment: katexEqnNo;
+        content: "(" counter(katexEqnNo) ")";
+    }
+
+    .mml-eqn-num::before {
+        counter-increment: mmlEqnNo;
+        content: "(" counter(mmlEqnNo) ")";
+    }
+
+    .mtr-glue {
+        width: 50%;
+    }
+
+    .cd-vert-arrow {
+        display: inline-block;
+        position: relative;
+    }
+
+    .cd-label-left {
+        display: inline-block;
+        position: absolute;
+        right: calc(50% + 0.3em);
+        text-align: left;
+    }
+
+    .cd-label-right {
+        display: inline-block;
+        position: absolute;
+        left: calc(50% + 0.3em);
+        text-align: right;
+    }
 }
 
 .katex-display {
@@ -623,3 +670,9 @@
     text-align: left;
     padding-left: 2em;
 }
+
+// Automatic equation numbers for some environments.
+// Use parallel counters for HTML and MathML.
+body {
+    counter-reset: katexEqnNo mmlEqnNo;
+}

package/src/macros.js

@@ -4,7 +4,7 @@
  * This can be used to define some commands in terms of others.
  */
 
-import fontMetricsData from "../submodules/katex-fonts/fontMetricsData";
+import fontMetricsData from "./fontMetricsData";
 import functions from "./functions";
 import symbols from "./symbols";
 import utils from "./utils";
@@ -71,6 +71,12 @@ export interface MacroContextInterface {
      */
     expandMacroAsText(name: string): string | void;
 
+    /**
+     * Consume an argument from the token stream, and return the resulting array
+     * of tokens and start/end token.
+     */
+    consumeArg(delims?: ?string[]): MacroArg;
+
     /**
      * Consume the specified number of arguments from the token stream,
      * and return the resulting array of arguments.
@@ -91,10 +97,17 @@ export interface MacroContextInterface {
     isExpandable(name: string): boolean;
 }
 
+export type MacroArg = {
+    tokens: Token[],
+    start: Token,
+    end: Token
+};
+
 /** Macro tokens (in reverse order). */
 export type MacroExpansion = {
     tokens: Token[],
     numArgs: number,
+    delimiters?: string[][],
     unexpandable?: boolean, // used in \let
 };
 
@@ -240,7 +253,7 @@ defineMacro("\\char", function(context) {
 // \renewcommand{\macro}[args]{definition}
 // TODO: Optional arguments: \newcommand{\macro}[args][default]{definition}
 const newcommand = (context, existsOK: boolean, nonexistsOK: boolean) => {
-    let arg = context.consumeArgs(1)[0];
+    let arg = context.consumeArg().tokens;
     if (arg.length !== 1) {
         throw new ParseError(
             "\\newcommand's first argument must be a macro name");
@@ -258,7 +271,7 @@ const newcommand = (context, existsOK: boolean, nonexistsOK: boolean) => {
     }
 
     let numArgs = 0;
-    arg = context.consumeArgs(1)[0];
+    arg = context.consumeArg().tokens;
     if (arg.length === 1 && arg[0].text === "[") {
         let argText = '';
         let token = context.expandNextToken();
@@ -271,7 +284,7 @@ const newcommand = (context, existsOK: boolean, nonexistsOK: boolean) => {
             throw new ParseError(`Invalid number of arguments: ${argText}`);
         }
         numArgs = parseInt(argText);
-        arg = context.consumeArgs(1)[0];
+        arg = context.consumeArg().tokens;
     }
 
     // Final arg is the expansion of the macro
@@ -314,10 +327,12 @@ defineMacro("\\bgroup", "{");
 defineMacro("\\egroup", "}");
 
 // Symbols from latex.ltx:
+// \def~{\nobreakspace{}}
 // \def\lq{`}
 // \def\rq{'}
 // \def \aa {\r a}
 // \def \AA {\r A}
+defineMacro("~", "\\nobreakspace");
 defineMacro("\\lq", "`");
 defineMacro("\\rq", "'");
 defineMacro("\\aa", "\\r a");
@@ -361,6 +376,12 @@ defineMacro("\\llap", "\\mathllap{\\textrm{#1}}");
 defineMacro("\\rlap", "\\mathrlap{\\textrm{#1}}");
 defineMacro("\\clap", "\\mathclap{\\textrm{#1}}");
 
+// \mathstrut from the TeXbook, p 360
+defineMacro("\\mathstrut", "\\vphantom{(}");
+
+// \underbar from TeXbook p 353
+defineMacro("\\underbar", "\\underline{\\text{#1}}");
+
 // \not is defined by base/fontmath.ltx via
 // \DeclareMathSymbol{\not}{\mathrel}{symbols}{"36}
 // It's thus treated like a \mathrel, but defined by a symbol that has zero
@@ -693,8 +714,10 @@ defineMacro("\\pmb", "\\html@mathml{" +
 //////////////////////////////////////////////////////////////////////
 // LaTeX source2e
 
-// \\ defaults to \newline, but changes to \cr within array environment
-defineMacro("\\\\", "\\newline");
+// \expandafter\let\expandafter\@normalcr
+//     \csname\expandafter\@gobble\string\\ \endcsname
+// \DeclareRobustCommand\newline{\@normalcr\relax}
+defineMacro("\\newline", "\\\\\\relax");
 
 // \def\TeX{T\kern-.1667em\lower.5ex\hbox{E}\kern-.125emX\@}
 // TODO: Doesn't normally work in math mode because \@ fails.  KaTeX doesn't
@@ -839,6 +862,15 @@ defineMacro("\\notni", "\\html@mathml{\\not\\ni}{\\mathrel{\\char`\u220C}}");
 defineMacro("\\limsup", "\\DOTSB\\operatorname*{lim\\,sup}");
 defineMacro("\\liminf", "\\DOTSB\\operatorname*{lim\\,inf}");
 
+//////////////////////////////////////////////////////////////////////
+// From amsopn.sty
+defineMacro("\\injlim", "\\DOTSB\\operatorname*{inj\\,lim}");
+defineMacro("\\projlim", "\\DOTSB\\operatorname*{proj\\,lim}");
+defineMacro("\\varlimsup", "\\DOTSB\\operatorname*{\\overline{lim}}");
+defineMacro("\\varliminf", "\\DOTSB\\operatorname*{\\underline{lim}}");
+defineMacro("\\varinjlim", "\\DOTSB\\operatorname*{\\underrightarrow{lim}}");
+defineMacro("\\varprojlim", "\\DOTSB\\operatorname*{\\underleftarrow{lim}}");
+
 //////////////////////////////////////////////////////////////////////
 // MathML alternates for KaTeX glyphs in the Unicode private area
 defineMacro("\\gvertneqq", "\\html@mathml{\\@gvertneqq}{\u2269}");
@@ -987,6 +1019,10 @@ defineMacro("\\braket", "\\mathinner{\\langle{#1}\\rangle}");
 defineMacro("\\Bra", "\\left\\langle#1\\right|");
 defineMacro("\\Ket", "\\left|#1\\right\\rangle");
 
+//////////////////////////////////////////////////////////////////////
+// actuarialangle.dtx
+defineMacro("\\angln", "{\\angl n}");
+
 // Custom Khan Academy colors, should be moved to an optional package
 defineMacro("\\blue", "\\textcolor{##6495ed}{#1}");
 defineMacro("\\orange", "\\textcolor{##ffa500}{#1}");

package/src/mathMLTree.js

@@ -11,6 +11,7 @@
 
 import utils from "./utils";
 import {DocumentFragment} from "./tree";
+import {createClass} from "./domTree";
 
 import type {VirtualNode} from "./tree";
 
@@ -47,11 +48,17 @@ export class MathNode implements MathDomNode {
     type: MathNodeType;
     attributes: {[string]: string};
     children: $ReadOnlyArray<MathDomNode>;
+    classes: string[];
 
-    constructor(type: MathNodeType, children?: $ReadOnlyArray<MathDomNode>) {
+    constructor(
+        type: MathNodeType,
+        children?: $ReadOnlyArray<MathDomNode>,
+        classes?: string[]
+    ) {
         this.type = type;
         this.attributes = {};
         this.children = children || [];
+        this.classes = classes || [];
     }
 
     /**
@@ -82,6 +89,10 @@ export class MathNode implements MathDomNode {
             }
         }
 
+        if (this.classes.length > 0) {
+            node.className = createClass(this.classes);
+        }
+
         for (let i = 0; i < this.children.length; i++) {
             node.appendChild(this.children[i].toNode());
         }
@@ -104,6 +115,10 @@ export class MathNode implements MathDomNode {
             }
         }
 
+        if (this.classes.length > 0) {
+            markup += ` class ="${utils.escape(createClass(this.classes))}"`;
+        }
+
         markup += ">";
 
         for (let i = 0; i < this.children.length; i++) {

package/src/metrics/.gitignore

@@ -0,0 +1 @@
+*.pyc

package/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 ./docker/fonts/buildMetrics.sh
+
+which should generate new metrics and place them into `fontMetricsData.json`.
+You're done!

package/src/metrics/extract_tfms.py

@@ -0,0 +1,114 @@
+#!/usr/bin/env python
+
+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.iteritems():
+        for char, char_data in chars.iteritems():
+            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/src/metrics/extract_ttfs.py

@@ -0,0 +1,119 @@
+#!/usr/bin/env python
+
+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
+    },
+    "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.iteritems():
+            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/src/metrics/format_json.py

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