530 lines
13 KiB
JavaScript
530 lines
13 KiB
JavaScript
!(function (e, r) {
|
|
if ("object" == typeof exports && "object" == typeof module)
|
|
module.exports = r(require("katex"));
|
|
else if ("function" == typeof define && define.amd) define(["katex"], r);
|
|
else {
|
|
var t = "object" == typeof exports ? r(require("katex")) : r(e.katex);
|
|
for (var a in t) ("object" == typeof exports ? exports : e)[a] = t[a];
|
|
}
|
|
})("undefined" != typeof self ? self : this, function (e) {
|
|
return (function (e) {
|
|
var r = {};
|
|
function t(a) {
|
|
if (r[a]) return r[a].exports;
|
|
var o = (r[a] = { i: a, l: !1, exports: {} });
|
|
return e[a].call(o.exports, o, o.exports, t), (o.l = !0), o.exports;
|
|
}
|
|
return (
|
|
(t.m = e),
|
|
(t.c = r),
|
|
(t.d = function (e, r, a) {
|
|
t.o(e, r) || Object.defineProperty(e, r, { enumerable: !0, get: a });
|
|
}),
|
|
(t.r = function (e) {
|
|
"undefined" != typeof Symbol &&
|
|
Symbol.toStringTag &&
|
|
Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }),
|
|
Object.defineProperty(e, "__esModule", { value: !0 });
|
|
}),
|
|
(t.t = function (e, r) {
|
|
if ((1 & r && (e = t(e)), 8 & r)) return e;
|
|
if (4 & r && "object" == typeof e && e && e.__esModule) return e;
|
|
var a = Object.create(null);
|
|
if (
|
|
(t.r(a),
|
|
Object.defineProperty(a, "default", { enumerable: !0, value: e }),
|
|
2 & r && "string" != typeof e)
|
|
)
|
|
for (var o in e)
|
|
t.d(
|
|
a,
|
|
o,
|
|
function (r) {
|
|
return e[r];
|
|
}.bind(null, o),
|
|
);
|
|
return a;
|
|
}),
|
|
(t.n = function (e) {
|
|
var r =
|
|
e && e.__esModule
|
|
? function () {
|
|
return e.default;
|
|
}
|
|
: function () {
|
|
return e;
|
|
};
|
|
return t.d(r, "a", r), r;
|
|
}),
|
|
(t.o = function (e, r) {
|
|
return Object.prototype.hasOwnProperty.call(e, r);
|
|
}),
|
|
(t.p = ""),
|
|
t((t.s = 1))
|
|
);
|
|
})([
|
|
function (r, t) {
|
|
r.exports = e;
|
|
},
|
|
function (e, r, t) {
|
|
"use strict";
|
|
t.r(r);
|
|
var a = t(0),
|
|
o = t.n(a),
|
|
n = {
|
|
"(": "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",
|
|
"\\hat": "hat",
|
|
"\\acute": "acute",
|
|
},
|
|
s = {
|
|
prime: "prime",
|
|
degree: "degrees",
|
|
circle: "degrees",
|
|
2: "squared",
|
|
3: "cubed",
|
|
},
|
|
i = { "|": "open vertical bar", ".": "" },
|
|
l = { "|": "close vertical bar", ".": "" },
|
|
c = {
|
|
"+": "plus",
|
|
"-": "minus",
|
|
"\\pm": "plus minus",
|
|
"\\cdot": "dot",
|
|
"*": "times",
|
|
"/": "divided by",
|
|
"\\times": "times",
|
|
"\\div": "divided by",
|
|
"\\circ": "circle",
|
|
"\\bullet": "bullet",
|
|
},
|
|
u = {
|
|
"=": "equals",
|
|
"\\approx": "approximately equals",
|
|
"\u2260": "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",
|
|
},
|
|
p = {
|
|
"\\underleftarrow": "left arrow",
|
|
"\\underrightarrow": "right arrow",
|
|
"\\underleftrightarrow": "left-right arrow",
|
|
"\\undergroup": "group",
|
|
"\\underlinesegment": "line segment",
|
|
"\\utilde": "tilde",
|
|
},
|
|
d = function (e, r, t) {
|
|
var a;
|
|
e &&
|
|
(/^\d+$/.test(
|
|
(a =
|
|
"open" === r
|
|
? e in i
|
|
? i[e]
|
|
: n[e] || e
|
|
: "close" === r
|
|
? e in l
|
|
? l[e]
|
|
: n[e] || e
|
|
: "bin" === r
|
|
? c[e] || e
|
|
: "rel" === r
|
|
? u[e] || e
|
|
: n[e] || e),
|
|
) &&
|
|
t.length > 0 &&
|
|
/^\d+$/.test(t[t.length - 1])
|
|
? (t[t.length - 1] += a)
|
|
: a && t.push(a));
|
|
},
|
|
b = function (e, r) {
|
|
var t = [];
|
|
e.push(t), r(t);
|
|
},
|
|
h = function (e, r, t) {
|
|
switch (e.type) {
|
|
case "accent":
|
|
b(r, function (r) {
|
|
f(e.base, r, t),
|
|
r.push("with"),
|
|
d(e.label, "normal", r),
|
|
r.push("on top");
|
|
});
|
|
break;
|
|
case "accentUnder":
|
|
b(r, function (r) {
|
|
f(e.base, r, t),
|
|
r.push("with"),
|
|
d(p[e.label], "normal", r),
|
|
r.push("underneath");
|
|
});
|
|
break;
|
|
case "accent-token":
|
|
break;
|
|
case "atom":
|
|
var a = e.text;
|
|
switch (e.family) {
|
|
case "bin":
|
|
d(a, "bin", r);
|
|
break;
|
|
case "close":
|
|
d(a, "close", r);
|
|
break;
|
|
case "inner":
|
|
d(e.text, "inner", r);
|
|
break;
|
|
case "open":
|
|
d(a, "open", r);
|
|
break;
|
|
case "punct":
|
|
d(a, "punct", r);
|
|
break;
|
|
case "rel":
|
|
d(a, "rel", r);
|
|
break;
|
|
default:
|
|
throw (
|
|
(e.family,
|
|
new Error('"' + e.family + '" is not a valid atom type'))
|
|
);
|
|
}
|
|
break;
|
|
case "color":
|
|
var o = e.color.replace(/katex-/, "");
|
|
b(r, function (r) {
|
|
r.push("start color " + o),
|
|
f(e.body, r, t),
|
|
r.push("end color " + o);
|
|
});
|
|
break;
|
|
case "color-token":
|
|
break;
|
|
case "delimsizing":
|
|
e.delim && "." !== e.delim && d(e.delim, "normal", r);
|
|
break;
|
|
case "genfrac":
|
|
b(r, function (r) {
|
|
var a = e.leftDelim,
|
|
o = e.rightDelim;
|
|
e.hasBarLine
|
|
? (r.push("start fraction"),
|
|
a && d(a, "open", r),
|
|
f(e.numer, r, t),
|
|
r.push("divided by"),
|
|
f(e.denom, r, t),
|
|
o && d(o, "close", r),
|
|
r.push("end fraction"))
|
|
: (r.push("start binomial"),
|
|
a && d(a, "open", r),
|
|
f(e.numer, r, t),
|
|
r.push("over"),
|
|
f(e.denom, r, t),
|
|
o && d(o, "close", r),
|
|
r.push("end binomial"));
|
|
});
|
|
break;
|
|
case "kern":
|
|
break;
|
|
case "leftright":
|
|
b(r, function (r) {
|
|
d(e.left, "open", r), f(e.body, r, t), d(e.right, "close", r);
|
|
});
|
|
break;
|
|
case "leftright-right":
|
|
break;
|
|
case "lap":
|
|
f(e.body, r, t);
|
|
break;
|
|
case "mathord":
|
|
d(e.text, "normal", r);
|
|
break;
|
|
case "op":
|
|
var n = e.body,
|
|
i = e.name;
|
|
n ? f(n, r, t) : i && d(i, "normal", r);
|
|
break;
|
|
case "op-token":
|
|
d(e.text, t, r);
|
|
break;
|
|
case "ordgroup":
|
|
f(e.body, r, t);
|
|
break;
|
|
case "overline":
|
|
b(r, function (r) {
|
|
r.push("start overline"),
|
|
f(e.body, r, t),
|
|
r.push("end overline");
|
|
});
|
|
break;
|
|
case "phantom":
|
|
r.push("empty space");
|
|
break;
|
|
case "raisebox":
|
|
f(e.body, r, t);
|
|
break;
|
|
case "rule":
|
|
r.push("rectangle");
|
|
break;
|
|
case "sizing":
|
|
f(e.body, r, t);
|
|
break;
|
|
case "spacing":
|
|
r.push("space");
|
|
break;
|
|
case "styling":
|
|
f(e.body, r, t);
|
|
break;
|
|
case "sqrt":
|
|
b(r, function (r) {
|
|
var a = e.body,
|
|
o = e.index;
|
|
if (o)
|
|
return "3" === m(f(o, [], t)).join(",")
|
|
? (r.push("cube root of"),
|
|
f(a, r, t),
|
|
void r.push("end cube root"))
|
|
: (r.push("root"),
|
|
r.push("start index"),
|
|
f(o, r, t),
|
|
void r.push("end index"));
|
|
r.push("square root of"), f(a, r, t), r.push("end square root");
|
|
});
|
|
break;
|
|
case "supsub":
|
|
var l = e.base,
|
|
c = e.sub,
|
|
u = e.sup,
|
|
h = !1;
|
|
if (
|
|
(l && (f(l, r, t), (h = "op" === l.type && "\\log" === l.name)),
|
|
c)
|
|
) {
|
|
var y = h ? "base" : "subscript";
|
|
b(r, function (e) {
|
|
e.push("start " + y), f(c, e, t), e.push("end " + y);
|
|
});
|
|
}
|
|
u &&
|
|
b(r, function (e) {
|
|
var r = m(f(u, [], t)).join(",");
|
|
r in s
|
|
? e.push(s[r])
|
|
: (e.push("start superscript"),
|
|
f(u, e, t),
|
|
e.push("end superscript"));
|
|
});
|
|
break;
|
|
case "text":
|
|
if ("\\textbf" === e.font) {
|
|
b(r, function (r) {
|
|
r.push("start bold text"),
|
|
f(e.body, r, t),
|
|
r.push("end bold text");
|
|
});
|
|
break;
|
|
}
|
|
b(r, function (r) {
|
|
r.push("start text"), f(e.body, r, t), r.push("end text");
|
|
});
|
|
break;
|
|
case "textord":
|
|
d(e.text, t, r);
|
|
break;
|
|
case "smash":
|
|
f(e.body, r, t);
|
|
break;
|
|
case "enclose":
|
|
if (/cancel/.test(e.label)) {
|
|
b(r, function (r) {
|
|
r.push("start cancel"), f(e.body, r, t), r.push("end cancel");
|
|
});
|
|
break;
|
|
}
|
|
if (/box/.test(e.label)) {
|
|
b(r, function (r) {
|
|
r.push("start box"), f(e.body, r, t), r.push("end box");
|
|
});
|
|
break;
|
|
}
|
|
if (/sout/.test(e.label)) {
|
|
b(r, function (r) {
|
|
r.push("start strikeout"),
|
|
f(e.body, r, t),
|
|
r.push("end strikeout");
|
|
});
|
|
break;
|
|
}
|
|
throw new Error(
|
|
"KaTeX-a11y: enclose node with " +
|
|
e.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":
|
|
f(e.body, r, t);
|
|
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":
|
|
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":
|
|
d("start verbatim", "normal", r),
|
|
d(e.body, "normal", r),
|
|
d("end verbatim", "normal", r);
|
|
break;
|
|
case "environment":
|
|
throw new Error("KaTeX-a11y: environment not implemented yet");
|
|
case "horizBrace":
|
|
d("start " + e.label.slice(1), "normal", r),
|
|
f(e.base, r, t),
|
|
d("end " + e.label.slice(1), "normal", r);
|
|
break;
|
|
case "infix":
|
|
break;
|
|
case "includegraphics":
|
|
throw new Error(
|
|
"KaTeX-a11y: includegraphics not implemented yet",
|
|
);
|
|
case "font":
|
|
f(e.body, r, t);
|
|
break;
|
|
case "href":
|
|
throw new Error("KaTeX-a11y: href not implemented yet");
|
|
case "cr":
|
|
throw new Error("KaTeX-a11y: cr not implemented yet");
|
|
case "underline":
|
|
b(r, function (r) {
|
|
r.push("start underline"),
|
|
f(e.body, r, t),
|
|
r.push("end underline");
|
|
});
|
|
break;
|
|
case "xArrow":
|
|
throw new Error("KaTeX-a11y: xArrow not implemented yet");
|
|
case "mclass":
|
|
var g = e.mclass.slice(1);
|
|
f(e.body, r, g);
|
|
break;
|
|
case "mathchoice":
|
|
f(e.text, r, t);
|
|
break;
|
|
case "htmlmathml":
|
|
f(e.mathml, r, t);
|
|
break;
|
|
case "middle":
|
|
d(e.delim, t, r);
|
|
break;
|
|
default:
|
|
throw (
|
|
(e.type, new Error("KaTeX a11y un-recognized type: " + e.type))
|
|
);
|
|
}
|
|
},
|
|
f = function e(r, t, a) {
|
|
if ((void 0 === t && (t = []), r instanceof Array))
|
|
for (var o = 0; o < r.length; o++) e(r[o], t, a);
|
|
else h(r, t, a);
|
|
return t;
|
|
},
|
|
m = function e(r) {
|
|
var t = [];
|
|
return (
|
|
r.forEach(function (r) {
|
|
r instanceof Array ? (t = t.concat(e(r))) : t.push(r);
|
|
}),
|
|
t
|
|
);
|
|
};
|
|
r.default = function (e, r) {
|
|
var t = o.a.__parse(e, r),
|
|
a = f(t, [], "normal");
|
|
return m(a).join(", ");
|
|
};
|
|
},
|
|
]).default;
|
|
});
|