@umoteam/editor-external 9.0.0 → 10.1.0

package/libs/katex/contrib/render-a11y-string.js

@@ -7,15 +7,15 @@
 		var a = typeof exports === 'object' ? factory(require("katex")) : factory(root["katex"]);
 		for(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];
 	}
-})((typeof self !== 'undefined' ? self : this), function(__WEBPACK_EXTERNAL_MODULE__771__) {
+})((typeof self !== 'undefined' ? self : this), function(__WEBPACK_EXTERNAL_MODULE__757__) {
 return /******/ (function() { // webpackBootstrap
 /******/ 	"use strict";
 /******/ 	var __webpack_modules__ = ({
 
-/***/ 771:
+/***/ 757:
 /***/ (function(module) {
 
-module.exports = __WEBPACK_EXTERNAL_MODULE__771__;
+module.exports = __WEBPACK_EXTERNAL_MODULE__757__;
 
 /***/ })
 
@@ -77,9 +77,7 @@ module.exports = __WEBPACK_EXTERNAL_MODULE__771__;
 /******/ 	
 /************************************************************************/
 var __webpack_exports__ = {};
-// This entry need to be wrapped in an IIFE because it need to be isolated against other modules in the chunk.
-!function() {
-/* harmony import */ var katex__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(771);
+/* harmony import */ var katex__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(757);
 /* harmony import */ var katex__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(katex__WEBPACK_IMPORTED_MODULE_0__);
 /**
  * renderA11yString returns a readable string.
@@ -96,9 +94,10 @@ var __webpack_exports__ = {};
  * The commas in the string aim to increase ease of understanding
  * when read by a screenreader.
  */
+
 // NOTE: since we're importing types here these files won't actually be
 // included in the build.
-// $FlowIgnore: we import the types directly anyways
+
 
 const stringMap = {
   "(": "left parenthesis",
@@ -224,14 +223,11 @@ const accentUnderMap = {
   "\\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") {
@@ -242,28 +238,23 @@ const buildString = (str, type, a11yStrings) => {
     ret = relMap[str] || str;
   } else {
     ret = stringMap[str] || str;
-  } // If the text to add is a number and there is already a string
+  }
+
+  // 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])) {
+  const last = a11yStrings[a11yStrings.length - 1];
+  if (/^\d+$/.test(ret) && a11yStrings.length > 0 && typeof last === "string" && /^\d+$/.test(last)) {
     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) {
@@ -277,7 +268,6 @@ const handleObject = (tree, a11yStrings, atomType) => {
         });
         break;
       }
-
     case "accentUnder":
       {
         buildRegion(a11yStrings, a11yStrings => {
@@ -288,67 +278,56 @@ const handleObject = (tree, a11yStrings, atomType) => {
         });
         break;
       }
-
     case "accent-token":
       {
         // Used internally by accent symbols.
         break;
       }
-
     case "atom":
       {
         const {
           text
         } = tree;
-
         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-/, "");
@@ -359,23 +338,19 @@ const handleObject = (tree, a11yStrings, atomType) => {
         });
         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 => {
@@ -383,9 +358,10 @@ const handleObject = (tree, a11yStrings, atomType) => {
           const {
             leftDelim,
             rightDelim
-          } = tree; // NOTE: Not sure if this is a safe assumption
-          // hasBarLine true -> fraction, false -> binomial
+          } = tree;
 
+          // 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);
@@ -406,20 +382,17 @@ const handleObject = (tree, a11yStrings, atomType) => {
         });
         break;
       }
-
     case "hbox":
       {
         buildA11yStrings(tree.body, a11yStrings, atomType);
         break;
       }
-
     case "kern":
       {
         // No op: we don't attempt to present kerning information
         // to the screen reader.
         break;
       }
-
     case "leftright":
       {
         buildRegion(a11yStrings, regionStrings => {
@@ -429,54 +402,45 @@ const handleObject = (tree, a11yStrings, atomType) => {
         });
         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,
           name
         } = tree;
-
         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) {
@@ -486,50 +450,42 @@ const handleObject = (tree, a11yStrings, atomType) => {
         });
         break;
       }
-
     case "pmb":
       {
         a11yStrings.push("bold");
         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 => {
@@ -537,31 +493,26 @@ const handleObject = (tree, a11yStrings, atomType) => {
             body,
             index
           } = tree;
-
           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 {
@@ -570,12 +521,10 @@ const handleObject = (tree, a11yStrings, atomType) => {
           sup
         } = tree;
         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) {
@@ -584,25 +533,20 @@ const handleObject = (tree, a11yStrings, 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
@@ -614,7 +558,6 @@ const handleObject = (tree, a11yStrings, atomType) => {
           });
           break;
         }
-
         buildRegion(a11yStrings, function (regionStrings) {
           regionStrings.push("start text");
           buildA11yStrings(tree.body, regionStrings, atomType);
@@ -622,19 +565,16 @@ const handleObject = (tree, a11yStrings, atomType) => {
         });
         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.
@@ -669,59 +609,44 @@ const handleObject = (tree, a11yStrings, atomType) => {
           });
           break;
         }
-
         throw new Error("KaTeX-a11y: enclose node with " + tree.label + " not supported yet");
       }
-
     case "vcenter":
       {
         buildA11yStrings(tree.body, a11yStrings, atomType);
         break;
       }
-
     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);
@@ -729,12 +654,10 @@ const handleObject = (tree, a11yStrings, atomType) => {
         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);
@@ -742,18 +665,15 @@ const handleObject = (tree, 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
@@ -761,18 +681,15 @@ const handleObject = (tree, a11yStrings, atomType) => {
         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) {
@@ -782,32 +699,27 @@ const handleObject = (tree, a11yStrings, atomType) => {
         });
         break;
       }
-
     case "xArrow":
       {
         throw new Error("KaTeX-a11y: xArrow not implemented yet");
       }
-
     case "cdlabel":
       {
         throw new Error("KaTeX-a11y: cdlabel not implemented yet");
       }
-
     case "cdlabelparent":
       {
         throw new Error("KaTeX-a11y: cdlabelparent 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
-
+        const atomType = tree.mclass.slice(1);
+        // TODO(ts): drop the leading "m" from the values in mclass
         buildA11yStrings(tree.body, a11yStrings, atomType);
         break;
       }
-
     case "mathchoice":
       {
         // TODO: track which style we're using, e.g. display, text, etc.
@@ -815,42 +727,34 @@ const handleObject = (tree, a11yStrings, atomType) => {
         buildA11yStrings(tree.text, a11yStrings, atomType);
         break;
       }
-
     case "htmlmathml":
       {
         buildA11yStrings(tree.mathml, a11yStrings, atomType);
         break;
       }
-
     case "middle":
       {
         buildString(tree.delim, atomType, a11yStrings);
         break;
       }
-
     case "internal":
       {
         // internal nodes are never included in the parse tree
         break;
       }
-
     case "html":
       {
         buildA11yStrings(tree.body, a11yStrings, atomType);
         break;
       }
-
     default:
-      tree.type;
       throw new Error("KaTeX a11y un-recognized type: " + tree.type);
   }
 };
-
 const buildA11yStrings = function (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);
@@ -858,14 +762,12 @@ const buildA11yStrings = function (tree, a11yStrings, atomType) {
   } else {
     handleObject(tree, a11yStrings, atomType);
   }
-
   return a11yStrings;
 };
-
 const flatten = function (array) {
   let result = [];
   array.forEach(function (item) {
-    if (item instanceof Array) {
+    if (Array.isArray(item)) {
       result = result.concat(flatten(item));
     } else {
       result.push(item);
@@ -873,16 +775,12 @@ const flatten = function (array) {
   });
   return result;
 };
-
 const renderA11yString = function (text, settings) {
   const tree = katex__WEBPACK_IMPORTED_MODULE_0___default().__parse(text, settings);
-
   const a11yStrings = buildA11yStrings(tree, [], "normal");
   return flatten(a11yStrings).join(", ");
 };
-
 /* harmony default export */ __webpack_exports__["default"] = (renderA11yString);
-}();
 __webpack_exports__ = __webpack_exports__["default"];
 /******/ 	return __webpack_exports__;
 /******/ })()