katex 0.16.16 → 0.16.18

package/dist/katex.mjs

@@ -6677,7 +6677,19 @@ class MathNode {
     }
 
     for (var i = 0; i < this.children.length; i++) {
-      node.appendChild(this.children[i].toNode());
+      // Combine multiple TextNodes into one TextNode, to prevent
+      // screen readers from reading each as a separate word [#3995]
+      if (this.children[i] instanceof TextNode && this.children[i + 1] instanceof TextNode) {
+        var text = this.children[i].toText() + this.children[++i].toText();
+
+        while (this.children[i + 1] instanceof TextNode) {
+          text += this.children[++i].toText();
+        }
+
+        node.appendChild(new TextNode(text).toNode());
+      } else {
+        node.appendChild(this.children[i].toNode());
+      }
     }
 
     return node;
@@ -6947,12 +6959,34 @@ var getVariant = function getVariant(group, options) {
 
   return null;
 };
+/**
+ * Check for <mi>.</mi> which is how a dot renders in MathML,
+ * or <mo separator="true" lspace="0em" rspace="0em">,</mo>
+ * which is how a braced comma {,} renders in MathML
+ */
+
+function isNumberPunctuation(group) {
+  if (!group) {
+    return false;
+  }
+
+  if (group.type === 'mi' && group.children.length === 1) {
+    var child = group.children[0];
+    return child instanceof TextNode && child.text === '.';
+  } else if (group.type === 'mo' && group.children.length === 1 && group.getAttribute('separator') === 'true' && group.getAttribute('lspace') === '0em' && group.getAttribute('rspace') === '0em') {
+    var _child = group.children[0];
+    return _child instanceof TextNode && _child.text === ',';
+  } else {
+    return false;
+  }
+}
 /**
  * Takes a list of nodes, builds them, and returns a list of the generated
  * MathML nodes.  Also combine consecutive <mtext> outputs into a single
  * <mtext> tag.
  */
 
+
 var buildExpression = function buildExpression(expression, options, isOrdgroup) {
   if (expression.length === 1) {
     var group = buildGroup(expression[0], options);
@@ -6981,22 +7015,30 @@ var buildExpression = function buildExpression(expression, options, isOrdgroup)
       } else if (_group.type === 'mn' && lastGroup.type === 'mn') {
         lastGroup.children.push(..._group.children);
         continue; // Concatenate <mn>...</mn> followed by <mi>.</mi>
-      } else if (_group.type === 'mi' && _group.children.length === 1 && lastGroup.type === 'mn') {
-        var child = _group.children[0];
+      } else if (isNumberPunctuation(_group) && lastGroup.type === 'mn') {
+        lastGroup.children.push(..._group.children);
+        continue; // Concatenate <mi>.</mi> followed by <mn>...</mn>
+      } else if (_group.type === 'mn' && isNumberPunctuation(lastGroup)) {
+        _group.children = [...lastGroup.children, ..._group.children];
+        groups.pop(); // Put preceding <mn>...</mn> or <mi>.</mi> inside base of
+        // <msup><mn>...base...</mn>...exponent...</msup> (or <msub>)
+      } else if ((_group.type === 'msup' || _group.type === 'msub') && _group.children.length >= 1 && (lastGroup.type === 'mn' || isNumberPunctuation(lastGroup))) {
+        var base = _group.children[0];
+
+        if (base instanceof MathNode && base.type === 'mn') {
+          base.children = [...lastGroup.children, ...base.children];
+          groups.pop();
+        } // \not
 
-        if (child instanceof TextNode && child.text === '.') {
-          lastGroup.children.push(..._group.children);
-          continue;
-        }
       } else if (lastGroup.type === 'mi' && lastGroup.children.length === 1) {
         var lastChild = lastGroup.children[0];
 
         if (lastChild instanceof TextNode && lastChild.text === '\u0338' && (_group.type === 'mo' || _group.type === 'mi' || _group.type === 'mn')) {
-          var _child = _group.children[0];
+          var child = _group.children[0];
 
-          if (_child instanceof TextNode && _child.text.length > 0) {
+          if (child instanceof TextNode && child.text.length > 0) {
             // Overlay with combining character long solidus
-            _child.text = _child.text.slice(0, 1) + "\u0338" + _child.text.slice(1);
+            child.text = child.text.slice(0, 1) + "\u0338" + child.text.slice(1);
             groups.pop();
           }
         }
@@ -18371,7 +18413,7 @@ var renderToHTMLTree = function renderToHTMLTree(expression, options) {
   }
 };
 
-var version = "0.16.16";
+var version = "0.16.18";
 var __domTree = {
   Span,
   Anchor,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "katex",
-  "version": "0.16.16",
+  "version": "0.16.18",
   "description": "Fast math typesetting for the web.",
   "main": "dist/katex.js",
   "exports": {
@@ -50,7 +50,8 @@
     "cli.js",
     "src/",
     "contrib/",
-    "dist/"
+    "dist/",
+    "types/"
   ],
   "license": "MIT",
   "packageManager": "yarn@4.1.1",

package/src/buildMathML.js

@@ -128,6 +128,30 @@ export const getVariant = function(
     return null;
 };
 
+/**
+ * Check for <mi>.</mi> which is how a dot renders in MathML,
+ * or <mo separator="true" lspace="0em" rspace="0em">,</mo>
+ * which is how a braced comma {,} renders in MathML
+ */
+function isNumberPunctuation(group: ?MathNode): boolean {
+    if (!group) {
+        return false;
+    }
+    if (group.type === 'mi' && group.children.length === 1) {
+        const child = group.children[0];
+        return child instanceof TextNode && child.text === '.';
+    } else if (group.type === 'mo' && group.children.length === 1 &&
+        group.getAttribute('separator') === 'true' &&
+        group.getAttribute('lspace') === '0em' &&
+        group.getAttribute('rspace') === '0em'
+    ) {
+        const child = group.children[0];
+        return child instanceof TextNode && child.text === ',';
+    } else {
+        return false;
+    }
+}
+
 /**
  * Takes a list of nodes, builds them, and returns a list of the generated
  * MathML nodes.  Also combine consecutive <mtext> outputs into a single
@@ -165,13 +189,25 @@ export const buildExpression = function(
                 lastGroup.children.push(...group.children);
                 continue;
             // Concatenate <mn>...</mn> followed by <mi>.</mi>
-            } else if (group.type === 'mi' && group.children.length === 1 &&
-                       lastGroup.type === 'mn') {
-                const child = group.children[0];
-                if (child instanceof TextNode && child.text === '.') {
-                    lastGroup.children.push(...group.children);
-                    continue;
+            } else if (isNumberPunctuation(group) && lastGroup.type === 'mn') {
+                lastGroup.children.push(...group.children);
+                continue;
+            // Concatenate <mi>.</mi> followed by <mn>...</mn>
+            } else if (group.type === 'mn' && isNumberPunctuation(lastGroup)) {
+                group.children = [...lastGroup.children, ...group.children];
+                groups.pop();
+            // Put preceding <mn>...</mn> or <mi>.</mi> inside base of
+            // <msup><mn>...base...</mn>...exponent...</msup> (or <msub>)
+            } else if ((group.type === 'msup' || group.type === 'msub') &&
+                group.children.length >= 1 &&
+                (lastGroup.type === 'mn' || isNumberPunctuation(lastGroup))
+            ) {
+                const base = group.children[0];
+                if (base instanceof MathNode && base.type === 'mn') {
+                    base.children = [...lastGroup.children, ...base.children];
+                    groups.pop();
                 }
+            // \not
             } else if (lastGroup.type === 'mi' && lastGroup.children.length === 1) {
                 const lastChild = lastGroup.children[0];
                 if (lastChild instanceof TextNode && lastChild.text === '\u0338' &&

package/src/mathMLTree.js

@@ -95,7 +95,18 @@ export class MathNode implements MathDomNode {
         }
 
         for (let i = 0; i < this.children.length; i++) {
-            node.appendChild(this.children[i].toNode());
+            // Combine multiple TextNodes into one TextNode, to prevent
+            // screen readers from reading each as a separate word [#3995]
+            if (this.children[i] instanceof TextNode &&
+                this.children[i + 1] instanceof TextNode) {
+                let text = this.children[i].toText() + this.children[++i].toText();
+                while (this.children[i + 1] instanceof TextNode) {
+                    text += this.children[++i].toText();
+                }
+                node.appendChild(new TextNode(text).toNode());
+            } else {
+                node.appendChild(this.children[i].toNode());
+            }
         }
 
         return node;

package/types/katex.d.ts

@@ -0,0 +1,221 @@
+// Adapted from
+// - https://katex.org/docs/options
+// - https://katex.org/docs/api
+// - https://katex.org/docs/error
+// for v0.16.11 on 2024/12/01
+// with some references from https://www.npmjs.com/package/@types/katex
+
+/**
+ * For the `trust` option in `KatexOptions`, a custom function
+ * `handler(context)` can be provided to customize behavior depending on the
+ * context (command, arguments e.g. a URL, etc.)
+ * @see https://katex.org/docs/options
+ */
+export type TrustContext =
+    | { command: "\\url", url: string, protocol?: string }
+    | { command: "\\href", url: string, protocol?: string }
+    | { command: "\\includegraphics", url: string, protocol?: string }
+    | { command: "\\htmlClass", class: string }
+    | { command: "\\htmlId", id: string }
+    | { command: "\\htmlStyle", style: string }
+    | { command: "\\htmlData", attributes: Record<string, string> }
+
+/**
+ * Options for `katex.render` and `katex.renderToString`.
+ * @see https://katex.org/docs/options
+ */
+export interface KatexOptions {
+    /**
+     * If `true` the math will be rendered in display mode.
+     * If `false` the math will be rendered in inline mode.
+     * @see https://katex.org/docs/options
+     * 
+     * @default false
+     */
+    displayMode?: boolean;
+    /**
+     * Determines the markup language of the output. The valid choices are:
+     * - `html`: Outputs KaTeX in HTML only.
+     * - `mathml`: Outputs KaTeX in MathML only.
+     * - `htmlAndMathml`: Outputs HTML for visual rendering and includes MathML
+     * for accessibility.
+     * 
+     * @default "htmlAndMathml"
+     */
+    output?: "html" | "mathml" | "htmlAndMathml";
+    /**
+     * If `true`, display math has `\tag`s rendered on the left instead of the
+     * right, like `\usepackage[leqno]{amsmath}` in LaTeX.
+     * 
+     * @default false
+     */
+    leqno?: boolean;
+    /**
+     * If `true`, display math renders flush left with a `2em` left margin,
+     * like `\documentclass[fleqn]` in LaTeX with the `amsmath` package.
+     * 
+     * @default false
+     */
+    fleqn?: boolean;
+    /**
+     * If `true`, KaTeX will throw a `ParseError` when it encounters an
+     * unsupported command or invalid LaTeX.
+     * If `false`, KaTeX will render unsupported commands as text, and render
+     * invalid LaTeX as its source code with hover text giving the error, in
+     * the color given by `errorColor`.
+     * 
+     * @default true
+     */
+    throwOnError?: boolean;
+    /**
+     * A color string given in the format `"#XXX"` or `"#XXXXXX"`. This option
+     * determines the color that unsupported commands and invalid LaTeX are
+     * rendered in when `throwOnError` is set to `false`.
+     * 
+     * @default "#cc0000"
+     */
+    errorColor?: string;
+    /**
+     * A collection of custom macros.
+     * @see https://katex.org/docs/options
+     */
+    macros?: Record<string, string | object | ((macroExpander:object) => string | object)>;
+    /**
+     * Specifies a minimum thickness, in ems, for fraction lines, `\sqrt` top
+     * lines, `{array}` vertical lines, `\hline`, `\hdashline`, `\underline`,
+     * `\overline`, and the borders of `\fbox`, `\boxed`, and `\fcolorbox`.
+     * The usual value for these items is `0.04`, so for `minRuleThickness`
+     * to be effective it should probably take a value slightly above `0.04`,
+     * say `0.05` or `0.06`. Negative values will be ignored.
+     */
+    minRuleThickness?: number;
+    /**
+     * In early versions of both KaTeX (<0.8.0) and MathJax, the `\color`
+     * function expected the content to be a function argument, as in
+     * `\color{blue}{hello}`. In current KaTeX, `\color` is a switch, as in
+     * `\color{blue}` hello. This matches LaTeX behavior. If you want the old
+     * `\color` behavior, set option colorIsTextColor to true.
+     */
+    colorIsTextColor?: boolean;
+    /**
+     * All user-specified sizes, e.g. in `\rule{500em}{500em}`, will be capped
+     * to `maxSize` ems. If set to `Infinity` (the default), users can make
+     * elements and spaces arbitrarily large.
+     * 
+     * @default Infinity
+     */
+    maxSize?: number;
+    /**
+     * Limit the number of macro expansions to the specified number, to prevent
+     * e.g. infinite macro loops. `\edef` expansion counts all expanded tokens.
+     * If set to `Infinity`, the macro expander will try to fully expand as in
+     * LaTeX.
+     * 
+     * @default 1000
+     */
+    maxExpand?: number;
+    /**
+     * If `false` or `"ignore"`, allow features that make writing LaTeX
+     * convenient but are not actually supported by (Xe)LaTeX
+     * (similar to MathJax).
+     * If `true` or `"error"` (LaTeX faithfulness mode), throw an error for any
+     * such transgressions.
+     * If `"warn"` (the default), warn about such behavior via `console.warn`.
+     * Provide a custom function `handler(errorCode, errorMsg, token)` to
+     * customize behavior depending on the type of transgression (summarized by
+     * the string code `errorCode` and detailed in `errorMsg`); this function
+     * can also return `"ignore"`, `"error"`, or `"warn"` to use a built-in
+     * behavior.
+     * @see https://katex.org/docs/options
+     * 
+     * @default "warn"
+     */
+    strict?:
+        | boolean
+        | "ignore" | "warn" | "error"
+        | ((errorCode: string, errorMsg: string, token: object) => boolean | "ignore" | "warn" | "error" | undefined | null);
+    /**
+     * If `false` (do not trust input), prevent any commands like
+     * `\includegraphics` that could enable adverse behavior, rendering them
+     * instead in `errorColor`.
+     * If `true` (trust input), allow all such commands.
+     * Provide a custom function `handler(context)` to customize behavior
+     * depending on the context (command, arguments e.g. a URL, etc.).
+     * @see https://katex.org/docs/options
+     * 
+     * @default false
+    */
+    trust?: boolean | ((context: TrustContext) => boolean);
+    /**
+     * Run KaTeX code in the global group. As a consequence, macros defined at
+     * the top level by `\def` and `\newcommand` are added to the macros
+     * argument and can be used in subsequent render calls. In LaTeX,
+     * constructs such as `\begin{equation}` and `$$` create a local group and
+     * prevent definitions other than `\gdef` from becoming visible outside of
+     * those blocks, so this is KaTeX's default behavior.
+     * 
+     * @default false
+     */
+    globalGroup?: boolean;
+}
+
+/**
+ * In-browser rendering
+ *
+ * Call the `render` function with a TeX expression and a DOM element to
+ * render into.
+ *
+ * @param {string} tex A TeX expression.
+ * @param {HTMLElement} element A HTML DOM element.
+ * @param {KatexOptions} options An options object.
+ * @returns {void}
+ * @see https://katex.org/docs/api
+ */
+export function render(
+    tex: string,
+    element: HTMLElement,
+    options?: KatexOptions,
+): void;
+
+/**
+ * Server-side rendering or rendering to a string
+ *
+ * Use the `renderToString` function to generate HTML on the server or to
+ * generate an HTML string of the rendered math.
+ *
+ * @param {string} tex A TeX expression.
+ * @param {KatexOptions} options An options object.
+ * @returns {string} The HTML string of the rendered math.
+ * @see https://katex.org/docs/api
+ */
+export function renderToString(tex: string, options?: KatexOptions): string;
+
+/**
+ * If KaTeX encounters an error (invalid or unsupported LaTeX) and
+ * `throwOnError` hasn't been set to `false`, then `katex.render` and
+ * `katex.renderToString` will throw an exception of type
+ * `ParseError`. The message in this error includes some of the LaTeX source
+ * code, so needs to be escaped if you want to render it to HTML.
+ * @see https://katex.org/docs/error
+ */
+export class ParseError implements Error {
+    constructor(message: string, token?: object);
+    name: "ParseError";
+    position: number;
+    length: number;
+    rawMessage: string;
+    message: string;
+}
+
+export const version: string;
+
+export as namespace katex;
+
+declare const katex: {
+    version: string;
+    render: typeof render;
+    renderToString: typeof renderToString;
+    ParseError: typeof ParseError;
+};
+
+export default katex;