@pie-lib/math-rendering-accessible 3.4.0-beta.0

package/lib/render-math.js

@@ -0,0 +1,475 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.initializeMathJax = exports.getGlobal = exports.fixMathElements = exports.fixMathElement = exports["default"] = exports.MathJaxVersion = void 0;
+
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+
+var _normalization = require("./normalization");
+
+var _SerializedMmlVisitor = require("mathjax-full/js/core/MmlTree/SerializedMmlVisitor");
+
+var _TexError = _interopRequireDefault(require("mathjax-full/js/input/tex/TexError"));
+
+var visitor = new _SerializedMmlVisitor.SerializedMmlVisitor();
+
+var toMMl = function toMMl(node) {
+  return visitor.visitTree(node);
+};
+
+var NEWLINE_BLOCK_REGEX = /\\embed\{newLine\}\[\]/g;
+var NEWLINE_LATEX = '\\newline ';
+var mathRenderingKEY = '@pie-lib/math-rendering@2';
+var mathRenderingAccessibleKEY = '@pie-lib/math-rendering-accessible@1';
+var MathJaxVersion = '3.2.2';
+exports.MathJaxVersion = MathJaxVersion;
+
+var getGlobal = function getGlobal() {
+  // TODO does it make sense to use version?
+  // const key = `${pkg.name}@${pkg.version.split('.')[0]}`;
+  // It looks like Ed made this change when he switched from mathjax3 to mathjax-full
+  // I think it was supposed to make sure version 1 (using mathjax3) is not used
+  // in combination with version 2 (using mathjax-full)
+  // TODO higher level wrappers use this instance of math-rendering, and if 2 different instances are used, math rendering is not working
+  //  so I will hardcode this for now until a better solution is found
+  if (typeof window !== 'undefined') {
+    if (!window[mathRenderingAccessibleKEY]) {
+      window[mathRenderingAccessibleKEY] = {};
+    }
+
+    return window[mathRenderingAccessibleKEY];
+  } else {
+    return {};
+  }
+};
+
+exports.getGlobal = getGlobal;
+
+var fixMathElement = function fixMathElement(element) {
+  if (element.dataset.mathHandled) {
+    return;
+  }
+
+  var property = 'innerText';
+
+  if (element.textContent) {
+    property = 'textContent';
+  }
+
+  if (element[property]) {
+    element[property] = (0, _normalization.wrapMath)((0, _normalization.unWrapMath)(element[property]).unwrapped); // because mathquill doesn't understand line breaks, sometimes we end up with custom elements on prompts/rationale/etc.
+    // we need to replace the custom embedded elements with valid latex that Mathjax can understand
+
+    element[property] = element[property].replace(NEWLINE_BLOCK_REGEX, NEWLINE_LATEX);
+    element.dataset.mathHandled = true;
+  }
+};
+
+exports.fixMathElement = fixMathElement;
+
+var fixMathElements = function fixMathElements() {
+  var el = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : document;
+  var mathElements = el.querySelectorAll('[data-latex]');
+  mathElements.forEach(function (item) {
+    return fixMathElement(item);
+  });
+};
+
+exports.fixMathElements = fixMathElements;
+
+var adjustMathMLStyle = function adjustMathMLStyle() {
+  var el = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : document;
+  var nodes = el.querySelectorAll('math');
+  nodes.forEach(function (node) {
+    return node.setAttribute('displaystyle', 'true');
+  });
+};
+
+var createPlaceholder = function createPlaceholder(element) {
+  var _element$previousSibl;
+
+  if (!element.previousSibling || !((_element$previousSibl = element.previousSibling.classList) !== null && _element$previousSibl !== void 0 && _element$previousSibl.contains('math-placeholder'))) {
+    var _element$parentNode;
+
+    // Store the original display style before setting it to 'none'
+    element.dataset.originalDisplay = element.style.display || '';
+    element.style.display = 'none';
+    var placeholder = document.createElement('span');
+    placeholder.style.cssText = 'height: 10px; width: 50px; display: inline-block; vertical-align: middle; justify-content: center; background: #fafafa; border-radius: 4px;';
+    placeholder.classList.add('math-placeholder');
+    (_element$parentNode = element.parentNode) === null || _element$parentNode === void 0 ? void 0 : _element$parentNode.insertBefore(placeholder, element);
+  }
+};
+
+var removePlaceholdersAndRestoreDisplay = function removePlaceholdersAndRestoreDisplay() {
+  document.querySelectorAll('.math-placeholder').forEach(function (placeholder) {
+    var _targetElement$datase;
+
+    var targetElement = placeholder.nextElementSibling;
+
+    if (targetElement && ((_targetElement$datase = targetElement.dataset) === null || _targetElement$datase === void 0 ? void 0 : _targetElement$datase.originalDisplay) !== undefined) {
+      targetElement.style.display = targetElement.dataset.originalDisplay;
+      delete targetElement.dataset.originalDisplay;
+    }
+
+    placeholder.remove();
+  });
+};
+
+var removeExcessMjxContainers = function removeExcessMjxContainers(content) {
+  var elements = content.querySelectorAll('[data-latex][data-math-handled="true"]');
+  elements.forEach(function (element) {
+    var mjxContainers = element.querySelectorAll('mjx-container'); // Check if there are more than one mjx-container children.
+
+    if (mjxContainers.length > 1) {
+      for (var i = 1; i < mjxContainers.length; i++) {
+        mjxContainers[i].parentNode.removeChild(mjxContainers[i]);
+      }
+    }
+  });
+};
+
+var renderContentsWithMathJax = function renderContentsWithMathJax(el) {
+  // el sometimes is an array
+  // renderMath is used like that in pie-print-support and pie-element-extensions
+  // there seems to be no reason for that, however, it's better to handle the case here
+  if (el instanceof Array) {
+    el.forEach(function (elNode) {
+      return renderContentWithMathJax(elNode);
+    });
+  } else {
+    renderContentWithMathJax(el);
+  }
+};
+
+var renderContentWithMathJax = function renderContentWithMathJax(executeOn) {
+  executeOn = executeOn || document.body; // this happens for charting - mark-label; we receive a ref which is not yet ready ( el = { current: null })
+  //  we have to fix this in charting
+
+  if (!(executeOn instanceof HTMLElement)) return;
+  fixMathElements(executeOn);
+  adjustMathMLStyle(executeOn);
+  var mathJaxInstance = getGlobal().instance;
+
+  if (mathJaxInstance) {
+    // Reset and clear typesetting before processing the new content
+    // Reset the tex labels (and automatic equation number).
+    mathJaxInstance.texReset(); //  Reset the typesetting system (font caches, etc.)
+
+    mathJaxInstance.typesetClear(); // Use typesetPromise for asynchronous typesetting
+    // Using MathJax.typesetPromise() for asynchronous typesetting to handle situations where additional code needs to be loaded (e.g., for certain TeX commands or characters).
+    // This ensures typesetting waits for any needed resources to load and complete processing, unlike the synchronous MathJax.typeset() which can't handle such dynamic loading.
+
+    mathJaxInstance.typesetPromise([executeOn]).then(function () {
+      try {
+        removePlaceholdersAndRestoreDisplay();
+        removeExcessMjxContainers(executeOn);
+        var updatedDocument = mathJaxInstance.startup.document;
+        var list = updatedDocument.math.list;
+
+        for (var item = list.next; (0, _typeof2["default"])(item.data) !== 'symbol'; item = item.next) {
+          var mathMl = toMMl(item.data.root);
+          var parsedMathMl = mathMl.replaceAll('\n', '');
+          item.data.typesetRoot.setAttribute('data-mathml', parsedMathMl);
+          item.data.typesetRoot.setAttribute('tabindex', '-1');
+        } // If the original input was a string, return the parsed MathML
+
+      } catch (e) {
+        console.error('Error post-processing MathJax typesetting:', e.toString());
+      } // Clearing the document if needed
+
+
+      mathJaxInstance.startup.document.clear();
+    })["catch"](function (error) {
+      //  If there was an internal error, put the message into the output instead
+      console.error('Error in typesetting with MathJax:', error);
+    });
+  }
+};
+
+var convertMathJax2ToMathJax3 = function convertMathJax2ToMathJax3() {
+  // Make MathJax v2 compatible with v3
+  //  https://docs.mathjax.org/en/v3.2-latest/upgrading/v2.html#version-2-compatibility-example
+  //  Replace the require command map with a new one that checks for
+  //    renamed extensions and converts them to the new names.
+  var CommandMap = MathJax._.input.tex.SymbolMap.CommandMap;
+  var requireMap = MathJax.config.startup.requireMap;
+  var RequireLoad = MathJax._.input.tex.require.RequireConfiguration.RequireLoad;
+  var RequireMethods = {
+    Require: function Require(parser, name) {
+      var required = parser.GetArgument(name);
+
+      if (required.match(/[^_a-zA-Z0-9]/) || required === '') {
+        throw new _TexError["default"]('BadPackageName', 'Argument for %1 is not a valid package name', name);
+      }
+
+      if (requireMap.hasOwnProperty(required)) {
+        required = requireMap[required];
+      }
+
+      RequireLoad(parser, required);
+    }
+  };
+  new CommandMap('require', {
+    require: 'Require'
+  }, RequireMethods); //
+  // Add a replacement for MathJax.Callback command
+  //
+
+  MathJax.Callback = function (args) {
+    if (Array.isArray(args)) {
+      if (args.length === 1 && typeof args[0] === 'function') {
+        return args[0];
+      } else if (typeof args[0] === 'string' && args[1] instanceof Object && typeof args[1][args[0]] === 'function') {
+        return Function.bind.apply(args[1][args[0]], args.slice(1));
+      } else if (typeof args[0] === 'function') {
+        return Function.bind.apply(args[0], [window].concat(args.slice(1)));
+      } else if (typeof args[1] === 'function') {
+        return Function.bind.apply(args[1], [args[0]].concat(args.slice(2)));
+      }
+    } else if (typeof args === 'function') {
+      return args;
+    }
+
+    throw Error("Can't make callback from given data");
+  }; //
+  // Add a replacement for MathJax.Hub commands
+  //
+
+
+  MathJax.Hub = {
+    Queue: function Queue() {
+      for (var i = 0, m = arguments.length; i < m; i++) {
+        var fn = MathJax.Callback(arguments[i]);
+        MathJax.startup.promise = MathJax.startup.promise.then(fn);
+      }
+
+      return MathJax.startup.promise;
+    },
+    Typeset: function Typeset(elements, callback) {
+      var promise = MathJax.typesetPromise(elements);
+
+      if (callback) {
+        promise = promise.then(callback);
+      }
+
+      return promise;
+    },
+    Register: {
+      MessageHook: function MessageHook() {
+        console.log('MessageHooks are not supported in version 3');
+      },
+      StartupHook: function StartupHook() {
+        console.log('StartupHooks are not supported in version 3');
+      },
+      LoadHook: function LoadHook() {
+        console.log('LoadHooks are not supported in version 3');
+      }
+    },
+    Config: function Config() {
+      console.log('MathJax configurations should be converted for version 3');
+    }
+  };
+};
+
+var initializeMathJax = function initializeMathJax(callback) {
+  if (window.mathjaxLoadedP) {
+    return;
+  }
+
+  var PreviousMathJaxIsUsed = window.MathJax && window.MathJax.version && window.MathJax.version !== MathJaxVersion && window.MathJax.version[0] === '2';
+  var texConfig = {
+    macros: {
+      parallelogram: "\\lower.2em{\\Huge\\unicode{x25B1}}",
+      overarc: '\\overparen',
+      napprox: '\\not\\approx',
+      longdiv: '\\enclose{longdiv}'
+    },
+    displayMath: [['$$', '$$'], ['\\[', '\\]']]
+  };
+
+  if (PreviousMathJaxIsUsed) {
+    texConfig.autoload = {
+      color: [],
+      // don't autoload the color extension
+      colorv2: ['color'] // do autoload the colorv2 extension
+
+    };
+  } // Create a new promise that resolves when MathJax is ready
+
+
+  window.mathjaxLoadedP = new Promise(function (resolve) {
+    // Set up the MathJax configuration
+    window.MathJax = {
+      startup: {
+        //
+        //  Mapping of old extension names to new ones
+        //
+        requireMap: PreviousMathJaxIsUsed ? {
+          AMSmath: 'ams',
+          AMSsymbols: 'ams',
+          AMScd: 'amscd',
+          HTML: 'html',
+          noErrors: 'noerrors',
+          noUndefined: 'noundefined'
+        } : {},
+        typeset: false,
+        ready: function ready() {
+          if (PreviousMathJaxIsUsed) {
+            convertMathJax2ToMathJax3();
+          }
+
+          var mathjax = MathJax._.mathjax.mathjax;
+          var STATE = MathJax._.core.MathItem.STATE;
+          var Menu = MathJax._.ui.menu.Menu.Menu;
+          var rerender = Menu.prototype.rerender;
+
+          Menu.prototype.rerender = function () {
+            var _this = this;
+
+            var start = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : STATE.TYPESET;
+            mathjax.handleRetriesFor(function () {
+              return rerender.call(_this, start);
+            });
+          };
+
+          MathJax.startup.defaultReady(); // Set the MathJax instance in the global object
+
+          var globalObj = getGlobal();
+          globalObj.instance = MathJax;
+          window.mathjaxLoadedComplete = true;
+          console.log('MathJax has initialised!', new Date().toString()); // in this file, initializeMathJax is called with a callback that has to be executed when MathJax was loaded
+
+          if (callback) {
+            callback();
+          } // but previous versions of math-rendering-accessible they're expecting window.mathjaxLoadedP to be a Promise, so we also keep the
+          //  resolve here;
+
+
+          resolve();
+        }
+      },
+      loader: {
+        load: ['input/mml'],
+        // I just added preLoad: () => {} to prevent the console error: "MathJax.loader.preLoad is not a function",
+        //  which is being called because in math-rendering-accessible/render-math we're having this line:
+        //  import * as mr from '@pie-lib/math-rendering';
+        //  which takes us to: import { AllPackages } from 'mathjax-full/js/input/tex/AllPackages';
+        //  which tries to call MathJax.loader.preLoad.
+        // Understand that AllPackages is NOT needed in math-rendering-accessible, so it is not a problem if we hardcode this function.
+        // The better solution would be for math-rendering-accessible to import math-rendering only IF needed,
+        //  but that's actually complicated and could cause other issues.
+        preLoad: function preLoad() {},
+        // function to call if a component fails to load
+        // eslint-disable-next-line no-console
+        failed: function failed(error) {
+          return console.log("MathJax(".concat(error["package"] || '?', "): ").concat(error.message));
+        }
+      },
+      tex: texConfig,
+      chtml: {
+        fontURL: 'https://unpkg.com/mathjax-full@3.2.2/ts/output/chtml/fonts/tex-woff-v2',
+        displayAlign: 'center'
+      },
+      customKey: '@pie-lib/math-rendering-accessible@1',
+      options: {
+        enableEnrichment: true,
+        sre: {
+          speech: 'deep'
+        },
+        menuOptions: {
+          settings: {
+            assistiveMml: true,
+            collapsible: false,
+            explorer: false
+          }
+        }
+      }
+    }; // Load the MathJax script
+
+    var script = document.createElement('script');
+    script.type = 'text/javascript';
+    script.src = "https://cdn.jsdelivr.net/npm/mathjax@".concat(MathJaxVersion, "/es5/tex-chtml-full.js");
+    script.async = true;
+    document.head.appendChild(script); // at this time of the execution, there's no document.body; setTimeout does the trick
+
+    setTimeout(function () {
+      if (!window.mathjaxLoadedComplete) {
+        var _document, _document$body;
+
+        var mathElements = (_document = document) === null || _document === void 0 ? void 0 : (_document$body = _document.body) === null || _document$body === void 0 ? void 0 : _document$body.querySelectorAll('[data-latex]');
+        (mathElements || []).forEach(createPlaceholder);
+      }
+    });
+  });
+};
+
+exports.initializeMathJax = initializeMathJax;
+
+var renderMath = function renderMath(el, renderOpts) {
+  var usedForMmlOutput = typeof el === 'string';
+  var executeOn = document.body;
+
+  if (!usedForMmlOutput) {
+    // If math-rendering was not available, then:
+    //  If window.mathjaxLoadedComplete, it means that we initialised MathJax using the function from this file,
+    //  and it means MathJax is successfully completed, so we can already use it
+    if (window.mathjaxLoadedComplete) {
+      renderContentsWithMathJax(el);
+    } else if (window.mathjaxLoadedP) {
+      //  However, because there is a small chance that MathJax was initialised by a previous version of math-rendering-accessible,
+      //    we need to keep the old handling method, which means adding the .then.catch on window.mathjaxLoadedP Promise.
+      // We still want to set window.mathjaxLoadedComplete, to prevent adding .then.catch after the first initialization
+      //  (again, in case MathJax was initialised by a previous math-rendering-accessible version)
+      window.mathjaxLoadedP.then(function () {
+        window.mathjaxLoadedComplete = true;
+        renderContentsWithMathJax(el);
+      })["catch"](function (error) {
+        return console.error('Error in initializing MathJax:', error);
+      });
+    }
+  } else {
+    // Here we're handling the case when renderMath is being called for mmlOutput
+    if (window.MathJax && window.mathjaxLoadedP) {
+      var div = document.createElement('div');
+      div.innerHTML = el;
+      executeOn = div;
+
+      try {
+        MathJax.texReset();
+        MathJax.typesetClear();
+        window.MathJax.typeset([executeOn]);
+        var updatedDocument = window.MathJax.startup.document;
+        var list = updatedDocument.math.list;
+        var item = list.next;
+        var mathMl = toMMl(item.data.root);
+        var parsedMathMl = mathMl.replaceAll('\n', '');
+        return parsedMathMl;
+      } catch (error) {
+        console.error('Error rendering math:', error.message);
+      }
+
+      return el;
+    }
+
+    return el;
+  }
+}; // this function calls itself
+
+
+(function () {
+  initializeMathJax(renderContentWithMathJax);
+  window[mathRenderingKEY] = {
+    instance: {
+      Typeset: renderMath
+    }
+  };
+})();
+
+var _default = renderMath;
+exports["default"] = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/render-math.js"],"names":["visitor","SerializedMmlVisitor","toMMl","node","visitTree","NEWLINE_BLOCK_REGEX","NEWLINE_LATEX","mathRenderingKEY","mathRenderingAccessibleKEY","MathJaxVersion","getGlobal","window","fixMathElement","element","dataset","mathHandled","property","textContent","unwrapped","replace","fixMathElements","el","document","mathElements","querySelectorAll","forEach","item","adjustMathMLStyle","nodes","setAttribute","createPlaceholder","previousSibling","classList","contains","originalDisplay","style","display","placeholder","createElement","cssText","add","parentNode","insertBefore","removePlaceholdersAndRestoreDisplay","targetElement","nextElementSibling","undefined","remove","removeExcessMjxContainers","content","elements","mjxContainers","length","i","removeChild","renderContentsWithMathJax","Array","elNode","renderContentWithMathJax","executeOn","body","HTMLElement","mathJaxInstance","instance","texReset","typesetClear","typesetPromise","then","updatedDocument","startup","list","math","next","data","mathMl","root","parsedMathMl","replaceAll","typesetRoot","e","console","error","toString","clear","convertMathJax2ToMathJax3","CommandMap","MathJax","_","input","tex","SymbolMap","requireMap","config","RequireLoad","require","RequireConfiguration","RequireMethods","Require","parser","name","required","GetArgument","match","TexError","hasOwnProperty","Callback","args","isArray","Object","Function","bind","apply","slice","concat","Error","Hub","Queue","m","arguments","fn","promise","Typeset","callback","Register","MessageHook","log","StartupHook","LoadHook","Config","initializeMathJax","mathjaxLoadedP","PreviousMathJaxIsUsed","version","texConfig","macros","parallelogram","overarc","napprox","longdiv","displayMath","autoload","color","colorv2","Promise","resolve","AMSmath","AMSsymbols","AMScd","HTML","noErrors","noUndefined","typeset","ready","mathjax","STATE","core","MathItem","Menu","ui","menu","rerender","prototype","start","TYPESET","handleRetriesFor","call","defaultReady","globalObj","mathjaxLoadedComplete","Date","loader","load","preLoad","failed","message","chtml","fontURL","displayAlign","customKey","options","enableEnrichment","sre","speech","menuOptions","settings","assistiveMml","collapsible","explorer","script","type","src","async","head","appendChild","setTimeout","renderMath","renderOpts","usedForMmlOutput","div","innerHTML"],"mappings":"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","sourcesContent":["import { wrapMath, unWrapMath } from './normalization';\nimport { SerializedMmlVisitor } from 'mathjax-full/js/core/MmlTree/SerializedMmlVisitor';\nimport TexError from 'mathjax-full/js/input/tex/TexError';\n\nconst visitor = new SerializedMmlVisitor();\nconst toMMl = (node) => visitor.visitTree(node);\n\nconst NEWLINE_BLOCK_REGEX = /\\\\embed\\{newLine\\}\\[\\]/g;\nconst NEWLINE_LATEX = '\\\\newline ';\n\nconst mathRenderingKEY = '@pie-lib/math-rendering@2';\nconst mathRenderingAccessibleKEY = '@pie-lib/math-rendering-accessible@1';\n\nexport const MathJaxVersion = '3.2.2';\n\nexport const getGlobal = () => {\n  // TODO does it make sense to use version?\n  // const key = `${pkg.name}@${pkg.version.split('.')[0]}`;\n  // It looks like Ed made this change when he switched from mathjax3 to mathjax-full\n  // I think it was supposed to make sure version 1 (using mathjax3) is not used\n  // in combination with version 2 (using mathjax-full)\n  // TODO higher level wrappers use this instance of math-rendering, and if 2 different instances are used, math rendering is not working\n  //  so I will hardcode this for now until a better solution is found\n  if (typeof window !== 'undefined') {\n    if (!window[mathRenderingAccessibleKEY]) {\n      window[mathRenderingAccessibleKEY] = {};\n    }\n    return window[mathRenderingAccessibleKEY];\n  } else {\n    return {};\n  }\n};\n\nexport const fixMathElement = (element) => {\n  if (element.dataset.mathHandled) {\n    return;\n  }\n\n  let property = 'innerText';\n\n  if (element.textContent) {\n    property = 'textContent';\n  }\n\n  if (element[property]) {\n    element[property] = wrapMath(unWrapMath(element[property]).unwrapped);\n    // because mathquill doesn't understand line breaks, sometimes we end up with custom elements on prompts/rationale/etc.\n    // we need to replace the custom embedded elements with valid latex that Mathjax can understand\n    element[property] = element[property].replace(NEWLINE_BLOCK_REGEX, NEWLINE_LATEX);\n    element.dataset.mathHandled = true;\n  }\n};\n\nexport const fixMathElements = (el = document) => {\n  const mathElements = el.querySelectorAll('[data-latex]');\n\n  mathElements.forEach((item) => fixMathElement(item));\n};\n\nconst adjustMathMLStyle = (el = document) => {\n  const nodes = el.querySelectorAll('math');\n  nodes.forEach((node) => node.setAttribute('displaystyle', 'true'));\n};\n\nconst createPlaceholder = (element) => {\n  if (!element.previousSibling || !element.previousSibling.classList?.contains('math-placeholder')) {\n    // Store the original display style before setting it to 'none'\n    element.dataset.originalDisplay = element.style.display || '';\n    element.style.display = 'none';\n\n    const placeholder = document.createElement('span');\n    placeholder.style.cssText =\n      'height: 10px; width: 50px; display: inline-block; vertical-align: middle; justify-content: center; background: #fafafa; border-radius: 4px;';\n    placeholder.classList.add('math-placeholder');\n    element.parentNode?.insertBefore(placeholder, element);\n  }\n};\n\nconst removePlaceholdersAndRestoreDisplay = () => {\n  document.querySelectorAll('.math-placeholder').forEach((placeholder) => {\n    const targetElement = placeholder.nextElementSibling;\n\n    if (targetElement && targetElement.dataset?.originalDisplay !== undefined) {\n      targetElement.style.display = targetElement.dataset.originalDisplay;\n      delete targetElement.dataset.originalDisplay;\n    }\n\n    placeholder.remove();\n  });\n};\nconst removeExcessMjxContainers = (content) => {\n  const elements = content.querySelectorAll('[data-latex][data-math-handled=\"true\"]');\n\n  elements.forEach((element) => {\n    const mjxContainers = element.querySelectorAll('mjx-container');\n\n    // Check if there are more than one mjx-container children.\n    if (mjxContainers.length > 1) {\n      for (let i = 1; i < mjxContainers.length; i++) {\n        mjxContainers[i].parentNode.removeChild(mjxContainers[i]);\n      }\n    }\n  });\n};\n\nconst renderContentsWithMathJax = (el) => {\n  // el sometimes is an array\n  // renderMath is used like that in pie-print-support and pie-element-extensions\n  // there seems to be no reason for that, however, it's better to handle the case here\n  if (el instanceof Array) {\n    el.forEach((elNode) => renderContentWithMathJax(elNode));\n  } else {\n    renderContentWithMathJax(el);\n  }\n};\n\nconst renderContentWithMathJax = (executeOn) => {\n  executeOn = executeOn || document.body;\n\n  // this happens for charting - mark-label; we receive a ref which is not yet ready ( el = { current: null })\n  //  we have to fix this in charting\n  if (!(executeOn instanceof HTMLElement)) return;\n\n  fixMathElements(executeOn);\n  adjustMathMLStyle(executeOn);\n\n  const mathJaxInstance = getGlobal().instance;\n\n  if (mathJaxInstance) {\n    // Reset and clear typesetting before processing the new content\n    // Reset the tex labels (and automatic equation number).\n\n    mathJaxInstance.texReset();\n\n    //  Reset the typesetting system (font caches, etc.)\n    mathJaxInstance.typesetClear();\n\n    // Use typesetPromise for asynchronous typesetting\n    // Using MathJax.typesetPromise() for asynchronous typesetting to handle situations where additional code needs to be loaded (e.g., for certain TeX commands or characters).\n    // This ensures typesetting waits for any needed resources to load and complete processing, unlike the synchronous MathJax.typeset() which can't handle such dynamic loading.\n    mathJaxInstance\n      .typesetPromise([executeOn])\n      .then(() => {\n        try {\n          removePlaceholdersAndRestoreDisplay();\n          removeExcessMjxContainers(executeOn);\n\n          const updatedDocument = mathJaxInstance.startup.document;\n          const list = updatedDocument.math.list;\n\n          for (let item = list.next; typeof item.data !== 'symbol'; item = item.next) {\n            const mathMl = toMMl(item.data.root);\n            const parsedMathMl = mathMl.replaceAll('\\n', '');\n\n            item.data.typesetRoot.setAttribute('data-mathml', parsedMathMl);\n            item.data.typesetRoot.setAttribute('tabindex', '-1');\n          }\n\n          // If the original input was a string, return the parsed MathML\n        } catch (e) {\n          console.error('Error post-processing MathJax typesetting:', e.toString());\n        }\n\n        // Clearing the document if needed\n        mathJaxInstance.startup.document.clear();\n      })\n      .catch((error) => {\n        //  If there was an internal error, put the message into the output instead\n\n        console.error('Error in typesetting with MathJax:', error);\n      });\n  }\n};\n\nconst convertMathJax2ToMathJax3 = () => {\n  // Make MathJax v2 compatible with v3\n  //  https://docs.mathjax.org/en/v3.2-latest/upgrading/v2.html#version-2-compatibility-example\n  //  Replace the require command map with a new one that checks for\n  //    renamed extensions and converts them to the new names.\n  const CommandMap = MathJax._.input.tex.SymbolMap.CommandMap;\n  const requireMap = MathJax.config.startup.requireMap;\n  const RequireLoad = MathJax._.input.tex.require.RequireConfiguration.RequireLoad;\n  const RequireMethods = {\n    Require: function(parser, name) {\n      let required = parser.GetArgument(name);\n      if (required.match(/[^_a-zA-Z0-9]/) || required === '') {\n        throw new TexError('BadPackageName', 'Argument for %1 is not a valid package name', name);\n      }\n      if (requireMap.hasOwnProperty(required)) {\n        required = requireMap[required];\n      }\n      RequireLoad(parser, required);\n    },\n  };\n\n  new CommandMap('require', { require: 'Require' }, RequireMethods);\n\n  //\n  // Add a replacement for MathJax.Callback command\n  //\n  MathJax.Callback = function(args) {\n    if (Array.isArray(args)) {\n      if (args.length === 1 && typeof args[0] === 'function') {\n        return args[0];\n      } else if (typeof args[0] === 'string' && args[1] instanceof Object && typeof args[1][args[0]] === 'function') {\n        return Function.bind.apply(args[1][args[0]], args.slice(1));\n      } else if (typeof args[0] === 'function') {\n        return Function.bind.apply(args[0], [window].concat(args.slice(1)));\n      } else if (typeof args[1] === 'function') {\n        return Function.bind.apply(args[1], [args[0]].concat(args.slice(2)));\n      }\n    } else if (typeof args === 'function') {\n      return args;\n    }\n    throw Error(\"Can't make callback from given data\");\n  };\n\n  //\n  // Add a replacement for MathJax.Hub commands\n  //\n  MathJax.Hub = {\n    Queue: function() {\n      for (let i = 0, m = arguments.length; i < m; i++) {\n        const fn = MathJax.Callback(arguments[i]);\n        MathJax.startup.promise = MathJax.startup.promise.then(fn);\n      }\n      return MathJax.startup.promise;\n    },\n    Typeset: function(elements, callback) {\n      let promise = MathJax.typesetPromise(elements);\n\n      if (callback) {\n        promise = promise.then(callback);\n      }\n      return promise;\n    },\n    Register: {\n      MessageHook: function() {\n        console.log('MessageHooks are not supported in version 3');\n      },\n      StartupHook: function() {\n        console.log('StartupHooks are not supported in version 3');\n      },\n      LoadHook: function() {\n        console.log('LoadHooks are not supported in version 3');\n      },\n    },\n    Config: function() {\n      console.log('MathJax configurations should be converted for version 3');\n    },\n  };\n};\nexport const initializeMathJax = (callback) => {\n  if (window.mathjaxLoadedP) {\n    return;\n  }\n\n  const PreviousMathJaxIsUsed =\n    window.MathJax &&\n    window.MathJax.version &&\n    window.MathJax.version !== MathJaxVersion &&\n    window.MathJax.version[0] === '2';\n\n  const texConfig = {\n    macros: {\n      parallelogram: '\\\\lower.2em{\\\\Huge\\\\unicode{x25B1}}',\n      overarc: '\\\\overparen',\n      napprox: '\\\\not\\\\approx',\n      longdiv: '\\\\enclose{longdiv}',\n    },\n    displayMath: [\n      ['$$', '$$'],\n      ['\\\\[', '\\\\]'],\n    ],\n  };\n\n  if (PreviousMathJaxIsUsed) {\n    texConfig.autoload = {\n      color: [], // don't autoload the color extension\n      colorv2: ['color'], // do autoload the colorv2 extension\n    };\n  }\n\n  // Create a new promise that resolves when MathJax is ready\n  window.mathjaxLoadedP = new Promise((resolve) => {\n    // Set up the MathJax configuration\n    window.MathJax = {\n      startup: {\n        //\n        //  Mapping of old extension names to new ones\n        //\n        requireMap: PreviousMathJaxIsUsed\n          ? {\n              AMSmath: 'ams',\n              AMSsymbols: 'ams',\n              AMScd: 'amscd',\n              HTML: 'html',\n              noErrors: 'noerrors',\n              noUndefined: 'noundefined',\n            }\n          : {},\n        typeset: false,\n        ready: () => {\n          if (PreviousMathJaxIsUsed) {\n            convertMathJax2ToMathJax3();\n          }\n\n          const { mathjax } = MathJax._.mathjax;\n          const { STATE } = MathJax._.core.MathItem;\n          const { Menu } = MathJax._.ui.menu.Menu;\n          const rerender = Menu.prototype.rerender;\n          Menu.prototype.rerender = function(start = STATE.TYPESET) {\n            mathjax.handleRetriesFor(() => rerender.call(this, start));\n          };\n          MathJax.startup.defaultReady();\n          // Set the MathJax instance in the global object\n\n          const globalObj = getGlobal();\n          globalObj.instance = MathJax;\n\n          window.mathjaxLoadedComplete = true;\n          console.log('MathJax has initialised!', new Date().toString());\n\n          // in this file, initializeMathJax is called with a callback that has to be executed when MathJax was loaded\n          if (callback) {\n            callback();\n          }\n\n          // but previous versions of math-rendering-accessible they're expecting window.mathjaxLoadedP to be a Promise, so we also keep the\n          //  resolve here;\n          resolve();\n        },\n      },\n      loader: {\n        load: ['input/mml'],\n        // I just added preLoad: () => {} to prevent the console error: \"MathJax.loader.preLoad is not a function\",\n        //  which is being called because in math-rendering-accessible/render-math we're having this line:\n        //  import * as mr from '@pie-lib/math-rendering';\n        //  which takes us to: import { AllPackages } from 'mathjax-full/js/input/tex/AllPackages';\n        //  which tries to call MathJax.loader.preLoad.\n        // Understand that AllPackages is NOT needed in math-rendering-accessible, so it is not a problem if we hardcode this function.\n        // The better solution would be for math-rendering-accessible to import math-rendering only IF needed,\n        //  but that's actually complicated and could cause other issues.\n        preLoad: () => {},\n        // function to call if a component fails to load\n        // eslint-disable-next-line no-console\n        failed: (error) => console.log(`MathJax(${error.package || '?'}): ${error.message}`),\n      },\n      tex: texConfig,\n      chtml: {\n        fontURL: 'https://unpkg.com/mathjax-full@3.2.2/ts/output/chtml/fonts/tex-woff-v2',\n        displayAlign: 'center',\n      },\n      customKey: '@pie-lib/math-rendering-accessible@1',\n      options: {\n        enableEnrichment: true,\n        sre: {\n          speech: 'deep',\n        },\n        menuOptions: {\n          settings: {\n            assistiveMml: true,\n            collapsible: false,\n            explorer: false,\n          },\n        },\n      },\n    };\n    // Load the MathJax script\n    const script = document.createElement('script');\n    script.type = 'text/javascript';\n    script.src = `https://cdn.jsdelivr.net/npm/mathjax@${MathJaxVersion}/es5/tex-chtml-full.js`;\n    script.async = true;\n    document.head.appendChild(script);\n\n    // at this time of the execution, there's no document.body; setTimeout does the trick\n    setTimeout(() => {\n      if (!window.mathjaxLoadedComplete) {\n        const mathElements = document?.body?.querySelectorAll('[data-latex]');\n        (mathElements || []).forEach(createPlaceholder);\n      }\n    });\n  });\n};\n\nconst renderMath = (el, renderOpts) => {\n  const usedForMmlOutput = typeof el === 'string';\n  let executeOn = document.body;\n\n  if (!usedForMmlOutput) {\n    // If math-rendering was not available, then:\n    //  If window.mathjaxLoadedComplete, it means that we initialised MathJax using the function from this file,\n    //  and it means MathJax is successfully completed, so we can already use it\n    if (window.mathjaxLoadedComplete) {\n      renderContentsWithMathJax(el);\n    } else if (window.mathjaxLoadedP) {\n      //  However, because there is a small chance that MathJax was initialised by a previous version of math-rendering-accessible,\n      //    we need to keep the old handling method, which means adding the .then.catch on window.mathjaxLoadedP Promise.\n      // We still want to set window.mathjaxLoadedComplete, to prevent adding .then.catch after the first initialization\n      //  (again, in case MathJax was initialised by a previous math-rendering-accessible version)\n      window.mathjaxLoadedP\n        .then(() => {\n          window.mathjaxLoadedComplete = true;\n          renderContentsWithMathJax(el);\n        })\n        .catch((error) => console.error('Error in initializing MathJax:', error));\n    }\n  } else {\n    // Here we're handling the case when renderMath is being called for mmlOutput\n    if (window.MathJax && window.mathjaxLoadedP) {\n      const div = document.createElement('div');\n\n      div.innerHTML = el;\n      executeOn = div;\n\n      try {\n        MathJax.texReset();\n        MathJax.typesetClear();\n        window.MathJax.typeset([executeOn]);\n        const updatedDocument = window.MathJax.startup.document;\n        const list = updatedDocument.math.list;\n        const item = list.next;\n        const mathMl = toMMl(item.data.root);\n\n        const parsedMathMl = mathMl.replaceAll('\\n', '');\n\n        return parsedMathMl;\n      } catch (error) {\n        console.error('Error rendering math:', error.message);\n      }\n\n      return el;\n    }\n\n    return el;\n  }\n};\n\n// this function calls itself\n(function() {\n  initializeMathJax(renderContentWithMathJax);\n\n  window[mathRenderingKEY] = {\n    instance: {\n      Typeset: renderMath,\n    },\n  };\n})();\n\nexport default renderMath;\n"]}

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@pie-lib/math-rendering-accessible",
+  "version": "3.4.0-beta.0",
+  "description": "math rendering utilities",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "lib/index.js",
+  "module": "src/index.js",
+  "author": "pie-framework developers",
+  "license": "ISC",
+  "dependencies": {
+    "debug": "^4.1.1",
+    "lodash": "^4.17.11",
+    "mathjax-full": "3.2.2",
+    "mathml-to-latex": "1.2.0"
+  },
+  "gitHead": "3818c24530f62b5bb9be7a2c6aa5428f13a17e0a",
+  "scripts": {}
+}

package/src/__tests__/mml-to-latex.test.js

@@ -0,0 +1,13 @@
+import React from 'react';
+import mmlToLatex from '../mml-to-latex';
+describe('mmlToLatex', () => {
+  it('should work', () => {
+    const mml =
+      '<math xmlns="http://www.w3.org/1998/Math/MathML">  <mn>2</mn>  <mi>x</mi>  <mtext>&#xA0;</mtext>  <mo>&#x2264;</mo>  <mn>4</mn>  <mi>y</mi>  <mtext>&#xA0;</mtext>  <mo>+</mo>  <mtext>&#xA0;</mtext>  <mn>8</mn> <msqrt>    <mi>h</mi>  </msqrt></math>';
+    // todo revisit this
+    // const latex = '2x\\text{ }\\leq4y\\text{ }+\\text{ }8\\sqrt{h}';
+    const latex = '2 x \\textrm{ } \\leq 4 y \\textrm{ } + \\textrm{ } 8 \\sqrt{h}';
+
+    expect(mmlToLatex(mml)).toEqual(latex);
+  });
+});

package/src/__tests__/normalization.test.js

@@ -0,0 +1,51 @@
+import React from 'react';
+import debug from 'debug';
+import { Data } from 'slate';
+import { BracketTypes, wrapMath, unWrapMath } from '../normalization';
+
+const log = debug('@pie-lib:math-rendering:test:normalization');
+
+describe('normalization', () => {
+  describe('unWrapMath', () => {
+    const assertUnWrap = (html, expected, wrapType) => {
+      it(`innerHTML: ${html} is unWrapped to: ${expected} with wrapType: ${wrapType}`, () => {
+        const out = unWrapMath(html);
+
+        expect(out).toEqual({
+          unwrapped: expected,
+          wrapType: wrapType,
+        });
+      });
+    };
+
+    assertUnWrap('$$<$$', '<', BracketTypes.DOLLAR);
+    assertUnWrap('$<$', '<', BracketTypes.DOLLAR);
+    assertUnWrap('\\(<\\)', '<', BracketTypes.ROUND_BRACKETS);
+    assertUnWrap('\\[<\\]', '<', BracketTypes.ROUND_BRACKETS);
+    assertUnWrap('latex', 'latex', BracketTypes.ROUND_BRACKETS);
+    assertUnWrap('\\displaystyle foo', 'foo', BracketTypes.ROUND_BRACKETS);
+  });
+
+  describe('wrapMath', () => {
+    const assertWrap = (latex, expectedHtml, wrapper) => {
+      wrapper = wrapper || BracketTypes.ROUND_BRACKETS;
+      it(`${latex} is wrapped to: ${expectedHtml}`, () => {
+        const out = wrapMath(latex, wrapper);
+
+        log('out: ', out);
+
+        expect(out).toEqual(expectedHtml);
+      });
+    };
+
+    assertWrap('latex', '\\(latex\\)', BracketTypes.ROUND_BRACKETS);
+    assertWrap('latex', '\\(latex\\)', BracketTypes.SQUARE_BRACKETS);
+    assertWrap('latex', '$latex$', BracketTypes.DOLLAR);
+    assertWrap('latex', '$latex$', BracketTypes.DOUBLE_DOLLAR);
+
+    /**
+     * Note that when this is converted to html it get's escaped - but that's an issue with the slate html-serializer.
+     */
+    assertWrap('<', '\\(<\\)');
+  });
+});