. Since they don't, we\n // need to rewrite the way this function is called.\n }\n});\n// CONCATENATED MODULE: ./src/functions/text.js\n\n\n\n // Non-mathy text, possibly in a font\n\nvar textFontFamilies = {\n \"\\\\text\": undefined,\n \"\\\\textrm\": \"textrm\",\n \"\\\\textsf\": \"textsf\",\n \"\\\\texttt\": \"texttt\",\n \"\\\\textnormal\": \"textrm\"\n};\nvar textFontWeights = {\n \"\\\\textbf\": \"textbf\",\n \"\\\\textmd\": \"textmd\"\n};\nvar textFontShapes = {\n \"\\\\textit\": \"textit\",\n \"\\\\textup\": \"textup\"\n};\n\nvar optionsWithFont = function optionsWithFont(group, options) {\n var font = group.font; // Checks if the argument is a font family or a font style.\n\n if (!font) {\n return options;\n } else if (textFontFamilies[font]) {\n return options.withTextFontFamily(textFontFamilies[font]);\n } else if (textFontWeights[font]) {\n return options.withTextFontWeight(textFontWeights[font]);\n } else {\n return options.withTextFontShape(textFontShapes[font]);\n }\n};\n\ndefineFunction({\n type: \"text\",\n names: [// Font families\n \"\\\\text\", \"\\\\textrm\", \"\\\\textsf\", \"\\\\texttt\", \"\\\\textnormal\", // Font weights\n \"\\\\textbf\", \"\\\\textmd\", // Font Shapes\n \"\\\\textit\", \"\\\\textup\"],\n props: {\n numArgs: 1,\n argTypes: [\"text\"],\n greediness: 2,\n allowedInText: true\n },\n handler: function handler(_ref, args) {\n var parser = _ref.parser,\n funcName = _ref.funcName;\n var body = args[0];\n return {\n type: \"text\",\n mode: parser.mode,\n body: defineFunction_ordargument(body),\n font: funcName\n };\n },\n htmlBuilder: function htmlBuilder(group, options) {\n var newOptions = optionsWithFont(group, options);\n var inner = buildHTML_buildExpression(group.body, newOptions, true);\n return buildCommon.makeSpan([\"mord\", \"text\"], buildCommon.tryCombineChars(inner), newOptions);\n },\n mathmlBuilder: function mathmlBuilder(group, options) {\n var newOptions = optionsWithFont(group, options);\n return buildExpressionRow(group.body, newOptions);\n }\n});\n// CONCATENATED MODULE: ./src/functions/underline.js\n\n\n\n\n\ndefineFunction({\n type: \"underline\",\n names: [\"\\\\underline\"],\n props: {\n numArgs: 1,\n allowedInText: true\n },\n handler: function handler(_ref, args) {\n var parser = _ref.parser;\n return {\n type: \"underline\",\n mode: parser.mode,\n body: args[0]\n };\n },\n htmlBuilder: function htmlBuilder(group, options) {\n // Underlines are handled in the TeXbook pg 443, Rule 10.\n // Build the inner group.\n var innerGroup = buildHTML_buildGroup(group.body, options); // Create the line to go below the body\n\n var line = buildCommon.makeLineSpan(\"underline-line\", options); // Generate the vlist, with the appropriate kerns\n\n var defaultRuleThickness = options.fontMetrics().defaultRuleThickness;\n var vlist = buildCommon.makeVList({\n positionType: \"top\",\n positionData: innerGroup.height,\n children: [{\n type: \"kern\",\n size: defaultRuleThickness\n }, {\n type: \"elem\",\n elem: line\n }, {\n type: \"kern\",\n size: 3 * defaultRuleThickness\n }, {\n type: \"elem\",\n elem: innerGroup\n }]\n }, options);\n return buildCommon.makeSpan([\"mord\", \"underline\"], [vlist], options);\n },\n mathmlBuilder: function mathmlBuilder(group, options) {\n var operator = new mathMLTree.MathNode(\"mo\", [new mathMLTree.TextNode(\"\\u203E\")]);\n operator.setAttribute(\"stretchy\", \"true\");\n var node = new mathMLTree.MathNode(\"munder\", [buildMathML_buildGroup(group.body, options), operator]);\n node.setAttribute(\"accentunder\", \"true\");\n return node;\n }\n});\n// CONCATENATED MODULE: ./src/functions/verb.js\n\n\n\n\ndefineFunction({\n type: \"verb\",\n names: [\"\\\\verb\"],\n props: {\n numArgs: 0,\n allowedInText: true\n },\n handler: function handler(context, args, optArgs) {\n // \\verb and \\verb* are dealt with directly in Parser.js.\n // If we end up here, it's because of a failure to match the two delimiters\n // in the regex in Lexer.js. LaTeX raises the following error when \\verb is\n // terminated by end of line (or file).\n throw new src_ParseError(\"\\\\verb ended by end of line instead of matching delimiter\");\n },\n htmlBuilder: function htmlBuilder(group, options) {\n var text = makeVerb(group);\n var body = []; // \\verb enters text mode and therefore is sized like \\textstyle\n\n var newOptions = options.havingStyle(options.style.text());\n\n for (var i = 0; i < text.length; i++) {\n var c = text[i];\n\n if (c === '~') {\n c = '\\\\textasciitilde';\n }\n\n body.push(buildCommon.makeSymbol(c, \"Typewriter-Regular\", group.mode, newOptions, [\"mord\", \"texttt\"]));\n }\n\n return buildCommon.makeSpan([\"mord\", \"text\"].concat(newOptions.sizingClasses(options)), buildCommon.tryCombineChars(body), newOptions);\n },\n mathmlBuilder: function mathmlBuilder(group, options) {\n var text = new mathMLTree.TextNode(makeVerb(group));\n var node = new mathMLTree.MathNode(\"mtext\", [text]);\n node.setAttribute(\"mathvariant\", \"monospace\");\n return node;\n }\n});\n/**\n * Converts verb group into body string.\n *\n * \\verb* replaces each space with an open box \\u2423\n * \\verb replaces each space with a no-break space \\xA0\n */\n\nvar makeVerb = function makeVerb(group) {\n return group.body.replace(/ /g, group.star ? \"\\u2423\" : '\\xA0');\n};\n// CONCATENATED MODULE: ./src/functions.js\n/** Include this to ensure that all functions are defined. */\n\nvar functions = _functions;\n/* harmony default export */ var src_functions = (functions); // TODO(kevinb): have functions return an object and call defineFunction with\n// that object in this file instead of relying on side-effects.\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n// CONCATENATED MODULE: ./src/Lexer.js\n/**\n * The Lexer class handles tokenizing the input in various ways. Since our\n * parser expects us to be able to backtrack, the lexer allows lexing from any\n * given starting point.\n *\n * Its main exposed function is the `lex` function, which takes a position to\n * lex from and a type of token to lex. It defers to the appropriate `_innerLex`\n * function.\n *\n * The various `_innerLex` functions perform the actual lexing of different\n * kinds.\n */\n\n\n\n\n/* The following tokenRegex\n * - matches typical whitespace (but not NBSP etc.) using its first group\n * - does not match any control character \\x00-\\x1f except whitespace\n * - does not match a bare backslash\n * - matches any ASCII character except those just mentioned\n * - does not match the BMP private use area \\uE000-\\uF8FF\n * - does not match bare surrogate code units\n * - matches any BMP character except for those just described\n * - matches any valid Unicode surrogate pair\n * - matches a backslash followed by one or more letters\n * - matches a backslash followed by any BMP character, including newline\n * Just because the Lexer matches something doesn't mean it's valid input:\n * If there is no matching function or symbol definition, the Parser will\n * still reject the input.\n */\nvar spaceRegexString = \"[ \\r\\n\\t]\";\nvar controlWordRegexString = \"\\\\\\\\[a-zA-Z@]+\";\nvar controlSymbolRegexString = \"\\\\\\\\[^\\uD800-\\uDFFF]\";\nvar controlWordWhitespaceRegexString = \"\" + controlWordRegexString + spaceRegexString + \"*\";\nvar controlWordWhitespaceRegex = new RegExp(\"^(\" + controlWordRegexString + \")\" + spaceRegexString + \"*$\");\nvar combiningDiacriticalMarkString = \"[\\u0300-\\u036F]\";\nvar combiningDiacriticalMarksEndRegex = new RegExp(combiningDiacriticalMarkString + \"+$\");\nvar tokenRegexString = \"(\" + spaceRegexString + \"+)|\" + // whitespace\n\"([!-\\\\[\\\\]-\\u2027\\u202A-\\uD7FF\\uF900-\\uFFFF]\" + ( // single codepoint\ncombiningDiacriticalMarkString + \"*\") + // ...plus accents\n\"|[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]\" + ( // surrogate pair\ncombiningDiacriticalMarkString + \"*\") + // ...plus accents\n\"|\\\\\\\\verb\\\\*([^]).*?\\\\3\" + // \\verb*\n\"|\\\\\\\\verb([^*a-zA-Z]).*?\\\\4\" + // \\verb unstarred\n\"|\\\\\\\\operatorname\\\\*\" + ( // \\operatorname*\n\"|\" + controlWordWhitespaceRegexString) + ( // \\macroName + spaces\n\"|\" + controlSymbolRegexString + \")\"); // \\\\, \\', etc.\n\n/** Main Lexer class */\n\nvar Lexer_Lexer =\n/*#__PURE__*/\nfunction () {\n // category codes, only supports comment characters (14) for now\n function Lexer(input, settings) {\n this.input = void 0;\n this.settings = void 0;\n this.tokenRegex = void 0;\n this.catcodes = void 0;\n // Separate accents from characters\n this.input = input;\n this.settings = settings;\n this.tokenRegex = new RegExp(tokenRegexString, 'g');\n this.catcodes = {\n \"%\": 14 // comment character\n\n };\n }\n\n var _proto = Lexer.prototype;\n\n _proto.setCatcode = function setCatcode(char, code) {\n this.catcodes[char] = code;\n }\n /**\n * This function lexes a single token.\n */\n ;\n\n _proto.lex = function lex() {\n var input = this.input;\n var pos = this.tokenRegex.lastIndex;\n\n if (pos === input.length) {\n return new Token_Token(\"EOF\", new SourceLocation(this, pos, pos));\n }\n\n var match = this.tokenRegex.exec(input);\n\n if (match === null || match.index !== pos) {\n throw new src_ParseError(\"Unexpected character: '\" + input[pos] + \"'\", new Token_Token(input[pos], new SourceLocation(this, pos, pos + 1)));\n }\n\n var text = match[2] || \" \";\n\n if (this.catcodes[text] === 14) {\n // comment character\n var nlIndex = input.indexOf('\\n', this.tokenRegex.lastIndex);\n\n if (nlIndex === -1) {\n this.tokenRegex.lastIndex = input.length; // EOF\n\n this.settings.reportNonstrict(\"commentAtEnd\", \"% comment has no terminating newline; LaTeX would \" + \"fail because of commenting the end of math mode (e.g. $)\");\n } else {\n this.tokenRegex.lastIndex = nlIndex + 1;\n }\n\n return this.lex();\n } // Trim any trailing whitespace from control word match\n\n\n var controlMatch = text.match(controlWordWhitespaceRegex);\n\n if (controlMatch) {\n text = controlMatch[1];\n }\n\n return new Token_Token(text, new SourceLocation(this, pos, this.tokenRegex.lastIndex));\n };\n\n return Lexer;\n}();\n\n\n// CONCATENATED MODULE: ./src/Namespace.js\n/**\n * A `Namespace` refers to a space of nameable things like macros or lengths,\n * which can be `set` either globally or local to a nested group, using an\n * undo stack similar to how TeX implements this functionality.\n * Performance-wise, `get` and local `set` take constant time, while global\n * `set` takes time proportional to the depth of group nesting.\n */\n\n\nvar Namespace_Namespace =\n/*#__PURE__*/\nfunction () {\n /**\n * Both arguments are optional. The first argument is an object of\n * built-in mappings which never change. The second argument is an object\n * of initial (global-level) mappings, which will constantly change\n * according to any global/top-level `set`s done.\n */\n function Namespace(builtins, globalMacros) {\n if (builtins === void 0) {\n builtins = {};\n }\n\n if (globalMacros === void 0) {\n globalMacros = {};\n }\n\n this.current = void 0;\n this.builtins = void 0;\n this.undefStack = void 0;\n this.current = globalMacros;\n this.builtins = builtins;\n this.undefStack = [];\n }\n /**\n * Start a new nested group, affecting future local `set`s.\n */\n\n\n var _proto = Namespace.prototype;\n\n _proto.beginGroup = function beginGroup() {\n this.undefStack.push({});\n }\n /**\n * End current nested group, restoring values before the group began.\n */\n ;\n\n _proto.endGroup = function endGroup() {\n if (this.undefStack.length === 0) {\n throw new src_ParseError(\"Unbalanced namespace destruction: attempt \" + \"to pop global namespace; please report this as a bug\");\n }\n\n var undefs = this.undefStack.pop();\n\n for (var undef in undefs) {\n if (undefs.hasOwnProperty(undef)) {\n if (undefs[undef] === undefined) {\n delete this.current[undef];\n } else {\n this.current[undef] = undefs[undef];\n }\n }\n }\n }\n /**\n * Detect whether `name` has a definition. Equivalent to\n * `get(name) != null`.\n */\n ;\n\n _proto.has = function has(name) {\n return this.current.hasOwnProperty(name) || this.builtins.hasOwnProperty(name);\n }\n /**\n * Get the current value of a name, or `undefined` if there is no value.\n *\n * Note: Do not use `if (namespace.get(...))` to detect whether a macro\n * is defined, as the definition may be the empty string which evaluates\n * to `false` in JavaScript. Use `if (namespace.get(...) != null)` or\n * `if (namespace.has(...))`.\n */\n ;\n\n _proto.get = function get(name) {\n if (this.current.hasOwnProperty(name)) {\n return this.current[name];\n } else {\n return this.builtins[name];\n }\n }\n /**\n * Set the current value of a name, and optionally set it globally too.\n * Local set() sets the current value and (when appropriate) adds an undo\n * operation to the undo stack. Global set() may change the undo\n * operation at every level, so takes time linear in their number.\n */\n ;\n\n _proto.set = function set(name, value, global) {\n if (global === void 0) {\n global = false;\n }\n\n if (global) {\n // Global set is equivalent to setting in all groups. Simulate this\n // by destroying any undos currently scheduled for this name,\n // and adding an undo with the *new* value (in case it later gets\n // locally reset within this environment).\n for (var i = 0; i < this.undefStack.length; i++) {\n delete this.undefStack[i][name];\n }\n\n if (this.undefStack.length > 0) {\n this.undefStack[this.undefStack.length - 1][name] = value;\n }\n } else {\n // Undo this set at end of this group (possibly to `undefined`),\n // unless an undo is already in place, in which case that older\n // value is the correct one.\n var top = this.undefStack[this.undefStack.length - 1];\n\n if (top && !top.hasOwnProperty(name)) {\n top[name] = this.current[name];\n }\n }\n\n this.current[name] = value;\n };\n\n return Namespace;\n}();\n\n\n// CONCATENATED MODULE: ./src/macros.js\n/**\n * Predefined macros for KaTeX.\n * This can be used to define some commands in terms of others.\n */\n\n\n\n\n\nvar builtinMacros = {};\n/* harmony default export */ var macros = (builtinMacros); // This function might one day accept an additional argument and do more things.\n\nfunction defineMacro(name, body) {\n builtinMacros[name] = body;\n} //////////////////////////////////////////////////////////////////////\n// macro tools\n// LaTeX's \\@firstoftwo{#1}{#2} expands to #1, skipping #2\n// TeX source: \\long\\def\\@firstoftwo#1#2{#1}\n\ndefineMacro(\"\\\\@firstoftwo\", function (context) {\n var args = context.consumeArgs(2);\n return {\n tokens: args[0],\n numArgs: 0\n };\n}); // LaTeX's \\@secondoftwo{#1}{#2} expands to #2, skipping #1\n// TeX source: \\long\\def\\@secondoftwo#1#2{#2}\n\ndefineMacro(\"\\\\@secondoftwo\", function (context) {\n var args = context.consumeArgs(2);\n return {\n tokens: args[1],\n numArgs: 0\n };\n}); // LaTeX's \\@ifnextchar{#1}{#2}{#3} looks ahead to the next (unexpanded)\n// symbol. If it matches #1, then the macro expands to #2; otherwise, #3.\n// Note, however, that it does not consume the next symbol in either case.\n\ndefineMacro(\"\\\\@ifnextchar\", function (context) {\n var args = context.consumeArgs(3); // symbol, if, else\n\n var nextToken = context.future();\n\n if (args[0].length === 1 && args[0][0].text === nextToken.text) {\n return {\n tokens: args[1],\n numArgs: 0\n };\n } else {\n return {\n tokens: args[2],\n numArgs: 0\n };\n }\n}); // LaTeX's \\@ifstar{#1}{#2} looks ahead to the next (unexpanded) symbol.\n// If it is `*`, then it consumes the symbol, and the macro expands to #1;\n// otherwise, the macro expands to #2 (without consuming the symbol).\n// TeX source: \\def\\@ifstar#1{\\@ifnextchar *{\\@firstoftwo{#1}}}\n\ndefineMacro(\"\\\\@ifstar\", \"\\\\@ifnextchar *{\\\\@firstoftwo{#1}}\"); // LaTeX's \\TextOrMath{#1}{#2} expands to #1 in text mode, #2 in math mode\n\ndefineMacro(\"\\\\TextOrMath\", function (context) {\n var args = context.consumeArgs(2);\n\n if (context.mode === 'text') {\n return {\n tokens: args[0],\n numArgs: 0\n };\n } else {\n return {\n tokens: args[1],\n numArgs: 0\n };\n }\n}); // Lookup table for parsing numbers in base 8 through 16\n\nvar digitToNumber = {\n \"0\": 0,\n \"1\": 1,\n \"2\": 2,\n \"3\": 3,\n \"4\": 4,\n \"5\": 5,\n \"6\": 6,\n \"7\": 7,\n \"8\": 8,\n \"9\": 9,\n \"a\": 10,\n \"A\": 10,\n \"b\": 11,\n \"B\": 11,\n \"c\": 12,\n \"C\": 12,\n \"d\": 13,\n \"D\": 13,\n \"e\": 14,\n \"E\": 14,\n \"f\": 15,\n \"F\": 15\n}; // TeX \\char makes a literal character (catcode 12) using the following forms:\n// (see The TeXBook, p. 43)\n// \\char123 -- decimal\n// \\char'123 -- octal\n// \\char\"123 -- hex\n// \\char`x -- character that can be written (i.e. isn't active)\n// \\char`\\x -- character that cannot be written (e.g. %)\n// These all refer to characters from the font, so we turn them into special\n// calls to a function \\@char dealt with in the Parser.\n\ndefineMacro(\"\\\\char\", function (context) {\n var token = context.popToken();\n var base;\n var number = '';\n\n if (token.text === \"'\") {\n base = 8;\n token = context.popToken();\n } else if (token.text === '\"') {\n base = 16;\n token = context.popToken();\n } else if (token.text === \"`\") {\n token = context.popToken();\n\n if (token.text[0] === \"\\\\\") {\n number = token.text.charCodeAt(1);\n } else if (token.text === \"EOF\") {\n throw new src_ParseError(\"\\\\char` missing argument\");\n } else {\n number = token.text.charCodeAt(0);\n }\n } else {\n base = 10;\n }\n\n if (base) {\n // Parse a number in the given base, starting with first `token`.\n number = digitToNumber[token.text];\n\n if (number == null || number >= base) {\n throw new src_ParseError(\"Invalid base-\" + base + \" digit \" + token.text);\n }\n\n var digit;\n\n while ((digit = digitToNumber[context.future().text]) != null && digit < base) {\n number *= base;\n number += digit;\n context.popToken();\n }\n }\n\n return \"\\\\@char{\" + number + \"}\";\n}); // Basic support for macro definitions:\n// \\def\\macro{expansion}\n// \\def\\macro#1{expansion}\n// \\def\\macro#1#2{expansion}\n// \\def\\macro#1#2#3#4#5#6#7#8#9{expansion}\n// Also the \\gdef and \\global\\def equivalents\n\nvar macros_def = function def(context, global) {\n var arg = context.consumeArgs(1)[0];\n\n if (arg.length !== 1) {\n throw new src_ParseError(\"\\\\gdef's first argument must be a macro name\");\n }\n\n var name = arg[0].text; // Count argument specifiers, and check they are in the order #1 #2 ...\n\n var numArgs = 0;\n arg = context.consumeArgs(1)[0];\n\n while (arg.length === 1 && arg[0].text === \"#\") {\n arg = context.consumeArgs(1)[0];\n\n if (arg.length !== 1) {\n throw new src_ParseError(\"Invalid argument number length \\\"\" + arg.length + \"\\\"\");\n }\n\n if (!/^[1-9]$/.test(arg[0].text)) {\n throw new src_ParseError(\"Invalid argument number \\\"\" + arg[0].text + \"\\\"\");\n }\n\n numArgs++;\n\n if (parseInt(arg[0].text) !== numArgs) {\n throw new src_ParseError(\"Argument number \\\"\" + arg[0].text + \"\\\" out of order\");\n }\n\n arg = context.consumeArgs(1)[0];\n } // Final arg is the expansion of the macro\n\n\n context.macros.set(name, {\n tokens: arg,\n numArgs: numArgs\n }, global);\n return '';\n};\n\ndefineMacro(\"\\\\gdef\", function (context) {\n return macros_def(context, true);\n});\ndefineMacro(\"\\\\def\", function (context) {\n return macros_def(context, false);\n});\ndefineMacro(\"\\\\global\", function (context) {\n var next = context.consumeArgs(1)[0];\n\n if (next.length !== 1) {\n throw new src_ParseError(\"Invalid command after \\\\global\");\n }\n\n var command = next[0].text; // TODO: Should expand command\n\n if (command === \"\\\\def\") {\n // \\global\\def is equivalent to \\gdef\n return macros_def(context, true);\n } else {\n throw new src_ParseError(\"Invalid command '\" + command + \"' after \\\\global\");\n }\n}); // \\newcommand{\\macro}[args]{definition}\n// \\renewcommand{\\macro}[args]{definition}\n// TODO: Optional arguments: \\newcommand{\\macro}[args][default]{definition}\n\nvar macros_newcommand = function newcommand(context, existsOK, nonexistsOK) {\n var arg = context.consumeArgs(1)[0];\n\n if (arg.length !== 1) {\n throw new src_ParseError(\"\\\\newcommand's first argument must be a macro name\");\n }\n\n var name = arg[0].text;\n var exists = context.isDefined(name);\n\n if (exists && !existsOK) {\n throw new src_ParseError(\"\\\\newcommand{\" + name + \"} attempting to redefine \" + (name + \"; use \\\\renewcommand\"));\n }\n\n if (!exists && !nonexistsOK) {\n throw new src_ParseError(\"\\\\renewcommand{\" + name + \"} when command \" + name + \" \" + \"does not yet exist; use \\\\newcommand\");\n }\n\n var numArgs = 0;\n arg = context.consumeArgs(1)[0];\n\n if (arg.length === 1 && arg[0].text === \"[\") {\n var argText = '';\n var token = context.expandNextToken();\n\n while (token.text !== \"]\" && token.text !== \"EOF\") {\n // TODO: Should properly expand arg, e.g., ignore {}s\n argText += token.text;\n token = context.expandNextToken();\n }\n\n if (!argText.match(/^\\s*[0-9]+\\s*$/)) {\n throw new src_ParseError(\"Invalid number of arguments: \" + argText);\n }\n\n numArgs = parseInt(argText);\n arg = context.consumeArgs(1)[0];\n } // Final arg is the expansion of the macro\n\n\n context.macros.set(name, {\n tokens: arg,\n numArgs: numArgs\n });\n return '';\n};\n\ndefineMacro(\"\\\\newcommand\", function (context) {\n return macros_newcommand(context, false, true);\n});\ndefineMacro(\"\\\\renewcommand\", function (context) {\n return macros_newcommand(context, true, false);\n});\ndefineMacro(\"\\\\providecommand\", function (context) {\n return macros_newcommand(context, true, true);\n}); //////////////////////////////////////////////////////////////////////\n// Grouping\n// \\let\\bgroup={ \\let\\egroup=}\n\ndefineMacro(\"\\\\bgroup\", \"{\");\ndefineMacro(\"\\\\egroup\", \"}\"); // Symbols from latex.ltx:\n// \\def\\lq{`}\n// \\def\\rq{'}\n// \\def \\aa {\\r a}\n// \\def \\AA {\\r A}\n\ndefineMacro(\"\\\\lq\", \"`\");\ndefineMacro(\"\\\\rq\", \"'\");\ndefineMacro(\"\\\\aa\", \"\\\\r a\");\ndefineMacro(\"\\\\AA\", \"\\\\r A\"); // Copyright (C) and registered (R) symbols. Use raw symbol in MathML.\n// \\DeclareTextCommandDefault{\\textcopyright}{\\textcircled{c}}\n// \\DeclareTextCommandDefault{\\textregistered}{\\textcircled{%\n// \\check@mathfonts\\fontsize\\sf@size\\z@\\math@fontsfalse\\selectfont R}}\n// \\DeclareRobustCommand{\\copyright}{%\n// \\ifmmode{\\nfss@text{\\textcopyright}}\\else\\textcopyright\\fi}\n\ndefineMacro(\"\\\\textcopyright\", \"\\\\html@mathml{\\\\textcircled{c}}{\\\\char`©}\");\ndefineMacro(\"\\\\copyright\", \"\\\\TextOrMath{\\\\textcopyright}{\\\\text{\\\\textcopyright}}\");\ndefineMacro(\"\\\\textregistered\", \"\\\\html@mathml{\\\\textcircled{\\\\scriptsize R}}{\\\\char`®}\"); // Characters omitted from Unicode range 1D400–1D7FF\n\ndefineMacro(\"\\u212C\", \"\\\\mathscr{B}\"); // script\n\ndefineMacro(\"\\u2130\", \"\\\\mathscr{E}\");\ndefineMacro(\"\\u2131\", \"\\\\mathscr{F}\");\ndefineMacro(\"\\u210B\", \"\\\\mathscr{H}\");\ndefineMacro(\"\\u2110\", \"\\\\mathscr{I}\");\ndefineMacro(\"\\u2112\", \"\\\\mathscr{L}\");\ndefineMacro(\"\\u2133\", \"\\\\mathscr{M}\");\ndefineMacro(\"\\u211B\", \"\\\\mathscr{R}\");\ndefineMacro(\"\\u212D\", \"\\\\mathfrak{C}\"); // Fraktur\n\ndefineMacro(\"\\u210C\", \"\\\\mathfrak{H}\");\ndefineMacro(\"\\u2128\", \"\\\\mathfrak{Z}\"); // Define \\Bbbk with a macro that works in both HTML and MathML.\n\ndefineMacro(\"\\\\Bbbk\", \"\\\\Bbb{k}\"); // Unicode middle dot\n// The KaTeX fonts do not contain U+00B7. Instead, \\cdotp displays\n// the dot at U+22C5 and gives it punct spacing.\n\ndefineMacro(\"\\xB7\", \"\\\\cdotp\"); // \\llap and \\rlap render their contents in text mode\n\ndefineMacro(\"\\\\llap\", \"\\\\mathllap{\\\\textrm{#1}}\");\ndefineMacro(\"\\\\rlap\", \"\\\\mathrlap{\\\\textrm{#1}}\");\ndefineMacro(\"\\\\clap\", \"\\\\mathclap{\\\\textrm{#1}}\"); // \\not is defined by base/fontmath.ltx via\n// \\DeclareMathSymbol{\\not}{\\mathrel}{symbols}{\"36}\n// It's thus treated like a \\mathrel, but defined by a symbol that has zero\n// width but extends to the right. We use \\rlap to get that spacing.\n// For MathML we write U+0338 here. buildMathML.js will then do the overlay.\n\ndefineMacro(\"\\\\not\", '\\\\html@mathml{\\\\mathrel{\\\\mathrlap\\\\@not}}{\\\\char\"338}'); // Negated symbols from base/fontmath.ltx:\n// \\def\\neq{\\not=} \\let\\ne=\\neq\n// \\DeclareRobustCommand\n// \\notin{\\mathrel{\\m@th\\mathpalette\\c@ncel\\in}}\n// \\def\\c@ncel#1#2{\\m@th\\ooalign{$\\hfil#1\\mkern1mu/\\hfil$\\crcr$#1#2$}}\n\ndefineMacro(\"\\\\neq\", \"\\\\html@mathml{\\\\mathrel{\\\\not=}}{\\\\mathrel{\\\\char`≠}}\");\ndefineMacro(\"\\\\ne\", \"\\\\neq\");\ndefineMacro(\"\\u2260\", \"\\\\neq\");\ndefineMacro(\"\\\\notin\", \"\\\\html@mathml{\\\\mathrel{{\\\\in}\\\\mathllap{/\\\\mskip1mu}}}\" + \"{\\\\mathrel{\\\\char`∉}}\");\ndefineMacro(\"\\u2209\", \"\\\\notin\"); // Unicode stacked relations\n\ndefineMacro(\"\\u2258\", \"\\\\html@mathml{\" + \"\\\\mathrel{=\\\\kern{-1em}\\\\raisebox{0.4em}{$\\\\scriptsize\\\\frown$}}\" + \"}{\\\\mathrel{\\\\char`\\u2258}}\");\ndefineMacro(\"\\u2259\", \"\\\\html@mathml{\\\\stackrel{\\\\tiny\\\\wedge}{=}}{\\\\mathrel{\\\\char`\\u2258}}\");\ndefineMacro(\"\\u225A\", \"\\\\html@mathml{\\\\stackrel{\\\\tiny\\\\vee}{=}}{\\\\mathrel{\\\\char`\\u225A}}\");\ndefineMacro(\"\\u225B\", \"\\\\html@mathml{\\\\stackrel{\\\\scriptsize\\\\star}{=}}\" + \"{\\\\mathrel{\\\\char`\\u225B}}\");\ndefineMacro(\"\\u225D\", \"\\\\html@mathml{\\\\stackrel{\\\\tiny\\\\mathrm{def}}{=}}\" + \"{\\\\mathrel{\\\\char`\\u225D}}\");\ndefineMacro(\"\\u225E\", \"\\\\html@mathml{\\\\stackrel{\\\\tiny\\\\mathrm{m}}{=}}\" + \"{\\\\mathrel{\\\\char`\\u225E}}\");\ndefineMacro(\"\\u225F\", \"\\\\html@mathml{\\\\stackrel{\\\\tiny?}{=}}{\\\\mathrel{\\\\char`\\u225F}}\"); // Misc Unicode\n\ndefineMacro(\"\\u27C2\", \"\\\\perp\");\ndefineMacro(\"\\u203C\", \"\\\\mathclose{!\\\\mkern-0.8mu!}\");\ndefineMacro(\"\\u220C\", \"\\\\notni\");\ndefineMacro(\"\\u231C\", \"\\\\ulcorner\");\ndefineMacro(\"\\u231D\", \"\\\\urcorner\");\ndefineMacro(\"\\u231E\", \"\\\\llcorner\");\ndefineMacro(\"\\u231F\", \"\\\\lrcorner\");\ndefineMacro(\"\\xA9\", \"\\\\copyright\");\ndefineMacro(\"\\xAE\", \"\\\\textregistered\");\ndefineMacro(\"\\uFE0F\", \"\\\\textregistered\"); //////////////////////////////////////////////////////////////////////\n// LaTeX_2ε\n// \\vdots{\\vbox{\\baselineskip4\\p@ \\lineskiplimit\\z@\n// \\kern6\\p@\\hbox{.}\\hbox{.}\\hbox{.}}}\n// We'll call \\varvdots, which gets a glyph from symbols.js.\n// The zero-width rule gets us an equivalent to the vertical 6pt kern.\n\ndefineMacro(\"\\\\vdots\", \"\\\\mathord{\\\\varvdots\\\\rule{0pt}{15pt}}\");\ndefineMacro(\"\\u22EE\", \"\\\\vdots\"); //////////////////////////////////////////////////////////////////////\n// amsmath.sty\n// http://mirrors.concertpass.com/tex-archive/macros/latex/required/amsmath/amsmath.pdf\n// Italic Greek capital letters. AMS defines these with \\DeclareMathSymbol,\n// but they are equivalent to \\mathit{\\Letter}.\n\ndefineMacro(\"\\\\varGamma\", \"\\\\mathit{\\\\Gamma}\");\ndefineMacro(\"\\\\varDelta\", \"\\\\mathit{\\\\Delta}\");\ndefineMacro(\"\\\\varTheta\", \"\\\\mathit{\\\\Theta}\");\ndefineMacro(\"\\\\varLambda\", \"\\\\mathit{\\\\Lambda}\");\ndefineMacro(\"\\\\varXi\", \"\\\\mathit{\\\\Xi}\");\ndefineMacro(\"\\\\varPi\", \"\\\\mathit{\\\\Pi}\");\ndefineMacro(\"\\\\varSigma\", \"\\\\mathit{\\\\Sigma}\");\ndefineMacro(\"\\\\varUpsilon\", \"\\\\mathit{\\\\Upsilon}\");\ndefineMacro(\"\\\\varPhi\", \"\\\\mathit{\\\\Phi}\");\ndefineMacro(\"\\\\varPsi\", \"\\\\mathit{\\\\Psi}\");\ndefineMacro(\"\\\\varOmega\", \"\\\\mathit{\\\\Omega}\"); //\\newcommand{\\substack}[1]{\\subarray{c}#1\\endsubarray}\n\ndefineMacro(\"\\\\substack\", \"\\\\begin{subarray}{c}#1\\\\end{subarray}\"); // \\renewcommand{\\colon}{\\nobreak\\mskip2mu\\mathpunct{}\\nonscript\n// \\mkern-\\thinmuskip{:}\\mskip6muplus1mu\\relax}\n\ndefineMacro(\"\\\\colon\", \"\\\\nobreak\\\\mskip2mu\\\\mathpunct{}\" + \"\\\\mathchoice{\\\\mkern-3mu}{\\\\mkern-3mu}{}{}{:}\\\\mskip6mu\"); // \\newcommand{\\boxed}[1]{\\fbox{\\m@th$\\displaystyle#1$}}\n\ndefineMacro(\"\\\\boxed\", \"\\\\fbox{$\\\\displaystyle{#1}$}\"); // \\def\\iff{\\DOTSB\\;\\Longleftrightarrow\\;}\n// \\def\\implies{\\DOTSB\\;\\Longrightarrow\\;}\n// \\def\\impliedby{\\DOTSB\\;\\Longleftarrow\\;}\n\ndefineMacro(\"\\\\iff\", \"\\\\DOTSB\\\\;\\\\Longleftrightarrow\\\\;\");\ndefineMacro(\"\\\\implies\", \"\\\\DOTSB\\\\;\\\\Longrightarrow\\\\;\");\ndefineMacro(\"\\\\impliedby\", \"\\\\DOTSB\\\\;\\\\Longleftarrow\\\\;\"); // AMSMath's automatic \\dots, based on \\mdots@@ macro.\n\nvar dotsByToken = {\n ',': '\\\\dotsc',\n '\\\\not': '\\\\dotsb',\n // \\keybin@ checks for the following:\n '+': '\\\\dotsb',\n '=': '\\\\dotsb',\n '<': '\\\\dotsb',\n '>': '\\\\dotsb',\n '-': '\\\\dotsb',\n '*': '\\\\dotsb',\n ':': '\\\\dotsb',\n // Symbols whose definition starts with \\DOTSB:\n '\\\\DOTSB': '\\\\dotsb',\n '\\\\coprod': '\\\\dotsb',\n '\\\\bigvee': '\\\\dotsb',\n '\\\\bigwedge': '\\\\dotsb',\n '\\\\biguplus': '\\\\dotsb',\n '\\\\bigcap': '\\\\dotsb',\n '\\\\bigcup': '\\\\dotsb',\n '\\\\prod': '\\\\dotsb',\n '\\\\sum': '\\\\dotsb',\n '\\\\bigotimes': '\\\\dotsb',\n '\\\\bigoplus': '\\\\dotsb',\n '\\\\bigodot': '\\\\dotsb',\n '\\\\bigsqcup': '\\\\dotsb',\n '\\\\And': '\\\\dotsb',\n '\\\\longrightarrow': '\\\\dotsb',\n '\\\\Longrightarrow': '\\\\dotsb',\n '\\\\longleftarrow': '\\\\dotsb',\n '\\\\Longleftarrow': '\\\\dotsb',\n '\\\\longleftrightarrow': '\\\\dotsb',\n '\\\\Longleftrightarrow': '\\\\dotsb',\n '\\\\mapsto': '\\\\dotsb',\n '\\\\longmapsto': '\\\\dotsb',\n '\\\\hookrightarrow': '\\\\dotsb',\n '\\\\doteq': '\\\\dotsb',\n // Symbols whose definition starts with \\mathbin:\n '\\\\mathbin': '\\\\dotsb',\n // Symbols whose definition starts with \\mathrel:\n '\\\\mathrel': '\\\\dotsb',\n '\\\\relbar': '\\\\dotsb',\n '\\\\Relbar': '\\\\dotsb',\n '\\\\xrightarrow': '\\\\dotsb',\n '\\\\xleftarrow': '\\\\dotsb',\n // Symbols whose definition starts with \\DOTSI:\n '\\\\DOTSI': '\\\\dotsi',\n '\\\\int': '\\\\dotsi',\n '\\\\oint': '\\\\dotsi',\n '\\\\iint': '\\\\dotsi',\n '\\\\iiint': '\\\\dotsi',\n '\\\\iiiint': '\\\\dotsi',\n '\\\\idotsint': '\\\\dotsi',\n // Symbols whose definition starts with \\DOTSX:\n '\\\\DOTSX': '\\\\dotsx'\n};\ndefineMacro(\"\\\\dots\", function (context) {\n // TODO: If used in text mode, should expand to \\textellipsis.\n // However, in KaTeX, \\textellipsis and \\ldots behave the same\n // (in text mode), and it's unlikely we'd see any of the math commands\n // that affect the behavior of \\dots when in text mode. So fine for now\n // (until we support \\ifmmode ... \\else ... \\fi).\n var thedots = '\\\\dotso';\n var next = context.expandAfterFuture().text;\n\n if (next in dotsByToken) {\n thedots = dotsByToken[next];\n } else if (next.substr(0, 4) === '\\\\not') {\n thedots = '\\\\dotsb';\n } else if (next in src_symbols.math) {\n if (utils.contains(['bin', 'rel'], src_symbols.math[next].group)) {\n thedots = '\\\\dotsb';\n }\n }\n\n return thedots;\n});\nvar spaceAfterDots = {\n // \\rightdelim@ checks for the following:\n ')': true,\n ']': true,\n '\\\\rbrack': true,\n '\\\\}': true,\n '\\\\rbrace': true,\n '\\\\rangle': true,\n '\\\\rceil': true,\n '\\\\rfloor': true,\n '\\\\rgroup': true,\n '\\\\rmoustache': true,\n '\\\\right': true,\n '\\\\bigr': true,\n '\\\\biggr': true,\n '\\\\Bigr': true,\n '\\\\Biggr': true,\n // \\extra@ also tests for the following:\n '$': true,\n // \\extrap@ checks for the following:\n ';': true,\n '.': true,\n ',': true\n};\ndefineMacro(\"\\\\dotso\", function (context) {\n var next = context.future().text;\n\n if (next in spaceAfterDots) {\n return \"\\\\ldots\\\\,\";\n } else {\n return \"\\\\ldots\";\n }\n});\ndefineMacro(\"\\\\dotsc\", function (context) {\n var next = context.future().text; // \\dotsc uses \\extra@ but not \\extrap@, instead specially checking for\n // ';' and '.', but doesn't check for ','.\n\n if (next in spaceAfterDots && next !== ',') {\n return \"\\\\ldots\\\\,\";\n } else {\n return \"\\\\ldots\";\n }\n});\ndefineMacro(\"\\\\cdots\", function (context) {\n var next = context.future().text;\n\n if (next in spaceAfterDots) {\n return \"\\\\@cdots\\\\,\";\n } else {\n return \"\\\\@cdots\";\n }\n});\ndefineMacro(\"\\\\dotsb\", \"\\\\cdots\");\ndefineMacro(\"\\\\dotsm\", \"\\\\cdots\");\ndefineMacro(\"\\\\dotsi\", \"\\\\!\\\\cdots\"); // amsmath doesn't actually define \\dotsx, but \\dots followed by a macro\n// starting with \\DOTSX implies \\dotso, and then \\extra@ detects this case\n// and forces the added `\\,`.\n\ndefineMacro(\"\\\\dotsx\", \"\\\\ldots\\\\,\"); // \\let\\DOTSI\\relax\n// \\let\\DOTSB\\relax\n// \\let\\DOTSX\\relax\n\ndefineMacro(\"\\\\DOTSI\", \"\\\\relax\");\ndefineMacro(\"\\\\DOTSB\", \"\\\\relax\");\ndefineMacro(\"\\\\DOTSX\", \"\\\\relax\"); // Spacing, based on amsmath.sty's override of LaTeX defaults\n// \\DeclareRobustCommand{\\tmspace}[3]{%\n// \\ifmmode\\mskip#1#2\\else\\kern#1#3\\fi\\relax}\n\ndefineMacro(\"\\\\tmspace\", \"\\\\TextOrMath{\\\\kern#1#3}{\\\\mskip#1#2}\\\\relax\"); // \\renewcommand{\\,}{\\tmspace+\\thinmuskip{.1667em}}\n// TODO: math mode should use \\thinmuskip\n\ndefineMacro(\"\\\\,\", \"\\\\tmspace+{3mu}{.1667em}\"); // \\let\\thinspace\\,\n\ndefineMacro(\"\\\\thinspace\", \"\\\\,\"); // \\def\\>{\\mskip\\medmuskip}\n// \\renewcommand{\\:}{\\tmspace+\\medmuskip{.2222em}}\n// TODO: \\> and math mode of \\: should use \\medmuskip = 4mu plus 2mu minus 4mu\n\ndefineMacro(\"\\\\>\", \"\\\\mskip{4mu}\");\ndefineMacro(\"\\\\:\", \"\\\\tmspace+{4mu}{.2222em}\"); // \\let\\medspace\\:\n\ndefineMacro(\"\\\\medspace\", \"\\\\:\"); // \\renewcommand{\\;}{\\tmspace+\\thickmuskip{.2777em}}\n// TODO: math mode should use \\thickmuskip = 5mu plus 5mu\n\ndefineMacro(\"\\\\;\", \"\\\\tmspace+{5mu}{.2777em}\"); // \\let\\thickspace\\;\n\ndefineMacro(\"\\\\thickspace\", \"\\\\;\"); // \\renewcommand{\\!}{\\tmspace-\\thinmuskip{.1667em}}\n// TODO: math mode should use \\thinmuskip\n\ndefineMacro(\"\\\\!\", \"\\\\tmspace-{3mu}{.1667em}\"); // \\let\\negthinspace\\!\n\ndefineMacro(\"\\\\negthinspace\", \"\\\\!\"); // \\newcommand{\\negmedspace}{\\tmspace-\\medmuskip{.2222em}}\n// TODO: math mode should use \\medmuskip\n\ndefineMacro(\"\\\\negmedspace\", \"\\\\tmspace-{4mu}{.2222em}\"); // \\newcommand{\\negthickspace}{\\tmspace-\\thickmuskip{.2777em}}\n// TODO: math mode should use \\thickmuskip\n\ndefineMacro(\"\\\\negthickspace\", \"\\\\tmspace-{5mu}{.277em}\"); // \\def\\enspace{\\kern.5em }\n\ndefineMacro(\"\\\\enspace\", \"\\\\kern.5em \"); // \\def\\enskip{\\hskip.5em\\relax}\n\ndefineMacro(\"\\\\enskip\", \"\\\\hskip.5em\\\\relax\"); // \\def\\quad{\\hskip1em\\relax}\n\ndefineMacro(\"\\\\quad\", \"\\\\hskip1em\\\\relax\"); // \\def\\qquad{\\hskip2em\\relax}\n\ndefineMacro(\"\\\\qquad\", \"\\\\hskip2em\\\\relax\"); // \\tag@in@display form of \\tag\n\ndefineMacro(\"\\\\tag\", \"\\\\@ifstar\\\\tag@literal\\\\tag@paren\");\ndefineMacro(\"\\\\tag@paren\", \"\\\\tag@literal{({#1})}\");\ndefineMacro(\"\\\\tag@literal\", function (context) {\n if (context.macros.get(\"\\\\df@tag\")) {\n throw new src_ParseError(\"Multiple \\\\tag\");\n }\n\n return \"\\\\gdef\\\\df@tag{\\\\text{#1}}\";\n}); // \\renewcommand{\\bmod}{\\nonscript\\mskip-\\medmuskip\\mkern5mu\\mathbin\n// {\\operator@font mod}\\penalty900\n// \\mkern5mu\\nonscript\\mskip-\\medmuskip}\n// \\newcommand{\\pod}[1]{\\allowbreak\n// \\if@display\\mkern18mu\\else\\mkern8mu\\fi(#1)}\n// \\renewcommand{\\pmod}[1]{\\pod{{\\operator@font mod}\\mkern6mu#1}}\n// \\newcommand{\\mod}[1]{\\allowbreak\\if@display\\mkern18mu\n// \\else\\mkern12mu\\fi{\\operator@font mod}\\,\\,#1}\n// TODO: math mode should use \\medmuskip = 4mu plus 2mu minus 4mu\n\ndefineMacro(\"\\\\bmod\", \"\\\\mathchoice{\\\\mskip1mu}{\\\\mskip1mu}{\\\\mskip5mu}{\\\\mskip5mu}\" + \"\\\\mathbin{\\\\rm mod}\" + \"\\\\mathchoice{\\\\mskip1mu}{\\\\mskip1mu}{\\\\mskip5mu}{\\\\mskip5mu}\");\ndefineMacro(\"\\\\pod\", \"\\\\allowbreak\" + \"\\\\mathchoice{\\\\mkern18mu}{\\\\mkern8mu}{\\\\mkern8mu}{\\\\mkern8mu}(#1)\");\ndefineMacro(\"\\\\pmod\", \"\\\\pod{{\\\\rm mod}\\\\mkern6mu#1}\");\ndefineMacro(\"\\\\mod\", \"\\\\allowbreak\" + \"\\\\mathchoice{\\\\mkern18mu}{\\\\mkern12mu}{\\\\mkern12mu}{\\\\mkern12mu}\" + \"{\\\\rm mod}\\\\,\\\\,#1\"); // \\pmb -- A simulation of bold.\n// The version in ambsy.sty works by typesetting three copies of the argument\n// with small offsets. We use two copies. We omit the vertical offset because\n// of rendering problems that makeVList encounters in Safari.\n\ndefineMacro(\"\\\\pmb\", \"\\\\html@mathml{\" + \"\\\\@binrel{#1}{\\\\mathrlap{#1}\\\\kern0.5px#1}}\" + \"{\\\\mathbf{#1}}\"); //////////////////////////////////////////////////////////////////////\n// LaTeX source2e\n// \\\\ defaults to \\newline, but changes to \\cr within array environment\n\ndefineMacro(\"\\\\\\\\\", \"\\\\newline\"); // \\def\\TeX{T\\kern-.1667em\\lower.5ex\\hbox{E}\\kern-.125emX\\@}\n// TODO: Doesn't normally work in math mode because \\@ fails. KaTeX doesn't\n// support \\@ yet, so that's omitted, and we add \\text so that the result\n// doesn't look funny in math mode.\n\ndefineMacro(\"\\\\TeX\", \"\\\\textrm{\\\\html@mathml{\" + \"T\\\\kern-.1667em\\\\raisebox{-.5ex}{E}\\\\kern-.125emX\" + \"}{TeX}}\"); // \\DeclareRobustCommand{\\LaTeX}{L\\kern-.36em%\n// {\\sbox\\z@ T%\n// \\vbox to\\ht\\z@{\\hbox{\\check@mathfonts\n// \\fontsize\\sf@size\\z@\n// \\math@fontsfalse\\selectfont\n// A}%\n// \\vss}%\n// }%\n// \\kern-.15em%\n// \\TeX}\n// This code aligns the top of the A with the T (from the perspective of TeX's\n// boxes, though visually the A appears to extend above slightly).\n// We compute the corresponding \\raisebox when A is rendered in \\normalsize\n// \\scriptstyle, which has a scale factor of 0.7 (see Options.js).\n\nvar latexRaiseA = fontMetricsData['Main-Regular'][\"T\".charCodeAt(0)][1] - 0.7 * fontMetricsData['Main-Regular'][\"A\".charCodeAt(0)][1] + \"em\";\ndefineMacro(\"\\\\LaTeX\", \"\\\\textrm{\\\\html@mathml{\" + (\"L\\\\kern-.36em\\\\raisebox{\" + latexRaiseA + \"}{\\\\scriptstyle A}\") + \"\\\\kern-.15em\\\\TeX}{LaTeX}}\"); // New KaTeX logo based on tweaking LaTeX logo\n\ndefineMacro(\"\\\\KaTeX\", \"\\\\textrm{\\\\html@mathml{\" + (\"K\\\\kern-.17em\\\\raisebox{\" + latexRaiseA + \"}{\\\\scriptstyle A}\") + \"\\\\kern-.15em\\\\TeX}{KaTeX}}\"); // \\DeclareRobustCommand\\hspace{\\@ifstar\\@hspacer\\@hspace}\n// \\def\\@hspace#1{\\hskip #1\\relax}\n// \\def\\@hspacer#1{\\vrule \\@width\\z@\\nobreak\n// \\hskip #1\\hskip \\z@skip}\n\ndefineMacro(\"\\\\hspace\", \"\\\\@ifstar\\\\@hspacer\\\\@hspace\");\ndefineMacro(\"\\\\@hspace\", \"\\\\hskip #1\\\\relax\");\ndefineMacro(\"\\\\@hspacer\", \"\\\\rule{0pt}{0pt}\\\\hskip #1\\\\relax\"); //////////////////////////////////////////////////////////////////////\n// mathtools.sty\n//\\providecommand\\ordinarycolon{:}\n\ndefineMacro(\"\\\\ordinarycolon\", \":\"); //\\def\\vcentcolon{\\mathrel{\\mathop\\ordinarycolon}}\n//TODO(edemaine): Not yet centered. Fix via \\raisebox or #726\n\ndefineMacro(\"\\\\vcentcolon\", \"\\\\mathrel{\\\\mathop\\\\ordinarycolon}\"); // \\providecommand*\\dblcolon{\\vcentcolon\\mathrel{\\mkern-.9mu}\\vcentcolon}\n\ndefineMacro(\"\\\\dblcolon\", \"\\\\html@mathml{\" + \"\\\\mathrel{\\\\vcentcolon\\\\mathrel{\\\\mkern-.9mu}\\\\vcentcolon}}\" + \"{\\\\mathop{\\\\char\\\"2237}}\"); // \\providecommand*\\coloneqq{\\vcentcolon\\mathrel{\\mkern-1.2mu}=}\n\ndefineMacro(\"\\\\coloneqq\", \"\\\\html@mathml{\" + \"\\\\mathrel{\\\\vcentcolon\\\\mathrel{\\\\mkern-1.2mu}=}}\" + \"{\\\\mathop{\\\\char\\\"2254}}\"); // ≔\n// \\providecommand*\\Coloneqq{\\dblcolon\\mathrel{\\mkern-1.2mu}=}\n\ndefineMacro(\"\\\\Coloneqq\", \"\\\\html@mathml{\" + \"\\\\mathrel{\\\\dblcolon\\\\mathrel{\\\\mkern-1.2mu}=}}\" + \"{\\\\mathop{\\\\char\\\"2237\\\\char\\\"3d}}\"); // \\providecommand*\\coloneq{\\vcentcolon\\mathrel{\\mkern-1.2mu}\\mathrel{-}}\n\ndefineMacro(\"\\\\coloneq\", \"\\\\html@mathml{\" + \"\\\\mathrel{\\\\vcentcolon\\\\mathrel{\\\\mkern-1.2mu}\\\\mathrel{-}}}\" + \"{\\\\mathop{\\\\char\\\"3a\\\\char\\\"2212}}\"); // \\providecommand*\\Coloneq{\\dblcolon\\mathrel{\\mkern-1.2mu}\\mathrel{-}}\n\ndefineMacro(\"\\\\Coloneq\", \"\\\\html@mathml{\" + \"\\\\mathrel{\\\\dblcolon\\\\mathrel{\\\\mkern-1.2mu}\\\\mathrel{-}}}\" + \"{\\\\mathop{\\\\char\\\"2237\\\\char\\\"2212}}\"); // \\providecommand*\\eqqcolon{=\\mathrel{\\mkern-1.2mu}\\vcentcolon}\n\ndefineMacro(\"\\\\eqqcolon\", \"\\\\html@mathml{\" + \"\\\\mathrel{=\\\\mathrel{\\\\mkern-1.2mu}\\\\vcentcolon}}\" + \"{\\\\mathop{\\\\char\\\"2255}}\"); // ≕\n// \\providecommand*\\Eqqcolon{=\\mathrel{\\mkern-1.2mu}\\dblcolon}\n\ndefineMacro(\"\\\\Eqqcolon\", \"\\\\html@mathml{\" + \"\\\\mathrel{=\\\\mathrel{\\\\mkern-1.2mu}\\\\dblcolon}}\" + \"{\\\\mathop{\\\\char\\\"3d\\\\char\\\"2237}}\"); // \\providecommand*\\eqcolon{\\mathrel{-}\\mathrel{\\mkern-1.2mu}\\vcentcolon}\n\ndefineMacro(\"\\\\eqcolon\", \"\\\\html@mathml{\" + \"\\\\mathrel{\\\\mathrel{-}\\\\mathrel{\\\\mkern-1.2mu}\\\\vcentcolon}}\" + \"{\\\\mathop{\\\\char\\\"2239}}\"); // \\providecommand*\\Eqcolon{\\mathrel{-}\\mathrel{\\mkern-1.2mu}\\dblcolon}\n\ndefineMacro(\"\\\\Eqcolon\", \"\\\\html@mathml{\" + \"\\\\mathrel{\\\\mathrel{-}\\\\mathrel{\\\\mkern-1.2mu}\\\\dblcolon}}\" + \"{\\\\mathop{\\\\char\\\"2212\\\\char\\\"2237}}\"); // \\providecommand*\\colonapprox{\\vcentcolon\\mathrel{\\mkern-1.2mu}\\approx}\n\ndefineMacro(\"\\\\colonapprox\", \"\\\\html@mathml{\" + \"\\\\mathrel{\\\\vcentcolon\\\\mathrel{\\\\mkern-1.2mu}\\\\approx}}\" + \"{\\\\mathop{\\\\char\\\"3a\\\\char\\\"2248}}\"); // \\providecommand*\\Colonapprox{\\dblcolon\\mathrel{\\mkern-1.2mu}\\approx}\n\ndefineMacro(\"\\\\Colonapprox\", \"\\\\html@mathml{\" + \"\\\\mathrel{\\\\dblcolon\\\\mathrel{\\\\mkern-1.2mu}\\\\approx}}\" + \"{\\\\mathop{\\\\char\\\"2237\\\\char\\\"2248}}\"); // \\providecommand*\\colonsim{\\vcentcolon\\mathrel{\\mkern-1.2mu}\\sim}\n\ndefineMacro(\"\\\\colonsim\", \"\\\\html@mathml{\" + \"\\\\mathrel{\\\\vcentcolon\\\\mathrel{\\\\mkern-1.2mu}\\\\sim}}\" + \"{\\\\mathop{\\\\char\\\"3a\\\\char\\\"223c}}\"); // \\providecommand*\\Colonsim{\\dblcolon\\mathrel{\\mkern-1.2mu}\\sim}\n\ndefineMacro(\"\\\\Colonsim\", \"\\\\html@mathml{\" + \"\\\\mathrel{\\\\dblcolon\\\\mathrel{\\\\mkern-1.2mu}\\\\sim}}\" + \"{\\\\mathop{\\\\char\\\"2237\\\\char\\\"223c}}\"); // Some Unicode characters are implemented with macros to mathtools functions.\n\ndefineMacro(\"\\u2237\", \"\\\\dblcolon\"); // ::\n\ndefineMacro(\"\\u2239\", \"\\\\eqcolon\"); // -:\n\ndefineMacro(\"\\u2254\", \"\\\\coloneqq\"); // :=\n\ndefineMacro(\"\\u2255\", \"\\\\eqqcolon\"); // =:\n\ndefineMacro(\"\\u2A74\", \"\\\\Coloneqq\"); // ::=\n//////////////////////////////////////////////////////////////////////\n// colonequals.sty\n// Alternate names for mathtools's macros:\n\ndefineMacro(\"\\\\ratio\", \"\\\\vcentcolon\");\ndefineMacro(\"\\\\coloncolon\", \"\\\\dblcolon\");\ndefineMacro(\"\\\\colonequals\", \"\\\\coloneqq\");\ndefineMacro(\"\\\\coloncolonequals\", \"\\\\Coloneqq\");\ndefineMacro(\"\\\\equalscolon\", \"\\\\eqqcolon\");\ndefineMacro(\"\\\\equalscoloncolon\", \"\\\\Eqqcolon\");\ndefineMacro(\"\\\\colonminus\", \"\\\\coloneq\");\ndefineMacro(\"\\\\coloncolonminus\", \"\\\\Coloneq\");\ndefineMacro(\"\\\\minuscolon\", \"\\\\eqcolon\");\ndefineMacro(\"\\\\minuscoloncolon\", \"\\\\Eqcolon\"); // \\colonapprox name is same in mathtools and colonequals.\n\ndefineMacro(\"\\\\coloncolonapprox\", \"\\\\Colonapprox\"); // \\colonsim name is same in mathtools and colonequals.\n\ndefineMacro(\"\\\\coloncolonsim\", \"\\\\Colonsim\"); // Additional macros, implemented by analogy with mathtools definitions:\n\ndefineMacro(\"\\\\simcolon\", \"\\\\mathrel{\\\\sim\\\\mathrel{\\\\mkern-1.2mu}\\\\vcentcolon}\");\ndefineMacro(\"\\\\simcoloncolon\", \"\\\\mathrel{\\\\sim\\\\mathrel{\\\\mkern-1.2mu}\\\\dblcolon}\");\ndefineMacro(\"\\\\approxcolon\", \"\\\\mathrel{\\\\approx\\\\mathrel{\\\\mkern-1.2mu}\\\\vcentcolon}\");\ndefineMacro(\"\\\\approxcoloncolon\", \"\\\\mathrel{\\\\approx\\\\mathrel{\\\\mkern-1.2mu}\\\\dblcolon}\"); // Present in newtxmath, pxfonts and txfonts\n\ndefineMacro(\"\\\\notni\", \"\\\\html@mathml{\\\\not\\\\ni}{\\\\mathrel{\\\\char`\\u220C}}\");\ndefineMacro(\"\\\\limsup\", \"\\\\DOTSB\\\\operatorname*{lim\\\\,sup}\");\ndefineMacro(\"\\\\liminf\", \"\\\\DOTSB\\\\operatorname*{lim\\\\,inf}\"); //////////////////////////////////////////////////////////////////////\n// MathML alternates for KaTeX glyphs in the Unicode private area\n\ndefineMacro(\"\\\\gvertneqq\", \"\\\\html@mathml{\\\\@gvertneqq}{\\u2269}\");\ndefineMacro(\"\\\\lvertneqq\", \"\\\\html@mathml{\\\\@lvertneqq}{\\u2268}\");\ndefineMacro(\"\\\\ngeqq\", \"\\\\html@mathml{\\\\@ngeqq}{\\u2271}\");\ndefineMacro(\"\\\\ngeqslant\", \"\\\\html@mathml{\\\\@ngeqslant}{\\u2271}\");\ndefineMacro(\"\\\\nleqq\", \"\\\\html@mathml{\\\\@nleqq}{\\u2270}\");\ndefineMacro(\"\\\\nleqslant\", \"\\\\html@mathml{\\\\@nleqslant}{\\u2270}\");\ndefineMacro(\"\\\\nshortmid\", \"\\\\html@mathml{\\\\@nshortmid}{∤}\");\ndefineMacro(\"\\\\nshortparallel\", \"\\\\html@mathml{\\\\@nshortparallel}{∦}\");\ndefineMacro(\"\\\\nsubseteqq\", \"\\\\html@mathml{\\\\@nsubseteqq}{\\u2288}\");\ndefineMacro(\"\\\\nsupseteqq\", \"\\\\html@mathml{\\\\@nsupseteqq}{\\u2289}\");\ndefineMacro(\"\\\\varsubsetneq\", \"\\\\html@mathml{\\\\@varsubsetneq}{⊊}\");\ndefineMacro(\"\\\\varsubsetneqq\", \"\\\\html@mathml{\\\\@varsubsetneqq}{⫋}\");\ndefineMacro(\"\\\\varsupsetneq\", \"\\\\html@mathml{\\\\@varsupsetneq}{⊋}\");\ndefineMacro(\"\\\\varsupsetneqq\", \"\\\\html@mathml{\\\\@varsupsetneqq}{⫌}\"); //////////////////////////////////////////////////////////////////////\n// stmaryrd and semantic\n// The stmaryrd and semantic packages render the next four items by calling a\n// glyph. Those glyphs do not exist in the KaTeX fonts. Hence the macros.\n\ndefineMacro(\"\\\\llbracket\", \"\\\\html@mathml{\" + \"\\\\mathopen{[\\\\mkern-3.2mu[}}\" + \"{\\\\mathopen{\\\\char`\\u27E6}}\");\ndefineMacro(\"\\\\rrbracket\", \"\\\\html@mathml{\" + \"\\\\mathclose{]\\\\mkern-3.2mu]}}\" + \"{\\\\mathclose{\\\\char`\\u27E7}}\");\ndefineMacro(\"\\u27E6\", \"\\\\llbracket\"); // blackboard bold [\n\ndefineMacro(\"\\u27E7\", \"\\\\rrbracket\"); // blackboard bold ]\n\ndefineMacro(\"\\\\lBrace\", \"\\\\html@mathml{\" + \"\\\\mathopen{\\\\{\\\\mkern-3.2mu[}}\" + \"{\\\\mathopen{\\\\char`\\u2983}}\");\ndefineMacro(\"\\\\rBrace\", \"\\\\html@mathml{\" + \"\\\\mathclose{]\\\\mkern-3.2mu\\\\}}}\" + \"{\\\\mathclose{\\\\char`\\u2984}}\");\ndefineMacro(\"\\u2983\", \"\\\\lBrace\"); // blackboard bold {\n\ndefineMacro(\"\\u2984\", \"\\\\rBrace\"); // blackboard bold }\n// TODO: Create variable sized versions of the last two items. I believe that\n// will require new font glyphs.\n//////////////////////////////////////////////////////////////////////\n// texvc.sty\n// The texvc package contains macros available in mediawiki pages.\n// We omit the functions deprecated at\n// https://en.wikipedia.org/wiki/Help:Displaying_a_formula#Deprecated_syntax\n// We also omit texvc's \\O, which conflicts with \\text{\\O}\n\ndefineMacro(\"\\\\darr\", \"\\\\downarrow\");\ndefineMacro(\"\\\\dArr\", \"\\\\Downarrow\");\ndefineMacro(\"\\\\Darr\", \"\\\\Downarrow\");\ndefineMacro(\"\\\\lang\", \"\\\\langle\");\ndefineMacro(\"\\\\rang\", \"\\\\rangle\");\ndefineMacro(\"\\\\uarr\", \"\\\\uparrow\");\ndefineMacro(\"\\\\uArr\", \"\\\\Uparrow\");\ndefineMacro(\"\\\\Uarr\", \"\\\\Uparrow\");\ndefineMacro(\"\\\\N\", \"\\\\mathbb{N}\");\ndefineMacro(\"\\\\R\", \"\\\\mathbb{R}\");\ndefineMacro(\"\\\\Z\", \"\\\\mathbb{Z}\");\ndefineMacro(\"\\\\alef\", \"\\\\aleph\");\ndefineMacro(\"\\\\alefsym\", \"\\\\aleph\");\ndefineMacro(\"\\\\Alpha\", \"\\\\mathrm{A}\");\ndefineMacro(\"\\\\Beta\", \"\\\\mathrm{B}\");\ndefineMacro(\"\\\\bull\", \"\\\\bullet\");\ndefineMacro(\"\\\\Chi\", \"\\\\mathrm{X}\");\ndefineMacro(\"\\\\clubs\", \"\\\\clubsuit\");\ndefineMacro(\"\\\\cnums\", \"\\\\mathbb{C}\");\ndefineMacro(\"\\\\Complex\", \"\\\\mathbb{C}\");\ndefineMacro(\"\\\\Dagger\", \"\\\\ddagger\");\ndefineMacro(\"\\\\diamonds\", \"\\\\diamondsuit\");\ndefineMacro(\"\\\\empty\", \"\\\\emptyset\");\ndefineMacro(\"\\\\Epsilon\", \"\\\\mathrm{E}\");\ndefineMacro(\"\\\\Eta\", \"\\\\mathrm{H}\");\ndefineMacro(\"\\\\exist\", \"\\\\exists\");\ndefineMacro(\"\\\\harr\", \"\\\\leftrightarrow\");\ndefineMacro(\"\\\\hArr\", \"\\\\Leftrightarrow\");\ndefineMacro(\"\\\\Harr\", \"\\\\Leftrightarrow\");\ndefineMacro(\"\\\\hearts\", \"\\\\heartsuit\");\ndefineMacro(\"\\\\image\", \"\\\\Im\");\ndefineMacro(\"\\\\infin\", \"\\\\infty\");\ndefineMacro(\"\\\\Iota\", \"\\\\mathrm{I}\");\ndefineMacro(\"\\\\isin\", \"\\\\in\");\ndefineMacro(\"\\\\Kappa\", \"\\\\mathrm{K}\");\ndefineMacro(\"\\\\larr\", \"\\\\leftarrow\");\ndefineMacro(\"\\\\lArr\", \"\\\\Leftarrow\");\ndefineMacro(\"\\\\Larr\", \"\\\\Leftarrow\");\ndefineMacro(\"\\\\lrarr\", \"\\\\leftrightarrow\");\ndefineMacro(\"\\\\lrArr\", \"\\\\Leftrightarrow\");\ndefineMacro(\"\\\\Lrarr\", \"\\\\Leftrightarrow\");\ndefineMacro(\"\\\\Mu\", \"\\\\mathrm{M}\");\ndefineMacro(\"\\\\natnums\", \"\\\\mathbb{N}\");\ndefineMacro(\"\\\\Nu\", \"\\\\mathrm{N}\");\ndefineMacro(\"\\\\Omicron\", \"\\\\mathrm{O}\");\ndefineMacro(\"\\\\plusmn\", \"\\\\pm\");\ndefineMacro(\"\\\\rarr\", \"\\\\rightarrow\");\ndefineMacro(\"\\\\rArr\", \"\\\\Rightarrow\");\ndefineMacro(\"\\\\Rarr\", \"\\\\Rightarrow\");\ndefineMacro(\"\\\\real\", \"\\\\Re\");\ndefineMacro(\"\\\\reals\", \"\\\\mathbb{R}\");\ndefineMacro(\"\\\\Reals\", \"\\\\mathbb{R}\");\ndefineMacro(\"\\\\Rho\", \"\\\\mathrm{P}\");\ndefineMacro(\"\\\\sdot\", \"\\\\cdot\");\ndefineMacro(\"\\\\sect\", \"\\\\S\");\ndefineMacro(\"\\\\spades\", \"\\\\spadesuit\");\ndefineMacro(\"\\\\sub\", \"\\\\subset\");\ndefineMacro(\"\\\\sube\", \"\\\\subseteq\");\ndefineMacro(\"\\\\supe\", \"\\\\supseteq\");\ndefineMacro(\"\\\\Tau\", \"\\\\mathrm{T}\");\ndefineMacro(\"\\\\thetasym\", \"\\\\vartheta\"); // TODO: defineMacro(\"\\\\varcoppa\", \"\\\\\\mbox{\\\\coppa}\");\n\ndefineMacro(\"\\\\weierp\", \"\\\\wp\");\ndefineMacro(\"\\\\Zeta\", \"\\\\mathrm{Z}\"); //////////////////////////////////////////////////////////////////////\n// statmath.sty\n// https://ctan.math.illinois.edu/macros/latex/contrib/statmath/statmath.pdf\n\ndefineMacro(\"\\\\argmin\", \"\\\\DOTSB\\\\operatorname*{arg\\\\,min}\");\ndefineMacro(\"\\\\argmax\", \"\\\\DOTSB\\\\operatorname*{arg\\\\,max}\");\ndefineMacro(\"\\\\plim\", \"\\\\DOTSB\\\\mathop{\\\\operatorname{plim}}\\\\limits\"); // Custom Khan Academy colors, should be moved to an optional package\n\ndefineMacro(\"\\\\blue\", \"\\\\textcolor{##6495ed}{#1}\");\ndefineMacro(\"\\\\orange\", \"\\\\textcolor{##ffa500}{#1}\");\ndefineMacro(\"\\\\pink\", \"\\\\textcolor{##ff00af}{#1}\");\ndefineMacro(\"\\\\red\", \"\\\\textcolor{##df0030}{#1}\");\ndefineMacro(\"\\\\green\", \"\\\\textcolor{##28ae7b}{#1}\");\ndefineMacro(\"\\\\gray\", \"\\\\textcolor{gray}{#1}\");\ndefineMacro(\"\\\\purple\", \"\\\\textcolor{##9d38bd}{#1}\");\ndefineMacro(\"\\\\blueA\", \"\\\\textcolor{##ccfaff}{#1}\");\ndefineMacro(\"\\\\blueB\", \"\\\\textcolor{##80f6ff}{#1}\");\ndefineMacro(\"\\\\blueC\", \"\\\\textcolor{##63d9ea}{#1}\");\ndefineMacro(\"\\\\blueD\", \"\\\\textcolor{##11accd}{#1}\");\ndefineMacro(\"\\\\blueE\", \"\\\\textcolor{##0c7f99}{#1}\");\ndefineMacro(\"\\\\tealA\", \"\\\\textcolor{##94fff5}{#1}\");\ndefineMacro(\"\\\\tealB\", \"\\\\textcolor{##26edd5}{#1}\");\ndefineMacro(\"\\\\tealC\", \"\\\\textcolor{##01d1c1}{#1}\");\ndefineMacro(\"\\\\tealD\", \"\\\\textcolor{##01a995}{#1}\");\ndefineMacro(\"\\\\tealE\", \"\\\\textcolor{##208170}{#1}\");\ndefineMacro(\"\\\\greenA\", \"\\\\textcolor{##b6ffb0}{#1}\");\ndefineMacro(\"\\\\greenB\", \"\\\\textcolor{##8af281}{#1}\");\ndefineMacro(\"\\\\greenC\", \"\\\\textcolor{##74cf70}{#1}\");\ndefineMacro(\"\\\\greenD\", \"\\\\textcolor{##1fab54}{#1}\");\ndefineMacro(\"\\\\greenE\", \"\\\\textcolor{##0d923f}{#1}\");\ndefineMacro(\"\\\\goldA\", \"\\\\textcolor{##ffd0a9}{#1}\");\ndefineMacro(\"\\\\goldB\", \"\\\\textcolor{##ffbb71}{#1}\");\ndefineMacro(\"\\\\goldC\", \"\\\\textcolor{##ff9c39}{#1}\");\ndefineMacro(\"\\\\goldD\", \"\\\\textcolor{##e07d10}{#1}\");\ndefineMacro(\"\\\\goldE\", \"\\\\textcolor{##a75a05}{#1}\");\ndefineMacro(\"\\\\redA\", \"\\\\textcolor{##fca9a9}{#1}\");\ndefineMacro(\"\\\\redB\", \"\\\\textcolor{##ff8482}{#1}\");\ndefineMacro(\"\\\\redC\", \"\\\\textcolor{##f9685d}{#1}\");\ndefineMacro(\"\\\\redD\", \"\\\\textcolor{##e84d39}{#1}\");\ndefineMacro(\"\\\\redE\", \"\\\\textcolor{##bc2612}{#1}\");\ndefineMacro(\"\\\\maroonA\", \"\\\\textcolor{##ffbde0}{#1}\");\ndefineMacro(\"\\\\maroonB\", \"\\\\textcolor{##ff92c6}{#1}\");\ndefineMacro(\"\\\\maroonC\", \"\\\\textcolor{##ed5fa6}{#1}\");\ndefineMacro(\"\\\\maroonD\", \"\\\\textcolor{##ca337c}{#1}\");\ndefineMacro(\"\\\\maroonE\", \"\\\\textcolor{##9e034e}{#1}\");\ndefineMacro(\"\\\\purpleA\", \"\\\\textcolor{##ddd7ff}{#1}\");\ndefineMacro(\"\\\\purpleB\", \"\\\\textcolor{##c6b9fc}{#1}\");\ndefineMacro(\"\\\\purpleC\", \"\\\\textcolor{##aa87ff}{#1}\");\ndefineMacro(\"\\\\purpleD\", \"\\\\textcolor{##7854ab}{#1}\");\ndefineMacro(\"\\\\purpleE\", \"\\\\textcolor{##543b78}{#1}\");\ndefineMacro(\"\\\\mintA\", \"\\\\textcolor{##f5f9e8}{#1}\");\ndefineMacro(\"\\\\mintB\", \"\\\\textcolor{##edf2df}{#1}\");\ndefineMacro(\"\\\\mintC\", \"\\\\textcolor{##e0e5cc}{#1}\");\ndefineMacro(\"\\\\grayA\", \"\\\\textcolor{##f6f7f7}{#1}\");\ndefineMacro(\"\\\\grayB\", \"\\\\textcolor{##f0f1f2}{#1}\");\ndefineMacro(\"\\\\grayC\", \"\\\\textcolor{##e3e5e6}{#1}\");\ndefineMacro(\"\\\\grayD\", \"\\\\textcolor{##d6d8da}{#1}\");\ndefineMacro(\"\\\\grayE\", \"\\\\textcolor{##babec2}{#1}\");\ndefineMacro(\"\\\\grayF\", \"\\\\textcolor{##888d93}{#1}\");\ndefineMacro(\"\\\\grayG\", \"\\\\textcolor{##626569}{#1}\");\ndefineMacro(\"\\\\grayH\", \"\\\\textcolor{##3b3e40}{#1}\");\ndefineMacro(\"\\\\grayI\", \"\\\\textcolor{##21242c}{#1}\");\ndefineMacro(\"\\\\kaBlue\", \"\\\\textcolor{##314453}{#1}\");\ndefineMacro(\"\\\\kaGreen\", \"\\\\textcolor{##71B307}{#1}\");\n// CONCATENATED MODULE: ./src/MacroExpander.js\n/**\n * This file contains the “gullet” where macros are expanded\n * until only non-macro tokens remain.\n */\n\n\n\n\n\n\n\n// List of commands that act like macros but aren't defined as a macro,\n// function, or symbol. Used in `isDefined`.\nvar implicitCommands = {\n \"\\\\relax\": true,\n // MacroExpander.js\n \"^\": true,\n // Parser.js\n \"_\": true,\n // Parser.js\n \"\\\\limits\": true,\n // Parser.js\n \"\\\\nolimits\": true // Parser.js\n\n};\n\nvar MacroExpander_MacroExpander =\n/*#__PURE__*/\nfunction () {\n function MacroExpander(input, settings, mode) {\n this.settings = void 0;\n this.expansionCount = void 0;\n this.lexer = void 0;\n this.macros = void 0;\n this.stack = void 0;\n this.mode = void 0;\n this.settings = settings;\n this.expansionCount = 0;\n this.feed(input); // Make new global namespace\n\n this.macros = new Namespace_Namespace(macros, settings.macros);\n this.mode = mode;\n this.stack = []; // contains tokens in REVERSE order\n }\n /**\n * Feed a new input string to the same MacroExpander\n * (with existing macros etc.).\n */\n\n\n var _proto = MacroExpander.prototype;\n\n _proto.feed = function feed(input) {\n this.lexer = new Lexer_Lexer(input, this.settings);\n }\n /**\n * Switches between \"text\" and \"math\" modes.\n */\n ;\n\n _proto.switchMode = function switchMode(newMode) {\n this.mode = newMode;\n }\n /**\n * Start a new group nesting within all namespaces.\n */\n ;\n\n _proto.beginGroup = function beginGroup() {\n this.macros.beginGroup();\n }\n /**\n * End current group nesting within all namespaces.\n */\n ;\n\n _proto.endGroup = function endGroup() {\n this.macros.endGroup();\n }\n /**\n * Returns the topmost token on the stack, without expanding it.\n * Similar in behavior to TeX's `\\futurelet`.\n */\n ;\n\n _proto.future = function future() {\n if (this.stack.length === 0) {\n this.pushToken(this.lexer.lex());\n }\n\n return this.stack[this.stack.length - 1];\n }\n /**\n * Remove and return the next unexpanded token.\n */\n ;\n\n _proto.popToken = function popToken() {\n this.future(); // ensure non-empty stack\n\n return this.stack.pop();\n }\n /**\n * Add a given token to the token stack. In particular, this get be used\n * to put back a token returned from one of the other methods.\n */\n ;\n\n _proto.pushToken = function pushToken(token) {\n this.stack.push(token);\n }\n /**\n * Append an array of tokens to the token stack.\n */\n ;\n\n _proto.pushTokens = function pushTokens(tokens) {\n var _this$stack;\n\n (_this$stack = this.stack).push.apply(_this$stack, tokens);\n }\n /**\n * Consume all following space tokens, without expansion.\n */\n ;\n\n _proto.consumeSpaces = function consumeSpaces() {\n for (;;) {\n var token = this.future();\n\n if (token.text === \" \") {\n this.stack.pop();\n } else {\n break;\n }\n }\n }\n /**\n * Consume the specified number of arguments from the token stream,\n * and return the resulting array of arguments.\n */\n ;\n\n _proto.consumeArgs = function consumeArgs(numArgs) {\n var args = []; // obtain arguments, either single token or balanced {…} group\n\n for (var i = 0; i < numArgs; ++i) {\n this.consumeSpaces(); // ignore spaces before each argument\n\n var startOfArg = this.popToken();\n\n if (startOfArg.text === \"{\") {\n var arg = [];\n var depth = 1;\n\n while (depth !== 0) {\n var tok = this.popToken();\n arg.push(tok);\n\n if (tok.text === \"{\") {\n ++depth;\n } else if (tok.text === \"}\") {\n --depth;\n } else if (tok.text === \"EOF\") {\n throw new src_ParseError(\"End of input in macro argument\", startOfArg);\n }\n }\n\n arg.pop(); // remove last }\n\n arg.reverse(); // like above, to fit in with stack order\n\n args[i] = arg;\n } else if (startOfArg.text === \"EOF\") {\n throw new src_ParseError(\"End of input expecting macro argument\");\n } else {\n args[i] = [startOfArg];\n }\n }\n\n return args;\n }\n /**\n * Expand the next token only once if possible.\n *\n * If the token is expanded, the resulting tokens will be pushed onto\n * the stack in reverse order and will be returned as an array,\n * also in reverse order.\n *\n * If not, the next token will be returned without removing it\n * from the stack. This case can be detected by a `Token` return value\n * instead of an `Array` return value.\n *\n * In either case, the next token will be on the top of the stack,\n * or the stack will be empty.\n *\n * Used to implement `expandAfterFuture` and `expandNextToken`.\n *\n * At the moment, macro expansion doesn't handle delimited macros,\n * i.e. things like those defined by \\def\\foo#1\\end{…}.\n * See the TeX book page 202ff. for details on how those should behave.\n */\n ;\n\n _proto.expandOnce = function expandOnce() {\n var topToken = this.popToken();\n var name = topToken.text;\n\n var expansion = this._getExpansion(name);\n\n if (expansion == null) {\n // mainly checking for undefined here\n // Fully expanded\n this.pushToken(topToken);\n return topToken;\n }\n\n this.expansionCount++;\n\n if (this.expansionCount > this.settings.maxExpand) {\n throw new src_ParseError(\"Too many expansions: infinite loop or \" + \"need to increase maxExpand setting\");\n }\n\n var tokens = expansion.tokens;\n\n if (expansion.numArgs) {\n var args = this.consumeArgs(expansion.numArgs); // paste arguments in place of the placeholders\n\n tokens = tokens.slice(); // make a shallow copy\n\n for (var i = tokens.length - 1; i >= 0; --i) {\n var tok = tokens[i];\n\n if (tok.text === \"#\") {\n if (i === 0) {\n throw new src_ParseError(\"Incomplete placeholder at end of macro body\", tok);\n }\n\n tok = tokens[--i]; // next token on stack\n\n if (tok.text === \"#\") {\n // ## → #\n tokens.splice(i + 1, 1); // drop first #\n } else if (/^[1-9]$/.test(tok.text)) {\n var _tokens;\n\n // replace the placeholder with the indicated argument\n (_tokens = tokens).splice.apply(_tokens, [i, 2].concat(args[+tok.text - 1]));\n } else {\n throw new src_ParseError(\"Not a valid argument number\", tok);\n }\n }\n }\n } // Concatenate expansion onto top of stack.\n\n\n this.pushTokens(tokens);\n return tokens;\n }\n /**\n * Expand the next token only once (if possible), and return the resulting\n * top token on the stack (without removing anything from the stack).\n * Similar in behavior to TeX's `\\expandafter\\futurelet`.\n * Equivalent to expandOnce() followed by future().\n */\n ;\n\n _proto.expandAfterFuture = function expandAfterFuture() {\n this.expandOnce();\n return this.future();\n }\n /**\n * Recursively expand first token, then return first non-expandable token.\n */\n ;\n\n _proto.expandNextToken = function expandNextToken() {\n for (;;) {\n var expanded = this.expandOnce(); // expandOnce returns Token if and only if it's fully expanded.\n\n if (expanded instanceof Token_Token) {\n // \\relax stops the expansion, but shouldn't get returned (a\n // null return value couldn't get implemented as a function).\n if (expanded.text === \"\\\\relax\") {\n this.stack.pop();\n } else {\n return this.stack.pop(); // === expanded\n }\n }\n } // Flow unable to figure out that this pathway is impossible.\n // https://github.com/facebook/flow/issues/4808\n\n\n throw new Error(); // eslint-disable-line no-unreachable\n }\n /**\n * Fully expand the given macro name and return the resulting list of\n * tokens, or return `undefined` if no such macro is defined.\n */\n ;\n\n _proto.expandMacro = function expandMacro(name) {\n if (!this.macros.get(name)) {\n return undefined;\n }\n\n var output = [];\n var oldStackLength = this.stack.length;\n this.pushToken(new Token_Token(name));\n\n while (this.stack.length > oldStackLength) {\n var expanded = this.expandOnce(); // expandOnce returns Token if and only if it's fully expanded.\n\n if (expanded instanceof Token_Token) {\n output.push(this.stack.pop());\n }\n }\n\n return output;\n }\n /**\n * Fully expand the given macro name and return the result as a string,\n * or return `undefined` if no such macro is defined.\n */\n ;\n\n _proto.expandMacroAsText = function expandMacroAsText(name) {\n var tokens = this.expandMacro(name);\n\n if (tokens) {\n return tokens.map(function (token) {\n return token.text;\n }).join(\"\");\n } else {\n return tokens;\n }\n }\n /**\n * Returns the expanded macro as a reversed array of tokens and a macro\n * argument count. Or returns `null` if no such macro.\n */\n ;\n\n _proto._getExpansion = function _getExpansion(name) {\n var definition = this.macros.get(name);\n\n if (definition == null) {\n // mainly checking for undefined here\n return definition;\n }\n\n var expansion = typeof definition === \"function\" ? definition(this) : definition;\n\n if (typeof expansion === \"string\") {\n var numArgs = 0;\n\n if (expansion.indexOf(\"#\") !== -1) {\n var stripped = expansion.replace(/##/g, \"\");\n\n while (stripped.indexOf(\"#\" + (numArgs + 1)) !== -1) {\n ++numArgs;\n }\n }\n\n var bodyLexer = new Lexer_Lexer(expansion, this.settings);\n var tokens = [];\n var tok = bodyLexer.lex();\n\n while (tok.text !== \"EOF\") {\n tokens.push(tok);\n tok = bodyLexer.lex();\n }\n\n tokens.reverse(); // to fit in with stack using push and pop\n\n var expanded = {\n tokens: tokens,\n numArgs: numArgs\n };\n return expanded;\n }\n\n return expansion;\n }\n /**\n * Determine whether a command is currently \"defined\" (has some\n * functionality), meaning that it's a macro (in the current group),\n * a function, a symbol, or one of the special commands listed in\n * `implicitCommands`.\n */\n ;\n\n _proto.isDefined = function isDefined(name) {\n return this.macros.has(name) || src_functions.hasOwnProperty(name) || src_symbols.math.hasOwnProperty(name) || src_symbols.text.hasOwnProperty(name) || implicitCommands.hasOwnProperty(name);\n };\n\n return MacroExpander;\n}();\n\n\n// CONCATENATED MODULE: ./src/unicodeAccents.js\n// Mapping of Unicode accent characters to their LaTeX equivalent in text and\n// math mode (when they exist).\n/* harmony default export */ var unicodeAccents = ({\n \"\\u0301\": {\n text: \"\\\\'\",\n math: '\\\\acute'\n },\n \"\\u0300\": {\n text: '\\\\`',\n math: '\\\\grave'\n },\n \"\\u0308\": {\n text: '\\\\\"',\n math: '\\\\ddot'\n },\n \"\\u0303\": {\n text: '\\\\~',\n math: '\\\\tilde'\n },\n \"\\u0304\": {\n text: '\\\\=',\n math: '\\\\bar'\n },\n \"\\u0306\": {\n text: \"\\\\u\",\n math: '\\\\breve'\n },\n \"\\u030C\": {\n text: '\\\\v',\n math: '\\\\check'\n },\n \"\\u0302\": {\n text: '\\\\^',\n math: '\\\\hat'\n },\n \"\\u0307\": {\n text: '\\\\.',\n math: '\\\\dot'\n },\n \"\\u030A\": {\n text: '\\\\r',\n math: '\\\\mathring'\n },\n \"\\u030B\": {\n text: '\\\\H'\n }\n});\n// CONCATENATED MODULE: ./src/unicodeSymbols.js\n// This file is GENERATED by unicodeMake.js. DO NOT MODIFY.\n/* harmony default export */ var unicodeSymbols = ({\n \"\\xE1\": \"a\\u0301\",\n // á = \\'{a}\n \"\\xE0\": \"a\\u0300\",\n // à = \\`{a}\n \"\\xE4\": \"a\\u0308\",\n // ä = \\\"{a}\n \"\\u01DF\": \"a\\u0308\\u0304\",\n // ǟ = \\\"\\={a}\n \"\\xE3\": \"a\\u0303\",\n // ã = \\~{a}\n \"\\u0101\": \"a\\u0304\",\n // ā = \\={a}\n \"\\u0103\": \"a\\u0306\",\n // ă = \\u{a}\n \"\\u1EAF\": \"a\\u0306\\u0301\",\n // ắ = \\u\\'{a}\n \"\\u1EB1\": \"a\\u0306\\u0300\",\n // ằ = \\u\\`{a}\n \"\\u1EB5\": \"a\\u0306\\u0303\",\n // ẵ = \\u\\~{a}\n \"\\u01CE\": \"a\\u030C\",\n // ǎ = \\v{a}\n \"\\xE2\": \"a\\u0302\",\n // â = \\^{a}\n \"\\u1EA5\": \"a\\u0302\\u0301\",\n // ấ = \\^\\'{a}\n \"\\u1EA7\": \"a\\u0302\\u0300\",\n // ầ = \\^\\`{a}\n \"\\u1EAB\": \"a\\u0302\\u0303\",\n // ẫ = \\^\\~{a}\n \"\\u0227\": \"a\\u0307\",\n // ȧ = \\.{a}\n \"\\u01E1\": \"a\\u0307\\u0304\",\n // ǡ = \\.\\={a}\n \"\\xE5\": \"a\\u030A\",\n // å = \\r{a}\n \"\\u01FB\": \"a\\u030A\\u0301\",\n // ǻ = \\r\\'{a}\n \"\\u1E03\": \"b\\u0307\",\n // ḃ = \\.{b}\n \"\\u0107\": \"c\\u0301\",\n // ć = \\'{c}\n \"\\u010D\": \"c\\u030C\",\n // č = \\v{c}\n \"\\u0109\": \"c\\u0302\",\n // ĉ = \\^{c}\n \"\\u010B\": \"c\\u0307\",\n // ċ = \\.{c}\n \"\\u010F\": \"d\\u030C\",\n // ď = \\v{d}\n \"\\u1E0B\": \"d\\u0307\",\n // ḋ = \\.{d}\n \"\\xE9\": \"e\\u0301\",\n // é = \\'{e}\n \"\\xE8\": \"e\\u0300\",\n // è = \\`{e}\n \"\\xEB\": \"e\\u0308\",\n // ë = \\\"{e}\n \"\\u1EBD\": \"e\\u0303\",\n // ẽ = \\~{e}\n \"\\u0113\": \"e\\u0304\",\n // ē = \\={e}\n \"\\u1E17\": \"e\\u0304\\u0301\",\n // ḗ = \\=\\'{e}\n \"\\u1E15\": \"e\\u0304\\u0300\",\n // ḕ = \\=\\`{e}\n \"\\u0115\": \"e\\u0306\",\n // ĕ = \\u{e}\n \"\\u011B\": \"e\\u030C\",\n // ě = \\v{e}\n \"\\xEA\": \"e\\u0302\",\n // ê = \\^{e}\n \"\\u1EBF\": \"e\\u0302\\u0301\",\n // ế = \\^\\'{e}\n \"\\u1EC1\": \"e\\u0302\\u0300\",\n // ề = \\^\\`{e}\n \"\\u1EC5\": \"e\\u0302\\u0303\",\n // ễ = \\^\\~{e}\n \"\\u0117\": \"e\\u0307\",\n // ė = \\.{e}\n \"\\u1E1F\": \"f\\u0307\",\n // ḟ = \\.{f}\n \"\\u01F5\": \"g\\u0301\",\n // ǵ = \\'{g}\n \"\\u1E21\": \"g\\u0304\",\n // ḡ = \\={g}\n \"\\u011F\": \"g\\u0306\",\n // ğ = \\u{g}\n \"\\u01E7\": \"g\\u030C\",\n // ǧ = \\v{g}\n \"\\u011D\": \"g\\u0302\",\n // ĝ = \\^{g}\n \"\\u0121\": \"g\\u0307\",\n // ġ = \\.{g}\n \"\\u1E27\": \"h\\u0308\",\n // ḧ = \\\"{h}\n \"\\u021F\": \"h\\u030C\",\n // ȟ = \\v{h}\n \"\\u0125\": \"h\\u0302\",\n // ĥ = \\^{h}\n \"\\u1E23\": \"h\\u0307\",\n // ḣ = \\.{h}\n \"\\xED\": \"i\\u0301\",\n // í = \\'{i}\n \"\\xEC\": \"i\\u0300\",\n // ì = \\`{i}\n \"\\xEF\": \"i\\u0308\",\n // ï = \\\"{i}\n \"\\u1E2F\": \"i\\u0308\\u0301\",\n // ḯ = \\\"\\'{i}\n \"\\u0129\": \"i\\u0303\",\n // ĩ = \\~{i}\n \"\\u012B\": \"i\\u0304\",\n // ī = \\={i}\n \"\\u012D\": \"i\\u0306\",\n // ĭ = \\u{i}\n \"\\u01D0\": \"i\\u030C\",\n // ǐ = \\v{i}\n \"\\xEE\": \"i\\u0302\",\n // î = \\^{i}\n \"\\u01F0\": \"j\\u030C\",\n // ǰ = \\v{j}\n \"\\u0135\": \"j\\u0302\",\n // ĵ = \\^{j}\n \"\\u1E31\": \"k\\u0301\",\n // ḱ = \\'{k}\n \"\\u01E9\": \"k\\u030C\",\n // ǩ = \\v{k}\n \"\\u013A\": \"l\\u0301\",\n // ĺ = \\'{l}\n \"\\u013E\": \"l\\u030C\",\n // ľ = \\v{l}\n \"\\u1E3F\": \"m\\u0301\",\n // ḿ = \\'{m}\n \"\\u1E41\": \"m\\u0307\",\n // ṁ = \\.{m}\n \"\\u0144\": \"n\\u0301\",\n // ń = \\'{n}\n \"\\u01F9\": \"n\\u0300\",\n // ǹ = \\`{n}\n \"\\xF1\": \"n\\u0303\",\n // ñ = \\~{n}\n \"\\u0148\": \"n\\u030C\",\n // ň = \\v{n}\n \"\\u1E45\": \"n\\u0307\",\n // ṅ = \\.{n}\n \"\\xF3\": \"o\\u0301\",\n // ó = \\'{o}\n \"\\xF2\": \"o\\u0300\",\n // ò = \\`{o}\n \"\\xF6\": \"o\\u0308\",\n // ö = \\\"{o}\n \"\\u022B\": \"o\\u0308\\u0304\",\n // ȫ = \\\"\\={o}\n \"\\xF5\": \"o\\u0303\",\n // õ = \\~{o}\n \"\\u1E4D\": \"o\\u0303\\u0301\",\n // ṍ = \\~\\'{o}\n \"\\u1E4F\": \"o\\u0303\\u0308\",\n // ṏ = \\~\\\"{o}\n \"\\u022D\": \"o\\u0303\\u0304\",\n // ȭ = \\~\\={o}\n \"\\u014D\": \"o\\u0304\",\n // ō = \\={o}\n \"\\u1E53\": \"o\\u0304\\u0301\",\n // ṓ = \\=\\'{o}\n \"\\u1E51\": \"o\\u0304\\u0300\",\n // ṑ = \\=\\`{o}\n \"\\u014F\": \"o\\u0306\",\n // ŏ = \\u{o}\n \"\\u01D2\": \"o\\u030C\",\n // ǒ = \\v{o}\n \"\\xF4\": \"o\\u0302\",\n // ô = \\^{o}\n \"\\u1ED1\": \"o\\u0302\\u0301\",\n // ố = \\^\\'{o}\n \"\\u1ED3\": \"o\\u0302\\u0300\",\n // ồ = \\^\\`{o}\n \"\\u1ED7\": \"o\\u0302\\u0303\",\n // ỗ = \\^\\~{o}\n \"\\u022F\": \"o\\u0307\",\n // ȯ = \\.{o}\n \"\\u0231\": \"o\\u0307\\u0304\",\n // ȱ = \\.\\={o}\n \"\\u0151\": \"o\\u030B\",\n // ő = \\H{o}\n \"\\u1E55\": \"p\\u0301\",\n // ṕ = \\'{p}\n \"\\u1E57\": \"p\\u0307\",\n // ṗ = \\.{p}\n \"\\u0155\": \"r\\u0301\",\n // ŕ = \\'{r}\n \"\\u0159\": \"r\\u030C\",\n // ř = \\v{r}\n \"\\u1E59\": \"r\\u0307\",\n // ṙ = \\.{r}\n \"\\u015B\": \"s\\u0301\",\n // ś = \\'{s}\n \"\\u1E65\": \"s\\u0301\\u0307\",\n // ṥ = \\'\\.{s}\n \"\\u0161\": \"s\\u030C\",\n // š = \\v{s}\n \"\\u1E67\": \"s\\u030C\\u0307\",\n // ṧ = \\v\\.{s}\n \"\\u015D\": \"s\\u0302\",\n // ŝ = \\^{s}\n \"\\u1E61\": \"s\\u0307\",\n // ṡ = \\.{s}\n \"\\u1E97\": \"t\\u0308\",\n // ẗ = \\\"{t}\n \"\\u0165\": \"t\\u030C\",\n // ť = \\v{t}\n \"\\u1E6B\": \"t\\u0307\",\n // ṫ = \\.{t}\n \"\\xFA\": \"u\\u0301\",\n // ú = \\'{u}\n \"\\xF9\": \"u\\u0300\",\n // ù = \\`{u}\n \"\\xFC\": \"u\\u0308\",\n // ü = \\\"{u}\n \"\\u01D8\": \"u\\u0308\\u0301\",\n // ǘ = \\\"\\'{u}\n \"\\u01DC\": \"u\\u0308\\u0300\",\n // ǜ = \\\"\\`{u}\n \"\\u01D6\": \"u\\u0308\\u0304\",\n // ǖ = \\\"\\={u}\n \"\\u01DA\": \"u\\u0308\\u030C\",\n // ǚ = \\\"\\v{u}\n \"\\u0169\": \"u\\u0303\",\n // ũ = \\~{u}\n \"\\u1E79\": \"u\\u0303\\u0301\",\n // ṹ = \\~\\'{u}\n \"\\u016B\": \"u\\u0304\",\n // ū = \\={u}\n \"\\u1E7B\": \"u\\u0304\\u0308\",\n // ṻ = \\=\\\"{u}\n \"\\u016D\": \"u\\u0306\",\n // ŭ = \\u{u}\n \"\\u01D4\": \"u\\u030C\",\n // ǔ = \\v{u}\n \"\\xFB\": \"u\\u0302\",\n // û = \\^{u}\n \"\\u016F\": \"u\\u030A\",\n // ů = \\r{u}\n \"\\u0171\": \"u\\u030B\",\n // ű = \\H{u}\n \"\\u1E7D\": \"v\\u0303\",\n // ṽ = \\~{v}\n \"\\u1E83\": \"w\\u0301\",\n // ẃ = \\'{w}\n \"\\u1E81\": \"w\\u0300\",\n // ẁ = \\`{w}\n \"\\u1E85\": \"w\\u0308\",\n // ẅ = \\\"{w}\n \"\\u0175\": \"w\\u0302\",\n // ŵ = \\^{w}\n \"\\u1E87\": \"w\\u0307\",\n // ẇ = \\.{w}\n \"\\u1E98\": \"w\\u030A\",\n // ẘ = \\r{w}\n \"\\u1E8D\": \"x\\u0308\",\n // ẍ = \\\"{x}\n \"\\u1E8B\": \"x\\u0307\",\n // ẋ = \\.{x}\n \"\\xFD\": \"y\\u0301\",\n // ý = \\'{y}\n \"\\u1EF3\": \"y\\u0300\",\n // ỳ = \\`{y}\n \"\\xFF\": \"y\\u0308\",\n // ÿ = \\\"{y}\n \"\\u1EF9\": \"y\\u0303\",\n // ỹ = \\~{y}\n \"\\u0233\": \"y\\u0304\",\n // ȳ = \\={y}\n \"\\u0177\": \"y\\u0302\",\n // ŷ = \\^{y}\n \"\\u1E8F\": \"y\\u0307\",\n // ẏ = \\.{y}\n \"\\u1E99\": \"y\\u030A\",\n // ẙ = \\r{y}\n \"\\u017A\": \"z\\u0301\",\n // ź = \\'{z}\n \"\\u017E\": \"z\\u030C\",\n // ž = \\v{z}\n \"\\u1E91\": \"z\\u0302\",\n // ẑ = \\^{z}\n \"\\u017C\": \"z\\u0307\",\n // ż = \\.{z}\n \"\\xC1\": \"A\\u0301\",\n // Á = \\'{A}\n \"\\xC0\": \"A\\u0300\",\n // À = \\`{A}\n \"\\xC4\": \"A\\u0308\",\n // Ä = \\\"{A}\n \"\\u01DE\": \"A\\u0308\\u0304\",\n // Ǟ = \\\"\\={A}\n \"\\xC3\": \"A\\u0303\",\n // Ã = \\~{A}\n \"\\u0100\": \"A\\u0304\",\n // Ā = \\={A}\n \"\\u0102\": \"A\\u0306\",\n // Ă = \\u{A}\n \"\\u1EAE\": \"A\\u0306\\u0301\",\n // Ắ = \\u\\'{A}\n \"\\u1EB0\": \"A\\u0306\\u0300\",\n // Ằ = \\u\\`{A}\n \"\\u1EB4\": \"A\\u0306\\u0303\",\n // Ẵ = \\u\\~{A}\n \"\\u01CD\": \"A\\u030C\",\n // Ǎ = \\v{A}\n \"\\xC2\": \"A\\u0302\",\n // Â = \\^{A}\n \"\\u1EA4\": \"A\\u0302\\u0301\",\n // Ấ = \\^\\'{A}\n \"\\u1EA6\": \"A\\u0302\\u0300\",\n // Ầ = \\^\\`{A}\n \"\\u1EAA\": \"A\\u0302\\u0303\",\n // Ẫ = \\^\\~{A}\n \"\\u0226\": \"A\\u0307\",\n // Ȧ = \\.{A}\n \"\\u01E0\": \"A\\u0307\\u0304\",\n // Ǡ = \\.\\={A}\n \"\\xC5\": \"A\\u030A\",\n // Å = \\r{A}\n \"\\u01FA\": \"A\\u030A\\u0301\",\n // Ǻ = \\r\\'{A}\n \"\\u1E02\": \"B\\u0307\",\n // Ḃ = \\.{B}\n \"\\u0106\": \"C\\u0301\",\n // Ć = \\'{C}\n \"\\u010C\": \"C\\u030C\",\n // Č = \\v{C}\n \"\\u0108\": \"C\\u0302\",\n // Ĉ = \\^{C}\n \"\\u010A\": \"C\\u0307\",\n // Ċ = \\.{C}\n \"\\u010E\": \"D\\u030C\",\n // Ď = \\v{D}\n \"\\u1E0A\": \"D\\u0307\",\n // Ḋ = \\.{D}\n \"\\xC9\": \"E\\u0301\",\n // É = \\'{E}\n \"\\xC8\": \"E\\u0300\",\n // È = \\`{E}\n \"\\xCB\": \"E\\u0308\",\n // Ë = \\\"{E}\n \"\\u1EBC\": \"E\\u0303\",\n // Ẽ = \\~{E}\n \"\\u0112\": \"E\\u0304\",\n // Ē = \\={E}\n \"\\u1E16\": \"E\\u0304\\u0301\",\n // Ḗ = \\=\\'{E}\n \"\\u1E14\": \"E\\u0304\\u0300\",\n // Ḕ = \\=\\`{E}\n \"\\u0114\": \"E\\u0306\",\n // Ĕ = \\u{E}\n \"\\u011A\": \"E\\u030C\",\n // Ě = \\v{E}\n \"\\xCA\": \"E\\u0302\",\n // Ê = \\^{E}\n \"\\u1EBE\": \"E\\u0302\\u0301\",\n // Ế = \\^\\'{E}\n \"\\u1EC0\": \"E\\u0302\\u0300\",\n // Ề = \\^\\`{E}\n \"\\u1EC4\": \"E\\u0302\\u0303\",\n // Ễ = \\^\\~{E}\n \"\\u0116\": \"E\\u0307\",\n // Ė = \\.{E}\n \"\\u1E1E\": \"F\\u0307\",\n // Ḟ = \\.{F}\n \"\\u01F4\": \"G\\u0301\",\n // Ǵ = \\'{G}\n \"\\u1E20\": \"G\\u0304\",\n // Ḡ = \\={G}\n \"\\u011E\": \"G\\u0306\",\n // Ğ = \\u{G}\n \"\\u01E6\": \"G\\u030C\",\n // Ǧ = \\v{G}\n \"\\u011C\": \"G\\u0302\",\n // Ĝ = \\^{G}\n \"\\u0120\": \"G\\u0307\",\n // Ġ = \\.{G}\n \"\\u1E26\": \"H\\u0308\",\n // Ḧ = \\\"{H}\n \"\\u021E\": \"H\\u030C\",\n // Ȟ = \\v{H}\n \"\\u0124\": \"H\\u0302\",\n // Ĥ = \\^{H}\n \"\\u1E22\": \"H\\u0307\",\n // Ḣ = \\.{H}\n \"\\xCD\": \"I\\u0301\",\n // Í = \\'{I}\n \"\\xCC\": \"I\\u0300\",\n // Ì = \\`{I}\n \"\\xCF\": \"I\\u0308\",\n // Ï = \\\"{I}\n \"\\u1E2E\": \"I\\u0308\\u0301\",\n // Ḯ = \\\"\\'{I}\n \"\\u0128\": \"I\\u0303\",\n // Ĩ = \\~{I}\n \"\\u012A\": \"I\\u0304\",\n // Ī = \\={I}\n \"\\u012C\": \"I\\u0306\",\n // Ĭ = \\u{I}\n \"\\u01CF\": \"I\\u030C\",\n // Ǐ = \\v{I}\n \"\\xCE\": \"I\\u0302\",\n // Î = \\^{I}\n \"\\u0130\": \"I\\u0307\",\n // İ = \\.{I}\n \"\\u0134\": \"J\\u0302\",\n // Ĵ = \\^{J}\n \"\\u1E30\": \"K\\u0301\",\n // Ḱ = \\'{K}\n \"\\u01E8\": \"K\\u030C\",\n // Ǩ = \\v{K}\n \"\\u0139\": \"L\\u0301\",\n // Ĺ = \\'{L}\n \"\\u013D\": \"L\\u030C\",\n // Ľ = \\v{L}\n \"\\u1E3E\": \"M\\u0301\",\n // Ḿ = \\'{M}\n \"\\u1E40\": \"M\\u0307\",\n // Ṁ = \\.{M}\n \"\\u0143\": \"N\\u0301\",\n // Ń = \\'{N}\n \"\\u01F8\": \"N\\u0300\",\n // Ǹ = \\`{N}\n \"\\xD1\": \"N\\u0303\",\n // Ñ = \\~{N}\n \"\\u0147\": \"N\\u030C\",\n // Ň = \\v{N}\n \"\\u1E44\": \"N\\u0307\",\n // Ṅ = \\.{N}\n \"\\xD3\": \"O\\u0301\",\n // Ó = \\'{O}\n \"\\xD2\": \"O\\u0300\",\n // Ò = \\`{O}\n \"\\xD6\": \"O\\u0308\",\n // Ö = \\\"{O}\n \"\\u022A\": \"O\\u0308\\u0304\",\n // Ȫ = \\\"\\={O}\n \"\\xD5\": \"O\\u0303\",\n // Õ = \\~{O}\n \"\\u1E4C\": \"O\\u0303\\u0301\",\n // Ṍ = \\~\\'{O}\n \"\\u1E4E\": \"O\\u0303\\u0308\",\n // Ṏ = \\~\\\"{O}\n \"\\u022C\": \"O\\u0303\\u0304\",\n // Ȭ = \\~\\={O}\n \"\\u014C\": \"O\\u0304\",\n // Ō = \\={O}\n \"\\u1E52\": \"O\\u0304\\u0301\",\n // Ṓ = \\=\\'{O}\n \"\\u1E50\": \"O\\u0304\\u0300\",\n // Ṑ = \\=\\`{O}\n \"\\u014E\": \"O\\u0306\",\n // Ŏ = \\u{O}\n \"\\u01D1\": \"O\\u030C\",\n // Ǒ = \\v{O}\n \"\\xD4\": \"O\\u0302\",\n // Ô = \\^{O}\n \"\\u1ED0\": \"O\\u0302\\u0301\",\n // Ố = \\^\\'{O}\n \"\\u1ED2\": \"O\\u0302\\u0300\",\n // Ồ = \\^\\`{O}\n \"\\u1ED6\": \"O\\u0302\\u0303\",\n // Ỗ = \\^\\~{O}\n \"\\u022E\": \"O\\u0307\",\n // Ȯ = \\.{O}\n \"\\u0230\": \"O\\u0307\\u0304\",\n // Ȱ = \\.\\={O}\n \"\\u0150\": \"O\\u030B\",\n // Ő = \\H{O}\n \"\\u1E54\": \"P\\u0301\",\n // Ṕ = \\'{P}\n \"\\u1E56\": \"P\\u0307\",\n // Ṗ = \\.{P}\n \"\\u0154\": \"R\\u0301\",\n // Ŕ = \\'{R}\n \"\\u0158\": \"R\\u030C\",\n // Ř = \\v{R}\n \"\\u1E58\": \"R\\u0307\",\n // Ṙ = \\.{R}\n \"\\u015A\": \"S\\u0301\",\n // Ś = \\'{S}\n \"\\u1E64\": \"S\\u0301\\u0307\",\n // Ṥ = \\'\\.{S}\n \"\\u0160\": \"S\\u030C\",\n // Š = \\v{S}\n \"\\u1E66\": \"S\\u030C\\u0307\",\n // Ṧ = \\v\\.{S}\n \"\\u015C\": \"S\\u0302\",\n // Ŝ = \\^{S}\n \"\\u1E60\": \"S\\u0307\",\n // Ṡ = \\.{S}\n \"\\u0164\": \"T\\u030C\",\n // Ť = \\v{T}\n \"\\u1E6A\": \"T\\u0307\",\n // Ṫ = \\.{T}\n \"\\xDA\": \"U\\u0301\",\n // Ú = \\'{U}\n \"\\xD9\": \"U\\u0300\",\n // Ù = \\`{U}\n \"\\xDC\": \"U\\u0308\",\n // Ü = \\\"{U}\n \"\\u01D7\": \"U\\u0308\\u0301\",\n // Ǘ = \\\"\\'{U}\n \"\\u01DB\": \"U\\u0308\\u0300\",\n // Ǜ = \\\"\\`{U}\n \"\\u01D5\": \"U\\u0308\\u0304\",\n // Ǖ = \\\"\\={U}\n \"\\u01D9\": \"U\\u0308\\u030C\",\n // Ǚ = \\\"\\v{U}\n \"\\u0168\": \"U\\u0303\",\n // Ũ = \\~{U}\n \"\\u1E78\": \"U\\u0303\\u0301\",\n // Ṹ = \\~\\'{U}\n \"\\u016A\": \"U\\u0304\",\n // Ū = \\={U}\n \"\\u1E7A\": \"U\\u0304\\u0308\",\n // Ṻ = \\=\\\"{U}\n \"\\u016C\": \"U\\u0306\",\n // Ŭ = \\u{U}\n \"\\u01D3\": \"U\\u030C\",\n // Ǔ = \\v{U}\n \"\\xDB\": \"U\\u0302\",\n // Û = \\^{U}\n \"\\u016E\": \"U\\u030A\",\n // Ů = \\r{U}\n \"\\u0170\": \"U\\u030B\",\n // Ű = \\H{U}\n \"\\u1E7C\": \"V\\u0303\",\n // Ṽ = \\~{V}\n \"\\u1E82\": \"W\\u0301\",\n // Ẃ = \\'{W}\n \"\\u1E80\": \"W\\u0300\",\n // Ẁ = \\`{W}\n \"\\u1E84\": \"W\\u0308\",\n // Ẅ = \\\"{W}\n \"\\u0174\": \"W\\u0302\",\n // Ŵ = \\^{W}\n \"\\u1E86\": \"W\\u0307\",\n // Ẇ = \\.{W}\n \"\\u1E8C\": \"X\\u0308\",\n // Ẍ = \\\"{X}\n \"\\u1E8A\": \"X\\u0307\",\n // Ẋ = \\.{X}\n \"\\xDD\": \"Y\\u0301\",\n // Ý = \\'{Y}\n \"\\u1EF2\": \"Y\\u0300\",\n // Ỳ = \\`{Y}\n \"\\u0178\": \"Y\\u0308\",\n // Ÿ = \\\"{Y}\n \"\\u1EF8\": \"Y\\u0303\",\n // Ỹ = \\~{Y}\n \"\\u0232\": \"Y\\u0304\",\n // Ȳ = \\={Y}\n \"\\u0176\": \"Y\\u0302\",\n // Ŷ = \\^{Y}\n \"\\u1E8E\": \"Y\\u0307\",\n // Ẏ = \\.{Y}\n \"\\u0179\": \"Z\\u0301\",\n // Ź = \\'{Z}\n \"\\u017D\": \"Z\\u030C\",\n // Ž = \\v{Z}\n \"\\u1E90\": \"Z\\u0302\",\n // Ẑ = \\^{Z}\n \"\\u017B\": \"Z\\u0307\",\n // Ż = \\.{Z}\n \"\\u03AC\": \"\\u03B1\\u0301\",\n // ά = \\'{α}\n \"\\u1F70\": \"\\u03B1\\u0300\",\n // ὰ = \\`{α}\n \"\\u1FB1\": \"\\u03B1\\u0304\",\n // ᾱ = \\={α}\n \"\\u1FB0\": \"\\u03B1\\u0306\",\n // ᾰ = \\u{α}\n \"\\u03AD\": \"\\u03B5\\u0301\",\n // έ = \\'{ε}\n \"\\u1F72\": \"\\u03B5\\u0300\",\n // ὲ = \\`{ε}\n \"\\u03AE\": \"\\u03B7\\u0301\",\n // ή = \\'{η}\n \"\\u1F74\": \"\\u03B7\\u0300\",\n // ὴ = \\`{η}\n \"\\u03AF\": \"\\u03B9\\u0301\",\n // ί = \\'{ι}\n \"\\u1F76\": \"\\u03B9\\u0300\",\n // ὶ = \\`{ι}\n \"\\u03CA\": \"\\u03B9\\u0308\",\n // ϊ = \\\"{ι}\n \"\\u0390\": \"\\u03B9\\u0308\\u0301\",\n // ΐ = \\\"\\'{ι}\n \"\\u1FD2\": \"\\u03B9\\u0308\\u0300\",\n // ῒ = \\\"\\`{ι}\n \"\\u1FD1\": \"\\u03B9\\u0304\",\n // ῑ = \\={ι}\n \"\\u1FD0\": \"\\u03B9\\u0306\",\n // ῐ = \\u{ι}\n \"\\u03CC\": \"\\u03BF\\u0301\",\n // ό = \\'{ο}\n \"\\u1F78\": \"\\u03BF\\u0300\",\n // ὸ = \\`{ο}\n \"\\u03CD\": \"\\u03C5\\u0301\",\n // ύ = \\'{υ}\n \"\\u1F7A\": \"\\u03C5\\u0300\",\n // ὺ = \\`{υ}\n \"\\u03CB\": \"\\u03C5\\u0308\",\n // ϋ = \\\"{υ}\n \"\\u03B0\": \"\\u03C5\\u0308\\u0301\",\n // ΰ = \\\"\\'{υ}\n \"\\u1FE2\": \"\\u03C5\\u0308\\u0300\",\n // ῢ = \\\"\\`{υ}\n \"\\u1FE1\": \"\\u03C5\\u0304\",\n // ῡ = \\={υ}\n \"\\u1FE0\": \"\\u03C5\\u0306\",\n // ῠ = \\u{υ}\n \"\\u03CE\": \"\\u03C9\\u0301\",\n // ώ = \\'{ω}\n \"\\u1F7C\": \"\\u03C9\\u0300\",\n // ὼ = \\`{ω}\n \"\\u038E\": \"\\u03A5\\u0301\",\n // Ύ = \\'{Υ}\n \"\\u1FEA\": \"\\u03A5\\u0300\",\n // Ὺ = \\`{Υ}\n \"\\u03AB\": \"\\u03A5\\u0308\",\n // Ϋ = \\\"{Υ}\n \"\\u1FE9\": \"\\u03A5\\u0304\",\n // Ῡ = \\={Υ}\n \"\\u1FE8\": \"\\u03A5\\u0306\",\n // Ῠ = \\u{Υ}\n \"\\u038F\": \"\\u03A9\\u0301\",\n // Ώ = \\'{Ω}\n \"\\u1FFA\": \"\\u03A9\\u0300\" // Ὼ = \\`{Ω}\n\n});\n// CONCATENATED MODULE: ./src/Parser.js\n/* eslint no-constant-condition:0 */\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n/**\n * This file contains the parser used to parse out a TeX expression from the\n * input. Since TeX isn't context-free, standard parsers don't work particularly\n * well.\n *\n * The strategy of this parser is as such:\n *\n * The main functions (the `.parse...` ones) take a position in the current\n * parse string to parse tokens from. The lexer (found in Lexer.js, stored at\n * this.gullet.lexer) also supports pulling out tokens at arbitrary places. When\n * individual tokens are needed at a position, the lexer is called to pull out a\n * token, which is then used.\n *\n * The parser has a property called \"mode\" indicating the mode that\n * the parser is currently in. Currently it has to be one of \"math\" or\n * \"text\", which denotes whether the current environment is a math-y\n * one or a text-y one (e.g. inside \\text). Currently, this serves to\n * limit the functions which can be used in text mode.\n *\n * The main functions then return an object which contains the useful data that\n * was parsed at its given point, and a new position at the end of the parsed\n * data. The main functions can call each other and continue the parsing by\n * using the returned position as a new starting point.\n *\n * There are also extra `.handle...` functions, which pull out some reused\n * functionality into self-contained functions.\n *\n * The functions return ParseNodes.\n */\nvar Parser_Parser =\n/*#__PURE__*/\nfunction () {\n function Parser(input, settings) {\n this.mode = void 0;\n this.gullet = void 0;\n this.settings = void 0;\n this.leftrightDepth = void 0;\n this.nextToken = void 0;\n // Start in math mode\n this.mode = \"math\"; // Create a new macro expander (gullet) and (indirectly via that) also a\n // new lexer (mouth) for this parser (stomach, in the language of TeX)\n\n this.gullet = new MacroExpander_MacroExpander(input, settings, this.mode); // Store the settings for use in parsing\n\n this.settings = settings; // Count leftright depth (for \\middle errors)\n\n this.leftrightDepth = 0;\n }\n /**\n * Checks a result to make sure it has the right type, and throws an\n * appropriate error otherwise.\n */\n\n\n var _proto = Parser.prototype;\n\n _proto.expect = function expect(text, consume) {\n if (consume === void 0) {\n consume = true;\n }\n\n if (this.fetch().text !== text) {\n throw new src_ParseError(\"Expected '\" + text + \"', got '\" + this.fetch().text + \"'\", this.fetch());\n }\n\n if (consume) {\n this.consume();\n }\n }\n /**\n * Discards the current lookahead token, considering it consumed.\n */\n ;\n\n _proto.consume = function consume() {\n this.nextToken = null;\n }\n /**\n * Return the current lookahead token, or if there isn't one (at the\n * beginning, or if the previous lookahead token was consume()d),\n * fetch the next token as the new lookahead token and return it.\n */\n ;\n\n _proto.fetch = function fetch() {\n if (this.nextToken == null) {\n this.nextToken = this.gullet.expandNextToken();\n }\n\n return this.nextToken;\n }\n /**\n * Switches between \"text\" and \"math\" modes.\n */\n ;\n\n _proto.switchMode = function switchMode(newMode) {\n this.mode = newMode;\n this.gullet.switchMode(newMode);\n }\n /**\n * Main parsing function, which parses an entire input.\n */\n ;\n\n _proto.parse = function parse() {\n // Create a group namespace for the math expression.\n // (LaTeX creates a new group for every $...$, $$...$$, \\[...\\].)\n this.gullet.beginGroup(); // Use old \\color behavior (same as LaTeX's \\textcolor) if requested.\n // We do this within the group for the math expression, so it doesn't\n // pollute settings.macros.\n\n if (this.settings.colorIsTextColor) {\n this.gullet.macros.set(\"\\\\color\", \"\\\\textcolor\");\n } // Try to parse the input\n\n\n var parse = this.parseExpression(false); // If we succeeded, make sure there's an EOF at the end\n\n this.expect(\"EOF\"); // End the group namespace for the expression\n\n this.gullet.endGroup();\n return parse;\n };\n\n _proto.parseExpression = function parseExpression(breakOnInfix, breakOnTokenText) {\n var body = []; // Keep adding atoms to the body until we can't parse any more atoms (either\n // we reached the end, a }, or a \\right)\n\n while (true) {\n // Ignore spaces in math mode\n if (this.mode === \"math\") {\n this.consumeSpaces();\n }\n\n var lex = this.fetch();\n\n if (Parser.endOfExpression.indexOf(lex.text) !== -1) {\n break;\n }\n\n if (breakOnTokenText && lex.text === breakOnTokenText) {\n break;\n }\n\n if (breakOnInfix && src_functions[lex.text] && src_functions[lex.text].infix) {\n break;\n }\n\n var atom = this.parseAtom(breakOnTokenText);\n\n if (!atom) {\n break;\n }\n\n body.push(atom);\n }\n\n if (this.mode === \"text\") {\n this.formLigatures(body);\n }\n\n return this.handleInfixNodes(body);\n }\n /**\n * Rewrites infix operators such as \\over with corresponding commands such\n * as \\frac.\n *\n * There can only be one infix operator per group. If there's more than one\n * then the expression is ambiguous. This can be resolved by adding {}.\n */\n ;\n\n _proto.handleInfixNodes = function handleInfixNodes(body) {\n var overIndex = -1;\n var funcName;\n\n for (var i = 0; i < body.length; i++) {\n var node = checkNodeType(body[i], \"infix\");\n\n if (node) {\n if (overIndex !== -1) {\n throw new src_ParseError(\"only one infix operator per group\", node.token);\n }\n\n overIndex = i;\n funcName = node.replaceWith;\n }\n }\n\n if (overIndex !== -1 && funcName) {\n var numerNode;\n var denomNode;\n var numerBody = body.slice(0, overIndex);\n var denomBody = body.slice(overIndex + 1);\n\n if (numerBody.length === 1 && numerBody[0].type === \"ordgroup\") {\n numerNode = numerBody[0];\n } else {\n numerNode = {\n type: \"ordgroup\",\n mode: this.mode,\n body: numerBody\n };\n }\n\n if (denomBody.length === 1 && denomBody[0].type === \"ordgroup\") {\n denomNode = denomBody[0];\n } else {\n denomNode = {\n type: \"ordgroup\",\n mode: this.mode,\n body: denomBody\n };\n }\n\n var _node;\n\n if (funcName === \"\\\\\\\\abovefrac\") {\n _node = this.callFunction(funcName, [numerNode, body[overIndex], denomNode], []);\n } else {\n _node = this.callFunction(funcName, [numerNode, denomNode], []);\n }\n\n return [_node];\n } else {\n return body;\n }\n } // The greediness of a superscript or subscript\n ;\n\n /**\n * Handle a subscript or superscript with nice errors.\n */\n _proto.handleSupSubscript = function handleSupSubscript(name) {\n var symbolToken = this.fetch();\n var symbol = symbolToken.text;\n this.consume();\n var group = this.parseGroup(name, false, Parser.SUPSUB_GREEDINESS, undefined, undefined, true); // ignore spaces before sup/subscript argument\n\n if (!group) {\n throw new src_ParseError(\"Expected group after '\" + symbol + \"'\", symbolToken);\n }\n\n return group;\n }\n /**\n * Converts the textual input of an unsupported command into a text node\n * contained within a color node whose color is determined by errorColor\n */\n ;\n\n _proto.formatUnsupportedCmd = function formatUnsupportedCmd(text) {\n var textordArray = [];\n\n for (var i = 0; i < text.length; i++) {\n textordArray.push({\n type: \"textord\",\n mode: \"text\",\n text: text[i]\n });\n }\n\n var textNode = {\n type: \"text\",\n mode: this.mode,\n body: textordArray\n };\n var colorNode = {\n type: \"color\",\n mode: this.mode,\n color: this.settings.errorColor,\n body: [textNode]\n };\n return colorNode;\n }\n /**\n * Parses a group with optional super/subscripts.\n */\n ;\n\n _proto.parseAtom = function parseAtom(breakOnTokenText) {\n // The body of an atom is an implicit group, so that things like\n // \\left(x\\right)^2 work correctly.\n var base = this.parseGroup(\"atom\", false, null, breakOnTokenText); // In text mode, we don't have superscripts or subscripts\n\n if (this.mode === \"text\") {\n return base;\n } // Note that base may be empty (i.e. null) at this point.\n\n\n var superscript;\n var subscript;\n\n while (true) {\n // Guaranteed in math mode, so eat any spaces first.\n this.consumeSpaces(); // Lex the first token\n\n var lex = this.fetch();\n\n if (lex.text === \"\\\\limits\" || lex.text === \"\\\\nolimits\") {\n // We got a limit control\n var opNode = checkNodeType(base, \"op\");\n\n if (opNode) {\n var limits = lex.text === \"\\\\limits\";\n opNode.limits = limits;\n opNode.alwaysHandleSupSub = true;\n } else {\n opNode = checkNodeType(base, \"operatorname\");\n\n if (opNode && opNode.alwaysHandleSupSub) {\n var _limits = lex.text === \"\\\\limits\";\n\n opNode.limits = _limits;\n } else {\n throw new src_ParseError(\"Limit controls must follow a math operator\", lex);\n }\n }\n\n this.consume();\n } else if (lex.text === \"^\") {\n // We got a superscript start\n if (superscript) {\n throw new src_ParseError(\"Double superscript\", lex);\n }\n\n superscript = this.handleSupSubscript(\"superscript\");\n } else if (lex.text === \"_\") {\n // We got a subscript start\n if (subscript) {\n throw new src_ParseError(\"Double subscript\", lex);\n }\n\n subscript = this.handleSupSubscript(\"subscript\");\n } else if (lex.text === \"'\") {\n // We got a prime\n if (superscript) {\n throw new src_ParseError(\"Double superscript\", lex);\n }\n\n var prime = {\n type: \"textord\",\n mode: this.mode,\n text: \"\\\\prime\"\n }; // Many primes can be grouped together, so we handle this here\n\n var primes = [prime];\n this.consume(); // Keep lexing tokens until we get something that's not a prime\n\n while (this.fetch().text === \"'\") {\n // For each one, add another prime to the list\n primes.push(prime);\n this.consume();\n } // If there's a superscript following the primes, combine that\n // superscript in with the primes.\n\n\n if (this.fetch().text === \"^\") {\n primes.push(this.handleSupSubscript(\"superscript\"));\n } // Put everything into an ordgroup as the superscript\n\n\n superscript = {\n type: \"ordgroup\",\n mode: this.mode,\n body: primes\n };\n } else {\n // If it wasn't ^, _, or ', stop parsing super/subscripts\n break;\n }\n } // Base must be set if superscript or subscript are set per logic above,\n // but need to check here for type check to pass.\n\n\n if (superscript || subscript) {\n // If we got either a superscript or subscript, create a supsub\n return {\n type: \"supsub\",\n mode: this.mode,\n base: base,\n sup: superscript,\n sub: subscript\n };\n } else {\n // Otherwise return the original body\n return base;\n }\n }\n /**\n * Parses an entire function, including its base and all of its arguments.\n */\n ;\n\n _proto.parseFunction = function parseFunction(breakOnTokenText, name, // For error reporting.\n greediness) {\n var token = this.fetch();\n var func = token.text;\n var funcData = src_functions[func];\n\n if (!funcData) {\n return null;\n }\n\n this.consume(); // consume command token\n\n if (greediness != null && funcData.greediness <= greediness) {\n throw new src_ParseError(\"Got function '\" + func + \"' with no arguments\" + (name ? \" as \" + name : \"\"), token);\n } else if (this.mode === \"text\" && !funcData.allowedInText) {\n throw new src_ParseError(\"Can't use function '\" + func + \"' in text mode\", token);\n } else if (this.mode === \"math\" && funcData.allowedInMath === false) {\n throw new src_ParseError(\"Can't use function '\" + func + \"' in math mode\", token);\n }\n\n var _this$parseArguments = this.parseArguments(func, funcData),\n args = _this$parseArguments.args,\n optArgs = _this$parseArguments.optArgs;\n\n return this.callFunction(func, args, optArgs, token, breakOnTokenText);\n }\n /**\n * Call a function handler with a suitable context and arguments.\n */\n ;\n\n _proto.callFunction = function callFunction(name, args, optArgs, token, breakOnTokenText) {\n var context = {\n funcName: name,\n parser: this,\n token: token,\n breakOnTokenText: breakOnTokenText\n };\n var func = src_functions[name];\n\n if (func && func.handler) {\n return func.handler(context, args, optArgs);\n } else {\n throw new src_ParseError(\"No function handler for \" + name);\n }\n }\n /**\n * Parses the arguments of a function or environment\n */\n ;\n\n _proto.parseArguments = function parseArguments(func, // Should look like \"\\name\" or \"\\begin{name}\".\n funcData) {\n var totalArgs = funcData.numArgs + funcData.numOptionalArgs;\n\n if (totalArgs === 0) {\n return {\n args: [],\n optArgs: []\n };\n }\n\n var baseGreediness = funcData.greediness;\n var args = [];\n var optArgs = [];\n\n for (var i = 0; i < totalArgs; i++) {\n var argType = funcData.argTypes && funcData.argTypes[i];\n var isOptional = i < funcData.numOptionalArgs; // Ignore spaces between arguments. As the TeXbook says:\n // \"After you have said ‘\\def\\row#1#2{...}’, you are allowed to\n // put spaces between the arguments (e.g., ‘\\row x n’), because\n // TeX doesn’t use single spaces as undelimited arguments.\"\n\n var consumeSpaces = i > 0 && !isOptional || // Also consume leading spaces in math mode, as parseSymbol\n // won't know what to do with them. This can only happen with\n // macros, e.g. \\frac\\foo\\foo where \\foo expands to a space symbol.\n // In LaTeX, the \\foo's get treated as (blank) arguments.\n // In KaTeX, for now, both spaces will get consumed.\n // TODO(edemaine)\n i === 0 && !isOptional && this.mode === \"math\";\n var arg = this.parseGroupOfType(\"argument to '\" + func + \"'\", argType, isOptional, baseGreediness, consumeSpaces);\n\n if (!arg) {\n if (isOptional) {\n optArgs.push(null);\n continue;\n }\n\n throw new src_ParseError(\"Expected group after '\" + func + \"'\", this.fetch());\n }\n\n (isOptional ? optArgs : args).push(arg);\n }\n\n return {\n args: args,\n optArgs: optArgs\n };\n }\n /**\n * Parses a group when the mode is changing.\n */\n ;\n\n _proto.parseGroupOfType = function parseGroupOfType(name, type, optional, greediness, consumeSpaces) {\n switch (type) {\n case \"color\":\n if (consumeSpaces) {\n this.consumeSpaces();\n }\n\n return this.parseColorGroup(optional);\n\n case \"size\":\n if (consumeSpaces) {\n this.consumeSpaces();\n }\n\n return this.parseSizeGroup(optional);\n\n case \"url\":\n return this.parseUrlGroup(optional, consumeSpaces);\n\n case \"math\":\n case \"text\":\n return this.parseGroup(name, optional, greediness, undefined, type, consumeSpaces);\n\n case \"hbox\":\n {\n // hbox argument type wraps the argument in the equivalent of\n // \\hbox, which is like \\text but switching to \\textstyle size.\n var group = this.parseGroup(name, optional, greediness, undefined, \"text\", consumeSpaces);\n\n if (!group) {\n return group;\n }\n\n var styledGroup = {\n type: \"styling\",\n mode: group.mode,\n body: [group],\n style: \"text\" // simulate \\textstyle\n\n };\n return styledGroup;\n }\n\n case \"raw\":\n {\n if (consumeSpaces) {\n this.consumeSpaces();\n }\n\n if (optional && this.fetch().text === \"{\") {\n return null;\n }\n\n var token = this.parseStringGroup(\"raw\", optional, true);\n\n if (token) {\n return {\n type: \"raw\",\n mode: \"text\",\n string: token.text\n };\n } else {\n throw new src_ParseError(\"Expected raw group\", this.fetch());\n }\n }\n\n case \"original\":\n case null:\n case undefined:\n return this.parseGroup(name, optional, greediness, undefined, undefined, consumeSpaces);\n\n default:\n throw new src_ParseError(\"Unknown group type as \" + name, this.fetch());\n }\n }\n /**\n * Discard any space tokens, fetching the next non-space token.\n */\n ;\n\n _proto.consumeSpaces = function consumeSpaces() {\n while (this.fetch().text === \" \") {\n this.consume();\n }\n }\n /**\n * Parses a group, essentially returning the string formed by the\n * brace-enclosed tokens plus some position information.\n */\n ;\n\n _proto.parseStringGroup = function parseStringGroup(modeName, // Used to describe the mode in error messages.\n optional, raw) {\n var groupBegin = optional ? \"[\" : \"{\";\n var groupEnd = optional ? \"]\" : \"}\";\n var beginToken = this.fetch();\n\n if (beginToken.text !== groupBegin) {\n if (optional) {\n return null;\n } else if (raw && beginToken.text !== \"EOF\" && /[^{}[\\]]/.test(beginToken.text)) {\n this.consume();\n return beginToken;\n }\n }\n\n var outerMode = this.mode;\n this.mode = \"text\";\n this.expect(groupBegin);\n var str = \"\";\n var firstToken = this.fetch();\n var nested = 0; // allow nested braces in raw string group\n\n var lastToken = firstToken;\n var nextToken;\n\n while ((nextToken = this.fetch()).text !== groupEnd || raw && nested > 0) {\n switch (nextToken.text) {\n case \"EOF\":\n throw new src_ParseError(\"Unexpected end of input in \" + modeName, firstToken.range(lastToken, str));\n\n case groupBegin:\n nested++;\n break;\n\n case groupEnd:\n nested--;\n break;\n }\n\n lastToken = nextToken;\n str += lastToken.text;\n this.consume();\n }\n\n this.expect(groupEnd);\n this.mode = outerMode;\n return firstToken.range(lastToken, str);\n }\n /**\n * Parses a regex-delimited group: the largest sequence of tokens\n * whose concatenated strings match `regex`. Returns the string\n * formed by the tokens plus some position information.\n */\n ;\n\n _proto.parseRegexGroup = function parseRegexGroup(regex, modeName) {\n var outerMode = this.mode;\n this.mode = \"text\";\n var firstToken = this.fetch();\n var lastToken = firstToken;\n var str = \"\";\n var nextToken;\n\n while ((nextToken = this.fetch()).text !== \"EOF\" && regex.test(str + nextToken.text)) {\n lastToken = nextToken;\n str += lastToken.text;\n this.consume();\n }\n\n if (str === \"\") {\n throw new src_ParseError(\"Invalid \" + modeName + \": '\" + firstToken.text + \"'\", firstToken);\n }\n\n this.mode = outerMode;\n return firstToken.range(lastToken, str);\n }\n /**\n * Parses a color description.\n */\n ;\n\n _proto.parseColorGroup = function parseColorGroup(optional) {\n var res = this.parseStringGroup(\"color\", optional);\n\n if (!res) {\n return null;\n }\n\n var match = /^(#[a-f0-9]{3}|#?[a-f0-9]{6}|[a-z]+)$/i.exec(res.text);\n\n if (!match) {\n throw new src_ParseError(\"Invalid color: '\" + res.text + \"'\", res);\n }\n\n var color = match[0];\n\n if (/^[0-9a-f]{6}$/i.test(color)) {\n // We allow a 6-digit HTML color spec without a leading \"#\".\n // This follows the xcolor package's HTML color model.\n // Predefined color names are all missed by this RegEx pattern.\n color = \"#\" + color;\n }\n\n return {\n type: \"color-token\",\n mode: this.mode,\n color: color\n };\n }\n /**\n * Parses a size specification, consisting of magnitude and unit.\n */\n ;\n\n _proto.parseSizeGroup = function parseSizeGroup(optional) {\n var res;\n var isBlank = false;\n\n if (!optional && this.fetch().text !== \"{\") {\n res = this.parseRegexGroup(/^[-+]? *(?:$|\\d+|\\d+\\.\\d*|\\.\\d*) *[a-z]{0,2} *$/, \"size\");\n } else {\n res = this.parseStringGroup(\"size\", optional);\n }\n\n if (!res) {\n return null;\n }\n\n if (!optional && res.text.length === 0) {\n // Because we've tested for what is !optional, this block won't\n // affect \\kern, \\hspace, etc. It will capture the mandatory arguments\n // to \\genfrac and \\above.\n res.text = \"0pt\"; // Enable \\above{}\n\n isBlank = true; // This is here specifically for \\genfrac\n }\n\n var match = /([-+]?) *(\\d+(?:\\.\\d*)?|\\.\\d+) *([a-z]{2})/.exec(res.text);\n\n if (!match) {\n throw new src_ParseError(\"Invalid size: '\" + res.text + \"'\", res);\n }\n\n var data = {\n number: +(match[1] + match[2]),\n // sign + magnitude, cast to number\n unit: match[3]\n };\n\n if (!validUnit(data)) {\n throw new src_ParseError(\"Invalid unit: '\" + data.unit + \"'\", res);\n }\n\n return {\n type: \"size\",\n mode: this.mode,\n value: data,\n isBlank: isBlank\n };\n }\n /**\n * Parses an URL, checking escaped letters and allowed protocols,\n * and setting the catcode of % as an active character (as in \\hyperref).\n */\n ;\n\n _proto.parseUrlGroup = function parseUrlGroup(optional, consumeSpaces) {\n this.gullet.lexer.setCatcode(\"%\", 13); // active character\n\n var res = this.parseStringGroup(\"url\", optional, true); // get raw string\n\n this.gullet.lexer.setCatcode(\"%\", 14); // comment character\n\n if (!res) {\n return null;\n } // hyperref package allows backslashes alone in href, but doesn't\n // generate valid links in such cases; we interpret this as\n // \"undefined\" behaviour, and keep them as-is. Some browser will\n // replace backslashes with forward slashes.\n\n\n var url = res.text.replace(/\\\\([#$%&~_^{}])/g, '$1');\n return {\n type: \"url\",\n mode: this.mode,\n url: url\n };\n }\n /**\n * If `optional` is false or absent, this parses an ordinary group,\n * which is either a single nucleus (like \"x\") or an expression\n * in braces (like \"{x+y}\") or an implicit group, a group that starts\n * at the current position, and ends right before a higher explicit\n * group ends, or at EOF.\n * If `optional` is true, it parses either a bracket-delimited expression\n * (like \"[x+y]\") or returns null to indicate the absence of a\n * bracket-enclosed group.\n * If `mode` is present, switches to that mode while parsing the group,\n * and switches back after.\n */\n ;\n\n _proto.parseGroup = function parseGroup(name, // For error reporting.\n optional, greediness, breakOnTokenText, mode, consumeSpaces) {\n // Switch to specified mode\n var outerMode = this.mode;\n\n if (mode) {\n this.switchMode(mode);\n } // Consume spaces if requested, crucially *after* we switch modes,\n // so that the next non-space token is parsed in the correct mode.\n\n\n if (consumeSpaces) {\n this.consumeSpaces();\n } // Get first token\n\n\n var firstToken = this.fetch();\n var text = firstToken.text;\n var result; // Try to parse an open brace or \\begingroup\n\n if (optional ? text === \"[\" : text === \"{\" || text === \"\\\\begingroup\") {\n this.consume();\n var groupEnd = Parser.endOfGroup[text]; // Start a new group namespace\n\n this.gullet.beginGroup(); // If we get a brace, parse an expression\n\n var expression = this.parseExpression(false, groupEnd);\n var lastToken = this.fetch(); // Check that we got a matching closing brace\n\n this.expect(groupEnd); // End group namespace\n\n this.gullet.endGroup();\n result = {\n type: \"ordgroup\",\n mode: this.mode,\n loc: SourceLocation.range(firstToken, lastToken),\n body: expression,\n // A group formed by \\begingroup...\\endgroup is a semi-simple group\n // which doesn't affect spacing in math mode, i.e., is transparent.\n // https://tex.stackexchange.com/questions/1930/when-should-one-\n // use-begingroup-instead-of-bgroup\n semisimple: text === \"\\\\begingroup\" || undefined\n };\n } else if (optional) {\n // Return nothing for an optional group\n result = null;\n } else {\n // If there exists a function with this name, parse the function.\n // Otherwise, just return a nucleus\n result = this.parseFunction(breakOnTokenText, name, greediness) || this.parseSymbol();\n\n if (result == null && text[0] === \"\\\\\" && !implicitCommands.hasOwnProperty(text)) {\n if (this.settings.throwOnError) {\n throw new src_ParseError(\"Undefined control sequence: \" + text, firstToken);\n }\n\n result = this.formatUnsupportedCmd(text);\n this.consume();\n }\n } // Switch mode back\n\n\n if (mode) {\n this.switchMode(outerMode);\n }\n\n return result;\n }\n /**\n * Form ligature-like combinations of characters for text mode.\n * This includes inputs like \"--\", \"---\", \"``\" and \"''\".\n * The result will simply replace multiple textord nodes with a single\n * character in each value by a single textord node having multiple\n * characters in its value. The representation is still ASCII source.\n * The group will be modified in place.\n */\n ;\n\n _proto.formLigatures = function formLigatures(group) {\n var n = group.length - 1;\n\n for (var i = 0; i < n; ++i) {\n var a = group[i]; // $FlowFixMe: Not every node type has a `text` property.\n\n var v = a.text;\n\n if (v === \"-\" && group[i + 1].text === \"-\") {\n if (i + 1 < n && group[i + 2].text === \"-\") {\n group.splice(i, 3, {\n type: \"textord\",\n mode: \"text\",\n loc: SourceLocation.range(a, group[i + 2]),\n text: \"---\"\n });\n n -= 2;\n } else {\n group.splice(i, 2, {\n type: \"textord\",\n mode: \"text\",\n loc: SourceLocation.range(a, group[i + 1]),\n text: \"--\"\n });\n n -= 1;\n }\n }\n\n if ((v === \"'\" || v === \"`\") && group[i + 1].text === v) {\n group.splice(i, 2, {\n type: \"textord\",\n mode: \"text\",\n loc: SourceLocation.range(a, group[i + 1]),\n text: v + v\n });\n n -= 1;\n }\n }\n }\n /**\n * Parse a single symbol out of the string. Here, we handle single character\n * symbols and special functions like \\verb.\n */\n ;\n\n _proto.parseSymbol = function parseSymbol() {\n var nucleus = this.fetch();\n var text = nucleus.text;\n\n if (/^\\\\verb[^a-zA-Z]/.test(text)) {\n this.consume();\n var arg = text.slice(5);\n var star = arg.charAt(0) === \"*\";\n\n if (star) {\n arg = arg.slice(1);\n } // Lexer's tokenRegex is constructed to always have matching\n // first/last characters.\n\n\n if (arg.length < 2 || arg.charAt(0) !== arg.slice(-1)) {\n throw new src_ParseError(\"\\\\verb assertion failed --\\n please report what input caused this bug\");\n }\n\n arg = arg.slice(1, -1); // remove first and last char\n\n return {\n type: \"verb\",\n mode: \"text\",\n body: arg,\n star: star\n };\n } // At this point, we should have a symbol, possibly with accents.\n // First expand any accented base symbol according to unicodeSymbols.\n\n\n if (unicodeSymbols.hasOwnProperty(text[0]) && !src_symbols[this.mode][text[0]]) {\n // This behavior is not strict (XeTeX-compatible) in math mode.\n if (this.settings.strict && this.mode === \"math\") {\n this.settings.reportNonstrict(\"unicodeTextInMathMode\", \"Accented Unicode text character \\\"\" + text[0] + \"\\\" used in \" + \"math mode\", nucleus);\n }\n\n text = unicodeSymbols[text[0]] + text.substr(1);\n } // Strip off any combining characters\n\n\n var match = combiningDiacriticalMarksEndRegex.exec(text);\n\n if (match) {\n text = text.substring(0, match.index);\n\n if (text === 'i') {\n text = \"\\u0131\"; // dotless i, in math and text mode\n } else if (text === 'j') {\n text = \"\\u0237\"; // dotless j, in math and text mode\n }\n } // Recognize base symbol\n\n\n var symbol;\n\n if (src_symbols[this.mode][text]) {\n if (this.settings.strict && this.mode === 'math' && extraLatin.indexOf(text) >= 0) {\n this.settings.reportNonstrict(\"unicodeTextInMathMode\", \"Latin-1/Unicode text character \\\"\" + text[0] + \"\\\" used in \" + \"math mode\", nucleus);\n }\n\n var group = src_symbols[this.mode][text].group;\n var loc = SourceLocation.range(nucleus);\n var s;\n\n if (ATOMS.hasOwnProperty(group)) {\n // $FlowFixMe\n var family = group;\n s = {\n type: \"atom\",\n mode: this.mode,\n family: family,\n loc: loc,\n text: text\n };\n } else {\n // $FlowFixMe\n s = {\n type: group,\n mode: this.mode,\n loc: loc,\n text: text\n };\n }\n\n symbol = s;\n } else if (text.charCodeAt(0) >= 0x80) {\n // no symbol for e.g. ^\n if (this.settings.strict) {\n if (!supportedCodepoint(text.charCodeAt(0))) {\n this.settings.reportNonstrict(\"unknownSymbol\", \"Unrecognized Unicode character \\\"\" + text[0] + \"\\\"\" + (\" (\" + text.charCodeAt(0) + \")\"), nucleus);\n } else if (this.mode === \"math\") {\n this.settings.reportNonstrict(\"unicodeTextInMathMode\", \"Unicode text character \\\"\" + text[0] + \"\\\" used in math mode\", nucleus);\n }\n } // All nonmathematical Unicode characters are rendered as if they\n // are in text mode (wrapped in \\text) because that's what it\n // takes to render them in LaTeX. Setting `mode: this.mode` is\n // another natural choice (the user requested math mode), but\n // this makes it more difficult for getCharacterMetrics() to\n // distinguish Unicode characters without metrics and those for\n // which we want to simulate the letter M.\n\n\n symbol = {\n type: \"textord\",\n mode: \"text\",\n loc: SourceLocation.range(nucleus),\n text: text\n };\n } else {\n return null; // EOF, ^, _, {, }, etc.\n }\n\n this.consume(); // Transform combining characters into accents\n\n if (match) {\n for (var i = 0; i < match[0].length; i++) {\n var accent = match[0][i];\n\n if (!unicodeAccents[accent]) {\n throw new src_ParseError(\"Unknown accent ' \" + accent + \"'\", nucleus);\n }\n\n var command = unicodeAccents[accent][this.mode];\n\n if (!command) {\n throw new src_ParseError(\"Accent \" + accent + \" unsupported in \" + this.mode + \" mode\", nucleus);\n }\n\n symbol = {\n type: \"accent\",\n mode: this.mode,\n loc: SourceLocation.range(nucleus),\n label: command,\n isStretchy: false,\n isShifty: true,\n base: symbol\n };\n }\n }\n\n return symbol;\n };\n\n return Parser;\n}();\n\nParser_Parser.endOfExpression = [\"}\", \"\\\\endgroup\", \"\\\\end\", \"\\\\right\", \"&\"];\nParser_Parser.endOfGroup = {\n \"[\": \"]\",\n \"{\": \"}\",\n \"\\\\begingroup\": \"\\\\endgroup\"\n /**\n * Parses an \"expression\", which is a list of atoms.\n *\n * `breakOnInfix`: Should the parsing stop when we hit infix nodes? This\n * happens when functions have higher precendence han infix\n * nodes in implicit parses.\n *\n * `breakOnTokenText`: The text of the token that the expression should end\n * with, or `null` if something else should end the\n * expression.\n */\n\n};\nParser_Parser.SUPSUB_GREEDINESS = 1;\n\n// CONCATENATED MODULE: ./src/parseTree.js\n/**\n * Provides a single function for parsing an expression using a Parser\n * TODO(emily): Remove this\n */\n\n\n\n/**\n * Parses an expression using a Parser, then returns the parsed result.\n */\nvar parseTree_parseTree = function parseTree(toParse, settings) {\n if (!(typeof toParse === 'string' || toParse instanceof String)) {\n throw new TypeError('KaTeX can only parse string typed expression');\n }\n\n var parser = new Parser_Parser(toParse, settings); // Blank out any \\df@tag to avoid spurious \"Duplicate \\tag\" errors\n\n delete parser.gullet.macros.current[\"\\\\df@tag\"];\n var tree = parser.parse(); // If the input used \\tag, it will set the \\df@tag macro to the tag.\n // In this case, we separately parse the tag and wrap the tree.\n\n if (parser.gullet.macros.get(\"\\\\df@tag\")) {\n if (!settings.displayMode) {\n throw new src_ParseError(\"\\\\tag works only in display equations\");\n }\n\n parser.gullet.feed(\"\\\\df@tag\");\n tree = [{\n type: \"tag\",\n mode: \"text\",\n body: tree,\n tag: parser.parse()\n }];\n }\n\n return tree;\n};\n\n/* harmony default export */ var src_parseTree = (parseTree_parseTree);\n// CONCATENATED MODULE: ./katex.js\n/* eslint no-console:0 */\n\n/**\n * This is the main entry point for KaTeX. Here, we expose functions for\n * rendering expressions either to DOM nodes or to markup strings.\n *\n * We also expose the ParseError class to check if errors thrown from KaTeX are\n * errors in the expression, or errors in javascript handling.\n */\n\n\n\n\n\n\n\n\n\n\n/**\n * Parse and build an expression, and place that expression in the DOM node\n * given.\n */\nvar katex_render = function render(expression, baseNode, options) {\n baseNode.textContent = \"\";\n var node = katex_renderToDomTree(expression, options).toNode();\n baseNode.appendChild(node);\n}; // KaTeX's styles don't work properly in quirks mode. Print out an error, and\n// disable rendering.\n\n\nif (typeof document !== \"undefined\") {\n if (document.compatMode !== \"CSS1Compat\") {\n typeof console !== \"undefined\" && console.warn(\"Warning: KaTeX doesn't work in quirks mode. Make sure your \" + \"website has a suitable doctype.\");\n\n katex_render = function render() {\n throw new src_ParseError(\"KaTeX doesn't work in quirks mode.\");\n };\n }\n}\n/**\n * Parse and build an expression, and return the markup for that.\n */\n\n\nvar renderToString = function renderToString(expression, options) {\n var markup = katex_renderToDomTree(expression, options).toMarkup();\n return markup;\n};\n/**\n * Parse an expression and return the parse tree.\n */\n\n\nvar katex_generateParseTree = function generateParseTree(expression, options) {\n var settings = new Settings_Settings(options);\n return src_parseTree(expression, settings);\n};\n/**\n * If the given error is a KaTeX ParseError and options.throwOnError is false,\n * renders the invalid LaTeX as a span with hover title giving the KaTeX\n * error message. Otherwise, simply throws the error.\n */\n\n\nvar katex_renderError = function renderError(error, expression, options) {\n if (options.throwOnError || !(error instanceof src_ParseError)) {\n throw error;\n }\n\n var node = buildCommon.makeSpan([\"katex-error\"], [new domTree_SymbolNode(expression)]);\n node.setAttribute(\"title\", error.toString());\n node.setAttribute(\"style\", \"color:\" + options.errorColor);\n return node;\n};\n/**\n * Generates and returns the katex build tree. This is used for advanced\n * use cases (like rendering to custom output).\n */\n\n\nvar katex_renderToDomTree = function renderToDomTree(expression, options) {\n var settings = new Settings_Settings(options);\n\n try {\n var tree = src_parseTree(expression, settings);\n return buildTree_buildTree(tree, expression, settings);\n } catch (error) {\n return katex_renderError(error, expression, settings);\n }\n};\n/**\n * Generates and returns the katex build tree, with just HTML (no MathML).\n * This is used for advanced use cases (like rendering to custom output).\n */\n\n\nvar katex_renderToHTMLTree = function renderToHTMLTree(expression, options) {\n var settings = new Settings_Settings(options);\n\n try {\n var tree = src_parseTree(expression, settings);\n return buildTree_buildHTMLTree(tree, expression, settings);\n } catch (error) {\n return katex_renderError(error, expression, settings);\n }\n};\n\n/* harmony default export */ var katex_0 = ({\n /**\n * Current KaTeX version\n */\n version: \"0.11.1\",\n\n /**\n * Renders the given LaTeX into an HTML+MathML combination, and adds\n * it as a child to the specified DOM node.\n */\n render: katex_render,\n\n /**\n * Renders the given LaTeX into an HTML+MathML combination string,\n * for sending to the client.\n */\n renderToString: renderToString,\n\n /**\n * KaTeX error, usually during parsing.\n */\n ParseError: src_ParseError,\n\n /**\n * Parses the given LaTeX into KaTeX's internal parse tree structure,\n * without rendering to HTML or MathML.\n *\n * NOTE: This method is not currently recommended for public use.\n * The internal tree representation is unstable and is very likely\n * to change. Use at your own risk.\n */\n __parse: katex_generateParseTree,\n\n /**\n * Renders the given LaTeX into an HTML+MathML internal DOM tree\n * representation, without flattening that representation to a string.\n *\n * NOTE: This method is not currently recommended for public use.\n * The internal tree representation is unstable and is very likely\n * to change. Use at your own risk.\n */\n __renderToDomTree: katex_renderToDomTree,\n\n /**\n * Renders the given LaTeX into an HTML internal DOM tree representation,\n * without MathML and without flattening that representation to a string.\n *\n * NOTE: This method is not currently recommended for public use.\n * The internal tree representation is unstable and is very likely\n * to change. Use at your own risk.\n */\n __renderToHTMLTree: katex_renderToHTMLTree,\n\n /**\n * extends internal font metrics object with a new object\n * each key in the new object represents a font name\n */\n __setFontMetrics: setFontMetrics,\n\n /**\n * adds a new symbol to builtin symbols table\n */\n __defineSymbol: defineSymbol,\n\n /**\n * adds a new macro to builtin macro list\n */\n __defineMacro: defineMacro,\n\n /**\n * Expose the dom tree node types, which can be useful for type checking nodes.\n *\n * NOTE: This method is not currently recommended for public use.\n * The internal tree representation is unstable and is very likely\n * to change. Use at your own risk.\n */\n __domTree: {\n Span: domTree_Span,\n Anchor: domTree_Anchor,\n SymbolNode: domTree_SymbolNode,\n SvgNode: SvgNode,\n PathNode: domTree_PathNode,\n LineNode: LineNode\n }\n});\n// CONCATENATED MODULE: ./katex.webpack.js\n/**\n * This is the webpack entry point for KaTeX. As ECMAScript, flow[1] and jest[2]\n * doesn't support CSS modules natively, a separate entry point is used and\n * it is not flowtyped.\n *\n * [1] https://gist.github.com/lambdahands/d19e0da96285b749f0ef\n * [2] https://facebook.github.io/jest/docs/en/webpack.html\n */\n\n\n/* harmony default export */ var katex_webpack = __webpack_exports__[\"default\"] = (katex_0);\n\n/***/ })\n/******/ ])[\"default\"];\n});","\n\nEpidemic Calculator \n\n\n\n
\n
\n
Day
\n\n \n
\n\n
\n
\n\n \n
Susceptible
\n
\n
∑ {formatNumber(Math.round(N*Iters[active_][0]))} \n ({ (100*Iters[active_][0]).toFixed(2) }%)
\n
Δ {formatNumber(Math.round(N*get_d(active_)[0]))} / day \n
\n
\n
Population not immune to disease.
\n\n \n\n \n
\n\n
\n \n\n \n
Exposed
\n\n
\n
∑ {formatNumber(Math.round(N*Iters[active_][1]))} \n ({ (100*Iters[active_][1]).toFixed(2) }%)
\n
Δ {formatNumber(Math.round(N*get_d(active_)[1])) } / day \n
\n
\n
Population currently in incubation.
\n\n \n\n \n
\n\n
\n \n\n \n
Infected
\n
\n
∑ {formatNumber(Math.round(N*Iters[active_][2]))} \n ({ (100*Iters[active_][2]).toFixed(2) }%)
\n
Δ {formatNumber(Math.round(N*get_d(active_)[2])) } / day \n
\n
\n
Number of infections actively circulating.
\n\n\n \n\n \n
\n\n
{checked[1] = s; checked[0] = s; checked[2] = s} }/>\n \n
Removed
\n
\n
∑ {formatNumber(Math.round(N* (1-Iters[active_][0]-Iters[active_][1]-Iters[active_][2])+I0 ))} \n ({ ((100*(1-Iters[active_][0]-Iters[active_][1]-Iters[active_][2]-I0/N))).toFixed(2) }%)
\n
Δ {formatNumber(Math.round(N*(get_d(active_)[3]+get_d(active_)[4]+get_d(active_)[5]+get_d(active_)[6]+get_d(active_)[7]) )) } / day \n
\n
\n
Population no longer infectious due to isolation or immunity.
\n\n \n\n \n
\n
\n \n
Recovered
\n\n
\n
∑ {formatNumber(Math.round(N*(Iters[active_][7]+Iters[active_][8]) ))} \n ({ (100*(Iters[active_][7]+Iters[active_][8])).toFixed(2) }%)
\n
\n
Full recoveries.
\n\n \n\n \n
\n
\n
\n \n
Hospitalized
\n
\n
∑ {formatNumber(Math.round(N*(Iters[active_][5]+Iters[active_][6]) ))} \n ({ (100*(Iters[active_][5]+Iters[active_][6])).toFixed(2) }%)
\n
\n
Δ {formatNumber(Math.round(N*(get_d(active_)[5]+get_d(active_)[6]))) } / day \n
\n
Active hospitalizations.
\n\n \n\n
\n
\n\n
\n\n \n
Fatalities
\n
\n
∑ {formatNumber(Math.round(N*Iters[active_][9]))} \n ({ (100*Iters[active_][9]).toFixed(2) }%)
\n
Δ {formatNumber(Math.round(N*get_d(active_)[9])) } / day \n
\n
\n
Deaths.
\n \n
\n
\n\n
\n\n
\n \n
\n\n
\n
\n\n
\n
\n\n \n
\n
\n\n
\n {@html math_inline(\"\\\\mathcal{R}_t=\" + (R0*InterventionAmt).toFixed(2) )} ⟶ \n
\n\n {#if xScaleTime(InterventionTime) >= 100}\n
\n ⟵ {@html math_inline(\"\\\\mathcal{R}_0=\" + (R0).toFixed(2) )} \n
\n {/if}\n\n
\n
Intervention on day {format(\"d\")(InterventionTime)}
\n
\n (drag me)
\n
\n
\n\n\n
\n\n
\n\n\n
\n
\n\n \n
\n
\n
\n
\n
\n
to decrease transmission by
\n
\n
\n
{(InterventionAmt).toFixed(2)}
\n
\n
\n
\n
\n
\n
\n\n\n\n\n
\n {#each milestones as milestone}\n
\n
\n
{@html milestone[1]}
\n
\n {/each}\n
\n \n
= 192? 1.0 : 0.2}\">\n
\n
\n\n
\n\n
\n
\n
Transmission Dynamics
\n
\n
Clinical Dynamics
\n
\n
\n\n
\n
Population Inputs
\n
Size of population.
\n
{format(\",\")(Math.round(N))}
\n
\n
Number of initial infections.
\n
{I0}
\n
\n
\n\n
\n
\n
Basic Reproduction Number {@html math_inline(\"\\\\mathcal{R}_0\")}
\n
Measure of contagiousness: the number of secondary infections each infected individual produces.
\n
\n
{R0}
\n
\n
\n\n
\n
Transmission Times
\n
Length of incubation period, {@html math_inline(\"T_{\\\\text{inc}}\")}.
\n
{(D_incbation).toFixed(2)} days
\n
\n
Duration patient is infectious, {@html math_inline(\"T_{\\\\text{inf}}\")}.
\n
{D_infectious} Days
\n
\n
\n\n
\n\n
\n
Morbidity Statistics
\n
Case fatality rate.
\n
{(CFR*100).toFixed(2)} %
\n
\n
Time from end of incubation to death.
\n
{Time_to_death} Days
\n
\n
\n\n
\n
Recovery Times
\n
Length of hospital stay
\n
{D_recovery_severe} Days
\n
\n
Recovery time for mild cases
\n
{D_recovery_mild} Days
\n
\n
\n\n
\n
Care statistics
\n
Hospitalization rate.
\n
{(P_SEVERE*100).toFixed(2)} %
\n
\n
Time to hospitalization.
\n
{D_hospital_lag} Days
\n
\n
\n\n
\n
Duration of Intervention
\n
{duration} Days
\n
\n
\n\n
\n
\n\n\nAt the time of writing, the coronavirus disease of 2019 remains a global health crisis of grave and uncertain magnitude. To the non-expert (such as myself), contextualizing the numbers, forecasts and epidemiological parameters described in the media and literature can be challenging. I created this calculator as an attempt to address this gap in understanding.\n
\n\n\nThis calculator implements a classical infectious disease model &mdash SEIR S usceptible → E I R Wu, et. al , Kucharski et. al ]. The dynamics of this model are characterized by a set of four ordinary differential equations that correspond to the stages of the disease's progression:\n{@html ode_eqn} \nIn addition to the transmission dynamics, this model allows the use of supplemental timing information to model the death rate and healthcare burden. \n
\n\n\nNote that one can use this calculator to measure one's risk exposure to the disease for any given day of the epidemic: the probability of getting infected on day {Math.round(indexToTime(active_))} given close contact with Burke et. al ].\n
\n\n\n\nA sampling of the estimates for epidemic parameters are presented below:\n
\n\n\n
\n \n Location \n Reproduction Number \n Incubation Period \n Infectious Period \n \n \n Kucharski et. al Wuhan \n 3.0 (1.5 — 4.5) \n 5.2 \n 2.9 \n \n \n Li, Leung and Leung Wuhan \n 2.2 (1.4 — 3.9) \n 5.2 (4.1 — 7.0) \n 2.3 (0.0 — 14.9) \n \n \n Wu et. al Greater Wuhan \n 2.68 (2.47 — 2.86) \n 6.1 \n 2.3 \n \n \n WHO Initial Estimate Hubei \n 1.95 (1.4 — 2.5) \n \n \n WHO-China Joint Mission Hubei \n 2.25 (2.0 — 2.5) \n 5.5 (5.0 - 6.0) \n \n \n Liu et. al Guangdong \n 4.5 (4.4 — 4.6) \n 4.8 (2.2 — 7.4) \n 2.9 (0 — 5.9) \n \n \n Rocklöv, Sjödin and Wilder-Smith Princess Diamond \n 14.8 \n 5.0 \n 10.0 \n \n \n Backer, Klinkenberg, Wallinga Wuhan \n 6.5 (5.6 — 7.9) \n \n \n Read et. al Wuhan \n 3.11 (2.39 — 4.13) \n \n \n Bi et. al Shenzhen \n 4.8 (4.2 — 5.4) \n 1.5 (0 — 3.4) \n \n\n \n Tang et. al China \n 6.47 (5.71 — 7.23) \n \n\n
\n
\nSee [Liu et. al ] detailed survey of current estimates of the reproduction number. Parameters for the diseases' clinical characteristics are taken from the following WHO Report . \n
\n\n\nPlease DM me feedback here or email me here . My website .\n
\n\n\n\n\n Model Details mild (patients who recover without the need for hospitalization), moderate (patients who require hospitalization but survive) and fatal (patients who require hospitalization and do not survive). Each of these variables follows its own trajectory to the final outcome, and the sum of these compartments add up to the values predicted by SEIR. Please refer to the source code for details. Note that we assume, for simplicity, that all fatalities come from hospitals, and that all fatal cases are admitted to hospitals immediately after the infectious period.\n
\n\n\n Acknowledgements Steven De Keninck for RK4 Integrator. Chris Olah , Shan Carter\n and Ludwig Schubert\n wonderful feedback. Charlie Huang for context and discussion.\n
\n\n\n\n\n
\n
Export parameters:
\n
\n
\n
+
Duration of Intervention
+
{duration} Days
+
+