[v4.1.1] Font commands not respected when using Unicode characters

[myca-rrhiza]

LLM Use Disclaimer

The bug was discovered after using Github Copilot through VSCode to replace Obsidian's v3 MathJax instance with v4. The following summary was written by Copilot as well.

Issue Summary

Font-switching commands (\symup, \mathrm, \mathup, etc.) fail to apply the correct mathvariant to Greek letters in two related scenarios:

1. lcGreek handler ignores env.font entirely — \symup{\alpha}, \mathrm{\alpha}, etc. never produce upright lowercase Greek, regardless of mathStyle. The handler unconditionally applies mathStyle() without checking whether a font command has set env.font. This affects all mathStyle configurations.

2. hl Unicode handler overwrites env.font with mathStyle — When a literal Unicode Greek character is used inside a font command (e.g. \symup{Π}), the Unicode fallback handler computes the mathStyle variant after env.font has been set and overwrites the mathvariant attribute. For uppercase Greek, this manifests only with mathStyle: 'ISO' (the only style where uppercase Greek is italic). For lowercase Greek, it compounds with bug 1.

The ucGreek handler (used by TeX commands like \Pi) is the only handler that correctly prioritises env.font over mathStyle. The variable handler (used by Latin letters) also works correctly.

Steps to Reproduce

1. Configure MathJax with tex: { mathStyle: 'ISO' }
2. Render the following expressions and compare output glyphs:

Input	Expected	Actual	Handler
\symup{\Pi}	Upright Π (U+03A0)	✓ Upright (U+03A0)	ucGreek
\symup{Π} (Unicode)	Upright Π (U+03A0)	✗ Italic 𝛱 (U+1D6F1)	hl — bug 2
\mathrm{Π} (Unicode)	Upright Π (U+03A0)	✗ Italic 𝛱 (U+1D6F1)	hl — bug 2
\symup{\alpha}	Upright α (U+03B1)	✗ Italic 𝛼 (U+1D6FC)	lcGreek — bug 1
\mathrm{\alpha}	Upright α (U+03B1)	✗ Italic 𝛼 (U+1D6FC)	lcGreek — bug 1
\symup{α} (Unicode)	Upright α (U+03B1)	✗ Italic 𝛼 (U+1D6FC)	hl — bugs 1+2
\symup{x}	Upright x (U+0078)	✓ Upright (U+0078)	variable
\symup{X}	Upright X (U+0058)	✓ Upright (U+0058)	variable

Bug 1 (lcGreek) reproduces with all mathStyle values. Bug 2 (hl) reproduces with mathStyle: 'ISO' for uppercase Greek; for lowercase Greek and Latin, the effect depends on whether mathStyle returns a non-NORMAL variant.

Root Cause

Bug 1 — lcGreek ignores env.font:

// lcGreek — never checks env.font
lcGreek(t, e) {
  const s = { mathvariant: t.configuration.mathStyle(e.char) || ITALIC };
  // ...
}

// Compare ucGreek — correctly checks env.font first
ucGreek(t, e) {
  const s = { mathvariant: t.stack.env.font || t.configuration.mathStyle(e.char, true) || NORMAL };
  // ...
}

Fix: lcGreek should check t.stack.env.font before falling back to mathStyle, matching ucGreek.

Bug 2 — hl (Unicode fallback handler) overwrites env.font:

function hl(t, e) {
  const s = t.stack.env.font;                      // e.g. "normal" from \symup
  const i = s ? { mathvariant: s } : {};           // correctly sets mathvariant="normal"
  const c = t.create("token", a, i, ...);          // token created with "normal"
  
  const l = isLatinOrGreekChar(e)
    ? t.configuration.mathStyle(e, true) || r
    : "";                                           // l = "italic" (ISO uppercase Greek)
  const h = o[4] || (s && l === NORMAL ? "" : l);   // h = "italic" (since l ≠ NORMAL)
  h && c.attributes.set("mathvariant", h);          // OVERWRITES "normal" → "italic"
}

Fix: hl should skip the mathStyle override when env.font is already set.

Technical Details

• MathJax Version: 4.1.1
• Client OS: Windows 11
• Browser: Electron (Chromium-based, Obsidian desktop app)

I am using the following MathJax configuration:

MathJax = {
  tex: {
    packages: ['base', 'ams', 'newcommand', 'configmacros', 'noundefined', 'textmacros'],
    mathStyle: 'ISO',
  },
  startup: {
    typeset: false,
  },
};

and loading a custom-built tex-chtml component (all TeX extensions pre-bundled via components/bin/makeAll).

Supporting Information

Verification via tex2chtml() in the console:

// Bug 1: lcGreek ignores env.font — all mathStyle values
MathJax.tex2chtml('\\symup{\\alpha}').querySelector('mjx-c').className
// → "mjx-c1D6FC"  (U+1D6FC = italic 𝛼)  ✗ expected "mjx-c3B1" (U+03B1 = upright α)

// Bug 2: hl overwrites env.font — mathStyle: 'ISO' only (for uppercase Greek)
MathJax.tex2chtml('\\symup{Π}').querySelector('mjx-c').className
// → "mjx-c1D6F1"  (U+1D6F1 = italic 𝛱)  ✗ expected "mjx-c3A0" (U+03A0 = upright Π)

// Working: ucGreek handler correctly respects env.font
MathJax.tex2chtml('\\symup{\\Pi}').querySelector('mjx-c').className
// → "mjx-c3A0"  (U+03A0 = upright Π)  ✓

// Working: variable handler correctly respects env.font (Latin)
MathJax.tex2chtml('\\symup{x}').querySelector('mjx-c').className
// → "mjx-c78"  (U+0078 = upright x)  ✓

[dpvc]

Thanks for your report. You are correct that the processing of the \sym... and \math...macros does work properly when math-style is not TeX, but the situation is a bit more complicated than it at first may appear. In particular, in some situations, the env.font needs to be combined with the math-style setting in some cases. Below are tables showing the results for the various \sym... macros for several math-style settings on Latin upper- and loser-case letters, Unicode Greek upper- and lower-case letters, and Greek letters given by macros: \Gamma\Delta\alpha\beta\gamma. This is using the unicode-math package with the math font set to the XITSMath-Regular.otf font.

The top line shows the result without an enclosing macro. At the bottom are also the results for \rm, \bf, \it, and \tt. Note that the Greek letters don't show up in these latter four at all (there are error messages about the symbols not existing in certain fonts being used).

Note that macros like \symbf and \symsf respect the math-style setting as well as the font, so that the results are bold italic for \symbf when mathtype=ISO. Similarly, while the TeX version uses italic bold for the lower-case Greek letters, when math-style=upright, they are upright bold.

As an aside, there are a few anomalies, here. For example, \symsf and \symfsit don't produce sans-serif Greek letters, and \symsfit doesn't produce italic upper-case Greek (but \symbfsfit does) in TeX and upright styles, even though italic versions are available, as shown in the ISO column.

Here are the \math... macros for similar inputs:

Again, there are some anomalies. For example, several of the forms don't produce lower-case Greek letters, and only produce upper-case Greek for the Unicode version, not the macro version (again with error message about missing characters in some fonts). Another issue is that \mathbf and \mathbfup don't use the same font, which seems a bit strange, and similarly for \mathsf and \mathsfup. There are similar issue to \sym... where the Greek letters aren't sans-serif or italic in some cases where they should be.

It is possible that I don't have unicode-math configured correctly, as it is not something I have use myself, so may not be using it correctly, but this is these are the results I obtained with a simple file such as

\documentclass{article}
\usepackage{unicode-math}
\def\style{ISO}
\setmathfont[math-style=TeX]{XITSMath-Regular.otf}

\begin{document}

\center{math-style=TeX}

\def\chars{A\,a\,Bb\,ΓΔαβγ\;\Gamma\Delta\alpha\beta\gamma}

\[
\begin{array}{r|l}
                 & \chars \\
\hline
\text{symup}     & \symup{\chars} \\
\text{symbf}     & \symbf{\chars} \\
\text{symbfup}   & \symbfup{\chars} \\
\text{symit}     & \symit{\chars} \\
\text{symbfit}   & \symbfit{\chars} \\
\text{symsf}     & \symsf{\chars} \\
\text{symbfsf}   & \symbfsf{\chars} \\
\text{symbfsfup} & \symbfsfup{\chars} \\
\text{symsfit}   & \symsfit{\chars} \\
\text{symbfsfit} & \symbfsfit{\chars} \\
\text{symrm}     & \symrm{\chars} \\
\text{rm}        & {\rm \chars} \\
\text{bf}        & {\bf \chars} \\
\text{it}        & {\it \chars} \\
\text{tt}        & {\tt \chars} \\
\end{array}
\]

\end{document}

It turns out that this means that none of the current functions (variable, other, lcGreek, ucGreek) work properly, as none of them properly handle the math-style settings in all cases (so your claim that variable and ucGreek are working isn't quite correct). Also, your hl function seems to be from the webpacked code (it has been minified), rather than from the original .ts file; it looks to be the other function from ts/input/tex/base/BaseConfiguration.ts that is the fallback handler for characters that are not otherwise mapped (so will handle Unicode Greek letters).

All four functions need adjustment in order to properly integrate the math-style with the specified font.

There is an additional wrinkle, however. the unicode-math package (which makes most of these macros available) alters the output of \mathrm, \mathbf, \mathit, and \mathttfrom their usual results. Here is a table showing the results for these macros whenunicode-math` is not used:

Note that the lower-case Greek are produced, but that they are always plain italic (so not affected by the font specified by the macro). Because MathJax doesn't have a unicode-math package and includes all the macros by default, it is not clear which behavior the user intends. Because the non-unicode versions are the only ones that produce output for the lower-case Greek letters (at least for me), I'm inclined to have them produce italic lower-case Greek in all cases, but provide a new configuration option that can be used to allow them to affect the lower-case Greek, and to honor the math-style setting.

[dpvc]

PS, I meant to say that I spent the last day or so working out the details for the solution. I will make a PR for it for the next release.

[myca-rrhiza]

Thanks for your response(s). I agree with all of your considerations, especially regarding the changes that unicode-math makes to existing LaTeX commands. (This response had no LLM involvement, except for generating the Unicode literals in the code block below.)

Regarding the \sym commands (introduced by unicode-math), I believe the first image in your comment exhibits expected behavior all-around. In particular, the output does not depend on whether the literal Unicode character or a TeX macro are used for Greek, and the characters (Latin and Greek) always follow the command variant, as long as it exists (see below), regardless of math-style. This is the main concern with the bug report. I believe that if anyone is using \sym then they will always intend for it to override the default from the style.

Regarding some of your anomalies: \symsf and \symsfit do not affect Greek letters because there are no Unicode codepoints for medium-weight sans Greek (this is discussed in the unicode-math docs, I believe). This is the reason for the "missing characters" warnings. On the other hand, there are for heavy-weight sans Greek (range U+1D756-U+1D7C9), hence \symbfsf and \symbfsfit do work. The way unicode-math chooses to handle this is to use the default instead of the bolded variant, a decision I am not sure about.

I tend to try to use \sym for all font adjustments (there's also \symbb, \symtt, etc) and Unicode literals for Greek characters, and I prefer ISO style, hence first found the bug that \symup{Π} is not upright. Copilot found the bug for \symup{\alpha}, but mistakenly reported that \symup{α} also experienced this bug—as far as I can tell, the bug(s) apply to only uppercase Greek Unicode literals and lowercase Greek macros (the latter even when math-style=TeX).

An aside: I've noticed (and this is not necessarily wrong, I think I prefer it) that, with respect to Unicode literals, MathJax is closer to unicode-math's math-style=literal than any of the four styles (TeX, ISO, french, upright) that are accepted as names of styles by MathJax. That is, it does not normalize the Unicode symbols in the Mathematical Alphanumeric Symbols block, unlike unicode-math. See the attached images—this behavior makes math-style=upright in MathJax behave almost exactly the same as math-style=literal in LaTeX. The TeX examples were made with the following code, and the MathJax examples just copy-pasted the math lines.

\documentclass{article}
\usepackage[math-style=literal]{unicode-math}
\setmathfont{STIX Two Math}

\begin{document}

\verb|math-style=literal, LaTeX:|

$αβγδεζηθικλμνξοπρςστυφχψωΓΔΘΛΞΠΣΦΨΩ$

$𝛼𝛽𝛾𝛿𝜀𝜁𝜂𝜃𝜄𝜅𝜆𝜇𝜈𝜉𝜊𝜋𝜌𝜍𝜎𝜏𝜐𝜑𝜒𝜓𝜔𝛤𝛥𝛩𝛬𝛯𝛱𝛴𝛷𝛹𝛺$

$𝛂𝛃𝛄𝛅𝛆𝛇𝛈𝛉𝛊𝛋𝛌𝛍𝛎𝛏𝛐𝛑𝛒𝛓𝛔𝛕𝛖𝛗𝛘𝛙𝛚𝚪𝚫𝚯𝚲𝚵𝚷𝚺𝚽𝚿𝛀$

$𝜶𝜷𝜸𝜹𝜺𝜻𝜼𝜽𝜾𝜿𝝀𝝁𝝂𝝃𝝄𝝅𝝆𝝇𝝈𝝉𝝊𝝋𝝌𝝍𝝎𝜞𝜟𝜣𝜦𝜩𝜫𝜮𝜱𝜳𝜴$

$𝝰𝝱𝝲𝝳𝝴𝝵𝝶𝝷𝝸𝝹𝝺𝝻𝝼𝝽𝝾𝝿𝞀𝞁𝞂𝞃𝞄𝞅𝞆𝞇𝞈𝝘𝝙𝝝𝝠𝝣𝝥𝝨𝝫𝝭𝝮$

$𝞪𝞫𝞬𝞭𝞮𝞯𝞰𝞱𝞲𝞳𝞴𝞵𝞶𝞷𝞸𝞹𝞺𝞻𝞼𝞽𝞾𝞿𝟀𝟁𝟂𝞒𝞓𝞗𝞚𝞝𝞟𝞢𝞥𝞧𝞨$

\end{document}

I don't know if there would be any differences using XeLaTeX; I use LuaLaTeX.

Hopefully some of this information you did not know (: either way, thanks for taking the time to fix this!

[myca-rrhiza]

By the way, would it be possible to add the XCharter font to MathJax? i don't know the implications of the undertaking. I could open a new issue/feature request if you'd like.

[dpvc]

Thank you for your additional information. This is very useful.

I'm afraid I never considered the issue of entering the Math Alphanumeric characters for the Greek variants explicitly (only the actual Greek and Coptic block), so MathJax doesn't honor the math-style for those, as you point out. That could be done, but would take more than just setting the mathvariant, as it would require actually changing the Unicode character being used. One would also need to treat the various Latin ranges in the Math Alphanumeric block as well. That can be done, of course, but I haven't put in the work for that yet. It seems that you might be against that, though. I was not aware of the literal option for math-style, and will need to add that to MathJax.

I guess I will need to read the unicode-math documentation. :-)

\symsf and \symsfit do not affect Greek letters because there are no Unicode codepoints for medium-weight sans Greek

That makes sense, and I should have thought of that. I was lead astray because MathJax has versions of these characters (but it is not based purely on Unicode positions, but also on the use of multiple fonts).

there's also \symbb, \symtt, etc

Yes, I know. I didn't include all of them, just a sampling. I should have included them all, as I did for the \math ones.

the characters (Latin and Greek) always follow the command variant, as long as it exists ..., regardless of math-style.

If I understand you correctly, that would mean that the result for any \sym... macro would be the same across all math-style settings but that isn't true for some of them. For example, the Latin and upper-case Greek in \symbf are upright for TeX but italic for ISO. This is why I said that in some cases the math-style and specified font must be combined.

I will look into adding the literal style, as well as handling the Math Alphanumeric block.

Again thanks for your observations and additional details.

[dpvc]

would it be possible to add the XCharter font to MathJax?

Yes, that can certainly be done.

I don't know the implications of the undertaking.

It usually takes me 3 to 5 days to put together a new font from scratch. There are lots of little details to work through that take time and testing.

I could open a new issue/feature request if you'd like.

Yes, that would be great. That way I can mark it as a feature request to make it easier to find when I get back to making new fonts (there are already requests for several others).

[myca-rrhiza]

It seems that you might be against that, though.

Thankfully it's not up to me (: but indeed I wouldn't mind if MathJax's Unicode literal behavior isn't changed.

that would mean that the result ... would be the same

I didn't intend to mean that, but I wasn't explicit enough. The way I think of the math font variants is that there is a base choice (mutually exclusive, assuming both exist) of upright/italics for all characters, and then any other font option is a simple on/off switch. The math-style setting only affects the default for upright/italics. So if a \sym... command does not specify one of upright/italics then it defaults to math-style, but otherwise the command completely specifies the character (and unicode-math accepts the override).

It's worth noting that this way of thinking about it is not totally accurate in unicode-math with respect to the math Unicode literals; for instance, using \sym... on any literal inside the Mathematical Alphanumeric block has somewhat unpredictable results as far as I am concerned. This and the default for \symsf on Greek characters are probably the only two gripes I have with how unicode-math handles character input.

MathJax has versions of these characters

I think only \symbbit is not in MathJax, but that has so little coverage anyway—there might not be a single font that has it for all Latin characters. It's a wonder sometimes why certain specific characters end up having Unicode codepoints in some font variants, but not all of them (relatedly, there's no Mathematical Italic Small H; but there is Planck Constant!).

[dpvc]

Thanks for your additional thoughts on this.

if a \sym... command does not specify one of upright/italics then it defaults to math-style,

This seems a useful way of thinking about it, but I'm not sure it covers all the behavior. For example, with mathstyle=TeX, we have \symsf producing italic lower-case Greek, but \symbfsf using upright ones. It seems to be that adding bf should just make a bold version of the non-bf results. Also, \symrm produces upright lower-case Greek, even though it doesn't include up or it. (But perhaps you think of rm as specifying up as well?)

I wouldn't mind if MathJax's Unicode literal behavior isn't changed.

If I do try to mimic unicode-math more closely, I will probably have to include a configuration option to preserve the current behavior for backward compatibility. The work I've already done includes an option to allow \mathrm and the other original macros to modify the lower-case Greek, as they do in unicode-math. Unfortunately, I didn't originally make a unicode-math extension for the other \math... and \sym... macros, which could have set that option when it is loaded, so that leads to the ambiguity in MathJax's current arrangement. Hindsight is always 20/20.

I think only \symbbit is not in MathJax

As you say, there is little coverage for it, and I probably didn't include it because MathJax's default fonts don't cover it. But it turns out that the STIX2 fonts do include both upper- and lower-case double-struck letters, so I should probably add it in so that it can be used with mathjax-stix2.

It's a wonder sometimes why certain specific characters end up having Unicode codepoints in some font variants, but not all of them

Agreed. I'm not sure how those decisions were made.

relatedly, there's no Mathematical Italic Small H; but there is Planck Constant!

Yes, the Letterlike Symbols block definitely complicates the situation for math alphabets. The Unicode committee doesn't like to duplicate symbols, but I really wish they had made a distinction between the Letterlike Symbols and the Mathematical Alphanumeric ones and included them all in the latter rather than leaving gaps that need to map back to the former.

[myca-rrhiza]

For example, with mathstyle=TeX, we have \symsf producing italic lower-case Greek, but \symbfsf using upright ones.

Yes, you're right. It seems my heuristic doesn't apply to math-style=TeX, probably due to trying to match TeX command behavior. I believe it works for the others.

I recall the unicode-math docs discuss each of these options in detail, so I would trust them and not me!

perhaps you think of rm as specifying up as well?

I've considered them synonyms, but maybe there is reason not to.

Thanks again for you attention to this issue.

[dpvc]

it took a little effort, but I had worked out the changes needed to support the \sym and \math commands more in line with the unicode-math package in actual LaTeX (or rather lualatex and xelatex), along with the handling of literal Math Alphanumerics characters. I also added the missing literal setting for math-style, and corrected the capitalization of french to be consistent with unicode-math. But I didn't get the chance to write it up before other things took over my time.

I have gotten back to it finally, and present you a configuration that implements the changes, in case you wanted to use it. It is pretty big, as there are changes to a number of places.

There are two new configuration options tex.mathStyleGreekLC, which determines whether \mathrm, \mathit, and the other \math macros from the original ams distribution will modify the lower-case Greek letters or not (original behavior is false, but unicode-math behavior is true), and mathStyleMathAlphabets, which determines whether MathJax will modify the characters in the Unicode Math Alphanumerics block or not. The default for both is false, so the behavior will be to modify the usual Latin and Greek blocks, but leave the Math Alphanumerics alone (I think that was what you preferred above).

I also added symbbit and \mathbbit, as you pointed out they were missing. The STIX2 font has italic double-struck characters, so these macros work with that font, at least, but that is the only one currently.

Here is the (extensive) configuration in an example file that illustrates the various macros and raw unicode characters. You can set the math-style and other values at the top. I've turned off speech generation just to speed up the display, as big tables like this will lots of entries take it a while.

<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width">
  <title>3536 - process unicode symbols in \symb... and \math... macros</title>
<script>
MathJax = {
  tex: {
    mathStyle: 'ISO',
    mathStyleGreekLC: true,
    mathStyleMathAlphabets: true,
//    identifierPattern: /^(?:[a-z]+|[A-Z]+)/, // for mathstyle=french, use this pattern
  },
  output: {
    font: 'mathjax-stix2',
  },
  options: {
    menuOptions: {
      settings: {
        enrich: false,    // speed up processing of the large tables
      }
    }
  },
  startup: {
    ready() {
      const {TeX} = MathJax._.input.tex_ts;

      Object.assign(TeX.OPTIONS, {
        mathStyleGreekLC: false,       // Whether the original \mathrm, \mathbf, etc. macros adjust lowercase Greek
        mathStyleMathAlphabets: false, // Whether \symup, \mathup, etc., adjust explit Math Alphanumeric chars
      });
      
      const ParseMethods = MathJax._.input.tex.ParseMethods.default;
      const ParseOptions = MathJax._.input.tex.ParseOptions.default;
      const {ParseUtil} = MathJax._.input.tex.ParseUtil;
      
      Object.assign(ParseMethods, {
        variable(parser, c) {
          const def = ParseUtil.getFontDef(parser);
          const env = parser.stack.env;
          if (env.multiLetterIdentifiers && env.font !== '') {
            c = parser.string.substring(parser.i - 1).match(env.multiLetterIdentifiers)?.[0] || c;
            parser.i += c.length - 1;
            if (def.mathvariant === MATHVARIANT.NORMAL && env.noAutoOP && c.length > 1) def.autoOP = false;
          }
          if (MathStyle.isLatinOrGreekChar(c, parser)) c = MathStyle.setVariant(c, parser, def);
          parser.Push(parser.create('token', 'mi', def, c));
        },
        lcGreek(parser, mchar) {
          const def = {};
          const c = MathStyle.setVariant(mchar.char, parser, def);
          parser.Push(parser.create('token', 'mi', def, c));
        },
        ucGreek(parser, mchar) {
          const def = {};
          const c = MathStyle.setVariant(mchar.char, parser, def, true);
          parser.Push(parser.create('token', 'mi', def, c));
        },
      });

      const TexParser = MathJax._.input.tex.TexParser.default;
      const {TexConstant} = MathJax._.input.tex.TexConstants;
      const {EnvList} = MathJax._.input.tex.StackItem;
      
      const MATHVARIANT = TexConstant.Variant;
      
      const MathStyle = {
        LatinPattern: /[a-zA-Z]/,
        LatinLcPattern: /[a-z]/,
        GreekPattern: /[\u0391-\u03A9\u03F4\u03B1-\u03C9\u03B5\u03C2\u03C6\u03D1\u03D6\u03F1]/,
        GreekUcPattern: /[\u0391-\u03A9\u03F4]/,
        GreekLcPattern: /[\u03B1-\u03C9\u03D1\u03D5\u03D6\u03F0\u03F1\u03F5\u2202]/,
        MathLatinPattern: /[\u{1D400}-\u{1D49B}\u{1D5A0}-\u{1D66F}\u210E]/u,
        MathGreekPattern: /[\u{1D6A8}-\u{1D7C9}]/u,
        MathAlphaPattern: /[\u{1D400}-\u{1D49B}\u{1D5A0}-\u{1D66F}\u210E\u{1D6A8}-\u{1D7C9}]/u,
        
        mathAlpha: new Map([
          ['TeX', [
            [0x1D6C2, 0x1D6E1, 0x1D736],
            [0x1D468, 0x1D49B, 0x1D400],
            [0x1D71C, 0x1D735, 0x1D6A8],
            [0x1D63C, 0x1D66F, 0x1D5D4],
            [0x1D790, 0x1D7C9, 0x1D756],
            [0x1D608, 0x1D63B, 0x1D5A0],
            [0x1D6E2, 0x1D6FA, 0x391, MATHVARIANT.NORMAL],
          ]],
          ['ISO', [
            [0x1D400, 0x1D433, 0x1D468],
            [0x1D6A8, 0x1D6E1, 0x1D71C],
            [0x1D5D4, 0x1D607, 0x1D63C],
            [0x1D756, 0x1D78F, 0x1D790],
            [0x1D5A0, 0x1D5D3, 0x1D608],
          ]],
          ['upright', [
            [0x1D434, 0x1D44D, 0x41, MATHVARIANT.NORMAL],
            [0x1D44E, 0x1D467, 0x61, MATHVARIANT.NORMAL],
            [0x1D6E2, 0x1D6FA, 0x391, MATHVARIANT.NORMAL],
            [0x1D6FC, 0x1D714, 0x3B1, MATHVARIANT.NORMAL],
            [0x1D468, 0x1D49B, 0x1D400],
            [0x1D71C, 0x1D755, 0x1D6A8],
            [0x1D63C, 0x1D66F, 0x1D5D4],
            [0x1D790, 0x1D7C9, 0x1D756],
            [0x1D608, 0x1D63B, 0x1D5A0],
          ]],
          ['french', [
            [0x1D434, 0x1D44D, 0x41, MATHVARIANT.NORMAL],
            [0x1D6E2, 0x1D6FA, 0x391, MATHVARIANT.NORMAL],
            [0x1D6FC, 0x1D714, 0x3B1, MATHVARIANT.NORMAL],
            [0x1D468, 0x1D49B, 0x1D400],
            [0x1D71C, 0x1D755, 0x1D6A8],
            [0x1D63C, 0x1D66F, 0x1D5D4],
            [0x1D790, 0x1D7C9, 0x1D756],
            [0x1D608, 0x1D63B, 0x1D5A0],
          ]],
          ['literal', []],
        ]),
        
        mathAlphaMap: new Map([
          ['TeX', new Map([
            [0x1D6F3, [MATHVARIANT.NORMAL, '\u03F4']],
            [0x1D6FB, [MATHVARIANT.NORMAL, '\u2207']],
          ])],
          ['upright', new Map([
            [0x0210E, [MATHVARIANT.NORMAL, 'h']],
            [0x1D6F3, [MATHVARIANT.NORMAL, '\u03F4']],
            [0x1D6FB, [MATHVARIANT.NORMAL, '\u2207']],
            [0x1D715, [MATHVARIANT.NORMAL, '\u2202']],
            [0x1D716, [MATHVARIANT.NORMAL, '\u03F5']],
            [0x1D717, [MATHVARIANT.NORMAL, '\u03D1']],
            [0x1D718, [MATHVARIANT.NORMAL, '\u03F0']],
            [0x1D719, [MATHVARIANT.NORMAL, '\u03D5']],
            [0x1D71A, [MATHVARIANT.NORMAL, '\u03F1']],
            [0x1D71B, [MATHVARIANT.NORMAL, '\u03D6']],
          ])],
          ['french', new Map([
            [0x1D6F3, [MATHVARIANT.NORMAL, '\u03F4']],
            [0x1D6FB, [MATHVARIANT.NORMAL, '\u2207']],
            [0x1D715, [MATHVARIANT.NORMAL, '\u2202']],
            [0x1D716, [MATHVARIANT.NORMAL, '\u03F5']],
            [0x1D717, [MATHVARIANT.NORMAL, '\u03D1']],
            [0x1D718, [MATHVARIANT.NORMAL, '\u03F0']],
            [0x1D719, [MATHVARIANT.NORMAL, '\u03D5']],
            [0x1D71A, [MATHVARIANT.NORMAL, '\u03F1']],
            [0x1D71B, [MATHVARIANT.NORMAL, '\u03D6']],
          ])],
        ]),
        
        styleFunction: new Map([
          ['TeX',
            ({c, C, font, afont, b}) => [
              b && C.match(MathStyle.GreekUcPattern) ? font
                : C.match(MathStyle.GreekLcPattern) || b ? afont : '',
              c
          ]],
          ['ISO', ({c, C, ifont, afont}) => [C.match(MathStyle.GreekPattern) ? afont : ifont, c]],
          ['french',
            ({c, C, font, ifont}) => [C.match(MathStyle.LatinLcPattern) ? ifont : font, c],
          ],
          ['upright', ({c, font}) => [font, c]],
          ['literal', ({c, font}) => [font || MATHVARIANT.NORMAL, c]],
        ]),
        
        convertMathAlpha(style, c) {
          const n = c.codePointAt(0);
          const map = MathStyle.mathAlphaMap.get(style);
          if (map?.has(n)) return map.get(n);
          for (const [m, M, N, variant = ''] of MathStyle.mathAlpha.get(style) || []) {
            if (n >= m && n <= M) {
              const C = N + (n - m);
              return [variant, String.fromCodePoint(C)];
            }
          }
          return ['', c];
        },
        
        isLatinOrGreekChar(c, parser) {
          const C = [...c.normalize('NFC')][0];
          return (!!C.match(this.LatinPattern) || !!C.match(this.GreekPattern)
            || (parser.configuration.options.mathStyleMathAlphabets && !!C.match(this.MathAlphaPattern))
          );
        },
        
        setVariant(c, parser, def, b = false) {
          const options = parser.configuration.options;
          const env = parser.stack.env;
          const font = env.font || '';
          const ifont = env.italicFont || font || MATHVARIANT.ITALIC;
          const afont = env.altItalicFont || ifont;
          const C = [...c.normalize('NFC')][0];
          if (font && !options.mathStyleGreekLC && !env.mathStyleGreekLC && C.match(this.GreekLcPattern)) {
            def.mathvariant = MATHVARIANT.ITALIC;
            return c;
          }
          const [variant, char] = (options.mathStyleMathAlphabets && !!C.match(this.MathAlphaPattern))
            ? this.convertMathAlpha(parser.configuration.options.mathStyle || 'TeX', c)
            : parser.configuration.mathStyle.call(MathStyle, {c, C, font: font || MATHVARIANT.NORMAL, ifont, afont, b});
            if (variant) def.mathvariant = variant;
          return char;
        }
      };
      MathStyle.mathAlpha.set('French', MathStyle.mathAlpha.get('french'));
      MathStyle.mathAlphaMap.set('French', MathStyle.mathAlphaMap.get('french'));
      MathStyle.styleFunction.set('French', MathStyle.styleFunction.get('french'));

      ParseOptions.getVariant = MathStyle.styleFunction;
      TexConstant.Variant.DOUBLESTRUCKITALIC = '-double-struck-italic';
      
      const {BaseConfiguration} = MathJax._.input.tex.base.BaseConfiguration;
      const BaseMethods = MathJax._.input.tex.base.BaseMethods.default;
      const {MapHandler} = MathJax._.input.tex.MapHandler;
      const {Macro} = MathJax._.input.tex.Token;
      const {getRange} = MathJax._.core.MmlTree.OperatorDictionary;
      const NodeUtil = MathJax._.input.tex.NodeUtil.default;
      
      Object.assign(BaseMethods, {
        MathFont(parser, name, variant, italic, altItalic = '', greekLC = true) {
          const text = parser.GetArgument(name);
          const mml = new TexParser(text, {
            multiLetterIdentifiers: parser.options.identifierPattern,
            ...parser.stack.env,
            font: variant,
            italicFont: italic || variant,
            altItalicFont: altItalic || italic || variant,
            mathStyleGreekLC: greekLC,
            noAutoOP: true,
          }, parser.configuration).mml();
          parser.Push(parser.create('node', 'TeXAtom', [mml]));
        },
        SetFont(parser, _name, font) {
          parser.stack.env['font'] = font;
          parser.stack.env['italicFont'] = font;
          parser.stack.env['altItalicFont'] = font;
          parser.stack.env['mathStyleGreekLC'] = false;
          parser.Push(parser.itemFactory.create('null'));
        },
      });

      BaseConfiguration.fallback.character = function Other(parser, char) {
        const remap = MapHandler.getMap('remap').lookup(char);
        const range = getRange(char);
        const type = range[3];
        const font = range[4] || parser.stack.env.font;
        const def = font ? { mathvariant: font } : {};
        if (MathStyle.isLatinOrGreekChar(char, parser)) {
          char = MathStyle.setVariant(char, parser, def, true);
        }
        const mo = parser.create('token', type, def, remap ? remap.char : char);
        if (type === 'mo') {
          NodeUtil.setProperty(mo, 'fixStretchy', true);
          parser.configuration.addNode('fixStretchy', mo);
        }
        parser.Push(mo);
      };
      
      const VARIANT = TexConstant.Variant;
      const macros = MapHandler.getMap('macros');
      for (const name of ['mathnormal', 'mathrm', 'mathbf', 'mathit', 'mathsf', 'mathtt', 'mathcal']) {
        macros.lookup(name)._args.push('', '', false);
      }
      for (const [name, args] of Object.entries({
        symbb: ['', VARIANT.DOUBLESTRUCKITALIC],
        symfrak: ['', VARIANT.ITALIC],
        symbffrak: ['', VARIANT.BOLDITALIC],
        symbfsf: [VARIANT.SANSSERIFBOLDITALIC],
        symtt: ['', VARIANT.ITALIC],
      })) {
        macros.lookup(name)._args.push(...args);
      }
      for (const name of ['normal', 'rm', 'up', 'bf', 'bfup', 'it', 'bfit', 'bb',
                          'frak', 'bffrak', 'scr', 'bfscr', 'sf', 'sfup', 'bfsf', 'bfsfup',
                          'sfit', 'bfsfit', 'tt', 'cal', 'bfcal']) {
        macros.lookup('sym' + name)._func  = BaseMethods.MathFont;
        macros.lookup('math' + name)._func = BaseMethods.MathFont;
      }
      macros.lookup('frak')._func = macros.lookup('Bbb')._func = BaseMethods.MathFont;
      macros.add('symbbit', new Macro('symbbit', BaseMethods.MathFont, [VARIANT.DOUBLESTRUCKITALIC]));
      macros.add('mathbbit', new Macro('mathbbit', BaseMethods.MathFont, [VARIANT.DOUBLESTRUCKITALIC]));
      for (const name of ['rm', 'bf', 'it', 'sf', 'tt', 'cal', 'mit', 'oldstyle']) {
        macros.lookup(name)._func = BaseMethods.SetFont;
      }
      
      MapHandler.getMap('letter')._parser  = ParseMethods.variable;
      MapHandler.getMap('lcGreek')._parser = ParseMethods.lcGreek;
      MapHandler.getMap('ucGreek')._parser = ParseMethods.ucGreek;
      
      const font = Object.values(Object.values(MathJax._.output.fonts)[0].chtml_ts)[0];
      font.defaultVariants.push(['-double-struck-italic', 'double-struck', 'bold-italic']);
      font.defaultCssFonts['-double-struck-italic'] = ['unknown', true, true];
      font.VariantSmp['double-struck'][5] = {
        0x0393: 0x213E,
        0x03A0: 0x213F,
        0x03A3: 0x2140,
        0x03B3: 0x213D,
        0x03C0: 0x213C,
      };
      font.VariantSmp['-double-struck-italic'] = [0x1D538, 0x1D552 , , , 0x1D7D8, {
        0x44: 0x2145,
        0x64: 0x2146,
        0x65: 0x2147,
        0x69: 0x2148,
        0x6A: 0x2149,
        0x0393: 0x213E,
        0x03A0: 0x213F,
        0x03A3: 0x2140,
        0x03B3: 0x213D,
        0x03C0: 0x213C,
      }];
      
      MathJax.startup.defaultReady();
    }
  }
};
</script>
<script src="https://cdn.jsdelivr.net/npm/mathjax@4/tex-chtml.js"></script>
</head>
<body>

<p style="text-align: center">math-style = <span id="mathstyle"></span></p>

\[
\def\chars{A\,a\,Bb\,ΓΔαβγ\;\Gamma\Delta\alpha\beta\gamma}
\begin{array}[t]{r|l}
                 & \chars \\
\hline
\text{symnormal} & \symnormal{\chars} \\
\text{symrm}     & \symrm{\chars} \\
\text{symup}     & \symup{\chars} \\
\text{symbf}     & \symbf{\chars} \\
\text{symbfup}   & \symbfup{\chars} \\
\text{symit}     & \symit{\chars} \\
\text{symbfit}   & \symbfit{\chars} \\
\text{symbb}     & \symbb{\chars} \\
\text{symbbit}   & \symbbit{\chars} \\
\text{symfrak}   & \symfrak{\chars} \\
\text{symbffrak} & \symbffrak{\chars} \\
\text{symscr}    & \symscr{\chars} \\
\text{symbfscr}  & \symbfscr{\chars} \\
\text{symsf}     & \symsf{\chars} \\
\text{symsfup}   & \symsfup{\chars} \\
\text{symbfsf}   & \symbfsf{\chars} \\
\text{symbfsfup} & \symbfsfup{\chars} \\
\text{symsfit}   & \symsfit{\chars} \\
\text{symbfsfit} & \symbfsfit{\chars} \\
\text{symtt}     & \symtt{\chars} \\
\text{symcal}    & \symcal{\chars} \\
\text{symbfcal}  & \symbfcal{\chars} \\
\hline
\text{rm}        & {\rm \chars} \\
\text{bf}        & {\bf \chars} \\
\text{it}        & {\it \chars} \\
\end{array}
%
\qquad
%
\begin{array}[t]{r|l}
          & \chars \\
\hline
\text{mathnormal} & \mathnormal{\chars} \\
\text{mathrm}     & \mathrm{\chars} \\
\text{mathup}     & \mathup{\chars} \\
\text{mathbf}     & \mathbf{\chars} \\
\text{mathbfup}   & \mathbfup{\chars} \\
\text{mathit}     & \mathit{\chars} \\
\text{mathbfit}   & \mathbfit{\chars} \\
\text{mathbb}     & \mathbb{\chars} \\
\text{mathbbit}   & \mathbbit{\chars} \\
\text{mathfrak}   & \mathfrak{\chars} \\
\text{mathbffrak} & \mathbffrak{\chars} \\
\text{mathscr}    & \mathscr{\chars} \\
\text{mathbfscr}  & \mathbfscr{\chars} \\
\text{mathsf}     & \mathsf{\chars} \\
\text{mathsfup}   & \mathsfup{\chars} \\
\text{mathbfsf}   & \mathbfsf{\chars} \\
\text{mathbfsfup} & \mathbfsfup{\chars} \\
\text{mathsfit}   & \mathsfit{\chars} \\
\text{mathbfsfit} & \mathbfsfit{\chars} \\
\text{mathtt}     & \mathtt{\chars} \\
\text{mathcal}    & \mathcal{\chars} \\
\text{mathbfcal}  & \mathbfcal{\chars} \\
\hline
\text{sf}        & {\sf \chars} \\
\text{cal}       & {\cal \chars} \\
\text{tt}        & {\tt \chars} \\
\end{array}
\]

\[
\begin{array}{l}
ABCabch\ αβγδεζηθικλμνξοπρςστυφχψω𝜕ϵϑϰϕϱϖΑΒΓΔΕΖΗΘΙΚΛΜΝΞΟΠΡϴΣΤΥΦΧΨΩ∇\\
𝐴𝐵𝐶𝑎𝑏𝑐ℎ\ 𝛼𝛽𝛾𝛿𝜀𝜁𝜂𝜃𝜄𝜅𝜆𝜇𝜈𝜉𝜊𝜋𝜌𝜍𝜎𝜏𝜐𝜑𝜒𝜓𝜔𝜕𝜖𝜗𝜘𝜙𝜚𝜛𝛢𝛣𝛤𝛥𝛦𝛧𝛨𝛩𝛪𝛫𝛬𝛭𝛮𝛯𝛰𝛱𝛲𝛳𝛴𝛵𝛶𝛷𝛸𝛹𝛺𝛻\\
𝐀𝐁𝐂𝐚𝐛𝐜\ 𝛂𝛃𝛄𝛅𝛆𝛇𝛈𝛉𝛊𝛋𝛌𝛍𝛎𝛏𝛐𝛑𝛒𝛓𝛔𝛕𝛖𝛗𝛘𝛙𝛚𝛛𝛜𝛝𝛞𝛟𝛠𝛡𝚨𝚩𝚪𝚫𝚬𝚭𝚮𝚯𝚰𝚱𝚲𝚳𝚴𝚵𝚶𝚷𝚸𝚹𝚺𝚻𝚼𝚽𝚾𝚿𝛀𝛁\\
𝑨𝑩𝑪𝒂𝒃𝒄\ 𝜶𝜷𝜸𝜹𝜺𝜻𝜼𝜽𝜾𝜿𝝀𝝁𝝂𝝃𝝄𝝅𝝆𝝇𝝈𝝉𝝊𝝋𝝌𝝍𝝎𝝏𝝐𝝑𝝒𝝓𝝔𝝕𝜜𝜝𝜞𝜟𝜠𝜡𝜢𝜣𝜤𝜥𝜦𝜧𝜨𝜩𝜪𝜫𝜬𝜭𝜮𝜯𝜰𝜱𝜲𝜳𝜴𝜵\\
𝗔𝗕𝗖𝗮𝗯𝗰\ 𝝰𝝱𝝲𝝳𝝴𝝵𝝶𝝷𝝸𝝹𝝺𝝻𝝼𝝽𝝾𝝿𝞀𝞁𝞂𝞃𝞄𝞅𝞆𝞇𝞈𝞉𝞊𝞋𝞌𝞍𝞎𝞏𝝖𝝗𝝘𝝙𝝚𝝛𝝜𝝝𝝞𝝟𝝠𝝡𝝢𝝣𝝤𝝥𝝦𝝧𝝨𝝩𝝪𝝫𝝬𝝭𝝮𝝯\\
𝘼𝘽𝘾𝙖𝙗𝙘\ 𝞪𝞫𝞬𝞭𝞮𝞯𝞰𝞱𝞲𝞳𝞴𝞵𝞶𝞷𝞸𝞹𝞺𝞻𝞼𝞽𝞾𝞿𝟀𝟁𝟂𝟃𝟄𝟅𝟆𝟇𝟈𝟉𝞐𝞑𝞒𝞓𝞔𝞕𝞖𝞗𝞘𝞙𝞚𝞛𝞜𝞝𝞞𝞟𝞠𝞡𝞢𝞣𝞤𝞥𝞦𝞧𝞨𝞩\\
𝖠𝖡𝖢𝖺𝖻𝖼\ 𝘈𝘉𝘊𝘢𝘣𝘤\ 𝙰𝙱𝙲𝚊𝚋𝚌\ 𝒜ℬ𝒞𝒶𝒷𝒸\ 𝓐𝓑𝓒𝓪𝓫𝓬\ 𝔄𝔅ℭ𝔞𝔟𝔠\ 𝕬𝕭𝕮𝖆𝖇𝖈\ 𝔸𝔹ℂ𝕒𝕓𝕔\\
\end{array}
\]

<script>
document.getElementById('mathstyle').textContent = MathJax.config.tex['mathStyle'];
</script>

</body>
</html>

I am thinking about whether to move the \sym and \math definitions to a separate package. It will include more of what unicode-math does (like map big operators and such), but this configuration should be enough for you for now.

[dpvc]

I should say that there are some differences between the results of this code and actual LaTeX, especially in the handling of the Greek characters. MathJax's fallbacks for these are not the same as LaTeX's in some cases.

MathJax considers \mathscr and \mathcal to be scripts that are italic, so the fall backs are italic, and it thinks of \mathbb as bold (that is what blackboard-bold was meant to represent bold), and similarly things like \mathbffrak are considered to be bold, so the Greek will be bold in those macros (which is not the case in LaTeX).

Here are the the results for math-style=ISO in LaTeX and MathJax:

---

---

---

I don't think it is necessary to match the LaTeX output in these cases, when MathJax has fonts that cover those situations better.