| (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__0__) { |
| return /******/ (function(modules) { // webpackBootstrap |
| /******/ // The module cache |
| /******/ var installedModules = {}; |
| /******/ |
| /******/ // The require function |
| /******/ function __webpack_require__(moduleId) { |
| /******/ |
| /******/ // Check if module is in cache |
| /******/ if(installedModules[moduleId]) { |
| /******/ return installedModules[moduleId].exports; |
| /******/ } |
| /******/ // Create a new module (and put it into the cache) |
| /******/ var module = installedModules[moduleId] = { |
| /******/ i: moduleId, |
| /******/ l: false, |
| /******/ exports: {} |
| /******/ }; |
| /******/ |
| /******/ // Execute the module function |
| /******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); |
| /******/ |
| /******/ // Flag the module as loaded |
| /******/ module.l = true; |
| /******/ |
| /******/ // Return the exports of the module |
| /******/ return module.exports; |
| /******/ } |
| /******/ |
| /******/ |
| /******/ // expose the modules object (__webpack_modules__) |
| /******/ __webpack_require__.m = modules; |
| /******/ |
| /******/ // expose the module cache |
| /******/ __webpack_require__.c = installedModules; |
| /******/ |
| /******/ // define getter function for harmony exports |
| /******/ __webpack_require__.d = function(exports, name, getter) { |
| /******/ if(!__webpack_require__.o(exports, name)) { |
| /******/ Object.defineProperty(exports, name, { enumerable: true, get: getter }); |
| /******/ } |
| /******/ }; |
| /******/ |
| /******/ // define __esModule on exports |
| /******/ __webpack_require__.r = function(exports) { |
| /******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) { |
| /******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); |
| /******/ } |
| /******/ Object.defineProperty(exports, '__esModule', { value: true }); |
| /******/ }; |
| /******/ |
| /******/ // create a fake namespace object |
| /******/ // mode & 1: value is a module id, require it |
| /******/ // mode & 2: merge all properties of value into the ns |
| /******/ // mode & 4: return value when already ns object |
| /******/ // mode & 8|1: behave like require |
| /******/ __webpack_require__.t = function(value, mode) { |
| /******/ if(mode & 1) value = __webpack_require__(value); |
| /******/ if(mode & 8) return value; |
| /******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value; |
| /******/ var ns = Object.create(null); |
| /******/ __webpack_require__.r(ns); |
| /******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value }); |
| /******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key)); |
| /******/ return ns; |
| /******/ }; |
| /******/ |
| /******/ // getDefaultExport function for compatibility with non-harmony modules |
| /******/ __webpack_require__.n = function(module) { |
| /******/ var getter = module && module.__esModule ? |
| /******/ function getDefault() { return module['default']; } : |
| /******/ function getModuleExports() { return module; }; |
| /******/ __webpack_require__.d(getter, 'a', getter); |
| /******/ return getter; |
| /******/ }; |
| /******/ |
| /******/ // Object.prototype.hasOwnProperty.call |
| /******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); }; |
| /******/ |
| /******/ // __webpack_public_path__ |
| /******/ __webpack_require__.p = ""; |
| /******/ |
| /******/ |
| /******/ // Load entry module and return exports |
| /******/ return __webpack_require__(__webpack_require__.s = 1); |
| /******/ }) |
| /************************************************************************/ |
| /******/ ([ |
| /* 0 */ |
| /***/ (function(module, exports) { |
| |
| module.exports = __WEBPACK_EXTERNAL_MODULE__0__; |
| |
| /***/ }), |
| /* 1 */ |
| /***/ (function(module, __webpack_exports__, __webpack_require__) { |
| |
| "use strict"; |
| __webpack_require__.r(__webpack_exports__); |
| /* harmony import */ var katex__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(0); |
| /* harmony import */ var katex__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(katex__WEBPACK_IMPORTED_MODULE_0__); |
| /** |
| * 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. |
| */ |
| // NOTE: since we're importing types here these files won't actually be |
| // included in the build. |
| // $FlowIgnore: we import the types directly anyways |
| |
| var 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" |
| }; |
| var powerMap = { |
| "prime": "prime", |
| "degree": "degrees", |
| "circle": "degrees", |
| "2": "squared", |
| "3": "cubed" |
| }; |
| var openMap = { |
| "|": "open vertical bar", |
| ".": "" |
| }; |
| var closeMap = { |
| "|": "close vertical bar", |
| ".": "" |
| }; |
| var binMap = { |
| "+": "plus", |
| "-": "minus", |
| "\\pm": "plus minus", |
| "\\cdot": "dot", |
| "*": "times", |
| "/": "divided by", |
| "\\times": "times", |
| "\\div": "divided by", |
| "\\circ": "circle", |
| "\\bullet": "bullet" |
| }; |
| var 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" |
| }; |
| var accentUnderMap = { |
| "\\underleftarrow": "left arrow", |
| "\\underrightarrow": "right arrow", |
| "\\underleftrightarrow": "left-right arrow", |
| "\\undergroup": "group", |
| "\\underlinesegment": "line segment", |
| "\\utilde": "tilde" |
| }; |
| |
| var buildString = function buildString(str, type, a11yStrings) { |
| if (!str) { |
| return; |
| } |
| |
| var 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); |
| } |
| }; |
| |
| var buildRegion = function buildRegion(a11yStrings, callback) { |
| var regionStrings = []; |
| a11yStrings.push(regionStrings); |
| callback(regionStrings); |
| }; |
| |
| var handleObject = function handleObject(tree, a11yStrings, atomType) { |
| // Everything else is assumed to be an object... |
| switch (tree.type) { |
| case "accent": |
| { |
| buildRegion(a11yStrings, function (a11yStrings) { |
| buildA11yStrings(tree.base, a11yStrings, atomType); |
| a11yStrings.push("with"); |
| buildString(tree.label, "normal", a11yStrings); |
| a11yStrings.push("on top"); |
| }); |
| break; |
| } |
| |
| case "accentUnder": |
| { |
| buildRegion(a11yStrings, function (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": |
| { |
| var 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": |
| { |
| var color = tree.color.replace(/katex-/, ""); |
| buildRegion(a11yStrings, function (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, function (regionStrings) { |
| // genfrac can have unbalanced delimiters |
| var 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, function (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": |
| { |
| var 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, function (regionStrings) { |
| var body = tree.body, |
| index = tree.index; |
| |
| if (index) { |
| var 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": |
| { |
| var base = tree.base, |
| sub = tree.sub, |
| sup = tree.sup; |
| var isLog = false; |
| |
| if (base) { |
| buildA11yStrings(base, a11yStrings, atomType); |
| isLog = base.type === "op" && base.name === "\\log"; |
| } |
| |
| if (sub) { |
| var 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) { |
| var 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. |
| var _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); |
| } |
| }; |
| |
| var buildA11yStrings = function buildA11yStrings(tree, a11yStrings, atomType) { |
| if (a11yStrings === void 0) { |
| a11yStrings = []; |
| } |
| |
| if (tree instanceof Array) { |
| for (var i = 0; i < tree.length; i++) { |
| buildA11yStrings(tree[i], a11yStrings, atomType); |
| } |
| } else { |
| handleObject(tree, a11yStrings, atomType); |
| } |
| |
| return a11yStrings; |
| }; |
| |
| var flatten = function flatten(array) { |
| var result = []; |
| array.forEach(function (item) { |
| if (item instanceof Array) { |
| result = result.concat(flatten(item)); |
| } else { |
| result.push(item); |
| } |
| }); |
| return result; |
| }; |
| |
| var renderA11yString = function renderA11yString(text, settings) { |
| var tree = katex__WEBPACK_IMPORTED_MODULE_0___default.a.__parse(text, settings); |
| |
| var a11yStrings = buildA11yStrings(tree, [], "normal"); |
| return flatten(a11yStrings).join(", "); |
| }; |
| |
| /* harmony default export */ __webpack_exports__["default"] = (renderA11yString); |
| |
| /***/ }) |
| /******/ ])["default"]; |
| }); |
