@rse/ase 0.0.30 → 0.0.32

package/plugin/node_modules/katex/dist/contrib/render-a11y-string.js

@@ -0,0 +1,827 @@
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory(require("katex"));
+	else if(typeof define === 'function' && define.amd)
+		define(["katex"], factory);
+	else {
+		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__757__) {
+return /******/ (function() { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	var __webpack_modules__ = ({
+
+/***/ 757:
+/***/ (function(module) {
+
+module.exports = __WEBPACK_EXTERNAL_MODULE__757__;
+
+/***/ })
+
+/******/ 	});
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 		if (cachedModule !== undefined) {
+/******/ 			return cachedModule.exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			// no module.id needed
+/******/ 			// no module.loaded needed
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/************************************************************************/
+/******/ 	/* webpack/runtime/compat get default export */
+/******/ 	!function() {
+/******/ 		// getDefaultExport function for compatibility with non-harmony modules
+/******/ 		__webpack_require__.n = function(module) {
+/******/ 			var getter = module && module.__esModule ?
+/******/ 				function() { return module['default']; } :
+/******/ 				function() { return module; };
+/******/ 			__webpack_require__.d(getter, { a: getter });
+/******/ 			return getter;
+/******/ 		};
+/******/ 	}();
+/******/ 	
+/******/ 	/* webpack/runtime/define property getters */
+/******/ 	!function() {
+/******/ 		// define getter functions for harmony exports
+/******/ 		__webpack_require__.d = function(exports, definition) {
+/******/ 			for(var key in definition) {
+/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ 				}
+/******/ 			}
+/******/ 		};
+/******/ 	}();
+/******/ 	
+/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
+/******/ 	!function() {
+/******/ 		__webpack_require__.o = function(obj, prop) { return Object.prototype.hasOwnProperty.call(obj, prop); }
+/******/ 	}();
+/******/ 	
+/************************************************************************/
+var __webpack_exports__ = {};
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  "default": function() { return /* binding */ render_a11y_string; }
+});
+
+;// ./src/atoms.ts
+/**
+ * Small module for atom-group constants and type guard.  Kept separate from
+ * `symbols.ts` so that consumers (notably `contrib/render-a11y-string`) can
+ * pull in `isAtom` without dragging in the ~870-line symbol tables.
+ */
+
+// Some of these have a "-token" suffix since these are also used as `ParseNode`
+// types for raw text tokens, and we want to avoid conflicts with higher-level
+// `ParseNode` types. These `ParseNode`s are constructed within `Parser` by
+// looking up the `symbols` map.
+const ATOMS = {
+  "bin": 1,
+  "close": 1,
+  "inner": 1,
+  "open": 1,
+  "punct": 1,
+  "rel": 1
+};
+const NON_ATOMS = {
+  "accent-token": 1,
+  "mathord": 1,
+  "op-token": 1,
+  "spacing": 1,
+  "textord": 1
+};
+function isAtom(value) {
+  return value in ATOMS;
+}
+// EXTERNAL MODULE: external "katex"
+var external_katex_ = __webpack_require__(757);
+var external_katex_default = /*#__PURE__*/__webpack_require__.n(external_katex_);
+;// ./contrib/render-a11y-string/render-a11y-string.ts
+/**
+ * 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
+  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) {
+    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;
+        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,
+            rightDelim
+          } = 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);
+            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 "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 => {
+          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,
+          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) {
+          a11yStrings.push("start overline");
+          buildA11yStrings(tree.body, a11yStrings, atomType);
+          a11yStrings.push("end overline");
+        });
+        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 => {
+          const {
+            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 {
+          base,
+          sub,
+          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) {
+            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;
+        } else if (/phase/.test(tree.label)) {
+          buildRegion(a11yStrings, function (regionStrings) {
+            regionStrings.push("start phase angle");
+            buildA11yStrings(tree.body, regionStrings, atomType);
+            regionStrings.push("end phase angle");
+          });
+          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 "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 "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.
+        // mclass values are prefixed with "m" (e.g. "mrel" -> "rel")
+        const atomType = tree.mclass.slice(1);
+        if (atomType === "normal" || isAtom(atomType)) {
+          buildA11yStrings(tree.body, a11yStrings, atomType);
+        } else {
+          throw new Error("Unexpected mclass atom type: \"" + atomType + "\"");
+        }
+        break;
+      }
+    case "mathchoice":
+      {
+        // TODO: track which style we're using, e.g. display, 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;
+      }
+    case "internal":
+      {
+        // internal nodes are never included in the parse tree
+        break;
+      }
+    case "html":
+      {
+        buildA11yStrings(tree.body, a11yStrings, atomType);
+        break;
+      }
+    default:
+      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);
+    }
+  } else {
+    handleObject(tree, a11yStrings, atomType);
+  }
+  return a11yStrings;
+};
+const flatten = function (array) {
+  let result = [];
+  array.forEach(function (item) {
+    if (Array.isArray(item)) {
+      result = result.concat(flatten(item));
+    } else {
+      result.push(item);
+    }
+  });
+  return result;
+};
+const renderA11yString = function (text, settings) {
+  const tree = external_katex_default().__parse(text, settings);
+  const a11yStrings = buildA11yStrings(tree, [], "normal");
+  return flatten(a11yStrings).join(", ");
+};
+/* harmony default export */ var render_a11y_string = (renderA11yString);
+__webpack_exports__ = __webpack_exports__["default"];
+/******/ 	return __webpack_exports__;
+/******/ })()
+;
+});