@iyulab/chat-components 0.17.0 → 0.17.1

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## [0.17.1] - 2026-10-05
+
+### Changed
+
+- **KaTeX 0.19** (was 0.18). Math renders as before. KaTeX now reports a character it has no metrics
+  for through its `strict` option (code `symbolNotInFont`): with the default `strict: "warn"` it is a
+  console warning, with `strict: "error"` it is a render error — set `strict` in the markdown math
+  options if you rely on either. A `strict` callback that returns nothing now warns; return `false`
+  or `"ignore"` to stay quiet.
+
 ## [0.17.0] - 2026-10-05
 
 ### Added

package/dist/node_modules/katex/dist/katex.js

@@ -246,43 +246,6 @@ var Settings = class {
 		}
 	}
 	/**
-	* Report nonstrict (non-LaTeX-compatible) input.
-	* Can safely not be called if `this.strict` is false in JavaScript.
-	*/
-	reportNonstrict(errorCode, errorMsg, token) {
-		var strict = this.strict;
-		if (typeof strict === "function") strict = strict(errorCode, errorMsg, token);
-		if (!strict || strict === "ignore") return;
-		else if (strict === true || strict === "error") throw new ParseError("LaTeX-incompatible input and strict mode is set to 'error': " + (errorMsg + " [" + errorCode + "]"), token);
-		else if (strict === "warn") typeof console !== "undefined" && console.warn("LaTeX-incompatible input and strict mode is set to 'warn': " + (errorMsg + " [" + errorCode + "]"));
-		else typeof console !== "undefined" && console.warn("LaTeX-incompatible input and strict mode is set to " + ("unrecognized '" + strict + "': " + errorMsg + " [" + errorCode + "]"));
-	}
-	/**
-	* Check whether to apply strict (LaTeX-adhering) behavior for unusual
-	* input (like `\\`).  Unlike `nonstrict`, will not throw an error;
-	* instead, "error" translates to a return value of `true`, while "ignore"
-	* translates to a return value of `false`.  May still print a warning:
-	* "warn" prints a warning and returns `false`.
-	* This is for the second category of `errorCode`s listed in the README.
-	*/
-	useStrictBehavior(errorCode, errorMsg, token) {
-		var strict = this.strict;
-		if (typeof strict === "function") try {
-			strict = strict(errorCode, errorMsg, token);
-		} catch (error) {
-			strict = "error";
-		}
-		if (!strict || strict === "ignore") return false;
-		else if (strict === true || strict === "error") return true;
-		else if (strict === "warn") {
-			typeof console !== "undefined" && console.warn("LaTeX-incompatible input and strict mode is set to 'warn': " + (errorMsg + " [" + errorCode + "]"));
-			return false;
-		} else {
-			typeof console !== "undefined" && console.warn("LaTeX-incompatible input and strict mode is set to " + ("unrecognized '" + strict + "': " + errorMsg + " [" + errorCode + "]"));
-			return false;
-		}
-	}
-	/**
 	* Check whether to test potentially dangerous input, and return
 	* `true` (trusted) or `false` (untrusted).  The sole argument `context`
 	* should be an object with `command` field specifying the relevant LaTeX
@@ -16588,6 +16551,34 @@ var wideCharacterFont = (wideChar) => {
 	else if (120486 < codePoint && codePoint < 120782) return noFont;
 	else throw new ParseError("Unsupported character: " + wideChar);
 };
+function handleStrict(params) {
+	var strict = params.strict, errorCode = params.errorCode, errorMsg = params.errorMsg, token = params.token, report = params.report;
+	var behavior = strict;
+	if (typeof strict === "function") {
+		if (report) behavior = strict(errorCode, errorMsg, token);
+		else try {
+			behavior = strict(errorCode, errorMsg, token);
+		} catch (error) {
+			behavior = "error";
+		}
+	}
+	switch (behavior) {
+		case true:
+		case "error": if (report) throw new ParseError("LaTeX-incompatible input and strict mode is set to 'error': " + (errorMsg + " [" + errorCode + "]"), token);
+		else return true;
+		case false:
+		case "ignore":
+			if (!report) return false;
+			break;
+		default:
+			typeof console !== "undefined" && console.warn("LaTeX-incompatible input and strict mode is set to 'warn': " + (errorMsg + " [" + errorCode + "]"));
+			if (!report) return false;
+	}
+}
+/**
+* This module contains general functions that can be used for building
+* different kinds of domTree nodes in a consistent manner.
+*/
 /**
 * Looks up the given symbol in fontMetrics, after applying any symbol
 * replacements defined in symbol.js
@@ -16610,7 +16601,6 @@ var lookupSymbol = function lookupSymbol(value, fontName, mode) {
 * TODO: make argument order closer to makeSpan
 * TODO: add a separate argument for math class (e.g. `mop`, `mbin`), which
 * should if present come first in `classes`.
-* TODO(#953): Make `options` mandatory and always pass it in.
 */
 var makeSymbol = function makeSymbol(value, fontName, mode, options, classes) {
 	var lookup = lookupSymbol(value, fontName, mode);
@@ -16622,15 +16612,18 @@ var makeSymbol = function makeSymbol(value, fontName, mode, options, classes) {
 		if (mode === "text" || options && options.font === "mathit") italic = 0;
 		symbolNode = new SymbolNode(value, metrics.height, metrics.depth, italic, metrics.skew, metrics.width, classes);
 	} else {
-		typeof console !== "undefined" && console.warn("No character metrics " + ("for '" + value + "' in style '" + fontName + "' and mode '" + mode + "'"));
+		handleStrict({
+			strict: options.strict,
+			errorCode: "symbolNotInFont",
+			errorMsg: "No character metrics for '" + value + "' in style '" + fontName + "' and mode '" + mode + "'",
+			report: true
+		});
 		symbolNode = new SymbolNode(value, 0, 0, 0, 0, 0, classes);
 	}
-	if (options) {
-		symbolNode.maxFontSize = options.sizeMultiplier;
-		if (options.style.isTight()) symbolNode.classes.push("mtight");
-		var color = options.getColor();
-		if (color) symbolNode.style.color = color;
-	}
+	symbolNode.maxFontSize = options.sizeMultiplier;
+	if (options.style.isTight()) symbolNode.classes.push("mtight");
+	var color = options.getColor();
+	if (color) symbolNode.style.color = color;
 	return symbolNode;
 };
 /**
@@ -17809,6 +17802,7 @@ var Options = class Options {
 		this.maxSize = void 0;
 		this.minRuleThickness = void 0;
 		this._fontMetrics = void 0;
+		this.strict = void 0;
 		this.style = data.style;
 		this.color = data.color;
 		this.size = data.size || Options.BASESIZE;
@@ -17821,6 +17815,7 @@ var Options = class Options {
 		this.sizeMultiplier = sizeMultipliers[this.size - 1];
 		this.maxSize = data.maxSize;
 		this.minRuleThickness = data.minRuleThickness;
+		this.strict = data.strict;
 		this._fontMetrics = void 0;
 	}
 	/**
@@ -17839,7 +17834,8 @@ var Options = class Options {
 			fontWeight: this.fontWeight,
 			fontShape: this.fontShape,
 			maxSize: this.maxSize,
-			minRuleThickness: this.minRuleThickness
+			minRuleThickness: this.minRuleThickness,
+			strict: this.strict
 		};
 		Object.assign(data, extension);
 		return new Options(data);
@@ -17999,13 +17995,12 @@ var Options = class Options {
 * The base size index.
 */
 Options.BASESIZE = 6;
-var optionsFromSettings = function optionsFromSettings(settings) {
-	return new Options({
-		style: settings.displayMode ? Style$1.DISPLAY : Style$1.TEXT,
-		maxSize: settings.maxSize,
-		minRuleThickness: settings.minRuleThickness
-	});
-};
+var optionsFromSettings = (settings) => new Options({
+	style: settings.displayMode ? Style$1.DISPLAY : Style$1.TEXT,
+	maxSize: settings.maxSize,
+	minRuleThickness: settings.minRuleThickness,
+	strict: settings.strict
+});
 var displayWrap = function displayWrap(node, settings) {
 	if (settings.displayMode) {
 		var classes = ["katex-display"];
@@ -18023,7 +18018,7 @@ var buildTree = function buildTree(tree, expression, settings) {
 	else katexNode = makeSpan(["katex"], [buildMathML(tree, expression, options, settings.displayMode, false), buildHTML(tree, options)]);
 	return displayWrap(katexNode, settings);
 };
-var buildHTMLTree = function buildHTMLTree(tree, expression, settings) {
+var buildHTMLTree = function buildHTMLTree(tree, settings) {
 	return displayWrap(makeSpan(["katex"], [buildHTML(tree, optionsFromSettings(settings))]), settings);
 };
 /**
@@ -18759,7 +18754,12 @@ defineFunction({
 		var base = args[0];
 		var mode = context.parser.mode;
 		if (mode === "math") {
-			context.parser.settings.reportNonstrict("mathVsTextAccents", "LaTeX's accent " + context.funcName + " works only in text mode");
+			handleStrict({
+				strict: context.parser.settings.strict,
+				errorCode: "mathVsTextAccents",
+				errorMsg: "LaTeX's accent " + context.funcName + " works only in text mode",
+				report: true
+			});
 			mode = "text";
 		}
 		return {
@@ -19371,10 +19371,15 @@ defineFunction({
 	numArgs: 0,
 	numOptionalArgs: 0,
 	allowedInText: true,
-	handler(_ref, args, optArgs) {
+	handler(_ref) {
 		var parser = _ref.parser;
 		var size = parser.gullet.future().text === "[" ? parser.parseSizeGroup(true) : null;
-		var newLine = !parser.settings.displayMode || !parser.settings.useStrictBehavior("newLineInDisplayMode", "In LaTeX, \\\\ or \\newline does nothing in display mode");
+		var newLine = !parser.settings.displayMode || !handleStrict({
+			strict: parser.settings.strict,
+			errorCode: "newLineInDisplayMode",
+			errorMsg: "In LaTeX, \\\\ or \\newline does nothing in display mode",
+			report: false
+		});
 		return {
 			type: "cr",
 			mode: parser.mode,
@@ -19625,13 +19630,13 @@ var makeLargeDelim = function makeLargeDelim(delim, size, center, options, mode,
 * Make a span from a font glyph with the given offset and in the given font.
 * This is used in makeStackedDelim to make the stacking pieces for the delimiter.
 */
-var makeGlyphSpan = function makeGlyphSpan(symbol, font, mode) {
+var makeGlyphSpan = function makeGlyphSpan(symbol, font, mode, options) {
 	var sizeClass;
 	if (font === "Size1-Regular") sizeClass = "delim-size1";
 	else sizeClass = "delim-size4";
 	return {
 		type: "elem",
-		elem: makeSpan(["delimsizinginner", sizeClass], [makeSpan([], [makeSymbol(symbol, font, mode)])])
+		elem: makeSpan(["delimsizinginner", sizeClass], [makeSpan([], [makeSymbol(symbol, font, mode, options)])])
 	};
 };
 var makeInner = function makeInner(ch, height, options) {
@@ -19826,7 +19831,7 @@ var makeStackedDelim = function makeStackedDelim(delim, heightTotal, center, opt
 			elem: wrapper
 		});
 	} else {
-		stack.push(makeGlyphSpan(bottom, font, mode));
+		stack.push(makeGlyphSpan(bottom, font, mode, options));
 		stack.push(lap);
 		if (middle === null) {
 			var innerHeight = realHeightTotal - topHeightTotal - bottomHeightTotal + 2 * lapInEms;
@@ -19835,12 +19840,12 @@ var makeStackedDelim = function makeStackedDelim(delim, heightTotal, center, opt
 			var _innerHeight = (realHeightTotal - topHeightTotal - bottomHeightTotal - middleHeightTotal) / 2 + 2 * lapInEms;
 			stack.push(makeInner(repeat, _innerHeight, options));
 			stack.push(lap);
-			stack.push(makeGlyphSpan(middle, font, mode));
+			stack.push(makeGlyphSpan(middle, font, mode, options));
 			stack.push(lap);
 			stack.push(makeInner(repeat, _innerHeight, options));
 		}
 		stack.push(lap);
-		stack.push(makeGlyphSpan(top, font, mode));
+		stack.push(makeGlyphSpan(top, font, mode, options));
 	}
 	var newOptions = options.havingBaseStyle(Style$1.TEXT);
 	return styleWrap(makeSpan(["delimsizing", "mult"], [makeVList({
@@ -20649,7 +20654,12 @@ defineFunction({
 	allowedInText: true,
 	handler(_ref5, args) {
 		var parser = _ref5.parser, funcName = _ref5.funcName;
-		if (parser.mode === "math") parser.settings.reportNonstrict("mathVsSout", "LaTeX's \\sout works only in text mode");
+		if (parser.mode === "math") handleStrict({
+			strict: parser.settings.strict,
+			errorCode: "mathVsSout",
+			errorMsg: "LaTeX's \\sout works only in text mode",
+			report: true
+		});
 		var body = args[0];
 		return {
 			type: "enclose",
@@ -20841,7 +20851,12 @@ function parseArray(parser, _ref, style) {
 		if (next === "&") {
 			if (maxNumCols && row.length === maxNumCols) {
 				if (singleRow || colSeparationType) throw new ParseError("Too many tab characters: &", parser.nextToken);
-				else parser.settings.reportNonstrict("textEnv", "Too few columns specified in the {array} column argument.");
+				else handleStrict({
+					strict: parser.settings.strict,
+					errorCode: "textEnv",
+					errorMsg: "Too few columns specified in the {array} column argument.",
+					report: true
+				});
 			}
 			parser.consume();
 		} else if (next === "\\end") {
@@ -22198,7 +22213,12 @@ defineFunction({
 		_ref.token;
 		var value = assertNodeType(args[0], "raw").string;
 		var body = args[1];
-		if (parser.settings.strict) parser.settings.reportNonstrict("htmlExtension", "HTML extension is disabled on strict mode");
+		if (parser.settings.strict) handleStrict({
+			strict: parser.settings.strict,
+			errorCode: "htmlExtension",
+			errorMsg: "HTML extension is disabled on strict mode",
+			report: true
+		});
 		var trustContext;
 		var attributes = {};
 		switch (funcName) {
@@ -22428,9 +22448,24 @@ defineFunction({
 			var mathFunction = funcName[1] === "m";
 			var muUnit = size.value.unit === "mu";
 			if (mathFunction) {
-				if (!muUnit) parser.settings.reportNonstrict("mathVsTextUnits", "LaTeX's " + funcName + " supports only mu units, " + ("not " + size.value.unit + " units"));
-				if (parser.mode !== "math") parser.settings.reportNonstrict("mathVsTextUnits", "LaTeX's " + funcName + " works only in math mode");
-			} else if (muUnit) parser.settings.reportNonstrict("mathVsTextUnits", "LaTeX's " + funcName + " doesn't support mu units");
+				if (!muUnit) handleStrict({
+					strict: parser.settings.strict,
+					errorCode: "mathVsTextUnits",
+					errorMsg: "LaTeX's " + funcName + " supports only mu units, " + ("not " + size.value.unit + " units"),
+					report: true
+				});
+				if (parser.mode !== "math") handleStrict({
+					strict: parser.settings.strict,
+					errorCode: "mathVsTextUnits",
+					errorMsg: "LaTeX's " + funcName + " works only in math mode",
+					report: true
+				});
+			} else if (muUnit) handleStrict({
+				strict: parser.settings.strict,
+				errorCode: "mathVsTextUnits",
+				errorMsg: "LaTeX's " + funcName + " doesn't support mu units",
+				report: true
+			});
 		}
 		return {
 			type: "kern",
@@ -23961,7 +23996,12 @@ var Lexer = class {
 			var nlIndex = input.indexOf("\n", this.tokenRegex.lastIndex);
 			if (nlIndex === -1) {
 				this.tokenRegex.lastIndex = input.length;
-				this.settings.reportNonstrict("commentAtEnd", "% comment has no terminating newline; LaTeX would fail because of commenting the end of math mode (e.g. $)");
+				handleStrict({
+					strict: this.settings.strict,
+					errorCode: "commentAtEnd",
+					errorMsg: "% comment has no terminating newline; LaTeX would fail because of commenting the end of math mode (e.g. $)",
+					report: true
+				});
 			} else this.tokenRegex.lastIndex = nlIndex + 1;
 			return this.lex();
 		}
@@ -26123,7 +26163,13 @@ var Parser = class Parser {
 			};
 		}
 		if (Object.prototype.hasOwnProperty.call(unicodeSymbols, text[0]) && !symbols[this.mode][text[0]]) {
-			if (this.settings.strict && this.mode === "math") this.settings.reportNonstrict("unicodeTextInMathMode", "Accented Unicode text character \"" + text[0] + "\" used in math mode", nucleus);
+			if (this.settings.strict && this.mode === "math") handleStrict({
+				strict: this.settings.strict,
+				errorCode: "unicodeTextInMathMode",
+				errorMsg: "Accented Unicode text character \"" + text[0] + "\" used in math mode",
+				report: true,
+				token: nucleus
+			});
 			text = unicodeSymbols[text[0]] + text.slice(1);
 		}
 		var match = combiningDiacriticalMarksEndRegex.exec(text);
@@ -26134,7 +26180,13 @@ var Parser = class Parser {
 		}
 		var symbol;
 		if (symbols[this.mode][text]) {
-			if (this.settings.strict && this.mode === "math" && extraLatin.includes(text)) this.settings.reportNonstrict("unicodeTextInMathMode", "Latin-1/Unicode text character \"" + text[0] + "\" used in math mode", nucleus);
+			if (this.settings.strict && this.mode === "math" && extraLatin.includes(text)) handleStrict({
+				strict: this.settings.strict,
+				errorCode: "unicodeTextInMathMode",
+				errorMsg: "Latin-1/Unicode text character \"" + text[0] + "\" used in math mode",
+				report: true,
+				token: nucleus
+			});
 			var group = symbols[this.mode][text].group;
 			var loc = SourceLocation.range(nucleus);
 			var s;
@@ -26154,8 +26206,20 @@ var Parser = class Parser {
 			symbol = s;
 		} else if (text.charCodeAt(0) >= 128) {
 			if (this.settings.strict) {
-				if (!supportedCodepoint(text.charCodeAt(0))) this.settings.reportNonstrict("unknownSymbol", "Unrecognized Unicode character \"" + text[0] + "\"" + (" (" + text.charCodeAt(0) + ")"), nucleus);
-				else if (this.mode === "math") this.settings.reportNonstrict("unicodeTextInMathMode", "Unicode text character \"" + text[0] + "\" used in math mode", nucleus);
+				if (!supportedCodepoint(text.charCodeAt(0))) handleStrict({
+					strict: this.settings.strict,
+					errorCode: "unknownSymbol",
+					errorMsg: "Unrecognized Unicode character \"" + text[0] + "\"" + (" (" + text.charCodeAt(0) + ")"),
+					report: true,
+					token: nucleus
+				});
+				else if (this.mode === "math") handleStrict({
+					strict: this.settings.strict,
+					errorCode: "unicodeTextInMathMode",
+					errorMsg: "Unicode text character \"" + text[0] + "\" used in math mode",
+					report: true,
+					token: nucleus
+				});
 			}
 			symbol = {
 				type: "textord",
@@ -26271,12 +26335,12 @@ var renderToDomTree = function renderToDomTree(expression, options) {
 var renderToHTMLTree = function renderToHTMLTree(expression, options) {
 	var settings = new Settings(options);
 	try {
-		return buildHTMLTree(parseTree(expression, settings), expression, settings);
+		return buildHTMLTree(parseTree(expression, settings), settings);
 	} catch (error) {
 		return renderError(error, expression, settings);
 	}
 };
-var version = "0.18.10";
+var version = "0.19.0";
 var __domTree = {
 	Span,
 	Anchor,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@iyulab/chat-components",
   "description": "llm chat components for building chat interfaces",
-  "version": "0.17.0",
+  "version": "0.17.1",
   "author": "iyulab",
   "license": "MIT",
   "keywords": [
@@ -56,6 +56,7 @@
     "preversion": "node -e \"if(require('fs').existsSync('../../scripts/preversion-check.mjs'))require('child_process').execFileSync('node',['../../scripts/preversion-check.mjs'],{stdio:'inherit'})\"",
     "start": "vite",
     "build": "npm run typecheck && eslint && vite build",
+    "pretest": "node -e \"if(require('fs').existsSync('../../scripts/sibling-dist-check.js'))require('child_process').execFileSync('node',['../../scripts/sibling-dist-check.js'],{stdio:'inherit'})\"",
     "test": "vitest run",
     "test:watch": "vitest",
     "lint": "eslint src/",
@@ -64,7 +65,7 @@
   },
   "dependencies": {
     "highlight.js": "^11.11.1",
-    "katex": "^0.18.7",
+    "katex": "^0.19.0",
     "lit": "^3.3.3",
     "marked": "^18.0.6"
   },