no message

node_modules/mavon-editor/dist/katex/contrib/auto-render.min.js

@@ -0,0 +1 @@
+!function(e,t){"object"==typeof exports&&"object"==typeof module?module.exports=t(require("katex")):"function"==typeof define&&define.amd?define(["katex"],t):"object"==typeof exports?exports.renderMathInElement=t(require("katex")):e.renderMathInElement=t(e.katex)}("undefined"!=typeof self?self:this,function(e){return function(e){var t={};function r(n){if(t[n])return t[n].exports;var o=t[n]={i:n,l:!1,exports:{}};return e[n].call(o.exports,o,o.exports,r),o.l=!0,o.exports}return r.m=e,r.c=t,r.d=function(e,t,n){r.o(e,t)||Object.defineProperty(e,t,{enumerable:!0,get:n})},r.r=function(e){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})},r.t=function(e,t){if(1&t&&(e=r(e)),8&t)return e;if(4&t&&"object"==typeof e&&e&&e.__esModule)return e;var n=Object.create(null);if(r.r(n),Object.defineProperty(n,"default",{enumerable:!0,value:e}),2&t&&"string"!=typeof e)for(var o in e)r.d(n,o,function(t){return e[t]}.bind(null,o));return n},r.n=function(e){var t=e&&e.__esModule?function(){return e.default}:function(){return e};return r.d(t,"a",t),t},r.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},r.p="",r(r.s=1)}([function(t,r){t.exports=e},function(e,t,r){"use strict";r.r(t);var n=r(0),o=r.n(n),a=function(e,t,r){for(var n=r,o=0,a=e.length;n<t.length;){var i=t[n];if(o<=0&&t.slice(n,n+a)===e)return n;"\\"===i?n++:"{"===i?o++:"}"===i&&o--,n++}return-1},i=function(e,t,r,n){for(var o=[],i=0;i<e.length;i++)if("text"===e[i].type){var l=e[i].data,d=!0,s=0,f=void 0;for(-1!==(f=l.indexOf(t))&&(s=f,o.push({type:"text",data:l.slice(0,s)}),d=!1);;){if(d){if(-1===(f=l.indexOf(t,s)))break;o.push({type:"text",data:l.slice(s,f)}),s=f}else{if(-1===(f=a(r,l,s+t.length)))break;o.push({type:"math",data:l.slice(s+t.length,f),rawData:l.slice(s,f+r.length),display:n}),s=f+r.length}d=!d}o.push({type:"text",data:l.slice(s)})}else o.push(e[i]);return o},l=function(e,t){for(var r=function(e,t){for(var r=[{type:"text",data:e}],n=0;n<t.length;n++){var o=t[n];r=i(r,o.left,o.right,o.display||!1)}return r}(e,t.delimiters),n=document.createDocumentFragment(),a=0;a<r.length;a++)if("text"===r[a].type)n.appendChild(document.createTextNode(r[a].data));else{var l=document.createElement("span"),d=r[a].data;t.displayMode=r[a].display;try{t.preProcess&&(d=t.preProcess(d)),o.a.render(d,l,t)}catch(e){if(!(e instanceof o.a.ParseError))throw e;t.errorCallback("KaTeX auto-render: Failed to parse `"+r[a].data+"` with ",e),n.appendChild(document.createTextNode(r[a].rawData));continue}n.appendChild(l)}return n};t.default=function(e,t){if(!e)throw new Error("No element provided to render");var r={};for(var n in t)t.hasOwnProperty(n)&&(r[n]=t[n]);r.delimiters=r.delimiters||[{left:"$$",right:"$$",display:!0},{left:"\\(",right:"\\)",display:!1},{left:"\\[",right:"\\]",display:!0}],r.ignoredTags=r.ignoredTags||["script","noscript","style","textarea","pre","code"],r.ignoredClasses=r.ignoredClasses||[],r.errorCallback=r.errorCallback||console.error,r.macros=r.macros||{},function e(t,r){for(var n=0;n<t.childNodes.length;n++){var o=t.childNodes[n];if(3===o.nodeType){var a=l(o.textContent,r);n+=a.childNodes.length-1,t.replaceChild(a,o)}else 1===o.nodeType&&function(){var t=" "+o.className+" ";-1===r.ignoredTags.indexOf(o.nodeName.toLowerCase())&&r.ignoredClasses.every(function(e){return-1===t.indexOf(" "+e+" ")})&&e(o,r)}()}}(e,r)}}]).default});

node_modules/mavon-editor/dist/katex/contrib/auto-render.mjs

@@ -0,0 +1,215 @@
+import katex from '../katex.mjs';
+
+/* eslint no-constant-condition:0 */
+const findEndOfMath = function findEndOfMath(delimiter, text, startIndex) {
+  // Adapted from
+  // https://github.com/Khan/perseus/blob/master/src/perseus-markdown.jsx
+  let index = startIndex;
+  let braceLevel = 0;
+  const delimLength = delimiter.length;
+
+  while (index < text.length) {
+    const character = text[index];
+
+    if (braceLevel <= 0 && text.slice(index, index + delimLength) === delimiter) {
+      return index;
+    } else if (character === "\\") {
+      index++;
+    } else if (character === "{") {
+      braceLevel++;
+    } else if (character === "}") {
+      braceLevel--;
+    }
+
+    index++;
+  }
+
+  return -1;
+};
+
+const splitAtDelimiters = function splitAtDelimiters(startData, leftDelim, rightDelim, display) {
+  const finalData = [];
+
+  for (let i = 0; i < startData.length; i++) {
+    if (startData[i].type === "text") {
+      const text = startData[i].data;
+      let lookingForLeft = true;
+      let currIndex = 0;
+      let nextIndex;
+      nextIndex = text.indexOf(leftDelim);
+
+      if (nextIndex !== -1) {
+        currIndex = nextIndex;
+        finalData.push({
+          type: "text",
+          data: text.slice(0, currIndex)
+        });
+        lookingForLeft = false;
+      }
+
+      while (true) {
+        if (lookingForLeft) {
+          nextIndex = text.indexOf(leftDelim, currIndex);
+
+          if (nextIndex === -1) {
+            break;
+          }
+
+          finalData.push({
+            type: "text",
+            data: text.slice(currIndex, nextIndex)
+          });
+          currIndex = nextIndex;
+        } else {
+          nextIndex = findEndOfMath(rightDelim, text, currIndex + leftDelim.length);
+
+          if (nextIndex === -1) {
+            break;
+          }
+
+          finalData.push({
+            type: "math",
+            data: text.slice(currIndex + leftDelim.length, nextIndex),
+            rawData: text.slice(currIndex, nextIndex + rightDelim.length),
+            display: display
+          });
+          currIndex = nextIndex + rightDelim.length;
+        }
+
+        lookingForLeft = !lookingForLeft;
+      }
+
+      finalData.push({
+        type: "text",
+        data: text.slice(currIndex)
+      });
+    } else {
+      finalData.push(startData[i]);
+    }
+  }
+
+  return finalData;
+};
+
+/* eslint no-console:0 */
+
+const splitWithDelimiters = function splitWithDelimiters(text, delimiters) {
+  let data = [{
+    type: "text",
+    data: text
+  }];
+
+  for (let i = 0; i < delimiters.length; i++) {
+    const delimiter = delimiters[i];
+    data = splitAtDelimiters(data, delimiter.left, delimiter.right, delimiter.display || false);
+  }
+
+  return data;
+};
+/* Note: optionsCopy is mutated by this method. If it is ever exposed in the
+ * API, we should copy it before mutating.
+ */
+
+
+const renderMathInText = function renderMathInText(text, optionsCopy) {
+  const data = splitWithDelimiters(text, optionsCopy.delimiters);
+  const fragment = document.createDocumentFragment();
+
+  for (let i = 0; i < data.length; i++) {
+    if (data[i].type === "text") {
+      fragment.appendChild(document.createTextNode(data[i].data));
+    } else {
+      const span = document.createElement("span");
+      let math = data[i].data; // Override any display mode defined in the settings with that
+      // defined by the text itself
+
+      optionsCopy.displayMode = data[i].display;
+
+      try {
+        if (optionsCopy.preProcess) {
+          math = optionsCopy.preProcess(math);
+        }
+
+        katex.render(math, span, optionsCopy);
+      } catch (e) {
+        if (!(e instanceof katex.ParseError)) {
+          throw e;
+        }
+
+        optionsCopy.errorCallback("KaTeX auto-render: Failed to parse `" + data[i].data + "` with ", e);
+        fragment.appendChild(document.createTextNode(data[i].rawData));
+        continue;
+      }
+
+      fragment.appendChild(span);
+    }
+  }
+
+  return fragment;
+};
+
+const renderElem = function renderElem(elem, optionsCopy) {
+  for (let i = 0; i < elem.childNodes.length; i++) {
+    const childNode = elem.childNodes[i];
+
+    if (childNode.nodeType === 3) {
+      // Text node
+      const frag = renderMathInText(childNode.textContent, optionsCopy);
+      i += frag.childNodes.length - 1;
+      elem.replaceChild(frag, childNode);
+    } else if (childNode.nodeType === 1) {
+      // Element node
+      const className = ' ' + childNode.className + ' ';
+      const shouldRender = optionsCopy.ignoredTags.indexOf(childNode.nodeName.toLowerCase()) === -1 && optionsCopy.ignoredClasses.every(x => className.indexOf(' ' + x + ' ') === -1);
+
+      if (shouldRender) {
+        renderElem(childNode, optionsCopy);
+      }
+    } // Otherwise, it's something else, and ignore it.
+
+  }
+};
+
+const renderMathInElement = function renderMathInElement(elem, options) {
+  if (!elem) {
+    throw new Error("No element provided to render");
+  }
+
+  const optionsCopy = {}; // Object.assign(optionsCopy, option)
+
+  for (const option in options) {
+    if (options.hasOwnProperty(option)) {
+      optionsCopy[option] = options[option];
+    }
+  } // default options
+
+
+  optionsCopy.delimiters = optionsCopy.delimiters || [{
+    left: "$$",
+    right: "$$",
+    display: true
+  }, {
+    left: "\\(",
+    right: "\\)",
+    display: false
+  }, // LaTeX uses $…$, but it ruins the display of normal `$` in text:
+  // {left: "$", right: "$", display: false},
+  //  \[…\] must come last in this array. Otherwise, renderMathInElement
+  //  will search for \[ before it searches for $$ or  \(
+  // That makes it susceptible to finding a \\[0.3em] row delimiter and
+  // treating it as if it were the start of a KaTeX math zone.
+  {
+    left: "\\[",
+    right: "\\]",
+    display: true
+  }];
+  optionsCopy.ignoredTags = optionsCopy.ignoredTags || ["script", "noscript", "style", "textarea", "pre", "code"];
+  optionsCopy.ignoredClasses = optionsCopy.ignoredClasses || [];
+  optionsCopy.errorCallback = optionsCopy.errorCallback || console.error; // Enable sharing of global macros defined via `\gdef` between different
+  // math elements within a single call to `renderMathInElement`.
+
+  optionsCopy.macros = optionsCopy.macros || {};
+  renderElem(elem, optionsCopy);
+};
+
+export default renderMathInElement;

node_modules/mavon-editor/dist/katex/contrib/copy-tex.min.css

@@ -0,0 +1 @@
+.katex,.katex-display{user-select:all;-moz-user-select:all;-webkit-user-select:all;-ms-user-select:all}

node_modules/mavon-editor/dist/katex/contrib/copy-tex.min.js

@@ -0,0 +1 @@
+!function(e,t){if("object"==typeof exports&&"object"==typeof module)module.exports=t();else if("function"==typeof define&&define.amd)define([],t);else{var n=t();for(var r in n)("object"==typeof exports?exports:e)[r]=n[r]}}("undefined"!=typeof self?self:this,function(){return function(e){var t={};function n(r){if(t[r])return t[r].exports;var o=t[r]={i:r,l:!1,exports:{}};return e[r].call(o.exports,o,o.exports,n),o.l=!0,o.exports}return n.m=e,n.c=t,n.d=function(e,t,r){n.o(e,t)||Object.defineProperty(e,t,{enumerable:!0,get:r})},n.r=function(e){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})},n.t=function(e,t){if(1&t&&(e=n(e)),8&t)return e;if(4&t&&"object"==typeof e&&e&&e.__esModule)return e;var r=Object.create(null);if(n.r(r),Object.defineProperty(r,"default",{enumerable:!0,value:e}),2&t&&"string"!=typeof e)for(var o in e)n.d(r,o,function(t){return e[t]}.bind(null,o));return r},n.n=function(e){var t=e&&e.__esModule?function(){return e.default}:function(){return e};return n.d(t,"a",t),t},n.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},n.p="",n(n.s=1)}([function(e,t,n){},function(e,t,n){"use strict";n.r(t);n(0);var r={inline:["$","$"],display:["$$","$$"]},o=function(e,t){void 0===t&&(t=r);for(var n=e.querySelectorAll(".katex-mathml + .katex-html"),o=0;o<n.length;o++){var l=n[o];l.remove?l.remove(null):l.parentNode.removeChild(l)}for(var i=e.querySelectorAll(".katex-mathml"),a=0;a<i.length;a++){var u=i[a],f=u.querySelector("annotation");f&&(u.replaceWith?u.replaceWith(f):u.parentNode.replaceChild(f,u),f.innerHTML=t.inline[0]+f.innerHTML+t.inline[1])}for(var c=e.querySelectorAll(".katex-display annotation"),d=0;d<c.length;d++){var p=c[d];p.innerHTML=t.display[0]+p.innerHTML.substr(t.inline[0].length,p.innerHTML.length-t.inline[0].length-t.inline[1].length)+t.display[1]}return e};document.addEventListener("copy",function(e){var t=window.getSelection();if(!t.isCollapsed){var n=t.getRangeAt(0).cloneContents();if(n.querySelector(".katex-mathml")){for(var r=[],l=0;l<n.childNodes.length;l++)r.push(n.childNodes[l].outerHTML);e.clipboardData.setData("text/html",r.join("")),e.clipboardData.setData("text/plain",o(n).textContent),e.preventDefault()}}})}]).default});

node_modules/mavon-editor/dist/katex/contrib/copy-tex.mjs

@@ -0,0 +1,85 @@
+// Set these to how you want inline and display math to be delimited.
+const defaultCopyDelimiters = {
+  inline: ['$', '$'],
+  // alternative: ['\(', '\)']
+  display: ['$$', '$$'] // alternative: ['\[', '\]']
+
+}; // Replace .katex elements with their TeX source (<annotation> element).
+// Modifies fragment in-place.  Useful for writing your own 'copy' handler,
+// as in copy-tex.js.
+
+const katexReplaceWithTex = function katexReplaceWithTex(fragment, copyDelimiters) {
+  if (copyDelimiters === void 0) {
+    copyDelimiters = defaultCopyDelimiters;
+  }
+
+  // Remove .katex-html blocks that are preceded by .katex-mathml blocks
+  // (which will get replaced below).
+  const katexHtml = fragment.querySelectorAll('.katex-mathml + .katex-html');
+
+  for (let i = 0; i < katexHtml.length; i++) {
+    const element = katexHtml[i];
+
+    if (element.remove) {
+      element.remove(null);
+    } else {
+      element.parentNode.removeChild(element);
+    }
+  } // Replace .katex-mathml elements with their annotation (TeX source)
+  // descendant, with inline delimiters.
+
+
+  const katexMathml = fragment.querySelectorAll('.katex-mathml');
+
+  for (let i = 0; i < katexMathml.length; i++) {
+    const element = katexMathml[i];
+    const texSource = element.querySelector('annotation');
+
+    if (texSource) {
+      if (element.replaceWith) {
+        element.replaceWith(texSource);
+      } else {
+        element.parentNode.replaceChild(texSource, element);
+      }
+
+      texSource.innerHTML = copyDelimiters.inline[0] + texSource.innerHTML + copyDelimiters.inline[1];
+    }
+  } // Switch display math to display delimiters.
+
+
+  const displays = fragment.querySelectorAll('.katex-display annotation');
+
+  for (let i = 0; i < displays.length; i++) {
+    const element = displays[i];
+    element.innerHTML = copyDelimiters.display[0] + element.innerHTML.substr(copyDelimiters.inline[0].length, element.innerHTML.length - copyDelimiters.inline[0].length - copyDelimiters.inline[1].length) + copyDelimiters.display[1];
+  }
+
+  return fragment;
+};
+
+document.addEventListener('copy', function (event) {
+  const selection = window.getSelection();
+
+  if (selection.isCollapsed) {
+    return; // default action OK if selection is empty
+  }
+
+  const fragment = selection.getRangeAt(0).cloneContents();
+
+  if (!fragment.querySelector('.katex-mathml')) {
+    return; // default action OK if no .katex-mathml elements
+  } // Preserve usual HTML copy/paste behavior.
+
+
+  const html = [];
+
+  for (let i = 0; i < fragment.childNodes.length; i++) {
+    html.push(fragment.childNodes[i].outerHTML);
+  }
+
+  event.clipboardData.setData('text/html', html.join('')); // Rewrite plain-text version.
+
+  event.clipboardData.setData('text/plain', katexReplaceWithTex(fragment).textContent); // Prevent normal copy handling.
+
+  event.preventDefault();
+});

node_modules/mavon-editor/dist/katex/contrib/mathtex-script-type.min.js

@@ -0,0 +1 @@
+!function(e,t){if("object"==typeof exports&&"object"==typeof module)module.exports=t(require("katex"));else if("function"==typeof define&&define.amd)define(["katex"],t);else{var r="object"==typeof exports?t(require("katex")):t(e.katex);for(var n in r)("object"==typeof exports?exports:e)[n]=r[n]}}("undefined"!=typeof self?self:this,function(e){return function(e){var t={};function r(n){if(t[n])return t[n].exports;var o=t[n]={i:n,l:!1,exports:{}};return e[n].call(o.exports,o,o.exports,r),o.l=!0,o.exports}return r.m=e,r.c=t,r.d=function(e,t,n){r.o(e,t)||Object.defineProperty(e,t,{enumerable:!0,get:n})},r.r=function(e){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})},r.t=function(e,t){if(1&t&&(e=r(e)),8&t)return e;if(4&t&&"object"==typeof e&&e&&e.__esModule)return e;var n=Object.create(null);if(r.r(n),Object.defineProperty(n,"default",{enumerable:!0,value:e}),2&t&&"string"!=typeof e)for(var o in e)r.d(n,o,function(t){return e[t]}.bind(null,o));return n},r.n=function(e){var t=e&&e.__esModule?function(){return e.default}:function(){return e};return r.d(t,"a",t),t},r.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},r.p="",r(r.s=1)}([function(t,r){t.exports=e},function(e,t,r){"use strict";r.r(t);var n=r(0),o=r.n(n),u=document.body.getElementsByTagName("script");(u=Array.prototype.slice.call(u)).forEach(function(e){if(!e.type||!e.type.match(/math\/tex/i))return-1;var t=null!=e.type.match(/mode\s*=\s*display(;|\s|\n|$)/),r=document.createElement(t?"div":"span");r.setAttribute("class",t?"equation":"inline-equation");try{o.a.render(e.text,r,{displayMode:t})}catch(t){r.textContent=e.text}e.parentNode.replaceChild(r,e)})}]).default});

node_modules/mavon-editor/dist/katex/contrib/mathtex-script-type.mjs

@@ -0,0 +1,24 @@
+import katex from '../katex.mjs';
+
+let scripts = document.body.getElementsByTagName("script");
+scripts = Array.prototype.slice.call(scripts);
+scripts.forEach(function (script) {
+  if (!script.type || !script.type.match(/math\/tex/i)) {
+    return -1;
+  }
+
+  const display = script.type.match(/mode\s*=\s*display(;|\s|\n|$)/) != null;
+  const katexElement = document.createElement(display ? "div" : "span");
+  katexElement.setAttribute("class", display ? "equation" : "inline-equation");
+
+  try {
+    katex.render(script.text, katexElement, {
+      displayMode: display
+    });
+  } catch (err) {
+    //console.error(err); linter doesn't like this
+    katexElement.textContent = script.text;
+  }
+
+  script.parentNode.replaceChild(katexElement, script);
+});

node_modules/mavon-editor/dist/katex/contrib/render-a11y-string.mjs

@@ -0,0 +1,741 @@
+import katex from '../katex.mjs';
+
+/**
+ * renderA11yString returns a readable string.
+ *
+ * In some cases the string will have the proper semantic math
+ * meaning,:
+ *   renderA11yString("\\frac{1}{2}"")
+ *   -> "start fraction, 1, divided by, 2, end fraction"
+ *
+ * However, other cases do not:
+ *   renderA11yString("f(x) = x^2")
+ *   -> "f, left parenthesis, x, right parenthesis, equals, x, squared"
+ *
+ * The commas in the string aim to increase ease of understanding
+ * when read by a screenreader.
+ */
+const stringMap = {
+  "(": "left parenthesis",
+  ")": "right parenthesis",
+  "[": "open bracket",
+  "]": "close bracket",
+  "\\{": "left brace",
+  "\\}": "right brace",
+  "\\lvert": "open vertical bar",
+  "\\rvert": "close vertical bar",
+  "|": "vertical bar",
+  "\\uparrow": "up arrow",
+  "\\Uparrow": "up arrow",
+  "\\downarrow": "down arrow",
+  "\\Downarrow": "down arrow",
+  "\\updownarrow": "up down arrow",
+  "\\leftarrow": "left arrow",
+  "\\Leftarrow": "left arrow",
+  "\\rightarrow": "right arrow",
+  "\\Rightarrow": "right arrow",
+  "\\langle": "open angle",
+  "\\rangle": "close angle",
+  "\\lfloor": "open floor",
+  "\\rfloor": "close floor",
+  "\\int": "integral",
+  "\\intop": "integral",
+  "\\lim": "limit",
+  "\\ln": "natural log",
+  "\\log": "log",
+  "\\sin": "sine",
+  "\\cos": "cosine",
+  "\\tan": "tangent",
+  "\\cot": "cotangent",
+  "\\sum": "sum",
+  "/": "slash",
+  ",": "comma",
+  ".": "point",
+  "-": "negative",
+  "+": "plus",
+  "~": "tilde",
+  ":": "colon",
+  "?": "question mark",
+  "'": "apostrophe",
+  "\\%": "percent",
+  " ": "space",
+  "\\ ": "space",
+  "\\$": "dollar sign",
+  "\\angle": "angle",
+  "\\degree": "degree",
+  "\\circ": "circle",
+  "\\vec": "vector",
+  "\\triangle": "triangle",
+  "\\pi": "pi",
+  "\\prime": "prime",
+  "\\infty": "infinity",
+  "\\alpha": "alpha",
+  "\\beta": "beta",
+  "\\gamma": "gamma",
+  "\\omega": "omega",
+  "\\theta": "theta",
+  "\\sigma": "sigma",
+  "\\lambda": "lambda",
+  "\\tau": "tau",
+  "\\Delta": "delta",
+  "\\delta": "delta",
+  "\\mu": "mu",
+  "\\rho": "rho",
+  "\\nabla": "del",
+  "\\ell": "ell",
+  "\\ldots": "dots",
+  // TODO: add entries for all accents
+  "\\hat": "hat",
+  "\\acute": "acute"
+};
+const powerMap = {
+  "prime": "prime",
+  "degree": "degrees",
+  "circle": "degrees",
+  "2": "squared",
+  "3": "cubed"
+};
+const openMap = {
+  "|": "open vertical bar",
+  ".": ""
+};
+const closeMap = {
+  "|": "close vertical bar",
+  ".": ""
+};
+const binMap = {
+  "+": "plus",
+  "-": "minus",
+  "\\pm": "plus minus",
+  "\\cdot": "dot",
+  "*": "times",
+  "/": "divided by",
+  "\\times": "times",
+  "\\div": "divided by",
+  "\\circ": "circle",
+  "\\bullet": "bullet"
+};
+const relMap = {
+  "=": "equals",
+  "\\approx": "approximately equals",
+  "≠": "does not equal",
+  "\\geq": "is greater than or equal to",
+  "\\ge": "is greater than or equal to",
+  "\\leq": "is less than or equal to",
+  "\\le": "is less than or equal to",
+  ">": "is greater than",
+  "<": "is less than",
+  "\\leftarrow": "left arrow",
+  "\\Leftarrow": "left arrow",
+  "\\rightarrow": "right arrow",
+  "\\Rightarrow": "right arrow",
+  ":": "colon"
+};
+const accentUnderMap = {
+  "\\underleftarrow": "left arrow",
+  "\\underrightarrow": "right arrow",
+  "\\underleftrightarrow": "left-right arrow",
+  "\\undergroup": "group",
+  "\\underlinesegment": "line segment",
+  "\\utilde": "tilde"
+};
+
+const buildString = (str, type, a11yStrings) => {
+  if (!str) {
+    return;
+  }
+
+  let ret;
+
+  if (type === "open") {
+    ret = str in openMap ? openMap[str] : stringMap[str] || str;
+  } else if (type === "close") {
+    ret = str in closeMap ? closeMap[str] : stringMap[str] || str;
+  } else if (type === "bin") {
+    ret = binMap[str] || str;
+  } else if (type === "rel") {
+    ret = relMap[str] || str;
+  } else {
+    ret = stringMap[str] || str;
+  } // If the text to add is a number and there is already a string
+  // in the list and the last string is a number then we should
+  // combine them into a single number
+
+
+  if (/^\d+$/.test(ret) && a11yStrings.length > 0 && // TODO(kevinb): check that the last item in a11yStrings is a string
+  // I think we might be able to drop the nested arrays, which would make
+  // this easier to type - $FlowFixMe
+  /^\d+$/.test(a11yStrings[a11yStrings.length - 1])) {
+    a11yStrings[a11yStrings.length - 1] += ret;
+  } else if (ret) {
+    a11yStrings.push(ret);
+  }
+};
+
+const buildRegion = (a11yStrings, callback) => {
+  const regionStrings = [];
+  a11yStrings.push(regionStrings);
+  callback(regionStrings);
+};
+
+const handleObject = (tree, a11yStrings, atomType) => {
+  // Everything else is assumed to be an object...
+  switch (tree.type) {
+    case "accent":
+      {
+        buildRegion(a11yStrings, a11yStrings => {
+          buildA11yStrings(tree.base, a11yStrings, atomType);
+          a11yStrings.push("with");
+          buildString(tree.label, "normal", a11yStrings);
+          a11yStrings.push("on top");
+        });
+        break;
+      }
+
+    case "accentUnder":
+      {
+        buildRegion(a11yStrings, a11yStrings => {
+          buildA11yStrings(tree.base, a11yStrings, atomType);
+          a11yStrings.push("with");
+          buildString(accentUnderMap[tree.label], "normal", a11yStrings);
+          a11yStrings.push("underneath");
+        });
+        break;
+      }
+
+    case "accent-token":
+      {
+        // Used internally by accent symbols.
+        break;
+      }
+
+    case "atom":
+      {
+        const text = tree.text;
+
+        switch (tree.family) {
+          case "bin":
+            {
+              buildString(text, "bin", a11yStrings);
+              break;
+            }
+
+          case "close":
+            {
+              buildString(text, "close", a11yStrings);
+              break;
+            }
+          // TODO(kevinb): figure out what should be done for inner
+
+          case "inner":
+            {
+              buildString(tree.text, "inner", a11yStrings);
+              break;
+            }
+
+          case "open":
+            {
+              buildString(text, "open", a11yStrings);
+              break;
+            }
+
+          case "punct":
+            {
+              buildString(text, "punct", a11yStrings);
+              break;
+            }
+
+          case "rel":
+            {
+              buildString(text, "rel", a11yStrings);
+              break;
+            }
+
+          default:
+            {
+              tree.family;
+              throw new Error(`"${tree.family}" is not a valid atom type`);
+            }
+        }
+
+        break;
+      }
+
+    case "color":
+      {
+        const color = tree.color.replace(/katex-/, "");
+        buildRegion(a11yStrings, regionStrings => {
+          regionStrings.push("start color " + color);
+          buildA11yStrings(tree.body, regionStrings, atomType);
+          regionStrings.push("end color " + color);
+        });
+        break;
+      }
+
+    case "color-token":
+      {
+        // Used by \color, \colorbox, and \fcolorbox but not directly rendered.
+        // It's a leaf node and has no children so just break.
+        break;
+      }
+
+    case "delimsizing":
+      {
+        if (tree.delim && tree.delim !== ".") {
+          buildString(tree.delim, "normal", a11yStrings);
+        }
+
+        break;
+      }
+
+    case "genfrac":
+      {
+        buildRegion(a11yStrings, regionStrings => {
+          // genfrac can have unbalanced delimiters
+          const leftDelim = tree.leftDelim,
+                rightDelim = tree.rightDelim; // NOTE: Not sure if this is a safe assumption
+          // hasBarLine true -> fraction, false -> binomial
+
+          if (tree.hasBarLine) {
+            regionStrings.push("start fraction");
+            leftDelim && buildString(leftDelim, "open", regionStrings);
+            buildA11yStrings(tree.numer, regionStrings, atomType);
+            regionStrings.push("divided by");
+            buildA11yStrings(tree.denom, regionStrings, atomType);
+            rightDelim && buildString(rightDelim, "close", regionStrings);
+            regionStrings.push("end fraction");
+          } else {
+            regionStrings.push("start binomial");
+            leftDelim && buildString(leftDelim, "open", regionStrings);
+            buildA11yStrings(tree.numer, regionStrings, atomType);
+            regionStrings.push("over");
+            buildA11yStrings(tree.denom, regionStrings, atomType);
+            rightDelim && buildString(rightDelim, "close", regionStrings);
+            regionStrings.push("end binomial");
+          }
+        });
+        break;
+      }
+
+    case "kern":
+      {
+        // No op: we don't attempt to present kerning information
+        // to the screen reader.
+        break;
+      }
+
+    case "leftright":
+      {
+        buildRegion(a11yStrings, regionStrings => {
+          buildString(tree.left, "open", regionStrings);
+          buildA11yStrings(tree.body, regionStrings, atomType);
+          buildString(tree.right, "close", regionStrings);
+        });
+        break;
+      }
+
+    case "leftright-right":
+      {
+        // TODO: double check that this is a no-op
+        break;
+      }
+
+    case "lap":
+      {
+        buildA11yStrings(tree.body, a11yStrings, atomType);
+        break;
+      }
+
+    case "mathord":
+      {
+        buildString(tree.text, "normal", a11yStrings);
+        break;
+      }
+
+    case "op":
+      {
+        const body = tree.body,
+              name = tree.name;
+
+        if (body) {
+          buildA11yStrings(body, a11yStrings, atomType);
+        } else if (name) {
+          buildString(name, "normal", a11yStrings);
+        }
+
+        break;
+      }
+
+    case "op-token":
+      {
+        // Used internally by operator symbols.
+        buildString(tree.text, atomType, a11yStrings);
+        break;
+      }
+
+    case "ordgroup":
+      {
+        buildA11yStrings(tree.body, a11yStrings, atomType);
+        break;
+      }
+
+    case "overline":
+      {
+        buildRegion(a11yStrings, function (a11yStrings) {
+          a11yStrings.push("start overline");
+          buildA11yStrings(tree.body, a11yStrings, atomType);
+          a11yStrings.push("end overline");
+        });
+        break;
+      }
+
+    case "phantom":
+      {
+        a11yStrings.push("empty space");
+        break;
+      }
+
+    case "raisebox":
+      {
+        buildA11yStrings(tree.body, a11yStrings, atomType);
+        break;
+      }
+
+    case "rule":
+      {
+        a11yStrings.push("rectangle");
+        break;
+      }
+
+    case "sizing":
+      {
+        buildA11yStrings(tree.body, a11yStrings, atomType);
+        break;
+      }
+
+    case "spacing":
+      {
+        a11yStrings.push("space");
+        break;
+      }
+
+    case "styling":
+      {
+        // We ignore the styling and just pass through the contents
+        buildA11yStrings(tree.body, a11yStrings, atomType);
+        break;
+      }
+
+    case "sqrt":
+      {
+        buildRegion(a11yStrings, regionStrings => {
+          const body = tree.body,
+                index = tree.index;
+
+          if (index) {
+            const indexString = flatten(buildA11yStrings(index, [], atomType)).join(",");
+
+            if (indexString === "3") {
+              regionStrings.push("cube root of");
+              buildA11yStrings(body, regionStrings, atomType);
+              regionStrings.push("end cube root");
+              return;
+            }
+
+            regionStrings.push("root");
+            regionStrings.push("start index");
+            buildA11yStrings(index, regionStrings, atomType);
+            regionStrings.push("end index");
+            return;
+          }
+
+          regionStrings.push("square root of");
+          buildA11yStrings(body, regionStrings, atomType);
+          regionStrings.push("end square root");
+        });
+        break;
+      }
+
+    case "supsub":
+      {
+        const base = tree.base,
+              sub = tree.sub,
+              sup = tree.sup;
+        let isLog = false;
+
+        if (base) {
+          buildA11yStrings(base, a11yStrings, atomType);
+          isLog = base.type === "op" && base.name === "\\log";
+        }
+
+        if (sub) {
+          const regionName = isLog ? "base" : "subscript";
+          buildRegion(a11yStrings, function (regionStrings) {
+            regionStrings.push(`start ${regionName}`);
+            buildA11yStrings(sub, regionStrings, atomType);
+            regionStrings.push(`end ${regionName}`);
+          });
+        }
+
+        if (sup) {
+          buildRegion(a11yStrings, function (regionStrings) {
+            const supString = flatten(buildA11yStrings(sup, [], atomType)).join(",");
+
+            if (supString in powerMap) {
+              regionStrings.push(powerMap[supString]);
+              return;
+            }
+
+            regionStrings.push("start superscript");
+            buildA11yStrings(sup, regionStrings, atomType);
+            regionStrings.push("end superscript");
+          });
+        }
+
+        break;
+      }
+
+    case "text":
+      {
+        // TODO: handle other fonts
+        if (tree.font === "\\textbf") {
+          buildRegion(a11yStrings, function (regionStrings) {
+            regionStrings.push("start bold text");
+            buildA11yStrings(tree.body, regionStrings, atomType);
+            regionStrings.push("end bold text");
+          });
+          break;
+        }
+
+        buildRegion(a11yStrings, function (regionStrings) {
+          regionStrings.push("start text");
+          buildA11yStrings(tree.body, regionStrings, atomType);
+          regionStrings.push("end text");
+        });
+        break;
+      }
+
+    case "textord":
+      {
+        buildString(tree.text, atomType, a11yStrings);
+        break;
+      }
+
+    case "smash":
+      {
+        buildA11yStrings(tree.body, a11yStrings, atomType);
+        break;
+      }
+
+    case "enclose":
+      {
+        // TODO: create a map for these.
+        // TODO: differentiate between a body with a single atom, e.g.
+        // "cancel a" instead of "start cancel, a, end cancel"
+        if (/cancel/.test(tree.label)) {
+          buildRegion(a11yStrings, function (regionStrings) {
+            regionStrings.push("start cancel");
+            buildA11yStrings(tree.body, regionStrings, atomType);
+            regionStrings.push("end cancel");
+          });
+          break;
+        } else if (/box/.test(tree.label)) {
+          buildRegion(a11yStrings, function (regionStrings) {
+            regionStrings.push("start box");
+            buildA11yStrings(tree.body, regionStrings, atomType);
+            regionStrings.push("end box");
+          });
+          break;
+        } else if (/sout/.test(tree.label)) {
+          buildRegion(a11yStrings, function (regionStrings) {
+            regionStrings.push("start strikeout");
+            buildA11yStrings(tree.body, regionStrings, atomType);
+            regionStrings.push("end strikeout");
+          });
+          break;
+        }
+
+        throw new Error(`KaTeX-a11y: enclose node with ${tree.label} not supported yet`);
+      }
+
+    case "vphantom":
+      {
+        throw new Error("KaTeX-a11y: vphantom not implemented yet");
+      }
+
+    case "hphantom":
+      {
+        throw new Error("KaTeX-a11y: hphantom not implemented yet");
+      }
+
+    case "operatorname":
+      {
+        buildA11yStrings(tree.body, a11yStrings, atomType);
+        break;
+      }
+
+    case "array":
+      {
+        throw new Error("KaTeX-a11y: array not implemented yet");
+      }
+
+    case "raw":
+      {
+        throw new Error("KaTeX-a11y: raw not implemented yet");
+      }
+
+    case "size":
+      {
+        // Although there are nodes of type "size" in the parse tree, they have
+        // no semantic meaning and should be ignored.
+        break;
+      }
+
+    case "url":
+      {
+        throw new Error("KaTeX-a11y: url not implemented yet");
+      }
+
+    case "tag":
+      {
+        throw new Error("KaTeX-a11y: tag not implemented yet");
+      }
+
+    case "verb":
+      {
+        buildString(`start verbatim`, "normal", a11yStrings);
+        buildString(tree.body, "normal", a11yStrings);
+        buildString(`end verbatim`, "normal", a11yStrings);
+        break;
+      }
+
+    case "environment":
+      {
+        throw new Error("KaTeX-a11y: environment not implemented yet");
+      }
+
+    case "horizBrace":
+      {
+        buildString(`start ${tree.label.slice(1)}`, "normal", a11yStrings);
+        buildA11yStrings(tree.base, a11yStrings, atomType);
+        buildString(`end ${tree.label.slice(1)}`, "normal", a11yStrings);
+        break;
+      }
+
+    case "infix":
+      {
+        // All infix nodes are replace with other nodes.
+        break;
+      }
+
+    case "includegraphics":
+      {
+        throw new Error("KaTeX-a11y: includegraphics not implemented yet");
+      }
+
+    case "font":
+      {
+        // TODO: callout the start/end of specific fonts
+        // TODO: map \BBb{N} to "the naturals" or something like that
+        buildA11yStrings(tree.body, a11yStrings, atomType);
+        break;
+      }
+
+    case "href":
+      {
+        throw new Error("KaTeX-a11y: href not implemented yet");
+      }
+
+    case "cr":
+      {
+        // This is used by environments.
+        throw new Error("KaTeX-a11y: cr not implemented yet");
+      }
+
+    case "underline":
+      {
+        buildRegion(a11yStrings, function (a11yStrings) {
+          a11yStrings.push("start underline");
+          buildA11yStrings(tree.body, a11yStrings, atomType);
+          a11yStrings.push("end underline");
+        });
+        break;
+      }
+
+    case "xArrow":
+      {
+        throw new Error("KaTeX-a11y: xArrow not implemented yet");
+      }
+
+    case "mclass":
+      {
+        // \neq and \ne are macros so we let "htmlmathml" render the mathmal
+        // side of things and extract the text from that.
+        const atomType = tree.mclass.slice(1); // $FlowFixMe: drop the leading "m" from the values in mclass
+
+        buildA11yStrings(tree.body, a11yStrings, atomType);
+        break;
+      }
+
+    case "mathchoice":
+      {
+        // TODO: track which which style we're using, e.g. dispaly, text, etc.
+        // default to text style if even that may not be the correct style
+        buildA11yStrings(tree.text, a11yStrings, atomType);
+        break;
+      }
+
+    case "htmlmathml":
+      {
+        buildA11yStrings(tree.mathml, a11yStrings, atomType);
+        break;
+      }
+
+    case "middle":
+      {
+        buildString(tree.delim, atomType, a11yStrings);
+        break;
+      }
+
+    default:
+      tree.type;
+      throw new Error("KaTeX a11y un-recognized type: " + tree.type);
+  }
+};
+
+const buildA11yStrings = function buildA11yStrings(tree, a11yStrings, atomType) {
+  if (a11yStrings === void 0) {
+    a11yStrings = [];
+  }
+
+  if (tree instanceof Array) {
+    for (let i = 0; i < tree.length; i++) {
+      buildA11yStrings(tree[i], a11yStrings, atomType);
+    }
+  } else {
+    handleObject(tree, a11yStrings, atomType);
+  }
+
+  return a11yStrings;
+};
+
+const flatten = function flatten(array) {
+  let result = [];
+  array.forEach(function (item) {
+    if (item instanceof Array) {
+      result = result.concat(flatten(item));
+    } else {
+      result.push(item);
+    }
+  });
+  return result;
+};
+
+const renderA11yString = function renderA11yString(text, settings) {
+  const tree = katex.__parse(text, settings);
+
+  const a11yStrings = buildA11yStrings(tree, [], "normal");
+  return flatten(a11yStrings).join(", ");
+};
+
+export default renderA11yString;