katex 0.12.0 → 0.13.3

package/src/fonts/xbbold.mf

@@ -0,0 +1,182 @@
+%% filename: xbbold.mf
+%% version: 2.2
+%% date: 1995/01/04
+%%
+%% (katex-fonts) The line 69 is modified to prevent overflow
+%%
+%% American Mathematical Society
+%% Technical Support
+%% Publications Technical Group
+%% 201 Charles Street
+%% Providence, RI 02904
+%% USA
+%% tel: (401) 455-4080
+%%      (800) 321-4267 (USA and Canada only)
+%% fax: (401) 331-3842
+%% email: tech-support@ams.org
+%%
+%% Copyright 1995, 2009 American Mathematical Society.
+%%
+%% This Font Software is licensed under the SIL Open Font License,
+%% Version 1.1.  This license is in the accompanying file OFL.txt, and
+%% is also available with a FAQ at: http://scripts.sil.org/OFL.
+%%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+% Changes of minimal parameters in outlined characters for version 2.1
+% done by Stefan Lindner, 18-April-1991
+
+input xbbase;
+%%mode_setup; %called by amsyb.mf; two calls confuse Metafont. NGB 15-OCT-1991
+
+%%%%designsize:= font_size;                 %  was 10pt#;
+width#:=     designsize;                 %  was 10pt#;
+unit#:=      width#/18;
+u#:=         width#/54;
+smallu#:=    width#/162;
+ascender#:=  37/3*unit#;
+cap#:=       37/3*unit#;
+number#:=    36/3*unit#;
+xheight#:=   25/3*unit#;
+descender#:= 12/4*unit#;
+define_whole_vertical_pixels
+  (width,unit,u,smallu,ascender,cap,number,xheight,descender);
+wpix(1.90u) (linethickness);
+wpix(0.65u) (Sover_bot);
+wpix(1.00u) (Aapex,Napex,Vapex,Wapex,Cover,Gover,Oover,Sover_top,Uover);
+wpix(9.00u) (Uthin_bracket);
+wpix(8.00u) (Kthin_diag_bracket,Xthin_diag_bracket,Ythin_diag_bracket);
+wpix(7.00u) (k_thin_diag);
+wpix(6.00u) (c_thin_stem_bracket);
+wpix(5.00u) (c_thick_stem_bracket,c_inner_bracket,lc_thick_stem_bracket);
+wpix(4.00u) (c_round_bracket);
+adjpix(1.35u) (serif_thickness);
+adjpix(1.30u) (Emid_tip,inbeak);
+adjpix(1.50u) (Atip,Btopthin,Bmidthin,Ebot_tip,Ltip,Mapex,
+               Ntip,Ttip,Vtip,Wtip,Ztip,outbeak);
+adjpix(1.65u) (Bbotthin,Gbotthin,Stopthin);
+adjpix(1.75u) (Dtopthin,Ebotarm,Lthin,Tthin);
+adjpix(1.80u) (Abar,Ctopthin,Dbotthin,Gtopthin,Jbotthin,Pmidarm,Sbotthin);
+adjpix(1.90u) (Emidarm,Etoparm,Othin,Pthin,Rthin,Ydiag,Zthin);
+adjpix(2.00u) (kthin,Mthin_diag,Wleftthin);
+adjpix(2.10u) (Ctip);
+adjpix(2.25u) (Athin,Kthin,Mthin_vert,Nthin,Uthin,Vthin,Wrightthin,Xthin);
+adjpix(2.50u) (Hbar);
+adjpix(2.60u) (Cbotthin);
+
+
+%%%% Begin of changes for version 2.1
+%(katex-fonts) Originally was pixels_per_inch*designsize < 1500:
+if pixels_per_inch < 1500/designsize:
+   if pixels_per_inch*designsize < 1000:
+      if pixels_per_inch*designsize < 800:
+         if pixels_per_inch*designsize < 700:
+            minadjpix(0)(8.80u) (stem);
+            minadjpix(0)(6.80u) (kdiag);
+            minadjpix(0)(7.40u) (kstem);
+            minadjpix(0)(7.80u) (Jbulb,Mdiag);
+            minadjpix(0)(8.20u) (Kdiag);
+            minadjpix(0)(8.30u) (Gstem,Mstem);
+            minadjpix(0)(8.60u) (Lstem,Ustem,Ythick_diag);
+            minadjpix(0)(8.50u) (Bstem,Estem,Fstem,Ndiag,Rdiag,Xdiag,Zdiag);
+            minadjpix(0)(8.90u) (Btopcurve);
+            minadjpix(1)(9.30u) (Bbotcurve,Pcurve,Rcurve);
+            minadjpix(1)(9.50u) (Ccurve,Dcurve,Gcurve,Ocurve);
+         else:
+            minadjpix(1)(8.80u) (stem);
+            minadjpix(1)(6.80u) (kdiag);
+            minadjpix(1)(7.40u) (kstem);
+            minadjpix(1)(7.80u) (Jbulb,Mdiag);
+            minadjpix(1)(8.20u) (Kdiag);
+            minadjpix(1)(8.30u) (Gstem,Mstem);
+            minadjpix(1)(8.60u) (Lstem,Ustem,Ythick_diag);
+            minadjpix(1)(8.50u) (Bstem,Estem,Fstem,Ndiag,Rdiag,Xdiag,Zdiag);
+            minadjpix(1)(8.90u) (Btopcurve);
+            minadjpix(2)(9.30u) (Bbotcurve,Pcurve,Rcurve);
+            minadjpix(2)(9.50u) (Ccurve,Dcurve,Gcurve,Ocurve);
+         fi
+      else:
+         adjpix(3.0u) (Mapex);
+         minadjpix(1)(8.80u) (stem);
+         minadjpix(2)(6.80u) (kdiag);
+         minadjpix(2)(7.40u) (kstem);
+         minadjpix(2)(7.80u) (Jbulb);
+         minadjpix(1)(6.00u) (Mdiag);
+         minadjpix(2)(8.20u) (Kdiag);
+         minadjpix(2)(8.30u) (Gstem)
+         minadjpix(2)(8.30u) (Mstem);
+         minadjpix(2)(8.60u) (Lstem,Ustem,Ythick_diag);
+         minadjpix(2)(8.50u) (Bstem,Ndiag,Rdiag,Xdiag,Zdiag);
+         minadjpix(1)(8.50u) (Estem, Fstem);
+         minadjpix(2)(8.90u) (Btopcurve);
+         minadjpix(3)(9.30u) (Bbotcurve,Pcurve,Rcurve);
+         minadjpix(3)(9.50u) (Ccurve,Dcurve,Gcurve,Ocurve);
+      fi
+   else:
+      adjpix(3.0u) (Mapex);
+      minadjpix(2)(8.80u) (stem);
+      minadjpix(3)(6.80u) (kdiag);
+      minadjpix(3)(7.40u) (kstem);
+      minadjpix(3)(7.80u) (Jbulb);
+      minadjpix(1)(5.00u) (Mdiag);
+      minadjpix(3)(8.20u) (Kdiag);
+      minadjpix(3)(8.30u) (Gstem);
+      minadjpix(2)(8.30u) (Mstem);
+      minadjpix(3)(8.60u) (Lstem,Ustem,Ythick_diag);
+      minadjpix(3)(8.50u) (Estem,Fstem,Ndiag,Rdiag,Xdiag,Zdiag);
+      minadjpix(2)(8.50u) (Bstem);
+      minadjpix(3)(8.90u) (Btopcurve);
+      minadjpix(3)(9.30u) (Bbotcurve,Pcurve,Rcurve);
+      minadjpix(3)(9.50u) (Ccurve,Dcurve,Gcurve,Ocurve)
+   fi
+else:
+   minadjpix(4)(8.80u) (stem);
+   minadjpix(4)(6.80u) (kdiag);
+   minadjpix(4)(7.40u) (kstem);
+   minadjpix(4)(7.80u) (Jbulb,Mdiag);
+   minadjpix(4)(8.20u) (Kdiag);
+   minadjpix(4)(8.30u) (Gstem,Mstem);
+   minadjpix(4)(8.60u) (Lstem,Ustem,Ythick_diag);
+   minadjpix(4)(8.50u) (Bstem,Estem,Fstem,Ndiag,Rdiag,Xdiag,Zdiag);
+   minadjpix(4)(8.90u) (Btopcurve);
+   minadjpix(5)(9.30u) (Bbotcurve,Pcurve,Rcurve);
+   minadjpix(5)(9.50u) (Ccurve,Dcurve,Gcurve,Ocurve)
+fi;
+%%%% end of changes for version 2.1
+
+boolean lowres; lowres:=width<50;
+highres_lowres(pullin)    (.85)(1);  % Emidarm
+highres_lowres(pulleven)  (1)(1.3);  % Etoparm,Tarms,Zarms
+highres_lowres(pullout)   (1.1)(1);  % Ebotarm,Lbotarm
+highres_lowres(bracket0)  (.0)(0);   % Ntopleft
+highres_lowres(bracket3)  (.3)(0);   % Nthinstems
+highres_lowres(bracket01) (.0)(.1);  % Uthin
+highres_lowres(bracket32) (.3)(.2);  % Vstems
+highres_lowres(bracket4)  (.4)(0);   % P-all,R-all,I-all,F-all
+highres_lowres(bracket42) (.4)(.2);  % Xdiag
+
+bool(ctrls):=false;
+entasis:=inlimit(0)(0,1);
+serif_constant_amt:=0pt;
+join_radius:=1;
+bool(softpath):=true;
+
+c_thick_stem_bracket:=min(.5cap-eps,c_thick_stem_bracket);
+rulepen:=pensquare scaled 1;
+extra_beginchar:=extra_beginchar&"save t,p,ref; path p[],p[]',p[]'',ref[];";
+extra_beginchar:=extra_beginchar&"pickup pencircle scaled linethickness;";
+
+for x:="R":
+ wanted[byte x]:=true; endfor                    % test these characters
+ let iff=always_iff;                             % tests all chars in the file
+
+font_normal_space .3width#;         % TeX fontdimen 2 normal word space
+font_normal_stretch .15width#;      % TeX fontdimen 3 interword stretch
+font_normal_shrink .1width#;        % TeX fontdimen 4 interword shrink
+font_x_height xheight#;             % Tex fontdinem 5 for accents
+font_quad width#;                   % TeX fontdimen 6 quad width
+font_extra_space .1width#;          % TeX fontdimen 7 extra space(period)
+
+
+input xbcaps
+bye                                 % changed from "end" 26 Aug 93; bnb

package/src/fonts.less

@@ -0,0 +1,64 @@
+@font-folder: "../fonts";
+@use-ttf: true;
+@use-woff: true;
+@use-woff2: true;
+
+.use-woff2(@family, @family-suffix) when (@use-woff2 = true) {
+    src+: url('@{font-folder}/KaTeX_@{family}-@{family-suffix}.woff2') format('woff2')
+}
+
+.use-woff(@family, @family-suffix) when (@use-woff = true) {
+    src+: url('@{font-folder}/KaTeX_@{family}-@{family-suffix}.woff') format('woff')
+}
+
+.use-ttf(@family, @family-suffix) when (@use-ttf = true) {
+    src+: url('@{font-folder}/KaTeX_@{family}-@{family-suffix}.ttf') format('truetype')
+}
+
+.generate-suffix(@weight, @style) when (@weight = normal) and (@style = normal) {
+    @suffix: 'Regular';
+}
+.generate-suffix(@weight, @style) when (@weight = normal) and (@style = italic) {
+    @suffix: 'Italic';
+}
+.generate-suffix(@weight, @style) when (@weight = bold) and (@style = normal) {
+    @suffix: 'Bold';
+}
+.generate-suffix(@weight, @style) when (@weight = bold) and (@style = italic) {
+    @suffix: 'BoldItalic';
+}
+
+.font-face(@family, @weight, @style) {
+    .generate-suffix(@weight, @style);
+    @font-face {
+        font-family: 'KaTeX_@{family}';
+        .use-woff2(@family, @suffix);
+        .use-woff(@family, @suffix);
+        .use-ttf(@family, @suffix);
+        font-weight: @weight;
+        font-style: @style;
+    }
+}
+
+.font-face('AMS', normal, normal);
+.font-face('Caligraphic', bold, normal);
+.font-face('Caligraphic', normal, normal);
+.font-face('Fraktur', bold, normal);
+.font-face('Fraktur', normal, normal);
+.font-face('Main', bold, normal);
+.font-face('Main', bold, italic);
+.font-face('Main', normal, italic);
+.font-face('Main', normal, normal);
+//.font-face('Math', bold, normal);
+.font-face('Math', bold, italic);
+.font-face('Math', normal, italic);
+//.font-face('Math', normal, normal);
+.font-face('SansSerif', bold, normal);
+.font-face('SansSerif', normal, italic);
+.font-face('SansSerif', normal, normal);
+.font-face('Script', normal, normal);
+.font-face('Size1', normal, normal);
+.font-face('Size2', normal, normal);
+.font-face('Size3', normal, normal);
+.font-face('Size4', normal, normal);
+.font-face('Typewriter', normal, normal);

package/src/functions/accent.js

@@ -1,5 +1,5 @@
 // @flow
-import defineFunction from "../defineFunction";
+import defineFunction, {normalizeArgument} from "../defineFunction";
 import buildCommon from "../buildCommon";
 import mathMLTree from "../mathMLTree";
 import utils from "../utils";
@@ -218,7 +218,7 @@ defineFunction({
         numArgs: 1,
     },
     handler: (context, args) => {
-        const base = args[0];
+        const base = normalizeArgument(args[0]);
 
         const isStretchy = !NON_STRETCHY_ACCENT_REGEX.test(context.funcName);
         const isShifty = !isStretchy ||
@@ -250,6 +250,7 @@ defineFunction({
         numArgs: 1,
         allowedInText: true,
         allowedInMath: false,
+        argTypes: ["primitive"],
     },
     handler: (context, args) => {
         const base = args[0];

package/src/functions/arrow.js

@@ -30,6 +30,8 @@ defineFunction({
         // The next 3 functions are here to support the mhchem extension.
         // Direct use of these functions is discouraged and may break someday.
         "\\xrightleftarrows", "\\xrightequilibrium", "\\xleftequilibrium",
+        // The next 3 functions are here only to support the {CD} environment.
+        "\\\\cdrightarrow", "\\\\cdleftarrow", "\\\\cdlongequal",
     ],
     props: {
         numArgs: 1,
@@ -57,7 +59,8 @@ defineFunction({
         let newOptions = options.havingStyle(style.sup());
         const upperGroup = buildCommon.wrapFragment(
             html.buildGroup(group.body, newOptions, options), options);
-        upperGroup.classes.push("x-arrow-pad");
+        const arrowPrefix = group.label.slice(0, 2) === "\\x" ? "x" : "cd";
+        upperGroup.classes.push(arrowPrefix + "-arrow-pad");
 
         let lowerGroup;
         if (group.below) {
@@ -65,7 +68,7 @@ defineFunction({
             newOptions = options.havingStyle(style.sub());
             lowerGroup = buildCommon.wrapFragment(
                 html.buildGroup(group.below, newOptions, options), options);
-            lowerGroup.classes.push("x-arrow-pad");
+            lowerGroup.classes.push(arrowPrefix + "-arrow-pad");
         }
 
         const arrowBody = stretchy.svgSpan(group, options);
@@ -112,6 +115,9 @@ defineFunction({
     },
     mathmlBuilder(group, options) {
         const arrowNode = stretchy.mathMLnode(group.label);
+        arrowNode.setAttribute(
+            "minsize", group.label.charAt(0) === "x" ? "1.75em" : "3.0em"
+        );
         let node;
 
         if (group.body) {

package/src/functions/color.js

@@ -4,6 +4,8 @@ import buildCommon from "../buildCommon";
 import mathMLTree from "../mathMLTree";
 import {assertNodeType} from "../parseNode";
 
+import type {AnyParseNode} from '../parseNode';
+
 import * as html from "../buildHTML";
 import * as mml from "../buildMathML";
 
@@ -38,7 +40,6 @@ defineFunction({
     props: {
         numArgs: 2,
         allowedInText: true,
-        greediness: 3,
         argTypes: ["color", "original"],
     },
     handler({parser}, args) {
@@ -48,7 +49,7 @@ defineFunction({
             type: "color",
             mode: parser.mode,
             color,
-            body: ordargument(body),
+            body: (ordargument(body): AnyParseNode[]),
         };
     },
     htmlBuilder,
@@ -61,7 +62,6 @@ defineFunction({
     props: {
         numArgs: 1,
         allowedInText: true,
-        greediness: 3,
         argTypes: ["color"],
     },
     handler({parser, breakOnTokenText}, args) {
@@ -74,7 +74,7 @@ defineFunction({
         parser.gullet.macros.set("\\current@color", color);
 
         // Parse out the implicit body that should be colored.
-        const body = parser.parseExpression(true, breakOnTokenText);
+        const body: AnyParseNode[] = parser.parseExpression(true, breakOnTokenText);
 
         return {
             type: "color",

package/src/functions/cr.js

@@ -5,17 +5,12 @@ import defineFunction from "../defineFunction";
 import buildCommon from "../buildCommon";
 import mathMLTree from "../mathMLTree";
 import {calculateSize} from "../units";
-import ParseError from "../ParseError";
 import {assertNodeType} from "../parseNode";
 
-// \\ is a macro mapping to either \cr or \newline.  Because they have the
-// same signature, we implement them as one megafunction, with newRow
-// indicating whether we're in the \cr case, and newLine indicating whether
-// to break the line in the \newline case.
-
+// \DeclareRobustCommand\\{...\@xnewline}
 defineFunction({
     type: "cr",
-    names: ["\\cr", "\\newline"],
+    names: ["\\\\"],
     props: {
         numArgs: 0,
         numOptionalArgs: 1,
@@ -23,25 +18,16 @@ defineFunction({
         allowedInText: true,
     },
 
-    handler({parser, funcName}, args, optArgs) {
+    handler({parser}, args, optArgs) {
         const size = optArgs[0];
-        const newRow = (funcName === "\\cr");
-        let newLine = false;
-        if (!newRow) {
-            if (parser.settings.displayMode &&
-                parser.settings.useStrictBehavior(
-                    "newLineInDisplayMode", "In LaTeX, \\\\ or \\newline " +
-                    "does nothing in display mode")) {
-                newLine = false;
-            } else {
-                newLine = true;
-            }
-        }
+        const newLine = !parser.settings.displayMode ||
+            !parser.settings.useStrictBehavior(
+                "newLineInDisplayMode", "In LaTeX, \\\\ or \\newline " +
+                "does nothing in display mode");
         return {
             type: "cr",
             mode: parser.mode,
             newLine,
-            newRow,
             size: size && assertNodeType(size, "size").value,
         };
     },
@@ -50,10 +36,6 @@ defineFunction({
     // not within tabular/array environments.
 
     htmlBuilder(group, options) {
-        if (group.newRow) {
-            throw new ParseError(
-                "\\cr valid only within a tabular/array environment");
-        }
         const span = buildCommon.makeSpan(["mspace"], [], options);
         if (group.newLine) {
             span.classes.push("newline");

package/src/functions/def.js

@@ -88,41 +88,65 @@ defineFunction({
     props: {
         numArgs: 0,
         allowedInText: true,
+        primitive: true,
     },
     handler({parser, funcName}) {
-        let arg = parser.gullet.consumeArgs(1)[0];
-        if (arg.length !== 1) {
-            throw new ParseError("\\gdef's first argument must be a macro name");
+        let tok = parser.gullet.popToken();
+        const name = tok.text;
+        if (/^(?:[\\{}$&#^_]|EOF)$/.test(name)) {
+            throw new ParseError("Expected a control sequence", tok);
         }
-        const name = arg[0].text;
-        // Count argument specifiers, and check they are in the order #1 #2 ...
+
         let numArgs = 0;
-        arg = parser.gullet.consumeArgs(1)[0];
-        while (arg.length === 1 && arg[0].text === "#") {
-            arg = parser.gullet.consumeArgs(1)[0];
-            if (arg.length !== 1) {
-                throw new ParseError(
-                    `Invalid argument number length "${arg.length}"`);
-            }
-            if (!(/^[1-9]$/.test(arg[0].text))) {
-                throw new ParseError(
-                    `Invalid argument number "${arg[0].text}"`);
-            }
-            numArgs++;
-            if (parseInt(arg[0].text) !== numArgs) {
-                throw new ParseError(
-                    `Argument number "${arg[0].text}" out of order`);
+        let insert;
+        const delimiters = [[]];
+        // <parameter text> contains no braces
+        while (parser.gullet.future().text !== "{") {
+            tok = parser.gullet.popToken();
+            if (tok.text === "#") {
+                // If the very last character of the <parameter text> is #, so that
+                // this # is immediately followed by {, TeX will behave as if the {
+                // had been inserted at the right end of both the parameter text
+                // and the replacement text.
+                if (parser.gullet.future().text === "{") {
+                    insert = parser.gullet.future();
+                    delimiters[numArgs].push("{");
+                    break;
+                }
+
+                // A parameter, the first appearance of # must be followed by 1,
+                // the next by 2, and so on; up to nine #’s are allowed
+                tok = parser.gullet.popToken();
+                if (!(/^[1-9]$/.test(tok.text))) {
+                    throw new ParseError(`Invalid argument number "${tok.text}"`);
+                }
+                if (parseInt(tok.text) !== numArgs + 1) {
+                    throw new ParseError(
+                        `Argument number "${tok.text}" out of order`);
+                }
+                numArgs++;
+                delimiters.push([]);
+            } else if (tok.text === "EOF") {
+                throw new ParseError("Expected a macro definition");
+            } else {
+                delimiters[numArgs].push(tok.text);
             }
-            arg = parser.gullet.consumeArgs(1)[0];
         }
+        // replacement text, enclosed in '{' and '}' and properly nested
+        let {tokens} = parser.gullet.consumeArg();
+        if (insert) {
+            tokens.unshift(insert);
+        }
+
         if (funcName === "\\edef" || funcName === "\\xdef") {
-            arg = parser.gullet.expandTokens(arg);
-            arg.reverse(); // to fit in with stack order
+            tokens = parser.gullet.expandTokens(tokens);
+            tokens.reverse(); // to fit in with stack order
         }
         // Final arg is the expansion of the macro
         parser.gullet.macros.set(name, {
-            tokens: arg,
+            tokens,
             numArgs,
+            delimiters,
         }, funcName === globalMap[funcName]);
 
         return {
@@ -145,6 +169,7 @@ defineFunction({
     props: {
         numArgs: 0,
         allowedInText: true,
+        primitive: true,
     },
     handler({parser, funcName}) {
         const name = checkControlSequence(parser.gullet.popToken());
@@ -168,6 +193,7 @@ defineFunction({
     props: {
         numArgs: 0,
         allowedInText: true,
+        primitive: true,
     },
     handler({parser, funcName}) {
         const name = checkControlSequence(parser.gullet.popToken());

package/src/functions/delimsizing.js

@@ -81,6 +81,7 @@ defineFunction({
     ],
     props: {
         numArgs: 1,
+        argTypes: ["primitive"],
     },
     handler: (context, args) => {
         const delim = checkDelimiter(args[0], context);
@@ -124,6 +125,10 @@ defineFunction({
             node.setAttribute("fence", "false");
         }
 
+        node.setAttribute("stretchy", "true");
+        node.setAttribute("minsize", delimiter.sizeToMaxHeight[group.size] + "em");
+        node.setAttribute("maxsize", delimiter.sizeToMaxHeight[group.size] + "em");
+
         return node;
     },
 });
@@ -141,6 +146,7 @@ defineFunction({
     names: ["\\right"],
     props: {
         numArgs: 1,
+        primitive: true,
     },
     handler: (context, args) => {
         // \left case below triggers parsing of \right in
@@ -166,6 +172,7 @@ defineFunction({
     names: ["\\left"],
     props: {
         numArgs: 1,
+        primitive: true,
     },
     handler: (context, args) => {
         const delim = checkDelimiter(args[0], context);
@@ -299,6 +306,7 @@ defineFunction({
     names: ["\\middle"],
     props: {
         numArgs: 1,
+        primitive: true,
     },
     handler: (context, args) => {
         const delim = checkDelimiter(args[0], context);