{"version":3,"sources":["webpack:///./node_modules/katex/src/buildCommon.js","webpack:///./node_modules/katex/src/buildHTML.js","webpack:///./node_modules/katex/src/buildMathML.js"],"names":["domTree","fontMetrics","symbols","utils","greekCapitals","dotlessLetters","makeSymbol","value","style","mode","color","classes","replace","symbolNode","metrics","getCharacterMetrics","height","depth","italic","skew","console","warn","mathsym","font","concat","mathDefault","type","mathit","Error","test","charAt","contains","makeOrd","group","options","getColor","fontName","fontMap","sizeElementFromChildren","elem","maxFontSize","children","i","length","makeSpan","span","makeFragment","fragment","documentFragment","makeFontSizer","fontSize","fontSizeInner","sizeMultiplier","fontSizer","size","makeVList","positionType","positionData","currPos","oldChildren","shift","diff","push","bottom","Math","max","realChildren","child","childWrap","top","baselineFix","vlist","sizingMultiplier","size1","size2","size3","size4","size5","size6","size7","size8","size9","size10","spacingFunctions","className","variant","module","exports","ParseError","Style","buildCommon","delimiter","buildExpression","expression","prev","groups","buildGroup","groupToType","mathord","textord","bin","rel","text","open","close","inner","genfrac","array","spacing","punct","ordgroup","op","katex","overline","underline","rule","leftright","sqrt","accent","getTypeOfGroup","base","delimType","shouldHandleSupSub","limits","DISPLAY","alwaysHandleSupSub","isCharacterBox","getBaseElem","baseElem","makeNullDelimiter","reset","TEXT","cls","groupTypes","prevAtom","atoms","body","elements","withColor","supmid","submid","sup","sub","supShift","subShift","minSupShift","withStyle","supDrop","subDrop","sup1","cramped","sup3","sup2","supsub","multiplier","scriptspace","ptPerEm","xHeight","sub2","ruleWidth","defaultRuleThickness","psi","marginLeft","marginRight","sub1","fstyle","numShift","clearance","denomShift","frac","delimSize","leftDelim","rightDelim","nstyle","fracNum","dstyle","fracDen","numer","numerreset","denom","denomreset","hasBarLine","num1","denom1","num2","num3","denom2","candiateClearance","axisHeight","mid","midShift","delim1","getDelim2","customSizedDelim","r","c","nr","nc","Array","pt","arraycolsep","baselineskip","arraystretch","deflt","arrayskip","arstrutHeight","arstrutDepth","totalHeight","inrow","outrow","elt","gap","rowGaps","unit","number","emPerEx","error","pos","colSep","colDescrNum","offset","colDescriptions","cols","colDescr","firstSeparator","width","doubleRuleSep","separator","verticalAlign","sepwidth","hskipBeforeAndAfter","pregap","col","row","align","postgap","fix","supGroup","subGroup","hasLimits","noSuccessor","large","symbol","baseShift","slant","output","supKern","subKern","finalGroup","bigOpSpacing1","bigOpSpacing3","bigOpSpacing2","bigOpSpacing4","bigOpSpacing5","k","a","t","e","x","innerGroup","cramp","line","phi","id","lineClearance","innerHeight","minDelimiterHeight","delim","delimDepth","delimShift","index","root","SCRIPTSCRIPT","rootWrap","innerRootHeight","innerRootDepth","toShift","rootVList","rootVListWrap","withSize","SCRIPT","newStyle","withFont","sizedDelim","innerDepth","left","leftRightDelim","unshift","right","borderRightWidth","borderTopWidth","supsubGroup","baseChar","baseGroup","min","vecClass","accentBody","accentWrap","withPhantom","groupNode","parentStyle","parentSize","buildHTML","tree","JSON","parse","stringify","topStrut","bottomStrut","htmlNode","setAttribute","mathMLTree","makeText","TextNode","getVariant","node","MathNode","nodeType","withDelims","leftOp","rightOp","outerNode","map","cell","leftNode","rightNode","accentNode","slice","styleAttributes","attr","operator","buildMathML","texExpression","wrapper","annotation","semantics","math"],"mappings":"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","file":"js/chunk-95d79dd4.7963152c.js","sourcesContent":["/* eslint no-console:0 */\n/**\n * This module contains general functions that can be used for building\n * different kinds of domTree nodes in a consistent manner.\n */\n\nvar domTree = require(\"./domTree\");\nvar fontMetrics = require(\"./fontMetrics\");\nvar symbols = require(\"./symbols\");\nvar utils = require(\"./utils\");\n\nvar greekCapitals = [\n    \"\\\\Gamma\",\n    \"\\\\Delta\",\n    \"\\\\Theta\",\n    \"\\\\Lambda\",\n    \"\\\\Xi\",\n    \"\\\\Pi\",\n    \"\\\\Sigma\",\n    \"\\\\Upsilon\",\n    \"\\\\Phi\",\n    \"\\\\Psi\",\n    \"\\\\Omega\",\n];\n\nvar dotlessLetters = [\n    \"\\u0131\",   // dotless i, \\imath\n    \"\\u0237\",   // dotless j, \\jmath\n];\n\n/**\n * Makes a symbolNode after translation via the list of symbols in symbols.js.\n * Correctly pulls out metrics for the character, and optionally takes a list of\n * classes to be attached to the node.\n */\nvar makeSymbol = function(value, style, mode, color, classes) {\n    // Replace the value with its replaced value from symbol.js\n    if (symbols[mode][value] && symbols[mode][value].replace) {\n        value = symbols[mode][value].replace;\n    }\n\n    var metrics = fontMetrics.getCharacterMetrics(value, style);\n\n    var symbolNode;\n    if (metrics) {\n        symbolNode = new domTree.symbolNode(\n            value, metrics.height, metrics.depth, metrics.italic, metrics.skew,\n            classes);\n    } else {\n        // TODO(emily): Figure out a good way to only print this in development\n        typeof console !== \"undefined\" && console.warn(\n            \"No character metrics for '\" + value + \"' in style '\" +\n                style + \"'\");\n        symbolNode = new domTree.symbolNode(value, 0, 0, 0, 0, classes);\n    }\n\n    if (color) {\n        symbolNode.style.color = color;\n    }\n\n    return symbolNode;\n};\n\n/**\n * Makes a symbol in Main-Regular or AMS-Regular.\n * Used for rel, bin, open, close, inner, and punct.\n */\nvar mathsym = function(value, mode, color, classes) {\n    // Decide what font to render the symbol in by its entry in the symbols\n    // table.\n    // Have a special case for when the value = \\ because the \\ is used as a\n    // textord in unsupported command errors but cannot be parsed as a regular\n    // text ordinal and is therefore not present as a symbol in the symbols\n    // table for text\n    if (value === \"\\\\\" || symbols[mode][value].font === \"main\") {\n        return makeSymbol(value, \"Main-Regular\", mode, color, classes);\n    } else {\n        return makeSymbol(\n            value, \"AMS-Regular\", mode, color, classes.concat([\"amsrm\"]));\n    }\n};\n\n/**\n * Makes a symbol in the default font for mathords and textords.\n */\nvar mathDefault = function(value, mode, color, classes, type) {\n    if (type === \"mathord\") {\n        return mathit(value, mode, color, classes);\n    } else if (type === \"textord\") {\n        return makeSymbol(\n            value, \"Main-Regular\", mode, color, classes.concat([\"mathrm\"]));\n    } else {\n        throw new Error(\"unexpected type: \" + type + \" in mathDefault\");\n    }\n};\n\n/**\n * Makes a symbol in the italic math font.\n */\nvar mathit = function(value, mode, color, classes) {\n    if (/[0-9]/.test(value.charAt(0)) ||\n            // glyphs for \\imath and \\jmath do not exist in Math-Italic so we\n            // need to use Main-Italic instead\n            utils.contains(dotlessLetters, value) ||\n            utils.contains(greekCapitals, value)) {\n        return makeSymbol(\n            value, \"Main-Italic\", mode, color, classes.concat([\"mainit\"]));\n    } else {\n        return makeSymbol(\n            value, \"Math-Italic\", mode, color, classes.concat([\"mathit\"]));\n    }\n};\n\n/**\n * Makes either a mathord or textord in the correct font and color.\n */\nvar makeOrd = function(group, options, type) {\n    var mode = group.mode;\n    var value = group.value;\n    if (symbols[mode][value] && symbols[mode][value].replace) {\n        value = symbols[mode][value].replace;\n    }\n\n    var classes = [\"mord\"];\n    var color = options.getColor();\n\n    var font = options.font;\n    if (font) {\n        if (font === \"mathit\" || utils.contains(dotlessLetters, value)) {\n            return mathit(value, mode, color, classes);\n        } else {\n            var fontName = fontMap[font].fontName;\n            if (fontMetrics.getCharacterMetrics(value, fontName)) {\n                return makeSymbol(\n                    value, fontName, mode, color, classes.concat([font]));\n            } else {\n                return mathDefault(value, mode, color, classes, type);\n            }\n        }\n    } else {\n        return mathDefault(value, mode, color, classes, type);\n    }\n};\n\n/**\n * Calculate the height, depth, and maxFontSize of an element based on its\n * children.\n */\nvar sizeElementFromChildren = function(elem) {\n    var height = 0;\n    var depth = 0;\n    var maxFontSize = 0;\n\n    if (elem.children) {\n        for (var i = 0; i < elem.children.length; i++) {\n            if (elem.children[i].height > height) {\n                height = elem.children[i].height;\n            }\n            if (elem.children[i].depth > depth) {\n                depth = elem.children[i].depth;\n            }\n            if (elem.children[i].maxFontSize > maxFontSize) {\n                maxFontSize = elem.children[i].maxFontSize;\n            }\n        }\n    }\n\n    elem.height = height;\n    elem.depth = depth;\n    elem.maxFontSize = maxFontSize;\n};\n\n/**\n * Makes a span with the given list of classes, list of children, and color.\n */\nvar makeSpan = function(classes, children, color) {\n    var span = new domTree.span(classes, children);\n\n    sizeElementFromChildren(span);\n\n    if (color) {\n        span.style.color = color;\n    }\n\n    return span;\n};\n\n/**\n * Makes a document fragment with the given list of children.\n */\nvar makeFragment = function(children) {\n    var fragment = new domTree.documentFragment(children);\n\n    sizeElementFromChildren(fragment);\n\n    return fragment;\n};\n\n/**\n * Makes an element placed in each of the vlist elements to ensure that each\n * element has the same max font size. To do this, we create a zero-width space\n * with the correct font size.\n */\nvar makeFontSizer = function(options, fontSize) {\n    var fontSizeInner = makeSpan([], [new domTree.symbolNode(\"\\u200b\")]);\n    fontSizeInner.style.fontSize =\n        (fontSize / options.style.sizeMultiplier) + \"em\";\n\n    var fontSizer = makeSpan(\n        [\"fontsize-ensurer\", \"reset-\" + options.size, \"size5\"],\n        [fontSizeInner]);\n\n    return fontSizer;\n};\n\n/**\n * Makes a vertical list by stacking elements and kerns on top of each other.\n * Allows for many different ways of specifying the positioning method.\n *\n * Arguments:\n *  - children: A list of child or kern nodes to be stacked on top of each other\n *              (i.e. the first element will be at the bottom, and the last at\n *              the top). Element nodes are specified as\n *                {type: \"elem\", elem: node}\n *              while kern nodes are specified as\n *                {type: \"kern\", size: size}\n *  - positionType: The method by which the vlist should be positioned. Valid\n *                  values are:\n *                   - \"individualShift\": The children list only contains elem\n *                                        nodes, and each node contains an extra\n *                                        \"shift\" value of how much it should be\n *                                        shifted (note that shifting is always\n *                                        moving downwards). positionData is\n *                                        ignored.\n *                   - \"top\": The positionData specifies the topmost point of\n *                            the vlist (note this is expected to be a height,\n *                            so positive values move up)\n *                   - \"bottom\": The positionData specifies the bottommost point\n *                               of the vlist (note this is expected to be a\n *                               depth, so positive values move down\n *                   - \"shift\": The vlist will be positioned such that its\n *                              baseline is positionData away from the baseline\n *                              of the first child. Positive values move\n *                              downwards.\n *                   - \"firstBaseline\": The vlist will be positioned such that\n *                                      its baseline is aligned with the\n *                                      baseline of the first child.\n *                                      positionData is ignored. (this is\n *                                      equivalent to \"shift\" with\n *                                      positionData=0)\n *  - positionData: Data used in different ways depending on positionType\n *  - options: An Options object\n *\n */\nvar makeVList = function(children, positionType, positionData, options) {\n    var depth;\n    var currPos;\n    var i;\n    if (positionType === \"individualShift\") {\n        var oldChildren = children;\n        children = [oldChildren[0]];\n\n        // Add in kerns to the list of children to get each element to be\n        // shifted to the correct specified shift\n        depth = -oldChildren[0].shift - oldChildren[0].elem.depth;\n        currPos = depth;\n        for (i = 1; i < oldChildren.length; i++) {\n            var diff = -oldChildren[i].shift - currPos -\n                oldChildren[i].elem.depth;\n            var size = diff -\n                (oldChildren[i - 1].elem.height +\n                 oldChildren[i - 1].elem.depth);\n\n            currPos = currPos + diff;\n\n            children.push({type: \"kern\", size: size});\n            children.push(oldChildren[i]);\n        }\n    } else if (positionType === \"top\") {\n        // We always start at the bottom, so calculate the bottom by adding up\n        // all the sizes\n        var bottom = positionData;\n        for (i = 0; i < children.length; i++) {\n            if (children[i].type === \"kern\") {\n                bottom -= children[i].size;\n            } else {\n                bottom -= children[i].elem.height + children[i].elem.depth;\n            }\n        }\n        depth = bottom;\n    } else if (positionType === \"bottom\") {\n        depth = -positionData;\n    } else if (positionType === \"shift\") {\n        depth = -children[0].elem.depth - positionData;\n    } else if (positionType === \"firstBaseline\") {\n        depth = -children[0].elem.depth;\n    } else {\n        depth = 0;\n    }\n\n    // Make the fontSizer\n    var maxFontSize = 0;\n    for (i = 0; i < children.length; i++) {\n        if (children[i].type === \"elem\") {\n            maxFontSize = Math.max(maxFontSize, children[i].elem.maxFontSize);\n        }\n    }\n    var fontSizer = makeFontSizer(options, maxFontSize);\n\n    // Create a new list of actual children at the correct offsets\n    var realChildren = [];\n    currPos = depth;\n    for (i = 0; i < children.length; i++) {\n        if (children[i].type === \"kern\") {\n            currPos += children[i].size;\n        } else {\n            var child = children[i].elem;\n\n            var shift = -child.depth - currPos;\n            currPos += child.height + child.depth;\n\n            var childWrap = makeSpan([], [fontSizer, child]);\n            childWrap.height -= shift;\n            childWrap.depth += shift;\n            childWrap.style.top = shift + \"em\";\n\n            realChildren.push(childWrap);\n        }\n    }\n\n    // Add in an element at the end with no offset to fix the calculation of\n    // baselines in some browsers (namely IE, sometimes safari)\n    var baselineFix = makeSpan(\n        [\"baseline-fix\"], [fontSizer, new domTree.symbolNode(\"\\u200b\")]);\n    realChildren.push(baselineFix);\n\n    var vlist = makeSpan([\"vlist\"], realChildren);\n    // Fix the final height and depth, in case there were kerns at the ends\n    // since the makeSpan calculation won't take that in to account.\n    vlist.height = Math.max(currPos, vlist.height);\n    vlist.depth = Math.max(-depth, vlist.depth);\n    return vlist;\n};\n\n// A table of size -> font size for the different sizing functions\nvar sizingMultiplier = {\n    size1: 0.5,\n    size2: 0.7,\n    size3: 0.8,\n    size4: 0.9,\n    size5: 1.0,\n    size6: 1.2,\n    size7: 1.44,\n    size8: 1.73,\n    size9: 2.07,\n    size10: 2.49,\n};\n\n// A map of spacing functions to their attributes, like size and corresponding\n// CSS class\nvar spacingFunctions = {\n    \"\\\\qquad\": {\n        size: \"2em\",\n        className: \"qquad\",\n    },\n    \"\\\\quad\": {\n        size: \"1em\",\n        className: \"quad\",\n    },\n    \"\\\\enspace\": {\n        size: \"0.5em\",\n        className: \"enspace\",\n    },\n    \"\\\\;\": {\n        size: \"0.277778em\",\n        className: \"thickspace\",\n    },\n    \"\\\\:\": {\n        size: \"0.22222em\",\n        className: \"mediumspace\",\n    },\n    \"\\\\,\": {\n        size: \"0.16667em\",\n        className: \"thinspace\",\n    },\n    \"\\\\!\": {\n        size: \"-0.16667em\",\n        className: \"negativethinspace\",\n    },\n};\n\n/**\n * Maps TeX font commands to objects containing:\n * - variant: string used for \"mathvariant\" attribute in buildMathML.js\n * - fontName: the \"style\" parameter to fontMetrics.getCharacterMetrics\n */\n// A map between tex font commands an MathML mathvariant attribute values\nvar fontMap = {\n    // styles\n    \"mathbf\": {\n        variant: \"bold\",\n        fontName: \"Main-Bold\",\n    },\n    \"mathrm\": {\n        variant: \"normal\",\n        fontName: \"Main-Regular\",\n    },\n\n    // \"mathit\" is missing because it requires the use of two fonts: Main-Italic\n    // and Math-Italic.  This is handled by a special case in makeOrd which ends\n    // up calling mathit.\n\n    // families\n    \"mathbb\": {\n        variant: \"double-struck\",\n        fontName: \"AMS-Regular\",\n    },\n    \"mathcal\": {\n        variant: \"script\",\n        fontName: \"Caligraphic-Regular\",\n    },\n    \"mathfrak\": {\n        variant: \"fraktur\",\n        fontName: \"Fraktur-Regular\",\n    },\n    \"mathscr\": {\n        variant: \"script\",\n        fontName: \"Script-Regular\",\n    },\n    \"mathsf\": {\n        variant: \"sans-serif\",\n        fontName: \"SansSerif-Regular\",\n    },\n    \"mathtt\": {\n        variant: \"monospace\",\n        fontName: \"Typewriter-Regular\",\n    },\n};\n\nmodule.exports = {\n    fontMap: fontMap,\n    makeSymbol: makeSymbol,\n    mathsym: mathsym,\n    makeSpan: makeSpan,\n    makeFragment: makeFragment,\n    makeVList: makeVList,\n    makeOrd: makeOrd,\n    sizingMultiplier: sizingMultiplier,\n    spacingFunctions: spacingFunctions,\n};\n","/* eslint no-console:0 */\n/**\n * This file does the main work of building a domTree structure from a parse\n * tree. The entry point is the `buildHTML` function, which takes a parse tree.\n * Then, the buildExpression, buildGroup, and various groupTypes functions are\n * called, to produce a final HTML tree.\n */\n\nvar ParseError = require(\"./ParseError\");\nvar Style = require(\"./Style\");\n\nvar buildCommon = require(\"./buildCommon\");\nvar delimiter = require(\"./delimiter\");\nvar domTree = require(\"./domTree\");\nvar fontMetrics = require(\"./fontMetrics\");\nvar utils = require(\"./utils\");\n\nvar makeSpan = buildCommon.makeSpan;\n\n/**\n * Take a list of nodes, build them in order, and return a list of the built\n * nodes. This function handles the `prev` node correctly, and passes the\n * previous element from the list as the prev of the next element.\n */\nvar buildExpression = function(expression, options, prev) {\n    var groups = [];\n    for (var i = 0; i < expression.length; i++) {\n        var group = expression[i];\n        groups.push(buildGroup(group, options, prev));\n        prev = group;\n    }\n    return groups;\n};\n\n// List of types used by getTypeOfGroup,\n// see https://github.com/Khan/KaTeX/wiki/Examining-TeX#group-types\nvar groupToType = {\n    mathord: \"mord\",\n    textord: \"mord\",\n    bin: \"mbin\",\n    rel: \"mrel\",\n    text: \"mord\",\n    open: \"mopen\",\n    close: \"mclose\",\n    inner: \"minner\",\n    genfrac: \"mord\",\n    array: \"mord\",\n    spacing: \"mord\",\n    punct: \"mpunct\",\n    ordgroup: \"mord\",\n    op: \"mop\",\n    katex: \"mord\",\n    overline: \"mord\",\n    underline: \"mord\",\n    rule: \"mord\",\n    leftright: \"minner\",\n    sqrt: \"mord\",\n    accent: \"mord\",\n};\n\n/**\n * Gets the final math type of an expression, given its group type. This type is\n * used to determine spacing between elements, and affects bin elements by\n * causing them to change depending on what types are around them. This type\n * must be attached to the outermost node of an element as a CSS class so that\n * spacing with its surrounding elements works correctly.\n *\n * Some elements can be mapped one-to-one from group type to math type, and\n * those are listed in the `groupToType` table.\n *\n * Others (usually elements that wrap around other elements) often have\n * recursive definitions, and thus call `getTypeOfGroup` on their inner\n * elements.\n */\nvar getTypeOfGroup = function(group) {\n    if (group == null) {\n        // Like when typesetting $^3$\n        return groupToType.mathord;\n    } else if (group.type === \"supsub\") {\n        return getTypeOfGroup(group.value.base);\n    } else if (group.type === \"llap\" || group.type === \"rlap\") {\n        return getTypeOfGroup(group.value);\n    } else if (group.type === \"color\") {\n        return getTypeOfGroup(group.value.value);\n    } else if (group.type === \"sizing\") {\n        return getTypeOfGroup(group.value.value);\n    } else if (group.type === \"styling\") {\n        return getTypeOfGroup(group.value.value);\n    } else if (group.type === \"delimsizing\") {\n        return groupToType[group.value.delimType];\n    } else {\n        return groupToType[group.type];\n    }\n};\n\n/**\n * Sometimes, groups perform special rules when they have superscripts or\n * subscripts attached to them. This function lets the `supsub` group know that\n * its inner element should handle the superscripts and subscripts instead of\n * handling them itself.\n */\nvar shouldHandleSupSub = function(group, options) {\n    if (!group) {\n        return false;\n    } else if (group.type === \"op\") {\n        // Operators handle supsubs differently when they have limits\n        // (e.g. `\\displaystyle\\sum_2^3`)\n        return group.value.limits &&\n            (options.style.size === Style.DISPLAY.size ||\n            group.value.alwaysHandleSupSub);\n    } else if (group.type === \"accent\") {\n        return isCharacterBox(group.value.base);\n    } else {\n        return null;\n    }\n};\n\n/**\n * Sometimes we want to pull out the innermost element of a group. In most\n * cases, this will just be the group itself, but when ordgroups and colors have\n * a single element, we want to pull that out.\n */\nvar getBaseElem = function(group) {\n    if (!group) {\n        return false;\n    } else if (group.type === \"ordgroup\") {\n        if (group.value.length === 1) {\n            return getBaseElem(group.value[0]);\n        } else {\n            return group;\n        }\n    } else if (group.type === \"color\") {\n        if (group.value.value.length === 1) {\n            return getBaseElem(group.value.value[0]);\n        } else {\n            return group;\n        }\n    } else {\n        return group;\n    }\n};\n\n/**\n * TeXbook algorithms often reference \"character boxes\", which are simply groups\n * with a single character in them. To decide if something is a character box,\n * we find its innermost group, and see if it is a single character.\n */\nvar isCharacterBox = function(group) {\n    var baseElem = getBaseElem(group);\n\n    // These are all they types of groups which hold single characters\n    return baseElem.type === \"mathord\" ||\n        baseElem.type === \"textord\" ||\n        baseElem.type === \"bin\" ||\n        baseElem.type === \"rel\" ||\n        baseElem.type === \"inner\" ||\n        baseElem.type === \"open\" ||\n        baseElem.type === \"close\" ||\n        baseElem.type === \"punct\";\n};\n\nvar makeNullDelimiter = function(options) {\n    return makeSpan([\n        \"sizing\", \"reset-\" + options.size, \"size5\",\n        options.style.reset(), Style.TEXT.cls(),\n        \"nulldelimiter\",\n    ]);\n};\n\n/**\n * This is a map of group types to the function used to handle that type.\n * Simpler types come at the beginning, while complicated types come afterwards.\n */\nvar groupTypes = {};\n\ngroupTypes.mathord = function(group, options, prev) {\n    return buildCommon.makeOrd(group, options, \"mathord\");\n};\n\ngroupTypes.textord = function(group, options, prev) {\n    return buildCommon.makeOrd(group, options, \"textord\");\n};\n\ngroupTypes.bin = function(group, options, prev) {\n    var className = \"mbin\";\n    // Pull out the most recent element. Do some special handling to find\n    // things at the end of a \\color group. Note that we don't use the same\n    // logic for ordgroups (which count as ords).\n    var prevAtom = prev;\n    while (prevAtom && prevAtom.type === \"color\") {\n        var atoms = prevAtom.value.value;\n        prevAtom = atoms[atoms.length - 1];\n    }\n    // See TeXbook pg. 442-446, Rules 5 and 6, and the text before Rule 19.\n    // Here, we determine whether the bin should turn into an ord. We\n    // currently only apply Rule 5.\n    if (!prev || utils.contains([\"mbin\", \"mopen\", \"mrel\", \"mop\", \"mpunct\"],\n            getTypeOfGroup(prevAtom))) {\n        group.type = \"textord\";\n        className = \"mord\";\n    }\n\n    return buildCommon.mathsym(\n        group.value, group.mode, options.getColor(), [className]);\n};\n\ngroupTypes.rel = function(group, options, prev) {\n    return buildCommon.mathsym(\n        group.value, group.mode, options.getColor(), [\"mrel\"]);\n};\n\ngroupTypes.open = function(group, options, prev) {\n    return buildCommon.mathsym(\n        group.value, group.mode, options.getColor(), [\"mopen\"]);\n};\n\ngroupTypes.close = function(group, options, prev) {\n    return buildCommon.mathsym(\n        group.value, group.mode, options.getColor(), [\"mclose\"]);\n};\n\ngroupTypes.inner = function(group, options, prev) {\n    return buildCommon.mathsym(\n        group.value, group.mode, options.getColor(), [\"minner\"]);\n};\n\ngroupTypes.punct = function(group, options, prev) {\n    return buildCommon.mathsym(\n        group.value, group.mode, options.getColor(), [\"mpunct\"]);\n};\n\ngroupTypes.ordgroup = function(group, options, prev) {\n    return makeSpan(\n        [\"mord\", options.style.cls()],\n        buildExpression(group.value, options.reset())\n    );\n};\n\ngroupTypes.text = function(group, options, prev) {\n    return makeSpan([\"text\", \"mord\", options.style.cls()],\n        buildExpression(group.value.body, options.reset()));\n};\n\ngroupTypes.color = function(group, options, prev) {\n    var elements = buildExpression(\n        group.value.value,\n        options.withColor(group.value.color),\n        prev\n    );\n\n    // \\color isn't supposed to affect the type of the elements it contains.\n    // To accomplish this, we wrap the results in a fragment, so the inner\n    // elements will be able to directly interact with their neighbors. For\n    // example, `\\color{red}{2 +} 3` has the same spacing as `2 + 3`\n    return new buildCommon.makeFragment(elements);\n};\n\ngroupTypes.supsub = function(group, options, prev) {\n    // Superscript and subscripts are handled in the TeXbook on page\n    // 445-446, rules 18(a-f).\n\n    // Here is where we defer to the inner group if it should handle\n    // superscripts and subscripts itself.\n    if (shouldHandleSupSub(group.value.base, options)) {\n        return groupTypes[group.value.base.type](group, options, prev);\n    }\n\n    var base = buildGroup(group.value.base, options.reset());\n    var supmid;\n    var submid;\n    var sup;\n    var sub;\n\n    if (group.value.sup) {\n        sup = buildGroup(group.value.sup,\n                options.withStyle(options.style.sup()));\n        supmid = makeSpan(\n                [options.style.reset(), options.style.sup().cls()], [sup]);\n    }\n\n    if (group.value.sub) {\n        sub = buildGroup(group.value.sub,\n                options.withStyle(options.style.sub()));\n        submid = makeSpan(\n                [options.style.reset(), options.style.sub().cls()], [sub]);\n    }\n\n    // Rule 18a\n    var supShift;\n    var subShift;\n    if (isCharacterBox(group.value.base)) {\n        supShift = 0;\n        subShift = 0;\n    } else {\n        supShift = base.height - fontMetrics.metrics.supDrop;\n        subShift = base.depth + fontMetrics.metrics.subDrop;\n    }\n\n    // Rule 18c\n    var minSupShift;\n    if (options.style === Style.DISPLAY) {\n        minSupShift = fontMetrics.metrics.sup1;\n    } else if (options.style.cramped) {\n        minSupShift = fontMetrics.metrics.sup3;\n    } else {\n        minSupShift = fontMetrics.metrics.sup2;\n    }\n\n    // scriptspace is a font-size-independent size, so scale it\n    // appropriately\n    var multiplier = Style.TEXT.sizeMultiplier *\n            options.style.sizeMultiplier;\n    var scriptspace =\n        (0.5 / fontMetrics.metrics.ptPerEm) / multiplier + \"em\";\n\n    var supsub;\n    if (!group.value.sup) {\n        // Rule 18b\n        subShift = Math.max(\n            subShift, fontMetrics.metrics.sub1,\n            sub.height - 0.8 * fontMetrics.metrics.xHeight);\n\n        supsub = buildCommon.makeVList([\n            {type: \"elem\", elem: submid},\n        ], \"shift\", subShift, options);\n\n        supsub.children[0].style.marginRight = scriptspace;\n\n        // Subscripts shouldn't be shifted by the base's italic correction.\n        // Account for that by shifting the subscript back the appropriate\n        // amount. Note we only do this when the base is a single symbol.\n        if (base instanceof domTree.symbolNode) {\n            supsub.children[0].style.marginLeft = -base.italic + \"em\";\n        }\n    } else if (!group.value.sub) {\n        // Rule 18c, d\n        supShift = Math.max(supShift, minSupShift,\n            sup.depth + 0.25 * fontMetrics.metrics.xHeight);\n\n        supsub = buildCommon.makeVList([\n            {type: \"elem\", elem: supmid},\n        ], \"shift\", -supShift, options);\n\n        supsub.children[0].style.marginRight = scriptspace;\n    } else {\n        supShift = Math.max(\n            supShift, minSupShift,\n            sup.depth + 0.25 * fontMetrics.metrics.xHeight);\n        subShift = Math.max(subShift, fontMetrics.metrics.sub2);\n\n        var ruleWidth = fontMetrics.metrics.defaultRuleThickness;\n\n        // Rule 18e\n        if ((supShift - sup.depth) - (sub.height - subShift) <\n                4 * ruleWidth) {\n            subShift = 4 * ruleWidth - (supShift - sup.depth) + sub.height;\n            var psi = 0.8 * fontMetrics.metrics.xHeight -\n                (supShift - sup.depth);\n            if (psi > 0) {\n                supShift += psi;\n                subShift -= psi;\n            }\n        }\n\n        supsub = buildCommon.makeVList([\n            {type: \"elem\", elem: submid, shift: subShift},\n            {type: \"elem\", elem: supmid, shift: -supShift},\n        ], \"individualShift\", null, options);\n\n        // See comment above about subscripts not being shifted\n        if (base instanceof domTree.symbolNode) {\n            supsub.children[0].style.marginLeft = -base.italic + \"em\";\n        }\n\n        supsub.children[0].style.marginRight = scriptspace;\n        supsub.children[1].style.marginRight = scriptspace;\n    }\n\n    return makeSpan([getTypeOfGroup(group.value.base)],\n        [base, supsub]);\n};\n\ngroupTypes.genfrac = function(group, options, prev) {\n    // Fractions are handled in the TeXbook on pages 444-445, rules 15(a-e).\n    // Figure out what style this fraction should be in based on the\n    // function used\n    var fstyle = options.style;\n    if (group.value.size === \"display\") {\n        fstyle = Style.DISPLAY;\n    } else if (group.value.size === \"text\") {\n        fstyle = Style.TEXT;\n    }\n\n    var nstyle = fstyle.fracNum();\n    var dstyle = fstyle.fracDen();\n\n    var numer = buildGroup(group.value.numer, options.withStyle(nstyle));\n    var numerreset = makeSpan([fstyle.reset(), nstyle.cls()], [numer]);\n\n    var denom = buildGroup(group.value.denom, options.withStyle(dstyle));\n    var denomreset = makeSpan([fstyle.reset(), dstyle.cls()], [denom]);\n\n    var ruleWidth;\n    if (group.value.hasBarLine) {\n        ruleWidth = fontMetrics.metrics.defaultRuleThickness /\n            options.style.sizeMultiplier;\n    } else {\n        ruleWidth = 0;\n    }\n\n    // Rule 15b\n    var numShift;\n    var clearance;\n    var denomShift;\n    if (fstyle.size === Style.DISPLAY.size) {\n        numShift = fontMetrics.metrics.num1;\n        if (ruleWidth > 0) {\n            clearance = 3 * ruleWidth;\n        } else {\n            clearance = 7 * fontMetrics.metrics.defaultRuleThickness;\n        }\n        denomShift = fontMetrics.metrics.denom1;\n    } else {\n        if (ruleWidth > 0) {\n            numShift = fontMetrics.metrics.num2;\n            clearance = ruleWidth;\n        } else {\n            numShift = fontMetrics.metrics.num3;\n            clearance = 3 * fontMetrics.metrics.defaultRuleThickness;\n        }\n        denomShift = fontMetrics.metrics.denom2;\n    }\n\n    var frac;\n    if (ruleWidth === 0) {\n        // Rule 15c\n        var candiateClearance =\n            (numShift - numer.depth) - (denom.height - denomShift);\n        if (candiateClearance < clearance) {\n            numShift += 0.5 * (clearance - candiateClearance);\n            denomShift += 0.5 * (clearance - candiateClearance);\n        }\n\n        frac = buildCommon.makeVList([\n            {type: \"elem\", elem: denomreset, shift: denomShift},\n            {type: \"elem\", elem: numerreset, shift: -numShift},\n        ], \"individualShift\", null, options);\n    } else {\n        // Rule 15d\n        var axisHeight = fontMetrics.metrics.axisHeight;\n\n        if ((numShift - numer.depth) - (axisHeight + 0.5 * ruleWidth) <\n                clearance) {\n            numShift +=\n                clearance - ((numShift - numer.depth) -\n                             (axisHeight + 0.5 * ruleWidth));\n        }\n\n        if ((axisHeight - 0.5 * ruleWidth) - (denom.height - denomShift) <\n                clearance) {\n            denomShift +=\n                clearance - ((axisHeight - 0.5 * ruleWidth) -\n                             (denom.height - denomShift));\n        }\n\n        var mid = makeSpan(\n            [options.style.reset(), Style.TEXT.cls(), \"frac-line\"]);\n        // Manually set the height of the line because its height is\n        // created in CSS\n        mid.height = ruleWidth;\n\n        var midShift = -(axisHeight - 0.5 * ruleWidth);\n\n        frac = buildCommon.makeVList([\n            {type: \"elem\", elem: denomreset, shift: denomShift},\n            {type: \"elem\", elem: mid,        shift: midShift},\n            {type: \"elem\", elem: numerreset, shift: -numShift},\n        ], \"individualShift\", null, options);\n    }\n\n    // Since we manually change the style sometimes (with \\dfrac or \\tfrac),\n    // account for the possible size change here.\n    frac.height *= fstyle.sizeMultiplier / options.style.sizeMultiplier;\n    frac.depth *= fstyle.sizeMultiplier / options.style.sizeMultiplier;\n\n    // Rule 15e\n    var delimSize;\n    if (fstyle.size === Style.DISPLAY.size) {\n        delimSize = fontMetrics.metrics.delim1;\n    } else {\n        delimSize = fontMetrics.metrics.getDelim2(fstyle);\n    }\n\n    var leftDelim;\n    var rightDelim;\n    if (group.value.leftDelim == null) {\n        leftDelim = makeNullDelimiter(options);\n    } else {\n        leftDelim = delimiter.customSizedDelim(\n            group.value.leftDelim, delimSize, true,\n            options.withStyle(fstyle), group.mode);\n    }\n    if (group.value.rightDelim == null) {\n        rightDelim = makeNullDelimiter(options);\n    } else {\n        rightDelim = delimiter.customSizedDelim(\n            group.value.rightDelim, delimSize, true,\n            options.withStyle(fstyle), group.mode);\n    }\n\n    return makeSpan(\n        [\"mord\", options.style.reset(), fstyle.cls()],\n        [leftDelim, makeSpan([\"mfrac\"], [frac]), rightDelim],\n        options.getColor());\n};\n\ngroupTypes.array = function(group, options, prev) {\n    var r;\n    var c;\n    var nr = group.value.body.length;\n    var nc = 0;\n    var body = new Array(nr);\n\n    // Horizontal spacing\n    var pt = 1 / fontMetrics.metrics.ptPerEm;\n    var arraycolsep = 5 * pt; // \\arraycolsep in article.cls\n\n    // Vertical spacing\n    var baselineskip = 12 * pt; // see size10.clo\n    // Default \\arraystretch from lttab.dtx\n    // TODO(gagern): may get redefined once we have user-defined macros\n    var arraystretch = utils.deflt(group.value.arraystretch, 1);\n    var arrayskip = arraystretch * baselineskip;\n    var arstrutHeight = 0.7 * arrayskip; // \\strutbox in ltfsstrc.dtx and\n    var arstrutDepth = 0.3 * arrayskip;  // \\@arstrutbox in lttab.dtx\n\n    var totalHeight = 0;\n    for (r = 0; r < group.value.body.length; ++r) {\n        var inrow = group.value.body[r];\n        var height = arstrutHeight; // \\@array adds an \\@arstrut\n        var depth = arstrutDepth;   // to each tow (via the template)\n\n        if (nc < inrow.length) {\n            nc = inrow.length;\n        }\n\n        var outrow = new Array(inrow.length);\n        for (c = 0; c < inrow.length; ++c) {\n            var elt = buildGroup(inrow[c], options);\n            if (depth < elt.depth) {\n                depth = elt.depth;\n            }\n            if (height < elt.height) {\n                height = elt.height;\n            }\n            outrow[c] = elt;\n        }\n\n        var gap = 0;\n        if (group.value.rowGaps[r]) {\n            gap = group.value.rowGaps[r].value;\n            switch (gap.unit) {\n                case \"em\":\n                    gap = gap.number;\n                    break;\n                case \"ex\":\n                    gap = gap.number * fontMetrics.metrics.emPerEx;\n                    break;\n                default:\n                    console.error(\"Can't handle unit \" + gap.unit);\n                    gap = 0;\n            }\n            if (gap > 0) { // \\@argarraycr\n                gap += arstrutDepth;\n                if (depth < gap) {\n                    depth = gap; // \\@xargarraycr\n                }\n                gap = 0;\n            }\n        }\n\n        outrow.height = height;\n        outrow.depth = depth;\n        totalHeight += height;\n        outrow.pos = totalHeight;\n        totalHeight += depth + gap; // \\@yargarraycr\n        body[r] = outrow;\n    }\n\n    var offset = totalHeight / 2 + fontMetrics.metrics.axisHeight;\n    var colDescriptions = group.value.cols || [];\n    var cols = [];\n    var colSep;\n    var colDescrNum;\n    for (c = 0, colDescrNum = 0;\n         // Continue while either there are more columns or more column\n         // descriptions, so trailing separators don't get lost.\n         c < nc || colDescrNum < colDescriptions.length;\n         ++c, ++colDescrNum) {\n\n        var colDescr = colDescriptions[colDescrNum] || {};\n\n        var firstSeparator = true;\n        while (colDescr.type === \"separator\") {\n            // If there is more than one separator in a row, add a space\n            // between them.\n            if (!firstSeparator) {\n                colSep = makeSpan([\"arraycolsep\"], []);\n                colSep.style.width =\n                    fontMetrics.metrics.doubleRuleSep + \"em\";\n                cols.push(colSep);\n            }\n\n            if (colDescr.separator === \"|\") {\n                var separator = makeSpan(\n                    [\"vertical-separator\"],\n                    []);\n                separator.style.height = totalHeight + \"em\";\n                separator.style.verticalAlign =\n                    -(totalHeight - offset) + \"em\";\n\n                cols.push(separator);\n            } else {\n                throw new ParseError(\n                    \"Invalid separator type: \" + colDescr.separator);\n            }\n\n            colDescrNum++;\n            colDescr = colDescriptions[colDescrNum] || {};\n            firstSeparator = false;\n        }\n\n        if (c >= nc) {\n            continue;\n        }\n\n        var sepwidth;\n        if (c > 0 || group.value.hskipBeforeAndAfter) {\n            sepwidth = utils.deflt(colDescr.pregap, arraycolsep);\n            if (sepwidth !== 0) {\n                colSep = makeSpan([\"arraycolsep\"], []);\n                colSep.style.width = sepwidth + \"em\";\n                cols.push(colSep);\n            }\n        }\n\n        var col = [];\n        for (r = 0; r < nr; ++r) {\n            var row = body[r];\n            var elem = row[c];\n            if (!elem) {\n                continue;\n            }\n            var shift = row.pos - offset;\n            elem.depth = row.depth;\n            elem.height = row.height;\n            col.push({type: \"elem\", elem: elem, shift: shift});\n        }\n\n        col = buildCommon.makeVList(col, \"individualShift\", null, options);\n        col = makeSpan(\n            [\"col-align-\" + (colDescr.align || \"c\")],\n            [col]);\n        cols.push(col);\n\n        if (c < nc - 1 || group.value.hskipBeforeAndAfter) {\n            sepwidth = utils.deflt(colDescr.postgap, arraycolsep);\n            if (sepwidth !== 0) {\n                colSep = makeSpan([\"arraycolsep\"], []);\n                colSep.style.width = sepwidth + \"em\";\n                cols.push(colSep);\n            }\n        }\n    }\n    body = makeSpan([\"mtable\"], cols);\n    return makeSpan([\"mord\"], [body], options.getColor());\n};\n\ngroupTypes.spacing = function(group, options, prev) {\n    if (group.value === \"\\\\ \" || group.value === \"\\\\space\" ||\n        group.value === \" \" || group.value === \"~\") {\n        // Spaces are generated by adding an actual space. Each of these\n        // things has an entry in the symbols table, so these will be turned\n        // into appropriate outputs.\n        return makeSpan(\n            [\"mord\", \"mspace\"],\n            [buildCommon.mathsym(group.value, group.mode)]\n        );\n    } else {\n        // Other kinds of spaces are of arbitrary width. We use CSS to\n        // generate these.\n        return makeSpan(\n            [\"mord\", \"mspace\",\n             buildCommon.spacingFunctions[group.value].className]);\n    }\n};\n\ngroupTypes.llap = function(group, options, prev) {\n    var inner = makeSpan(\n        [\"inner\"], [buildGroup(group.value.body, options.reset())]);\n    var fix = makeSpan([\"fix\"], []);\n    return makeSpan(\n        [\"llap\", options.style.cls()], [inner, fix]);\n};\n\ngroupTypes.rlap = function(group, options, prev) {\n    var inner = makeSpan(\n        [\"inner\"], [buildGroup(group.value.body, options.reset())]);\n    var fix = makeSpan([\"fix\"], []);\n    return makeSpan(\n        [\"rlap\", options.style.cls()], [inner, fix]);\n};\n\ngroupTypes.op = function(group, options, prev) {\n    // Operators are handled in the TeXbook pg. 443-444, rule 13(a).\n    var supGroup;\n    var subGroup;\n    var hasLimits = false;\n    if (group.type === \"supsub\" ) {\n        // If we have limits, supsub will pass us its group to handle. Pull\n        // out the superscript and subscript and set the group to the op in\n        // its base.\n        supGroup = group.value.sup;\n        subGroup = group.value.sub;\n        group = group.value.base;\n        hasLimits = true;\n    }\n\n    // Most operators have a large successor symbol, but these don't.\n    var noSuccessor = [\n        \"\\\\smallint\",\n    ];\n\n    var large = false;\n    if (options.style.size === Style.DISPLAY.size &&\n        group.value.symbol &&\n        !utils.contains(noSuccessor, group.value.body)) {\n\n        // Most symbol operators get larger in displaystyle (rule 13)\n        large = true;\n    }\n\n    var base;\n    var baseShift = 0;\n    var slant = 0;\n    if (group.value.symbol) {\n        // If this is a symbol, create the symbol.\n        var style = large ? \"Size2-Regular\" : \"Size1-Regular\";\n        base = buildCommon.makeSymbol(\n            group.value.body, style, \"math\", options.getColor(),\n            [\"op-symbol\", large ? \"large-op\" : \"small-op\", \"mop\"]);\n\n        // Shift the symbol so its center lies on the axis (rule 13). It\n        // appears that our fonts have the centers of the symbols already\n        // almost on the axis, so these numbers are very small. Note we\n        // don't actually apply this here, but instead it is used either in\n        // the vlist creation or separately when there are no limits.\n        baseShift = (base.height - base.depth) / 2 -\n            fontMetrics.metrics.axisHeight *\n            options.style.sizeMultiplier;\n\n        // The slant of the symbol is just its italic correction.\n        slant = base.italic;\n    } else {\n        // Otherwise, this is a text operator. Build the text from the\n        // operator's name.\n        // TODO(emily): Add a space in the middle of some of these\n        // operators, like \\limsup\n        var output = [];\n        for (var i = 1; i < group.value.body.length; i++) {\n            output.push(buildCommon.mathsym(group.value.body[i], group.mode));\n        }\n        base = makeSpan([\"mop\"], output, options.getColor());\n    }\n\n    if (hasLimits) {\n        // IE 8 clips \\int if it is in a display: inline-block. We wrap it\n        // in a new span so it is an inline, and works.\n        base = makeSpan([], [base]);\n\n        var supmid;\n        var supKern;\n        var submid;\n        var subKern;\n        // We manually have to handle the superscripts and subscripts. This,\n        // aside from the kern calculations, is copied from supsub.\n        if (supGroup) {\n            var sup = buildGroup(\n                supGroup, options.withStyle(options.style.sup()));\n            supmid = makeSpan(\n                [options.style.reset(), options.style.sup().cls()], [sup]);\n\n            supKern = Math.max(\n                fontMetrics.metrics.bigOpSpacing1,\n                fontMetrics.metrics.bigOpSpacing3 - sup.depth);\n        }\n\n        if (subGroup) {\n            var sub = buildGroup(\n                subGroup, options.withStyle(options.style.sub()));\n            submid = makeSpan(\n                [options.style.reset(), options.style.sub().cls()],\n                [sub]);\n\n            subKern = Math.max(\n                fontMetrics.metrics.bigOpSpacing2,\n                fontMetrics.metrics.bigOpSpacing4 - sub.height);\n        }\n\n        // Build the final group as a vlist of the possible subscript, base,\n        // and possible superscript.\n        var finalGroup;\n        var top;\n        var bottom;\n        if (!supGroup) {\n            top = base.height - baseShift;\n\n            finalGroup = buildCommon.makeVList([\n                {type: \"kern\", size: fontMetrics.metrics.bigOpSpacing5},\n                {type: \"elem\", elem: submid},\n                {type: \"kern\", size: subKern},\n                {type: \"elem\", elem: base},\n            ], \"top\", top, options);\n\n            // Here, we shift the limits by the slant of the symbol. Note\n            // that we are supposed to shift the limits by 1/2 of the slant,\n            // but since we are centering the limits adding a full slant of\n            // margin will shift by 1/2 that.\n            finalGroup.children[0].style.marginLeft = -slant + \"em\";\n        } else if (!subGroup) {\n            bottom = base.depth + baseShift;\n\n            finalGroup = buildCommon.makeVList([\n                {type: \"elem\", elem: base},\n                {type: \"kern\", size: supKern},\n                {type: \"elem\", elem: supmid},\n                {type: \"kern\", size: fontMetrics.metrics.bigOpSpacing5},\n            ], \"bottom\", bottom, options);\n\n            // See comment above about slants\n            finalGroup.children[1].style.marginLeft = slant + \"em\";\n        } else if (!supGroup && !subGroup) {\n            // This case probably shouldn't occur (this would mean the\n            // supsub was sending us a group with no superscript or\n            // subscript) but be safe.\n            return base;\n        } else {\n            bottom = fontMetrics.metrics.bigOpSpacing5 +\n                submid.height + submid.depth +\n                subKern +\n                base.depth + baseShift;\n\n            finalGroup = buildCommon.makeVList([\n                {type: \"kern\", size: fontMetrics.metrics.bigOpSpacing5},\n                {type: \"elem\", elem: submid},\n                {type: \"kern\", size: subKern},\n                {type: \"elem\", elem: base},\n                {type: \"kern\", size: supKern},\n                {type: \"elem\", elem: supmid},\n                {type: \"kern\", size: fontMetrics.metrics.bigOpSpacing5},\n            ], \"bottom\", bottom, options);\n\n            // See comment above about slants\n            finalGroup.children[0].style.marginLeft = -slant + \"em\";\n            finalGroup.children[2].style.marginLeft = slant + \"em\";\n        }\n\n        return makeSpan([\"mop\", \"op-limits\"], [finalGroup]);\n    } else {\n        if (group.value.symbol) {\n            base.style.top = baseShift + \"em\";\n        }\n\n        return base;\n    }\n};\n\ngroupTypes.katex = function(group, options, prev) {\n    // The KaTeX logo. The offsets for the K and a were chosen to look\n    // good, but the offsets for the T, E, and X were taken from the\n    // definition of \\TeX in TeX (see TeXbook pg. 356)\n    var k = makeSpan(\n        [\"k\"], [buildCommon.mathsym(\"K\", group.mode)]);\n    var a = makeSpan(\n        [\"a\"], [buildCommon.mathsym(\"A\", group.mode)]);\n\n    a.height = (a.height + 0.2) * 0.75;\n    a.depth = (a.height - 0.2) * 0.75;\n\n    var t = makeSpan(\n        [\"t\"], [buildCommon.mathsym(\"T\", group.mode)]);\n    var e = makeSpan(\n        [\"e\"], [buildCommon.mathsym(\"E\", group.mode)]);\n\n    e.height = (e.height - 0.2155);\n    e.depth = (e.depth + 0.2155);\n\n    var x = makeSpan(\n        [\"x\"], [buildCommon.mathsym(\"X\", group.mode)]);\n\n    return makeSpan(\n        [\"katex-logo\", \"mord\"], [k, a, t, e, x], options.getColor());\n};\n\ngroupTypes.overline = function(group, options, prev) {\n    // Overlines are handled in the TeXbook pg 443, Rule 9.\n\n    // Build the inner group in the cramped style.\n    var innerGroup = buildGroup(group.value.body,\n            options.withStyle(options.style.cramp()));\n\n    var ruleWidth = fontMetrics.metrics.defaultRuleThickness /\n        options.style.sizeMultiplier;\n\n    // Create the line above the body\n    var line = makeSpan(\n        [options.style.reset(), Style.TEXT.cls(), \"overline-line\"]);\n    line.height = ruleWidth;\n    line.maxFontSize = 1.0;\n\n    // Generate the vlist, with the appropriate kerns\n    var vlist = buildCommon.makeVList([\n        {type: \"elem\", elem: innerGroup},\n        {type: \"kern\", size: 3 * ruleWidth},\n        {type: \"elem\", elem: line},\n        {type: \"kern\", size: ruleWidth},\n    ], \"firstBaseline\", null, options);\n\n    return makeSpan([\"overline\", \"mord\"], [vlist], options.getColor());\n};\n\ngroupTypes.underline = function(group, options, prev) {\n    // Underlines are handled in the TeXbook pg 443, Rule 10.\n\n    // Build the inner group.\n    var innerGroup = buildGroup(group.value.body, options);\n\n    var ruleWidth = fontMetrics.metrics.defaultRuleThickness /\n        options.style.sizeMultiplier;\n\n    // Create the line above the body\n    var line = makeSpan(\n        [options.style.reset(), Style.TEXT.cls(), \"underline-line\"]);\n    line.height = ruleWidth;\n    line.maxFontSize = 1.0;\n\n    // Generate the vlist, with the appropriate kerns\n    var vlist = buildCommon.makeVList([\n        {type: \"kern\", size: ruleWidth},\n        {type: \"elem\", elem: line},\n        {type: \"kern\", size: 3 * ruleWidth},\n        {type: \"elem\", elem: innerGroup},\n    ], \"top\", innerGroup.height, options);\n\n    return makeSpan([\"underline\", \"mord\"], [vlist], options.getColor());\n};\n\ngroupTypes.sqrt = function(group, options, prev) {\n    // Square roots are handled in the TeXbook pg. 443, Rule 11.\n\n    // First, we do the same steps as in overline to build the inner group\n    // and line\n    var inner = buildGroup(group.value.body,\n            options.withStyle(options.style.cramp()));\n\n    var ruleWidth = fontMetrics.metrics.defaultRuleThickness /\n        options.style.sizeMultiplier;\n\n    var line = makeSpan(\n        [options.style.reset(), Style.TEXT.cls(), \"sqrt-line\"], [],\n        options.getColor());\n    line.height = ruleWidth;\n    line.maxFontSize = 1.0;\n\n    var phi = ruleWidth;\n    if (options.style.id < Style.TEXT.id) {\n        phi = fontMetrics.metrics.xHeight;\n    }\n\n    // Calculate the clearance between the body and line\n    var lineClearance = ruleWidth + phi / 4;\n\n    var innerHeight =\n        (inner.height + inner.depth) * options.style.sizeMultiplier;\n    var minDelimiterHeight = innerHeight + lineClearance + ruleWidth;\n\n    // Create a \\surd delimiter of the required minimum size\n    var delim = makeSpan([\"sqrt-sign\"], [\n        delimiter.customSizedDelim(\"\\\\surd\", minDelimiterHeight,\n                                   false, options, group.mode)],\n                         options.getColor());\n\n    var delimDepth = (delim.height + delim.depth) - ruleWidth;\n\n    // Adjust the clearance based on the delimiter size\n    if (delimDepth > inner.height + inner.depth + lineClearance) {\n        lineClearance =\n            (lineClearance + delimDepth - inner.height - inner.depth) / 2;\n    }\n\n    // Shift the delimiter so that its top lines up with the top of the line\n    var delimShift = -(inner.height + lineClearance + ruleWidth) + delim.height;\n    delim.style.top = delimShift + \"em\";\n    delim.height -= delimShift;\n    delim.depth += delimShift;\n\n    // We add a special case here, because even when `inner` is empty, we\n    // still get a line. So, we use a simple heuristic to decide if we\n    // should omit the body entirely. (note this doesn't work for something\n    // like `\\sqrt{\\rlap{x}}`, but if someone is doing that they deserve for\n    // it not to work.\n    var body;\n    if (inner.height === 0 && inner.depth === 0) {\n        body = makeSpan();\n    } else {\n        body = buildCommon.makeVList([\n            {type: \"elem\", elem: inner},\n            {type: \"kern\", size: lineClearance},\n            {type: \"elem\", elem: line},\n            {type: \"kern\", size: ruleWidth},\n        ], \"firstBaseline\", null, options);\n    }\n\n    if (!group.value.index) {\n        return makeSpan([\"sqrt\", \"mord\"], [delim, body]);\n    } else {\n        // Handle the optional root index\n\n        // The index is always in scriptscript style\n        var root = buildGroup(\n            group.value.index,\n            options.withStyle(Style.SCRIPTSCRIPT));\n        var rootWrap = makeSpan(\n            [options.style.reset(), Style.SCRIPTSCRIPT.cls()],\n            [root]);\n\n        // Figure out the height and depth of the inner part\n        var innerRootHeight = Math.max(delim.height, body.height);\n        var innerRootDepth = Math.max(delim.depth, body.depth);\n\n        // The amount the index is shifted by. This is taken from the TeX\n        // source, in the definition of `\\r@@t`.\n        var toShift = 0.6 * (innerRootHeight - innerRootDepth);\n\n        // Build a VList with the superscript shifted up correctly\n        var rootVList = buildCommon.makeVList(\n            [{type: \"elem\", elem: rootWrap}],\n            \"shift\", -toShift, options);\n        // Add a class surrounding it so we can add on the appropriate\n        // kerning\n        var rootVListWrap = makeSpan([\"root\"], [rootVList]);\n\n        return makeSpan([\"sqrt\", \"mord\"], [rootVListWrap, delim, body]);\n    }\n};\n\ngroupTypes.sizing = function(group, options, prev) {\n    // Handle sizing operators like \\Huge. Real TeX doesn't actually allow\n    // these functions inside of math expressions, so we do some special\n    // handling.\n    var inner = buildExpression(group.value.value,\n            options.withSize(group.value.size), prev);\n\n    var span = makeSpan([\"mord\"],\n        [makeSpan([\"sizing\", \"reset-\" + options.size, group.value.size,\n                   options.style.cls()],\n                  inner)]);\n\n    // Calculate the correct maxFontSize manually\n    var fontSize = buildCommon.sizingMultiplier[group.value.size];\n    span.maxFontSize = fontSize * options.style.sizeMultiplier;\n\n    return span;\n};\n\ngroupTypes.styling = function(group, options, prev) {\n    // Style changes are handled in the TeXbook on pg. 442, Rule 3.\n\n    // Figure out what style we're changing to.\n    var style = {\n        \"display\": Style.DISPLAY,\n        \"text\": Style.TEXT,\n        \"script\": Style.SCRIPT,\n        \"scriptscript\": Style.SCRIPTSCRIPT,\n    };\n\n    var newStyle = style[group.value.style];\n\n    // Build the inner expression in the new style.\n    var inner = buildExpression(\n        group.value.value, options.withStyle(newStyle), prev);\n\n    return makeSpan([options.style.reset(), newStyle.cls()], inner);\n};\n\ngroupTypes.font = function(group, options, prev) {\n    var font = group.value.font;\n    return buildGroup(group.value.body, options.withFont(font), prev);\n};\n\ngroupTypes.delimsizing = function(group, options, prev) {\n    var delim = group.value.value;\n\n    if (delim === \".\") {\n        // Empty delimiters still count as elements, even though they don't\n        // show anything.\n        return makeSpan([groupToType[group.value.delimType]]);\n    }\n\n    // Use delimiter.sizedDelim to generate the delimiter.\n    return makeSpan(\n        [groupToType[group.value.delimType]],\n        [delimiter.sizedDelim(\n            delim, group.value.size, options, group.mode)]);\n};\n\ngroupTypes.leftright = function(group, options, prev) {\n    // Build the inner expression\n    var inner = buildExpression(group.value.body, options.reset());\n\n    var innerHeight = 0;\n    var innerDepth = 0;\n\n    // Calculate its height and depth\n    for (var i = 0; i < inner.length; i++) {\n        innerHeight = Math.max(inner[i].height, innerHeight);\n        innerDepth = Math.max(inner[i].depth, innerDepth);\n    }\n\n    // The size of delimiters is the same, regardless of what style we are\n    // in. Thus, to correctly calculate the size of delimiter we need around\n    // a group, we scale down the inner size based on the size.\n    innerHeight *= options.style.sizeMultiplier;\n    innerDepth *= options.style.sizeMultiplier;\n\n    var leftDelim;\n    if (group.value.left === \".\") {\n        // Empty delimiters in \\left and \\right make null delimiter spaces.\n        leftDelim = makeNullDelimiter(options);\n    } else {\n        // Otherwise, use leftRightDelim to generate the correct sized\n        // delimiter.\n        leftDelim = delimiter.leftRightDelim(\n            group.value.left, innerHeight, innerDepth, options,\n            group.mode);\n    }\n    // Add it to the beginning of the expression\n    inner.unshift(leftDelim);\n\n    var rightDelim;\n    // Same for the right delimiter\n    if (group.value.right === \".\") {\n        rightDelim = makeNullDelimiter(options);\n    } else {\n        rightDelim = delimiter.leftRightDelim(\n            group.value.right, innerHeight, innerDepth, options,\n            group.mode);\n    }\n    // Add it to the end of the expression.\n    inner.push(rightDelim);\n\n    return makeSpan(\n        [\"minner\", options.style.cls()], inner, options.getColor());\n};\n\ngroupTypes.rule = function(group, options, prev) {\n    // Make an empty span for the rule\n    var rule = makeSpan([\"mord\", \"rule\"], [], options.getColor());\n\n    // Calculate the shift, width, and height of the rule, and account for units\n    var shift = 0;\n    if (group.value.shift) {\n        shift = group.value.shift.number;\n        if (group.value.shift.unit === \"ex\") {\n            shift *= fontMetrics.metrics.xHeight;\n        }\n    }\n\n    var width = group.value.width.number;\n    if (group.value.width.unit === \"ex\") {\n        width *= fontMetrics.metrics.xHeight;\n    }\n\n    var height = group.value.height.number;\n    if (group.value.height.unit === \"ex\") {\n        height *= fontMetrics.metrics.xHeight;\n    }\n\n    // The sizes of rules are absolute, so make it larger if we are in a\n    // smaller style.\n    shift /= options.style.sizeMultiplier;\n    width /= options.style.sizeMultiplier;\n    height /= options.style.sizeMultiplier;\n\n    // Style the rule to the right size\n    rule.style.borderRightWidth = width + \"em\";\n    rule.style.borderTopWidth = height + \"em\";\n    rule.style.bottom = shift + \"em\";\n\n    // Record the height and width\n    rule.width = width;\n    rule.height = height + shift;\n    rule.depth = -shift;\n\n    return rule;\n};\n\ngroupTypes.accent = function(group, options, prev) {\n    // Accents are handled in the TeXbook pg. 443, rule 12.\n    var base = group.value.base;\n\n    var supsubGroup;\n    if (group.type === \"supsub\") {\n        // If our base is a character box, and we have superscripts and\n        // subscripts, the supsub will defer to us. In particular, we want\n        // to attach the superscripts and subscripts to the inner body (so\n        // that the position of the superscripts and subscripts won't be\n        // affected by the height of the accent). We accomplish this by\n        // sticking the base of the accent into the base of the supsub, and\n        // rendering that, while keeping track of where the accent is.\n\n        // The supsub group is the group that was passed in\n        var supsub = group;\n        // The real accent group is the base of the supsub group\n        group = supsub.value.base;\n        // The character box is the base of the accent group\n        base = group.value.base;\n        // Stick the character box into the base of the supsub group\n        supsub.value.base = base;\n\n        // Rerender the supsub group with its new base, and store that\n        // result.\n        supsubGroup = buildGroup(\n            supsub, options.reset(), prev);\n    }\n\n    // Build the base group\n    var body = buildGroup(\n        base, options.withStyle(options.style.cramp()));\n\n    // Calculate the skew of the accent. This is based on the line \"If the\n    // nucleus is not a single character, let s = 0; otherwise set s to the\n    // kern amount for the nucleus followed by the \\skewchar of its font.\"\n    // Note that our skew metrics are just the kern between each character\n    // and the skewchar.\n    var skew;\n    if (isCharacterBox(base)) {\n        // If the base is a character box, then we want the skew of the\n        // innermost character. To do that, we find the innermost character:\n        var baseChar = getBaseElem(base);\n        // Then, we render its group to get the symbol inside it\n        var baseGroup = buildGroup(\n            baseChar, options.withStyle(options.style.cramp()));\n        // Finally, we pull the skew off of the symbol.\n        skew = baseGroup.skew;\n        // Note that we now throw away baseGroup, because the layers we\n        // removed with getBaseElem might contain things like \\color which\n        // we can't get rid of.\n        // TODO(emily): Find a better way to get the skew\n    } else {\n        skew = 0;\n    }\n\n    // calculate the amount of space between the body and the accent\n    var clearance = Math.min(body.height, fontMetrics.metrics.xHeight);\n\n    // Build the accent\n    var accent = buildCommon.makeSymbol(\n        group.value.accent, \"Main-Regular\", \"math\", options.getColor());\n    // Remove the italic correction of the accent, because it only serves to\n    // shift the accent over to a place we don't want.\n    accent.italic = 0;\n\n    // The \\vec character that the fonts use is a combining character, and\n    // thus shows up much too far to the left. To account for this, we add a\n    // specific class which shifts the accent over to where we want it.\n    // TODO(emily): Fix this in a better way, like by changing the font\n    var vecClass = group.value.accent === \"\\\\vec\" ? \"accent-vec\" : null;\n\n    var accentBody = makeSpan([\"accent-body\", vecClass], [\n        makeSpan([], [accent])]);\n\n    accentBody = buildCommon.makeVList([\n        {type: \"elem\", elem: body},\n        {type: \"kern\", size: -clearance},\n        {type: \"elem\", elem: accentBody},\n    ], \"firstBaseline\", null, options);\n\n    // Shift the accent over by the skew. Note we shift by twice the skew\n    // because we are centering the accent, so by adding 2*skew to the left,\n    // we shift it to the right by 1*skew.\n    accentBody.children[1].style.marginLeft = 2 * skew + \"em\";\n\n    var accentWrap = makeSpan([\"mord\", \"accent\"], [accentBody]);\n\n    if (supsubGroup) {\n        // Here, we replace the \"base\" child of the supsub with our newly\n        // generated accent.\n        supsubGroup.children[0] = accentWrap;\n\n        // Since we don't rerun the height calculation after replacing the\n        // accent, we manually recalculate height.\n        supsubGroup.height = Math.max(accentWrap.height, supsubGroup.height);\n\n        // Accents should always be ords, even when their innards are not.\n        supsubGroup.classes[0] = \"mord\";\n\n        return supsubGroup;\n    } else {\n        return accentWrap;\n    }\n};\n\ngroupTypes.phantom = function(group, options, prev) {\n    var elements = buildExpression(\n        group.value.value,\n        options.withPhantom(),\n        prev\n    );\n\n    // \\phantom isn't supposed to affect the elements it contains.\n    // See \"color\" for more details.\n    return new buildCommon.makeFragment(elements);\n};\n\n/**\n * buildGroup is the function that takes a group and calls the correct groupType\n * function for it. It also handles the interaction of size and style changes\n * between parents and children.\n */\nvar buildGroup = function(group, options, prev) {\n    if (!group) {\n        return makeSpan();\n    }\n\n    if (groupTypes[group.type]) {\n        // Call the groupTypes function\n        var groupNode = groupTypes[group.type](group, options, prev);\n        var multiplier;\n\n        // If the style changed between the parent and the current group,\n        // account for the size difference\n        if (options.style !== options.parentStyle) {\n            multiplier = options.style.sizeMultiplier /\n                    options.parentStyle.sizeMultiplier;\n\n            groupNode.height *= multiplier;\n            groupNode.depth *= multiplier;\n        }\n\n        // If the size changed between the parent and the current group, account\n        // for that size difference.\n        if (options.size !== options.parentSize) {\n            multiplier = buildCommon.sizingMultiplier[options.size] /\n                    buildCommon.sizingMultiplier[options.parentSize];\n\n            groupNode.height *= multiplier;\n            groupNode.depth *= multiplier;\n        }\n\n        return groupNode;\n    } else {\n        throw new ParseError(\n            \"Got group of unknown type: '\" + group.type + \"'\");\n    }\n};\n\n/**\n * Take an entire parse tree, and build it into an appropriate set of HTML\n * nodes.\n */\nvar buildHTML = function(tree, options) {\n    // buildExpression is destructive, so we need to make a clone\n    // of the incoming tree so that it isn't accidentally changed\n    tree = JSON.parse(JSON.stringify(tree));\n\n    // Build the expression contained in the tree\n    var expression = buildExpression(tree, options);\n    var body = makeSpan([\"base\", options.style.cls()], expression);\n\n    // Add struts, which ensure that the top of the HTML element falls at the\n    // height of the expression, and the bottom of the HTML element falls at the\n    // depth of the expression.\n    var topStrut = makeSpan([\"strut\"]);\n    var bottomStrut = makeSpan([\"strut\", \"bottom\"]);\n\n    topStrut.style.height = body.height + \"em\";\n    bottomStrut.style.height = (body.height + body.depth) + \"em\";\n    // We'd like to use `vertical-align: top` but in IE 9 this lowers the\n    // baseline of the box to the bottom of this strut (instead staying in the\n    // normal place) so we use an absolute value for vertical-align instead\n    bottomStrut.style.verticalAlign = -body.depth + \"em\";\n\n    // Wrap the struts and body together\n    var htmlNode = makeSpan([\"katex-html\"], [topStrut, bottomStrut, body]);\n\n    htmlNode.setAttribute(\"aria-hidden\", \"true\");\n\n    return htmlNode;\n};\n\nmodule.exports = buildHTML;\n","/**\n * This file converts a parse tree into a cooresponding MathML tree. The main\n * entry point is the `buildMathML` function, which takes a parse tree from the\n * parser.\n */\n\nvar buildCommon = require(\"./buildCommon\");\nvar fontMetrics = require(\"./fontMetrics\");\nvar mathMLTree = require(\"./mathMLTree\");\nvar ParseError = require(\"./ParseError\");\nvar symbols = require(\"./symbols\");\nvar utils = require(\"./utils\");\n\nvar makeSpan = buildCommon.makeSpan;\nvar fontMap = buildCommon.fontMap;\n\n/**\n * Takes a symbol and converts it into a MathML text node after performing\n * optional replacement from symbols.js.\n */\nvar makeText = function(text, mode) {\n    if (symbols[mode][text] && symbols[mode][text].replace) {\n        text = symbols[mode][text].replace;\n    }\n\n    return new mathMLTree.TextNode(text);\n};\n\n/**\n * Returns the math variant as a string or null if none is required.\n */\nvar getVariant = function(group, options) {\n    var font = options.font;\n    if (!font) {\n        return null;\n    }\n\n    var mode = group.mode;\n    if (font === \"mathit\") {\n        return \"italic\";\n    }\n\n    var value = group.value;\n    if (utils.contains([\"\\\\imath\", \"\\\\jmath\"], value)) {\n        return null;\n    }\n\n    if (symbols[mode][value] && symbols[mode][value].replace) {\n        value = symbols[mode][value].replace;\n    }\n\n    var fontName = fontMap[font].fontName;\n    if (fontMetrics.getCharacterMetrics(value, fontName)) {\n        return fontMap[options.font].variant;\n    }\n\n    return null;\n};\n\n/**\n * Functions for handling the different types of groups found in the parse\n * tree. Each function should take a parse group and return a MathML node.\n */\nvar groupTypes = {};\n\ngroupTypes.mathord = function(group, options) {\n    var node = new mathMLTree.MathNode(\n        \"mi\",\n        [makeText(group.value, group.mode)]);\n\n    var variant = getVariant(group, options);\n    if (variant) {\n        node.setAttribute(\"mathvariant\", variant);\n    }\n    return node;\n};\n\ngroupTypes.textord = function(group, options) {\n    var text = makeText(group.value, group.mode);\n\n    var variant = getVariant(group, options) || \"normal\";\n\n    var node;\n    if (/[0-9]/.test(group.value)) {\n        // TODO(kevinb) merge adjacent <mn> nodes\n        // do it as a post processing step\n        node = new mathMLTree.MathNode(\"mn\", [text]);\n        if (options.font) {\n            node.setAttribute(\"mathvariant\", variant);\n        }\n    } else {\n        node = new mathMLTree.MathNode(\"mi\", [text]);\n        node.setAttribute(\"mathvariant\", variant);\n    }\n\n    return node;\n};\n\ngroupTypes.bin = function(group) {\n    var node = new mathMLTree.MathNode(\n        \"mo\", [makeText(group.value, group.mode)]);\n\n    return node;\n};\n\ngroupTypes.rel = function(group) {\n    var node = new mathMLTree.MathNode(\n        \"mo\", [makeText(group.value, group.mode)]);\n\n    return node;\n};\n\ngroupTypes.open = function(group) {\n    var node = new mathMLTree.MathNode(\n        \"mo\", [makeText(group.value, group.mode)]);\n\n    return node;\n};\n\ngroupTypes.close = function(group) {\n    var node = new mathMLTree.MathNode(\n        \"mo\", [makeText(group.value, group.mode)]);\n\n    return node;\n};\n\ngroupTypes.inner = function(group) {\n    var node = new mathMLTree.MathNode(\n        \"mo\", [makeText(group.value, group.mode)]);\n\n    return node;\n};\n\ngroupTypes.punct = function(group) {\n    var node = new mathMLTree.MathNode(\n        \"mo\", [makeText(group.value, group.mode)]);\n\n    node.setAttribute(\"separator\", \"true\");\n\n    return node;\n};\n\ngroupTypes.ordgroup = function(group, options) {\n    var inner = buildExpression(group.value, options);\n\n    var node = new mathMLTree.MathNode(\"mrow\", inner);\n\n    return node;\n};\n\ngroupTypes.text = function(group, options) {\n    var inner = buildExpression(group.value.body, options);\n\n    var node = new mathMLTree.MathNode(\"mtext\", inner);\n\n    return node;\n};\n\ngroupTypes.color = function(group, options) {\n    var inner = buildExpression(group.value.value, options);\n\n    var node = new mathMLTree.MathNode(\"mstyle\", inner);\n\n    node.setAttribute(\"mathcolor\", group.value.color);\n\n    return node;\n};\n\ngroupTypes.supsub = function(group, options) {\n    var children = [buildGroup(group.value.base, options)];\n\n    if (group.value.sub) {\n        children.push(buildGroup(group.value.sub, options));\n    }\n\n    if (group.value.sup) {\n        children.push(buildGroup(group.value.sup, options));\n    }\n\n    var nodeType;\n    if (!group.value.sub) {\n        nodeType = \"msup\";\n    } else if (!group.value.sup) {\n        nodeType = \"msub\";\n    } else {\n        nodeType = \"msubsup\";\n    }\n\n    var node = new mathMLTree.MathNode(nodeType, children);\n\n    return node;\n};\n\ngroupTypes.genfrac = function(group, options) {\n    var node = new mathMLTree.MathNode(\n        \"mfrac\",\n        [buildGroup(group.value.numer, options),\n         buildGroup(group.value.denom, options)]);\n\n    if (!group.value.hasBarLine) {\n        node.setAttribute(\"linethickness\", \"0px\");\n    }\n\n    if (group.value.leftDelim != null || group.value.rightDelim != null) {\n        var withDelims = [];\n\n        if (group.value.leftDelim != null) {\n            var leftOp = new mathMLTree.MathNode(\n                \"mo\", [new mathMLTree.TextNode(group.value.leftDelim)]);\n\n            leftOp.setAttribute(\"fence\", \"true\");\n\n            withDelims.push(leftOp);\n        }\n\n        withDelims.push(node);\n\n        if (group.value.rightDelim != null) {\n            var rightOp = new mathMLTree.MathNode(\n                \"mo\", [new mathMLTree.TextNode(group.value.rightDelim)]);\n\n            rightOp.setAttribute(\"fence\", \"true\");\n\n            withDelims.push(rightOp);\n        }\n\n        var outerNode = new mathMLTree.MathNode(\"mrow\", withDelims);\n\n        return outerNode;\n    }\n\n    return node;\n};\n\ngroupTypes.array = function(group, options) {\n    return new mathMLTree.MathNode(\n        \"mtable\", group.value.body.map(function(row) {\n            return new mathMLTree.MathNode(\n                \"mtr\", row.map(function(cell) {\n                    return new mathMLTree.MathNode(\n                        \"mtd\", [buildGroup(cell, options)]);\n                }));\n        }));\n};\n\ngroupTypes.sqrt = function(group, options) {\n    var node;\n    if (group.value.index) {\n        node = new mathMLTree.MathNode(\n            \"mroot\", [\n                buildGroup(group.value.body, options),\n                buildGroup(group.value.index, options),\n            ]);\n    } else {\n        node = new mathMLTree.MathNode(\n            \"msqrt\", [buildGroup(group.value.body, options)]);\n    }\n\n    return node;\n};\n\ngroupTypes.leftright = function(group, options) {\n    var inner = buildExpression(group.value.body, options);\n\n    if (group.value.left !== \".\") {\n        var leftNode = new mathMLTree.MathNode(\n            \"mo\", [makeText(group.value.left, group.mode)]);\n\n        leftNode.setAttribute(\"fence\", \"true\");\n\n        inner.unshift(leftNode);\n    }\n\n    if (group.value.right !== \".\") {\n        var rightNode = new mathMLTree.MathNode(\n            \"mo\", [makeText(group.value.right, group.mode)]);\n\n        rightNode.setAttribute(\"fence\", \"true\");\n\n        inner.push(rightNode);\n    }\n\n    var outerNode = new mathMLTree.MathNode(\"mrow\", inner);\n\n    return outerNode;\n};\n\ngroupTypes.accent = function(group, options) {\n    var accentNode = new mathMLTree.MathNode(\n        \"mo\", [makeText(group.value.accent, group.mode)]);\n\n    var node = new mathMLTree.MathNode(\n        \"mover\",\n        [buildGroup(group.value.base, options),\n         accentNode]);\n\n    node.setAttribute(\"accent\", \"true\");\n\n    return node;\n};\n\ngroupTypes.spacing = function(group) {\n    var node;\n\n    if (group.value === \"\\\\ \" || group.value === \"\\\\space\" ||\n        group.value === \" \" || group.value === \"~\") {\n        node = new mathMLTree.MathNode(\n            \"mtext\", [new mathMLTree.TextNode(\"\\u00a0\")]);\n    } else {\n        node = new mathMLTree.MathNode(\"mspace\");\n\n        node.setAttribute(\n            \"width\", buildCommon.spacingFunctions[group.value].size);\n    }\n\n    return node;\n};\n\ngroupTypes.op = function(group) {\n    var node;\n\n    // TODO(emily): handle big operators using the `largeop` attribute\n\n    if (group.value.symbol) {\n        // This is a symbol. Just add the symbol.\n        node = new mathMLTree.MathNode(\n            \"mo\", [makeText(group.value.body, group.mode)]);\n    } else {\n        // This is a text operator. Add all of the characters from the\n        // operator's name.\n        // TODO(emily): Add a space in the middle of some of these\n        // operators, like \\limsup.\n        node = new mathMLTree.MathNode(\n            \"mi\", [new mathMLTree.TextNode(group.value.body.slice(1))]);\n    }\n\n    return node;\n};\n\ngroupTypes.katex = function(group) {\n    var node = new mathMLTree.MathNode(\n        \"mtext\", [new mathMLTree.TextNode(\"KaTeX\")]);\n\n    return node;\n};\n\ngroupTypes.font = function(group, options) {\n    var font = group.value.font;\n    return buildGroup(group.value.body, options.withFont(font));\n};\n\ngroupTypes.delimsizing = function(group) {\n    var children = [];\n\n    if (group.value.value !== \".\") {\n        children.push(makeText(group.value.value, group.mode));\n    }\n\n    var node = new mathMLTree.MathNode(\"mo\", children);\n\n    if (group.value.delimType === \"open\" ||\n        group.value.delimType === \"close\") {\n        // Only some of the delimsizing functions act as fences, and they\n        // return \"open\" or \"close\" delimTypes.\n        node.setAttribute(\"fence\", \"true\");\n    } else {\n        // Explicitly disable fencing if it's not a fence, to override the\n        // defaults.\n        node.setAttribute(\"fence\", \"false\");\n    }\n\n    return node;\n};\n\ngroupTypes.styling = function(group, options) {\n    var inner = buildExpression(group.value.value, options);\n\n    var node = new mathMLTree.MathNode(\"mstyle\", inner);\n\n    var styleAttributes = {\n        \"display\": [\"0\", \"true\"],\n        \"text\": [\"0\", \"false\"],\n        \"script\": [\"1\", \"false\"],\n        \"scriptscript\": [\"2\", \"false\"],\n    };\n\n    var attr = styleAttributes[group.value.style];\n\n    node.setAttribute(\"scriptlevel\", attr[0]);\n    node.setAttribute(\"displaystyle\", attr[1]);\n\n    return node;\n};\n\ngroupTypes.sizing = function(group, options) {\n    var inner = buildExpression(group.value.value, options);\n\n    var node = new mathMLTree.MathNode(\"mstyle\", inner);\n\n    // TODO(emily): This doesn't produce the correct size for nested size\n    // changes, because we don't keep state of what style we're currently\n    // in, so we can't reset the size to normal before changing it.  Now\n    // that we're passing an options parameter we should be able to fix\n    // this.\n    node.setAttribute(\n        \"mathsize\", buildCommon.sizingMultiplier[group.value.size] + \"em\");\n\n    return node;\n};\n\ngroupTypes.overline = function(group, options) {\n    var operator = new mathMLTree.MathNode(\n        \"mo\", [new mathMLTree.TextNode(\"\\u203e\")]);\n    operator.setAttribute(\"stretchy\", \"true\");\n\n    var node = new mathMLTree.MathNode(\n        \"mover\",\n        [buildGroup(group.value.body, options),\n         operator]);\n    node.setAttribute(\"accent\", \"true\");\n\n    return node;\n};\n\ngroupTypes.underline = function(group, options) {\n    var operator = new mathMLTree.MathNode(\n        \"mo\", [new mathMLTree.TextNode(\"\\u203e\")]);\n    operator.setAttribute(\"stretchy\", \"true\");\n\n    var node = new mathMLTree.MathNode(\n        \"munder\",\n        [buildGroup(group.value.body, options),\n         operator]);\n    node.setAttribute(\"accentunder\", \"true\");\n\n    return node;\n};\n\ngroupTypes.rule = function(group) {\n    // TODO(emily): Figure out if there's an actual way to draw black boxes\n    // in MathML.\n    var node = new mathMLTree.MathNode(\"mrow\");\n\n    return node;\n};\n\ngroupTypes.llap = function(group, options) {\n    var node = new mathMLTree.MathNode(\n        \"mpadded\", [buildGroup(group.value.body, options)]);\n\n    node.setAttribute(\"lspace\", \"-1width\");\n    node.setAttribute(\"width\", \"0px\");\n\n    return node;\n};\n\ngroupTypes.rlap = function(group, options) {\n    var node = new mathMLTree.MathNode(\n        \"mpadded\", [buildGroup(group.value.body, options)]);\n\n    node.setAttribute(\"width\", \"0px\");\n\n    return node;\n};\n\ngroupTypes.phantom = function(group, options, prev) {\n    var inner = buildExpression(group.value.value, options);\n    return new mathMLTree.MathNode(\"mphantom\", inner);\n};\n\n/**\n * Takes a list of nodes, builds them, and returns a list of the generated\n * MathML nodes. A little simpler than the HTML version because we don't do any\n * previous-node handling.\n */\nvar buildExpression = function(expression, options) {\n    var groups = [];\n    for (var i = 0; i < expression.length; i++) {\n        var group = expression[i];\n        groups.push(buildGroup(group, options));\n    }\n    return groups;\n};\n\n/**\n * Takes a group from the parser and calls the appropriate groupTypes function\n * on it to produce a MathML node.\n */\nvar buildGroup = function(group, options) {\n    if (!group) {\n        return new mathMLTree.MathNode(\"mrow\");\n    }\n\n    if (groupTypes[group.type]) {\n        // Call the groupTypes function\n        return groupTypes[group.type](group, options);\n    } else {\n        throw new ParseError(\n            \"Got group of unknown type: '\" + group.type + \"'\");\n    }\n};\n\n/**\n * Takes a full parse tree and settings and builds a MathML representation of\n * it. In particular, we put the elements from building the parse tree into a\n * <semantics> tag so we can also include that TeX source as an annotation.\n *\n * Note that we actually return a domTree element with a `<math>` inside it so\n * we can do appropriate styling.\n */\nvar buildMathML = function(tree, texExpression, options) {\n    var expression = buildExpression(tree, options);\n\n    // Wrap up the expression in an mrow so it is presented in the semantics\n    // tag correctly.\n    var wrapper = new mathMLTree.MathNode(\"mrow\", expression);\n\n    // Build a TeX annotation of the source\n    var annotation = new mathMLTree.MathNode(\n        \"annotation\", [new mathMLTree.TextNode(texExpression)]);\n\n    annotation.setAttribute(\"encoding\", \"application/x-tex\");\n\n    var semantics = new mathMLTree.MathNode(\n        \"semantics\", [wrapper, annotation]);\n\n    var math = new mathMLTree.MathNode(\"math\", [semantics]);\n\n    // You can't style <math> nodes, so we wrap the node in a span.\n    return makeSpan([\"katex-mathml\"], [math]);\n};\n\nmodule.exports = buildMathML;\n"],"sourceRoot":""}