Lines Matching refs:options
407 function Settings(options) {
422 options = options || {};
423 this.displayMode = utils.deflt(options.displayMode, false);
424 this.output = utils.deflt(options.output, "htmlAndMathml");
425 this.leqno = utils.deflt(options.leqno, false);
426 this.fleqn = utils.deflt(options.fleqn, false);
427 this.throwOnError = utils.deflt(options.throwOnError, true);
428 this.errorColor = utils.deflt(options.errorColor, "#cc0000");
429 this.macros = options.macros || {};
430 this.minRuleThickness = Math.max(0, utils.deflt(options.minRuleThickness, 0));
431 this.colorIsTextColor = utils.deflt(options.colorIsTextColor, false);
432 this.strict = utils.deflt(options.strict, "warn");
433 this.trust = utils.deflt(options.trust, false);
434 this.maxSize = Math.max(0, utils.deflt(options.maxSize, Infinity));
435 this.maxExpand = Math.max(0, utils.deflt(options.maxExpand, 1000));
1028 var initNode = function initNode(classes, options, style) {
1036 if (options) {
1037 if (options.style.isTight()) {
1041 var color = options.getColor();
1139 function Span(classes, children, options, style) {
1148 initNode.call(this, classes, options, style);
1186 function Anchor(href, classes, children, options) {
1194 initNode.call(this, classes, options);
5332 var units_calculateSize = function calculateSize(sizeValue, options) {
5338 / options.fontMetrics().ptPerEm // Convert pt to CSS em
5339 / options.sizeMultiplier; // Unscale to make absolute units
5342 scale = options.fontMetrics().cssEmPerMu;
5348 if (options.style.isTight()) {
5350 unitOptions = options.havingStyle(options.style.text());
5352 unitOptions = options;
5370 if (unitOptions !== options) {
5371 scale *= unitOptions.sizeMultiplier / options.sizeMultiplier;
5375 return Math.min(sizeValue.number * scale, options.maxSize);
5424 var buildCommon_makeSymbol = function makeSymbol(value, fontName, mode, options, classes) {
5433 if (mode === "text" || options && options.font === "mathit") {
5444 if (options) {
5445 symbolNode.maxFontSize = options.sizeMultiplier;
5447 if (options.style.isTight()) {
5451 var color = options.getColor();
5466 var buildCommon_mathsym = function mathsym(value, mode, options, classes) {
5478 if (options.font === "boldsymbol" && buildCommon_lookupSymbol(value, "Main-Bold", mode).metrics) {
5479 return buildCommon_makeSymbol(value, "Main-Bold", mode, options, classes.concat(["mathbf"]));
5481 return buildCommon_makeSymbol(value, "Main-Regular", mode, options, classes);
5483 return buildCommon_makeSymbol(value, "AMS-Regular", mode, options, classes.concat(["amsrm"]));
5493 var buildCommon_mathdefault = function mathdefault(value, mode, options, classes) {
5516 var buildCommon_mathnormal = function mathnormal(value, mode, options, classes) {
5542 var boldsymbol = function boldsymbol(value, mode, options, classes) {
5562 var buildCommon_makeOrd = function makeOrd(group, options, type) {
5567 var isFont = mode === "math" || mode === "text" && options.font;
5568 var fontOrFamily = isFont ? options.font : options.fontFamily;
5576 return buildCommon_makeSymbol(text, wideFontName, mode, options, classes.concat(wideFontClass));
5582 …ly === "boldsymbol" ? boldsymbol(text, mode, options, classes) : buildCommon_mathnormal(text, mode…
5592 fontName = retrieveTextFontName(fontOrFamily, options.fontWeight, options.fontShape);
5593 fontClasses = [fontOrFamily, options.fontWeight, options.fontShape];
5597 return buildCommon_makeSymbol(text, fontName, mode, options, classes.concat(fontClasses));
5603 … parts.push(buildCommon_makeSymbol(text[i], fontName, mode, options, classes.concat(fontClasses)));
5612 var fontLookup = buildCommon_mathdefault(text, mode, options, classes);
5613 …return buildCommon_makeSymbol(text, fontLookup.fontName, mode, options, classes.concat([fontLookup…
5618 var _fontName = retrieveTextFontName("amsrm", options.fontWeight, options.fontShape);
5620 …buildCommon_makeSymbol(text, _fontName, mode, options, classes.concat("amsrm", options.fontWeight,…
5622 var _fontName2 = retrieveTextFontName("textrm", options.fontWeight, options.fontShape);
5624 …urn buildCommon_makeSymbol(text, _fontName2, mode, options, classes.concat(options.fontWeight, opt…
5627 …var _fontName3 = retrieveTextFontName(font, options.fontWeight, options.fontShape); // We add font…
5630 …ildCommon_makeSymbol(text, _fontName3, mode, options, classes.concat(_fontName3, options.fontWeigh…
5728 var buildCommon_makeSpan = function makeSpan(classes, children, options, style) {
5729 var span = new domTree_Span(classes, children, options, style);
5736 var buildCommon_makeSvgSpan = function makeSvgSpan(classes, children, options, style) {
5737 return new domTree_Span(classes, children, options, style);
5740 var makeLineSpan = function makeLineSpan(className, options, thickness) {
5741 var line = buildCommon_makeSpan([className], [], options);
5742 …line.height = Math.max(thickness || options.fontMetrics().defaultRuleThickness, options.minRuleThi…
5753 var buildCommon_makeAnchor = function makeAnchor(href, classes, children, options) {
5754 var anchor = new domTree_Anchor(href, classes, children, options);
5774 var buildCommon_wrapFragment = function wrapFragment(group, options) {
5776 return buildCommon_makeSpan([], [group], options);
5858 var buildCommon_makeVList = function makeVList(params, options) {
5957 var buildCommon_makeGlue = function makeGlue(measurement, options) {
5959 var rule = buildCommon_makeSpan(["mspace"], [], options);
5960 var size = units_calculateSize(measurement, options);
6074 var buildCommon_staticSvg = function staticSvg(value, options) {
6089 var span = buildCommon_makeSvgSpan(["overlay"], [svgNode], options);
6419 var buildHTML_buildExpression = function buildExpression(expression, options, isRealGroup, surround…
6428 var output = buildHTML_buildGroup(expression[i], options);
6444 var glueOptions = options;
6451 glueOptions = options.havingSize(node.size);
6453 glueOptions = options.havingStyle(styleMap[node.style]);
6460 var dummyPrev = buildHTML_makeSpan([surrounding[0] || "leftmost"], [], options);
6461 …var dummyNext = buildHTML_makeSpan([surrounding[1] || "rightmost"], [], options); // TODO: These c…
6594 var makeNullDelimiter = function makeNullDelimiter(options, classes) {
6595 var moreClasses = ["nulldelimiter"].concat(options.baseSizingClasses());
6604 var buildHTML_buildGroup = function buildGroup(group, options, baseOptions) {
6611 …var groupNode = _htmlGroupBuilders[group.type](group, options); // If the size changed between the…
6614 if (baseOptions && options.size !== baseOptions.size) {
6615 groupNode = buildHTML_makeSpan(options.sizingClasses(baseOptions), [groupNode], options);
6616 var multiplier = options.sizeMultiplier / baseOptions.sizeMultiplier;
6633 function buildHTMLUnbreakable(children, options) {
6635 …var body = buildHTML_makeSpan(["base"], children, options); // Add strut, which ensures that the t…
6655 function buildHTML(tree, options) {
6665 var expression = buildHTML_buildExpression(tree, options, true);
6694 children.push(buildHTMLUnbreakable(parts, options));
6702 children.push(buildHTMLUnbreakable(parts, options));
6712 children.push(buildHTMLUnbreakable(parts, options));
6719 tagChild = buildHTMLUnbreakable(buildHTML_buildExpression(tag, options, true));
6995 var buildMathML_makeText = function makeText(text, mode, options) {
6996 …s.hasOwnProperty(text) && options && (options.fontFamily && options.fontFamily.substr(4, 2) === "t…
7018 var buildMathML_getVariant = function getVariant(group, options) {
7022 if (options.fontFamily === "texttt") {
7024 } else if (options.fontFamily === "textsf") {
7025 if (options.fontShape === "textit" && options.fontWeight === "textbf") {
7027 } else if (options.fontShape === "textit") {
7029 } else if (options.fontWeight === "textbf") {
7034 } else if (options.fontShape === "textit" && options.fontWeight === "textbf") {
7036 } else if (options.fontShape === "textit") {
7038 } else if (options.fontWeight === "textbf") {
7042 var font = options.font;
7093 var buildMathML_buildExpression = function buildExpression(expression, options, isOrdgroup) {
7095 var group = buildMathML_buildGroup(expression[0], options);
7111 var _group = buildMathML_buildGroup(expression[i], options);
7163 var buildExpressionRow = function buildExpressionRow(expression, options, isOrdgroup) {
7164 return buildMathML_makeRow(buildMathML_buildExpression(expression, options, isOrdgroup));
7171 var buildMathML_buildGroup = function buildGroup(group, options) {
7178 var result = _mathmlGroupBuilders[group.type](group, options);
7193 function buildMathML(tree, texExpression, options, forMathmlOnly) {
7194 …var expression = buildMathML_buildExpression(tree, options); // Wrap up the expression in an mrow …
7254 var options = buildTree_optionsFromSettings(settings);
7258 return buildMathML(tree, expression, options, true);
7260 var htmlNode = buildHTML(tree, options);
7263 var mathMLNode = buildMathML(tree, expression, options, false);
7265 var _htmlNode = buildHTML(tree, options);
7273 var options = buildTree_optionsFromSettings(settings);
7274 var htmlNode = buildHTML(tree, options);
7428 var stretchy_svgSpan = function svgSpan(group, options) {
7483 span: buildCommon.makeSvgSpan([], [svgNode], options),
7525 var _span = buildCommon.makeSvgSpan([widthClasses[i]], [_svgNode], options);
7540 span: buildCommon.makeSpan(["stretchy"], spans, options),
7565 var stretchy_encloseSpan = function encloseSpan(inner, label, pad, options) {
7571 img = buildCommon.makeSpan(["stretchy", label], [], options);
7574 var color = options.color && options.getColor();
7610 img = buildCommon.makeSvgSpan([], [svgNode], options);
7634 var accent_htmlBuilder = function htmlBuilder(grp, options) {
7657 supSubGroup = assertSpan(buildHTML_buildGroup(supSub, options)); // reset original base
7666 …var body = buildHTML_buildGroup(base, options.havingCrampedStyle()); // Does the accent need to sh…
7681 …var baseGroup = buildHTML_buildGroup(baseChar, options.havingCrampedStyle()); // Finally, we pull …
7690 var clearance = Math.min(body.height, options.fontMetrics().xHeight); // Build the accent
7704 accent = buildCommon.staticSvg("vec", options);
7710 }, options, "textord");
7758 }, options);
7760 accentBody = stretchy.svgSpan(group, options);
7775 }, options);
7778 var accentWrap = buildCommon.makeSpan(["mord", "accent"], [accentBody], options);
7795 var accent_mathmlBuilder = function mathmlBuilder(group, options) {
7797 …var node = new mathMLTree.MathNode("mover", [buildMathML_buildGroup(group.base, options), accentNo…
7876 htmlBuilder: function htmlBuilder(group, options) {
7878 var innerGroup = buildHTML_buildGroup(group.base, options);
7879 var accentBody = stretchy.svgSpan(group, options);
7896 }, options);
7897 return buildCommon.makeSpan(["mord", "accentunder"], [vlist], options);
7899 mathmlBuilder: function mathmlBuilder(group, options) {
7901 …var node = new mathMLTree.MathNode("munder", [buildMathML_buildGroup(group.base, options), accentN…
7945 htmlBuilder: function htmlBuilder(group, options) {
7946 var style = options.style; // Build the argument groups in the appropriate style.
7951 var newOptions = options.havingStyle(style.sup());
7952 …erGroup = buildCommon.wrapFragment(buildHTML_buildGroup(group.body, newOptions, options), options);
7958 newOptions = options.havingStyle(style.sub());
7959 …rGroup = buildCommon.wrapFragment(buildHTML_buildGroup(group.below, newOptions, options), options);
7963 …var arrowBody = stretchy.svgSpan(group, options); // Re shift: Note that stretchy.svgSpan returned…
7966 …var arrowShift = -options.fontMetrics().axisHeight + 0.5 * arrowBody.height; // 2 mu kern. Ref: am…
7968 …var upperShift = -options.fontMetrics().axisHeight - 0.5 * arrowBody.height - 0.111; // 0.111 em =…
7978 …var lowerShift = -options.fontMetrics().axisHeight + lowerGroup.height + 0.5 * arrowBody.height + …
7994 }, options);
8007 }, options);
8012 return buildCommon.makeSpan(["mrel", "x-arrow"], [vlist], options);
8014 mathmlBuilder: function mathmlBuilder(group, options) {
8019 var upperNode = arrow_paddedNode(buildMathML_buildGroup(group.body, options));
8022 var lowerNode = arrow_paddedNode(buildMathML_buildGroup(group.below, options));
8028 var _lowerNode = arrow_paddedNode(buildMathML_buildGroup(group.below, options));
8087 var color_htmlBuilder = function htmlBuilder(group, options) {
8088 …var elements = buildHTML_buildExpression(group.body, options.withColor(group.color), false); // \c…
8096 var color_mathmlBuilder = function mathmlBuilder(group, options) {
8097 var inner = buildMathML_buildExpression(group.body, options.withColor(group.color));
8202 htmlBuilder: function htmlBuilder(group, options) {
8207 var span = buildCommon.makeSpan(["mspace"], [], options);
8213 span.style.marginTop = units_calculateSize(group.size, options) + "em";
8219 mathmlBuilder: function mathmlBuilder(group, options) {
8226 node.setAttribute("height", units_calculateSize(group.size, options) + "em");
8284 var delimiter_styleWrap = function styleWrap(delim, toStyle, options, classes) {
8285 var newOptions = options.havingBaseStyle(toStyle);
8286 …r span = buildCommon.makeSpan(classes.concat(newOptions.sizingClasses(options)), [delim], options);
8287 var delimSizeMultiplier = newOptions.sizeMultiplier / options.sizeMultiplier;
8294 var centerSpan = function centerSpan(span, options, style) {
8295 var newOptions = options.havingBaseStyle(style);
8296 …var shift = (1 - options.sizeMultiplier / newOptions.sizeMultiplier) * options.fontMetrics().axisH…
8309 var delimiter_makeSmallDelim = function makeSmallDelim(delim, style, center, options, mode, classes…
8310 var text = buildCommon.makeSymbol(delim, "Main-Regular", mode, options);
8311 var span = delimiter_styleWrap(text, style, options, classes);
8314 centerSpan(span, options, style);
8324 var delimiter_mathrmSize = function mathrmSize(value, size, mode, options) {
8325 return buildCommon.makeSymbol(value, "Size" + size + "-Regular", mode, options);
8333 var delimiter_makeLargeDelim = function makeLargeDelim(delim, size, center, options, mode, classes)…
8334 var inner = delimiter_mathrmSize(delim, size, mode, options);
8335 …ildCommon.makeSpan(["delimsizing", "size" + size], [inner], options), src_Style.TEXT, options, cla…
8338 centerSpan(span, options, src_Style.TEXT);
8379 var delimiter_makeStackedDelim = function makeStackedDelim(delim, heightTotal, center, options, mod…
8506 var axisHeight = options.fontMetrics().axisHeight;
8509 axisHeight *= options.sizeMultiplier;
8570 var newOptions = options.havingBaseStyle(src_Style.TEXT);
8576 …ldCommon.makeSpan(["delimsizing", "mult"], [inner], newOptions), src_Style.TEXT, options, classes);
8585 var delimiter_sqrtSvg = function sqrtSvg(sqrtName, height, viewBoxHeight, extraViniculum, options) {
8595 return buildCommon.makeSvgSpan(["hide-tail"], [svg], options);
8602 var makeSqrtImage = function makeSqrtImage(height, options) {
8605 …var newOptions = options.havingBaseSizing(); // Pick the desired surd glyph from a sequence of sur…
8612 …var extraViniculum = Math.max(0, options.minRuleThickness - options.fontMetrics().sqrtRuleThicknes…
8637 span = delimiter_sqrtSvg("sqrtMain", spanHeight, viewBoxHeight, extraViniculum, options);
8645 …n = delimiter_sqrtSvg("sqrtSize" + delim.size, spanHeight, viewBoxHeight, extraViniculum, options);
8654 span = delimiter_sqrtSvg("sqrtTall", spanHeight, viewBoxHeight, extraViniculum, options);
8668 ruleWidth: (options.fontMetrics().sqrtRuleThickness + extraViniculum) * sizeMultiplier
8687 var delimiter_makeSizedDelim = function makeSizedDelim(delim, size, options, mode, classes) {
8697 return delimiter_makeLargeDelim(delim, size, false, options, mode, classes);
8699 return delimiter_makeStackedDelim(delim, sizeToMaxHeight[size], false, options, mode, classes);
8801 var traverseSequence = function traverseSequence(delim, height, sequence, options) {
8806 var start = Math.min(2, 3 - options.style.size);
8819 var newOptions = options.havingBaseStyle(sequence[i].style);
8838 var delimiter_makeCustomSizedDelim = function makeCustomSizedDelim(delim, height, center, options, …
8857 …var delimType = traverseSequence(delim, height, sequence, options); // Get the delimiter from font…
8862 return delimiter_makeSmallDelim(delim, delimType.style, center, options, mode, classes);
8864 return delimiter_makeLargeDelim(delim, delimType.size, center, options, mode, classes);
8868 return delimiter_makeStackedDelim(delim, height, center, options, mode, classes);
8877 var makeLeftRightDelim = function makeLeftRightDelim(delim, height, depth, options, mode, classes) {
8879 …var axisHeight = options.fontMetrics().axisHeight * options.sizeMultiplier; // Taken from TeX sour…
8882 var delimiterExtend = 5.0 / options.fontMetrics().ptPerEm;
8896 return delimiter_makeCustomSizedDelim(delim, totalHeight, true, options, mode, classes);
9011 htmlBuilder: function htmlBuilder(group, options) {
9019 return delimiter.sizedDelim(group.delim, group.size, options, group.mode, [group.mclass]);
9101 htmlBuilder: function htmlBuilder(group, options) {
9104 var inner = buildHTML_buildExpression(group.body, options, true, ["mopen", "mclose"]);
9124 innerHeight *= options.sizeMultiplier;
9125 innerDepth *= options.sizeMultiplier;
9130 leftDelim = makeNullDelimiter(options, ["mopen"]);
9134 …leftDelim = delimiter.leftRightDelim(group.left, innerHeight, innerDepth, options, group.mode, ["m…
9150 …elimiter.leftRightDelim(isMiddle.delim, innerHeight, innerDepth, isMiddle.options, group.mode, []);
9158 rightDelim = makeNullDelimiter(options, ["mclose"]);
9160 var colorOptions = group.rightColor ? options.withColor(group.rightColor) : options;
9166 return buildCommon.makeSpan(["minner"], inner, options);
9168 mathmlBuilder: function mathmlBuilder(group, options) {
9170 var inner = buildMathML_buildExpression(group.body, options);
9211 htmlBuilder: function htmlBuilder(group, options) {
9215 middleDelim = makeNullDelimiter(options, []);
9217 middleDelim = delimiter.sizedDelim(group.delim, 1, options, group.mode, []);
9220 options: options property
9232 mathmlBuilder: function mathmlBuilder(group, options) {
9257 var enclose_htmlBuilder = function htmlBuilder(group, options) {
9261 var inner = buildCommon.wrapFragment(buildHTML_buildGroup(group.body, options), options);
9263 var scale = options.sizeMultiplier;
9275 img.height = options.fontMetrics().defaultRuleThickness / scale;
9276 imgShift = -0.5 * options.fontMetrics().xHeight;
9292 ruleThickness = Math.max(options.fontMetrics().fboxrule, // default
9293 options.minRuleThickness // User override.
9295 vertPad = options.fontMetrics().fboxsep + (label === "colorbox" ? 0 : ruleThickness);
9300 img = stretchy.encloseSpan(inner, label, vertPad, options);
9333 }, options);
9348 }, options);
9360 return buildCommon.makeSpan(["mord", "cancel-lap"], [vlist], options);
9362 return buildCommon.makeSpan(["mord"], [vlist], options);
9366 var enclose_mathmlBuilder = function mathmlBuilder(group, options) {
9368 ….indexOf("colorbox") > -1 ? "mpadded" : "menclose", [buildMathML_buildGroup(group.body, options)]);
9391 fboxsep = options.fontMetrics().fboxsep * options.fontMetrics().ptPerEm;
9399 var thk = Math.max(options.fontMetrics().fboxrule, // default
9400 options.minRuleThickness // user override
9702 var array_htmlBuilder = function htmlBuilder(group, options) {
9711 options.fontMetrics().arrayRuleWidth, options.minRuleThickness // User override.
9714 var pt = 1 / options.fontMetrics().ptPerEm;
9723 var localMultiplier = options.havingStyle(src_Style.SCRIPT).sizeMultiplier;
9724 arraycolsep = 0.2778 * (localMultiplier / options.sizeMultiplier);
9768 var elt = buildHTML_buildGroup(inrow[c], options);
9785 gap = units_calculateSize(rowGap, options);
9817 var offset = totalHeight / 2 + options.fontMetrics().axisHeight;
9834 colSep.style.width = options.fontMetrics().doubleRuleSep + "em";
9840 var separator = buildCommon.makeSpan(["vertical-separator"], [], options);
9895 }, options);
9913 var line = buildCommon.makeLineSpan("hline", options, ruleThickness);
9914 var dashes = buildCommon.makeLineSpan("hdashline", options, ruleThickness);
9943 }, options);
9946 return buildCommon.makeSpan(["mord"], [body], options);
9955 var array_mathmlBuilder = function mathmlBuilder(group, options) {
9958 return new mathMLTree.MathNode("mtd", [buildMathML_buildGroup(cell, options)]);
10498 function mclass_htmlBuilder(group, options) {
10499 var elements = buildHTML_buildExpression(group.body, options, true);
10500 return mclass_makeSpan([group.mclass], elements, options);
10503 function mclass_mathmlBuilder(group, options) {
10505 var inner = buildMathML_buildExpression(group.body, options);
10656 var font_htmlBuilder = function htmlBuilder(group, options) {
10658 var newOptions = options.withFont(font);
10662 var font_mathmlBuilder = function mathmlBuilder(group, options) {
10664 var newOptions = options.withFont(font);
10793 var genfrac_htmlBuilder = function htmlBuilder(group, options) {
10795 var style = genfrac_adjustStyle(group.size, options.style);
10799 newOptions = options.havingStyle(nstyle);
10800 var numerm = buildHTML_buildGroup(group.numer, newOptions, options);
10805 var hStrut = 8.5 / options.fontMetrics().ptPerEm;
10806 var dStrut = 3.5 / options.fontMetrics().ptPerEm;
10811 newOptions = options.havingStyle(dstyle);
10812 var denomm = buildHTML_buildGroup(group.denom, newOptions, options);
10819 ruleWidth = units_calculateSize(group.barSize, options);
10820 rule = buildCommon.makeLineSpan("frac-line", options, ruleWidth);
10822 rule = buildCommon.makeLineSpan("frac-line", options);
10830 ruleSpacing = options.fontMetrics().defaultRuleThickness;
10839 numShift = options.fontMetrics().num1;
10847 denomShift = options.fontMetrics().denom1;
10850 numShift = options.fontMetrics().num2;
10853 numShift = options.fontMetrics().num3;
10857 denomShift = options.fontMetrics().denom2;
10882 }, options);
10885 var axisHeight = options.fontMetrics().axisHeight;
10911 }, options);
10916 newOptions = options.havingStyle(style);
10917 frac.height *= newOptions.sizeMultiplier / options.sizeMultiplier;
10918 frac.depth *= newOptions.sizeMultiplier / options.sizeMultiplier; // Rule 15e
10923 delimSize = options.fontMetrics().delim1;
10925 delimSize = options.fontMetrics().delim2;
10932 leftDelim = makeNullDelimiter(options, ["mopen"]);
10934 …leftDelim = delimiter.customSizedDelim(group.leftDelim, delimSize, true, options.havingStyle(style…
10940 rightDelim = makeNullDelimiter(options, ["mclose"]);
10942 …rightDelim = delimiter.customSizedDelim(group.rightDelim, delimSize, true, options.havingStyle(sty…
10945 …].concat(newOptions.sizingClasses(options)), [leftDelim, buildCommon.makeSpan(["mfrac"], [frac]), …
10948 var genfrac_mathmlBuilder = function mathmlBuilder(group, options) {
10949 …ode("mfrac", [buildMathML_buildGroup(group.numer, options), buildMathML_buildGroup(group.denom, op…
10954 var ruleWidth = units_calculateSize(group.barSize, options);
10958 var style = genfrac_adjustStyle(group.size, options.style);
10960 if (style.size !== options.style.size) {
11267 var horizBrace_htmlBuilder = function htmlBuilder(grp, options) {
11268 var style = options.style; // Pull out the `ParseNode<"horizBrace">` if `grp` is a "supsub" node.
11278 …roup(supSub.sup, options.havingStyle(style.sup()), options) : buildHTML_buildGroup(supSub.sub, opt…
11285 …var body = buildHTML_buildGroup(group.base, options.havingBaseStyle(src_Style.DISPLAY)); // Create…
11287 …var braceBody = stretchy.svgSpan(group, options); // Generate the vlist, with the appropriate kern…
11305 }, options); // $FlowFixMe: Replace this with passing "svg-align" into makeVList.
11322 }, options); // $FlowFixMe: Replace this with passing "svg-align" into makeVList.
11335 var vSpan = buildCommon.makeSpan(["mord", group.isOver ? "mover" : "munder"], [vlist], options);
11350 }, options);
11365 }, options);
11369 return buildCommon.makeSpan(["mord", group.isOver ? "mover" : "munder"], [vlist], options);
11372 var horizBrace_mathmlBuilder = function mathmlBuilder(group, options) {
11374 …Node(group.isOver ? "mover" : "munder", [buildMathML_buildGroup(group.base, options), accentNode]);
11432 htmlBuilder: function htmlBuilder(group, options) {
11433 var elements = buildHTML_buildExpression(group.body, options, false);
11434 return buildCommon.makeAnchor(group.href, [], elements, options);
11436 mathmlBuilder: function mathmlBuilder(group, options) {
11437 var math = buildExpressionRow(group.body, options);
11517 htmlBuilder: function htmlBuilder(group, options) {
11518 var elements = buildHTML_buildExpression(group.html, options, false);
11521 mathmlBuilder: function mathmlBuilder(group, options) {
11522 return buildExpressionRow(group.mathml, options);
11649 htmlBuilder: function htmlBuilder(group, options) {
11650 var height = units_calculateSize(group.height, options);
11654 depth = units_calculateSize(group.totalheight, options) - height;
11661 width = units_calculateSize(group.width, options);
11681 mathmlBuilder: function mathmlBuilder(group, options) {
11684 var height = units_calculateSize(group.height, options);
11688 depth = units_calculateSize(group.totalheight, options) - height;
11696 var width = units_calculateSize(group.width, options);
11752 htmlBuilder: function htmlBuilder(group, options) {
11753 return buildCommon.makeGlue(group.dimension, options);
11755 mathmlBuilder: function mathmlBuilder(group, options) {
11756 var dimension = units_calculateSize(group.dimension, options);
11785 htmlBuilder: function htmlBuilder(group, options) {
11791 …inner = buildCommon.makeSpan([], [buildHTML_buildGroup(group.body, options)]); // wrap, since CSS …
11793 inner = buildCommon.makeSpan(["inner"], [inner], options);
11795 inner = buildCommon.makeSpan(["inner"], [buildHTML_buildGroup(group.body, options)]);
11799 …var node = buildCommon.makeSpan([group.alignment], [inner, fix], options); // At this point, we ha…
11815 }, options); // Get the horizontal spacing correct relative to adjacent items.
11817 return buildCommon.makeSpan(["mord"], [node], options);
11819 mathmlBuilder: function mathmlBuilder(group, options) {
11821 var node = new mathMLTree.MathNode("mpadded", [buildMathML_buildGroup(group.body, options)]);
11882 var mathchoice_chooseMathStyle = function chooseMathStyle(group, options) {
11883 switch (options.style.size) {
11918 htmlBuilder: function htmlBuilder(group, options) {
11919 var body = mathchoice_chooseMathStyle(group, options);
11920 var elements = buildHTML_buildExpression(body, options, false);
11923 mathmlBuilder: function mathmlBuilder(group, options) {
11924 var body = mathchoice_chooseMathStyle(group, options);
11925 return buildExpressionRow(body, options);
11932 var assembleSupSub_assembleSupSub = function assembleSupSub(base, supGroup, subGroup, options, styl…
11941 var elem = buildHTML_buildGroup(supGroup, options.havingStyle(style.sup()), options);
11944 …kern: Math.max(options.fontMetrics().bigOpSpacing1, options.fontMetrics().bigOpSpacing3 - elem.dep…
11949 var _elem = buildHTML_buildGroup(subGroup, options.havingStyle(style.sub()), options);
11953 …kern: Math.max(options.fontMetrics().bigOpSpacing2, options.fontMetrics().bigOpSpacing4 - _elem.he…
11962 …var bottom = options.fontMetrics().bigOpSpacing5 + sub.elem.height + sub.elem.depth + sub.kern + b…
11968 size: options.fontMetrics().bigOpSpacing5
11988 size: options.fontMetrics().bigOpSpacing5
11990 }, options);
12002 size: options.fontMetrics().bigOpSpacing5
12014 }, options);
12033 size: options.fontMetrics().bigOpSpacing5
12035 }, options);
12043 return buildCommon.makeSpan(["mop", "op-limits"], [finalGroup], options);
12061 var op_htmlBuilder = function htmlBuilder(grp, options) {
12081 var style = options.style;
12104 …base = buildCommon.makeSymbol(group.name, fontName, "math", options, ["mop", "op-symbol", large ? …
12110 var oval = buildCommon.staticSvg(stash + "Size" + (large ? "2" : "1"), options);
12122 }, options); // $FlowFixMe
12131 var inner = buildHTML_buildExpression(group.body, options, true);
12137 base = buildCommon.makeSpan(["mop"], buildCommon.tryCombineChars(inner), options);
12147 output.push(buildCommon.mathsym(group.name[i], group.mode, options));
12150 base = buildCommon.makeSpan(["mop"], output, options);
12164 …baseShift = (base.height - base.depth) / 2 - options.fontMetrics().axisHeight; // The slant of the…
12171 … return assembleSupSub_assembleSupSub(base, supGroup, subGroup, options, style, slant, baseShift);
12182 var op_mathmlBuilder = function mathmlBuilder(group, options) {
12194 node = new mathMLTree_MathNode("mo", buildMathML_buildExpression(group.body, options));
12371 var operatorname_htmlBuilder = function htmlBuilder(grp, options) {
12409 var expression = buildHTML_buildExpression(body, options.withFont("mathrm"), true);
12421 base = buildCommon.makeSpan(["mop"], expression, options);
12423 base = buildCommon.makeSpan(["mop"], [], options);
12427 return assembleSupSub_assembleSupSub(base, supGroup, subGroup, options, options.style, 0, 0);
12433 var operatorname_mathmlBuilder = function mathmlBuilder(group, options) {
12435 …var expression = buildMathML_buildExpression(group.body, options.withFont("mathrm")); // Is expres…
12526 htmlBuilder: function htmlBuilder(group, options) {
12528 return buildCommon.makeFragment(buildHTML_buildExpression(group.body, options, false));
12531 …turn buildCommon.makeSpan(["mord"], buildHTML_buildExpression(group.body, options, true), options);
12533 mathmlBuilder: function mathmlBuilder(group, options) {
12534 return buildExpressionRow(group.body, options, true);
12558 htmlBuilder: function htmlBuilder(group, options) {
12561 …var innerGroup = buildHTML_buildGroup(group.body, options.havingCrampedStyle()); // Create the lin…
12563 …var line = buildCommon.makeLineSpan("overline-line", options); // Generate the vlist, with the app…
12565 var defaultRuleThickness = options.fontMetrics().defaultRuleThickness;
12581 }, options);
12582 return buildCommon.makeSpan(["mord", "overline"], [vlist], options);
12584 mathmlBuilder: function mathmlBuilder(group, options) {
12587 …var node = new mathMLTree.MathNode("mover", [buildMathML_buildGroup(group.body, options), operator…
12614 htmlBuilder: function htmlBuilder(group, options) {
12615 …var elements = buildHTML_buildExpression(group.body, options.withPhantom(), false); // \phantom is…
12620 mathmlBuilder: function mathmlBuilder(group, options) {
12621 var inner = buildMathML_buildExpression(group.body, options);
12641 htmlBuilder: function htmlBuilder(group, options) {
12642 var node = buildCommon.makeSpan([], [buildHTML_buildGroup(group.body, options.withPhantom())]);
12660 }, options); // For spacing, TeX treats \smash as a math group (same spacing as ord).
12662 return buildCommon.makeSpan(["mord"], [node], options);
12664 mathmlBuilder: function mathmlBuilder(group, options) {
12665 var inner = buildMathML_buildExpression(defineFunction_ordargument(group.body), options);
12689 htmlBuilder: function htmlBuilder(group, options) {
12690 …var inner = buildCommon.makeSpan(["inner"], [buildHTML_buildGroup(group.body, options.withPhantom(…
12692 return buildCommon.makeSpan(["mord", "rlap"], [inner, fix], options);
12694 mathmlBuilder: function mathmlBuilder(group, options) {
12695 var inner = buildMathML_buildExpression(defineFunction_ordargument(group.body), options);
12730 htmlBuilder: function htmlBuilder(group, options) {
12731 var body = buildHTML_buildGroup(group.body, options);
12732 var dy = units_calculateSize(group.dy, options);
12740 }, options);
12742 mathmlBuilder: function mathmlBuilder(group, options) {
12743 var node = new mathMLTree.MathNode("mpadded", [buildMathML_buildGroup(group.body, options)]);
12776 htmlBuilder: function htmlBuilder(group, options) {
12778 …var rule = buildCommon.makeSpan(["mord", "rule"], [], options); // Calculate the shift, width, and…
12780 var width = units_calculateSize(group.width, options);
12781 var height = units_calculateSize(group.height, options);
12782 …var shift = group.shift ? units_calculateSize(group.shift, options) : 0; // Style the rule to the …
12794 rule.maxFontSize = height * 1.125 * options.sizeMultiplier;
12797 mathmlBuilder: function mathmlBuilder(group, options) {
12798 var width = units_calculateSize(group.width, options);
12799 var height = units_calculateSize(group.height, options);
12800 var shift = group.shift ? units_calculateSize(group.shift, options) : 0;
12801 var color = options.color && options.getColor() || "black";
12825 function sizingGroup(value, options, baseOptions) {
12826 var inner = buildHTML_buildExpression(value, options, false);
12827 …var multiplier = options.sizeMultiplier / baseOptions.sizeMultiplier; // Add size-resetting classe…
12834 Array.prototype.push.apply(inner[i].classes, options.sizingClasses(baseOptions));
12835 } else if (inner[i].classes[pos + 1] === "reset-size" + options.size) {
12849 var sizing_htmlBuilder = function htmlBuilder(group, options) {
12853 var newOptions = options.havingSize(group.size);
12854 return sizingGroup(group.body, newOptions, options);
12877 mathmlBuilder: function mathmlBuilder(group, options) {
12878 var newOptions = options.havingSize(group.size);
12947 htmlBuilder: function htmlBuilder(group, options) {
12948 var node = buildCommon.makeSpan([], [buildHTML_buildGroup(group.body, options)]);
12984 }, options); // For spacing, TeX treats \hphantom as a math group (same spacing as ord).
12986 return buildCommon.makeSpan(["mord"], [smashedNode], options);
12988 mathmlBuilder: function mathmlBuilder(group, options) {
12989 var node = new mathMLTree.MathNode("mpadded", [buildMathML_buildGroup(group.body, options)]);
13028 htmlBuilder: function htmlBuilder(group, options) {
13032 var inner = buildHTML_buildGroup(group.body, options.havingCrampedStyle());
13036 inner.height = options.fontMetrics().xHeight;
13041 …inner = buildCommon.wrapFragment(inner, options); // Calculate the minimum size for the \surd deli…
13043 var metrics = options.fontMetrics();
13047 if (options.style.id < src_Style.TEXT.id) {
13048 phi = options.fontMetrics().xHeight;
13055 var _delimiter$sqrtImage = delimiter.sqrtImage(minDelimiterHeight, options),
13086 }, options);
13089 return buildCommon.makeSpan(["mord", "sqrt"], [body], options);
13093 var newOptions = options.havingStyle(src_Style.SCRIPTSCRIPT);
13094 …var rootm = buildHTML_buildGroup(group.index, newOptions, options); // The amount the index is shi…
13106 }, options); // Add a class surrounding it so we can add on the appropriate
13110 return buildCommon.makeSpan(["mord", "sqrt"], [rootVListWrap, body], options);
13113 mathmlBuilder: function mathmlBuilder(group, options) {
13116 …ildGroup(body, options), buildMathML_buildGroup(index, options)]) : new mathMLTree.MathNode("msqrt…
13157 htmlBuilder: function htmlBuilder(group, options) {
13160 var newOptions = options.havingStyle(newStyle).withFont('');
13161 return sizingGroup(group.body, newOptions, options);
13163 mathmlBuilder: function mathmlBuilder(group, options) {
13166 var newOptions = options.havingStyle(newStyle);
13203 var supsub_htmlBuilderDelegate = function htmlBuilderDelegate(group, options) {
13211 …var delegate = base.limits && (options.style.size === src_Style.DISPLAY.size || base.alwaysHandleS…
13214 …var _delegate = base.alwaysHandleSupSub && (options.style.size === src_Style.DISPLAY.size || base.…
13231 htmlBuilder: function htmlBuilder(group, options) {
13236 var builderDelegate = supsub_htmlBuilderDelegate(group, options);
13239 return builderDelegate(group, options);
13245 var base = buildHTML_buildGroup(valueBase, options);
13248 var metrics = options.fontMetrics(); // Rule 18a
13255 var newOptions = options.havingStyle(options.style.sup());
13256 supm = buildHTML_buildGroup(valueSup, newOptions, options);
13259 …ase.height - newOptions.fontMetrics().supDrop * newOptions.sizeMultiplier / options.sizeMultiplier;
13264 var _newOptions = options.havingStyle(options.style.sub());
13266 subm = buildHTML_buildGroup(valueSub, _newOptions, options);
13269 …se.depth + _newOptions.fontMetrics().subDrop * _newOptions.sizeMultiplier / options.sizeMultiplier;
13276 if (options.style === src_Style.DISPLAY) {
13278 } else if (options.style.cramped) {
13286 var multiplier = options.sizeMultiplier;
13336 }, options);
13350 }, options);
13362 }, options);
13369 …eturn buildCommon.makeSpan([mclass], [base, buildCommon.makeSpan(["msupsub"], [supsub])], options);
13371 mathmlBuilder: function mathmlBuilder(group, options) {
13391 var children = [buildMathML_buildGroup(group.base, options)];
13394 children.push(buildMathML_buildGroup(group.sub, options));
13398 children.push(buildMathML_buildGroup(group.sup, options));
13408 …if (base && base.type === "op" && base.limits && (options.style === src_Style.DISPLAY || base.alwa…
13410 …se.type === "operatorname" && base.alwaysHandleSupSub && (base.limits || options.style === src_Sty…
13418 …if (_base && _base.type === "op" && _base.limits && (options.style === src_Style.DISPLAY || _base.…
13420 ….type === "operatorname" && _base.alwaysHandleSupSub && (_base.limits || options.style === src_Sty…
13428 if (_base2 && _base2.type === "op" && _base2.limits && options.style === src_Style.DISPLAY) {
13430 …} else if (_base2 && _base2.type === "operatorname" && _base2.alwaysHandleSupSub && (options.style…
13449 htmlBuilder: function htmlBuilder(group, options) {
13450 return buildCommon.mathsym(group.text, group.mode, options, ["m" + group.family]);
13452 mathmlBuilder: function mathmlBuilder(group, options) {
13456 var variant = buildMathML_getVariant(group, options);
13485 htmlBuilder: function htmlBuilder(group, options) {
13486 return buildCommon.makeOrd(group, options, "mathord");
13488 mathmlBuilder: function mathmlBuilder(group, options) {
13489 … var node = new mathMLTree.MathNode("mi", [buildMathML_makeText(group.text, group.mode, options)]);
13490 var variant = buildMathML_getVariant(group, options) || "italic";
13501 htmlBuilder: function htmlBuilder(group, options) {
13502 return buildCommon.makeOrd(group, options, "textord");
13504 mathmlBuilder: function mathmlBuilder(group, options) {
13505 var text = buildMathML_makeText(group.text, group.mode, options);
13506 var variant = buildMathML_getVariant(group, options) || "normal";
13558 htmlBuilder: function htmlBuilder(group, options) {
13565 var ord = buildCommon.makeOrd(group, options, "textord");
13569 …n.makeSpan(["mspace", className], [buildCommon.mathsym(group.text, group.mode, options)], options);
13573 return buildCommon.makeSpan(["mspace", cssSpace[group.text]], [], options);
13578 mathmlBuilder: function mathmlBuilder(group, options) {
13606 mathmlBuilder: function mathmlBuilder(group, options) {
13607 …uildExpressionRow(group.body, options)]), tag_pad(), new mathMLTree.MathNode("mtd", [buildExpressi…
13640 var optionsWithFont = function optionsWithFont(group, options) {
13644 return options;
13646 return options.withTextFontFamily(textFontFamilies[font]);
13648 return options.withTextFontWeight(textFontWeights[font]);
13650 return options.withTextFontShape(textFontShapes[font]);
13677 htmlBuilder: function htmlBuilder(group, options) {
13678 var newOptions = optionsWithFont(group, options);
13682 mathmlBuilder: function mathmlBuilder(group, options) {
13683 var newOptions = optionsWithFont(group, options);
13708 htmlBuilder: function htmlBuilder(group, options) {
13711 …var innerGroup = buildHTML_buildGroup(group.body, options); // Create the line to go below the body
13713 …var line = buildCommon.makeLineSpan("underline-line", options); // Generate the vlist, with the ap…
13715 var defaultRuleThickness = options.fontMetrics().defaultRuleThickness;
13732 }, options);
13733 return buildCommon.makeSpan(["mord", "underline"], [vlist], options);
13735 mathmlBuilder: function mathmlBuilder(group, options) {
13738 …var node = new mathMLTree.MathNode("munder", [buildMathML_buildGroup(group.body, options), operato…
13762 htmlBuilder: function htmlBuilder(group, options) {
13766 var newOptions = options.havingStyle(options.style.text());
13778 …return buildCommon.makeSpan(["mord", "text"].concat(newOptions.sizingClasses(options)), buildCommo…
13780 mathmlBuilder: function mathmlBuilder(group, options) {
17240 var katex_render = function render(expression, baseNode, options) {
17242 var node = katex_renderToDomTree(expression, options).toNode();
17262 var renderToString = function renderToString(expression, options) {
17263 var markup = katex_renderToDomTree(expression, options).toMarkup();
17271 var katex_generateParseTree = function generateParseTree(expression, options) {
17272 var settings = new Settings_Settings(options);
17282 var katex_renderError = function renderError(error, expression, options) {
17283 if (options.throwOnError || !(error instanceof src_ParseError)) {
17289 node.setAttribute("style", "color:" + options.errorColor);
17298 var katex_renderToDomTree = function renderToDomTree(expression, options) {
17299 var settings = new Settings_Settings(options);
17314 var katex_renderToHTMLTree = function renderToHTMLTree(expression, options) {
17315 var settings = new Settings_Settings(options);