Lines Matching refs:expression
83 * errors from errors in the expression that the user provided.
264 * - displayMode: Whether the expression should be typeset as inline math
6387 * returned list contains no fragments. `isRealGroup` is true if `expression`
6392 const buildExpression = function buildExpression(expression, options, isRealGroup, surrounding) { argument
6400 for (let i = 0; i < expression.length; i++) {
6401 const output = buildGroup(expression[i], options);
6409 } // If `expression` is a partial group, let the parent handle spacings
6419 if (expression.length === 1) {
6420 const node = checkNodeType(expression[0], "sizing") || checkNodeType(expression[0], "styling");
6428 // If `expression` has no atoms on the left or right, class "leftmost"
6600 * make up the entire expression as a sequence of unbreakable units.
6606 // the height of the expression, and the bottom of the HTML element
6607 // falls at the depth of the expression.
6632 } // Build the expression contained in the tree
6635 const expression = buildExpression(tree, options, true);
6645 for (let i = 0; i < expression.length; i++) {
6646 parts.push(expression[i]);
6648 …if (expression[i].hasClass("mbin") || expression[i].hasClass("mrel") || expression[i].hasClass("al…
6653 …while (i < expression.length - 1 && expression[i + 1].hasClass("mspace") && !expression[i + 1].has…
6655 parts.push(expression[i]);
6657 if (expression[i].hasClass("nobreak")) {
6667 } else if (expression[i].hasClass("newline")) {
6677 children.push(expression[i]);
7036 const buildExpression$1 = function buildExpression(expression, options, isOrdgroup) { argument
7037 if (expression.length === 1) {
7038 const group = buildGroup$1(expression[0], options);
7053 for (let i = 0; i < expression.length; i++) {
7054 const group = buildGroup$1(expression[i], options);
7097 const buildExpressionRow = function buildExpressionRow(expression, options, isOrdgroup) { argument
7098 return makeRow(buildExpression$1(expression, options, isOrdgroup));
7128 …const expression = buildExpression$1(tree, options); // Wrap up the expression in an mrow so it is…
7133 …if (expression.length === 1 && expression[0] instanceof MathNode && utils.contains(["mrow", "mtabl…
7134 wrapper = expression[0];
7136 wrapper = new mathMLTree.MathNode("mrow", expression);
7180 const buildTree = function buildTree(tree, expression, settings) { argument
7185 return buildMathML(tree, expression, options, true);
7190 const mathMLNode = buildMathML(tree, expression, options, false);
7197 const buildHTMLTree = function buildHTMLTree(tree, expression, settings) { argument
8141 * delimiter which surrounds an expression of a given height an depth. It is
8754 * of an expression that the delimiters surround.
8974 assertParsed(group); // Build the inner expression
9007 } // Add it to the beginning of the expression
9034 } // Add it to the end of the expression.
9216 // to the expression, but tests show that isn't how it actually works.
12210 const expression = buildExpression(body, options.withFont("mathrm"), true); constant
12212 for (let i = 0; i < expression.length; i++) {
12213 const child = expression[i];
12222 base = buildCommon.makeSpan(["mop"], expression, options);
12236 …let expression = buildExpression$1(group.body, options.withFont("mathrm")); // Is expression a str… variable
12240 for (let i = 0; i < expression.length; i++) {
12241 const node = expression[i];
12276 const word = expression.map(node => node.toText()).join("");
12277 expression = [new mathMLTree.TextNode(word)];
12280 const identifier = new mathMLTree.MathNode("mi", expression);
15733 * This file contains the parser used to parse out a TeX expression from the
15834 // Create a group namespace for the math expression.
15837 // We do this within the group for the math expression, so it doesn't
15847 this.expect("EOF"); // End the group namespace for the expression
15897 * then the expression is ambiguous. This can be resolved by adding {}.
16507 * which is either a single nucleus (like "x") or an expression
16511 * If `optional` is true, it parses either a bracket-delimited expression
16543 this.gullet.beginGroup(); // If we get a brace, parse an expression
16545 const expression = this.parseExpression(false, groupEnd);
16555 body: expression,
16794 * Parses an "expression", which is a list of atoms.
16800 * `breakOnTokenText`: The text of the token that the expression should end
16802 * expression.
16809 * Provides a single function for parsing an expression using a Parser
16814 * Parses an expression using a Parser, then returns the parsed result.
16818 throw new TypeError('KaTeX can only parse string typed expression');
16847 * Parse and build an expression, and place that expression in the DOM node
16850 let render = function render(expression, baseNode, options) { argument
16852 const node = renderToDomTree(expression, options).toNode();
16868 * Parse and build an expression, and return the markup for that.
16872 const renderToString = function renderToString(expression, options) { argument
16873 const markup = renderToDomTree(expression, options).toMarkup();
16877 * Parse an expression and return the parse tree.
16881 const generateParseTree = function generateParseTree(expression, options) { argument
16883 return parseTree(expression, settings);
16892 const renderError = function renderError(error, expression, options) { argument
16897 const node = buildCommon.makeSpan(["katex-error"], [new SymbolNode(expression)]);
16908 const renderToDomTree = function renderToDomTree(expression, options) { argument
16912 const tree = parseTree(expression, settings);
16913 return buildTree(tree, expression, settings);
16915 return renderError(error, expression, settings);
16924 const renderToHTMLTree = function renderToHTMLTree(expression, options) { argument
16928 const tree = parseTree(expression, settings);
16929 return buildHTMLTree(tree, expression, settings);
16931 return renderError(error, expression, settings);