|
|
| 8行目: |
8行目: |
| === __webpack_modules__[265].call(r.exports, r, r.exports, __webpack_require__) === | | === __webpack_modules__[265].call(r.exports, r, r.exports, __webpack_require__) === |
| <syntaxhighlight lang="javascript"> | | <syntaxhighlight lang="javascript"> |
| 2388:
| |
| function(t, e, r) {
| |
| var n = this && this.__assign ||
| |
| function() {
| |
| return n = Object.assign ||
| |
| function(t) {
| |
| for(var e, r = 1, n = arguments.length; r < n; r++)
| |
| for(var o in e = arguments[r])
| |
| Object.prototype.hasOwnProperty.call(e, o) && (t[o] = e[o]);
| |
| return t
| |
| },
| |
| n.apply(this, arguments)
| |
| },
| |
| o = this && this.__values ||
| |
| function(t) {
| |
| var e = "function" == typeof Symbol && Symbol.iterator,
| |
| r = e && t[e],
| |
| n = 0;
| |
| if(r) return r.call(t);
| |
| if(t && "number" == typeof t.length) return {
| |
| next: function() {
| |
| return t && n >= t.length && (t = void 0), {
| |
| value: t && t[n++],
| |
| done: !t
| |
| }
| |
| }
| |
| };
| |
| throw new TypeError(e ? "Object is not iterable." : "Symbol.iterator is not defined.")
| |
| },
| |
| i = this && this.__read || function(t, e) {
| |
| var r = "function" == typeof Symbol && t[Symbol.iterator];
| |
| if(!r) return t;
| |
| var n, o, i = r.call(t),
| |
| s = [];
| |
| try {
| |
| for(;
| |
| ( void 0 === e || e-- > 0) && !(n = i.next()).done;
| |
| )
| |
| s.push(n.value)
| |
| }
| |
| catch(t) { o = { error: t } }
| |
| finally {
| |
| try { n && !n.done && (r = i.return) && r.call(i) }
| |
| finally { if(o) throw o.error }
| |
| }
| |
| return s
| |
| },
| |
| s = this && this.__spreadArray || function(t, e, r) {
| |
| if(r || 2 === arguments.length)
| |
| for(var n, o = 0, i = e.length; o < i; o++)
| |
| !n && o in e || (n || (n = Array.prototype.slice.call(e, 0, o)), n[o] = e[o]);
| |
| return t.concat(n || Array.prototype.slice.call(e))
| |
| };
| |
| Object.defineProperty(e, "__esModule", { value: !0 }),
| |
| e.CONFIG = e.MathJax = e.Startup = void 0;
| |
| var a, l = r(9515),
| |
| c = r(8666),
| |
| u = r(7233);
| |
| ! function(t) {
| |
| var a, l, u = new c.PrioritizedList;
| |
|
| |
|
| function h(e) {
| |
| return a.visitTree(e, t.document)
| |
| }
| |
|
| |
| function f() {
| |
| a = new e.MathJax._.core.MmlTree.SerializedMmlVisitor.SerializedMmlVisitor,
| |
| l = e.MathJax._.mathjax.mathjax,
| |
| t.input = v(),
| |
| t.output = _(),
| |
| t.adaptor = S(),
| |
| t.handler && l.handlers.unregister(t.handler),
| |
| t.handler = M(),
| |
| t.handler &&
| |
| (l.handlers.register(t.handler),
| |
| t.document = O()
| |
| )
| |
| }
| |
|
| |
| function d() {
| |
| var e, r;
| |
| t.input && t.output && m();
| |
| var n = t.output ? t.output.name.toLowerCase() : "";
| |
| try {
| |
| for(var i = o(t.input), s = i.next(); !s.done; s = i.next()) {
| |
| var a = s.value,
| |
| l = a.name.toLowerCase();
| |
| g(l, a), b(l, a), t.output && y(l, n, a)
| |
| }
| |
| }
| |
| catch(t) { e = { error: t } }
| |
| finally {
| |
| try { s && !s.done && (r = i.return) && r.call(i) }
| |
| finally { if(e) throw e.error }
| |
| }
| |
| }
| |
|
| |
| function m() {
| |
| e.MathJax.typeset = function(e) {
| |
| void 0 === e && (e = null),
| |
| t.document.options.elements = e,
| |
| t.document.reset(),
| |
| t.document.render()
| |
| },
| |
| e.MathJax.typesetPromise = function(e) {
| |
| return void 0 === e && (e = null),
| |
| t.document.options.elements = e,
| |
| t.document.reset(),
| |
| l.handleRetriesFor((function() {
| |
| t.document.render()
| |
| }))
| |
| },
| |
| e.MathJax.typesetClear = function(e) {
| |
| void 0 === e && (e = null), e ? t.document.clearMathItemsWithin(e) : t.document.clear()
| |
| }
| |
| }
| |
|
| |
| function y(r, n, o) {
| |
| var i = r + "2" + n;
| |
| e.MathJax[i] = function(e, r) {
| |
| return void 0 === r && (r = {}), r.format = o.name, t.document.convert(e, r)
| |
| },
| |
| e.MathJax[i + "Promise"] = function(e, r) {
| |
| return void 0 === r && (r = {}), r.format = o.name, l.handleRetriesFor((function() {
| |
| return t.document.convert(e, r)
| |
| }))
| |
| },
| |
| e.MathJax[n + "Stylesheet"] = function() {
| |
| return t.output.styleSheet(t.document)
| |
| },
| |
| "getMetricsFor" in t.output && (e.MathJax.getMetricsFor = function(e, r) {
| |
| return t.output.getMetricsFor(e, r)
| |
| })
| |
| }
| |
|
| |
| function g(r, n) {
| |
| var o = e.MathJax._.core.MathItem.STATE;
| |
| e.MathJax[r + "2mml"] = function(e, r) {
| |
| return
| |
| void 0 === r &&
| |
| (r = {}),
| |
| r.end = o.CONVERT,
| |
| r.format = n.name,
| |
| h(t.document.convert(e, r))
| |
| },
| |
| e.MathJax[r + "2mmlPromise"] = function(e, r) {
| |
| return
| |
| void 0 === r &&
| |
| (r = {}),
| |
| r.end = o.CONVERT,
| |
| r.format = n.name,
| |
| l.handleRetriesFor((function() {
| |
| return h(t.document.convert(e, r))
| |
| }))
| |
| }
| |
| }
| |
|
| |
| function b(t, r) {
| |
| e.MathJax[t + "Reset"] = function() {
| |
| for(var t = [], e = 0; e < arguments.length; e++) t[e] = arguments[e];
| |
| return r.reset.apply(r, s([], i(t), !1))
| |
| }
| |
| }
| |
|
| |
| function v() {
| |
| var r, n, i = [];
| |
| try {
| |
| for(var s = o(e.CONFIG.input), a = s.next(); !a.done; a = s.next()) {
| |
| var l = a.value,
| |
| c = t.constructors[l];
| |
| if(!c) throw Error('Input Jax "' + l + '" is not defined (has it been loaded?)');
| |
| i.push(new c(e.MathJax.config[l]))
| |
| }
| |
| } catch(t) {
| |
| r = {
| |
| error: t
| |
| }
| |
| } finally {
| |
| try {
| |
| a && !a.done && (n = s.return) && n.call(s)
| |
| } finally {
| |
| if(r) throw r.error
| |
| }
| |
| }
| |
| return i
| |
| }
| |
|
| |
| function _() {
| |
| var r = e.CONFIG.output;
| |
| if(!r)
| |
| return null;
| |
| var n = t.constructors[r];
| |
| if(!n)
| |
| throw Error('Output Jax "' + r + '" is not defined (has it been loaded?)');
| |
| return new n(e.MathJax.config[r])
| |
| }
| |
|
| |
| function S() {
| |
| var r = e.CONFIG.adaptor;
| |
| if(!r || "none" === r)
| |
| return null;
| |
| var n = t.constructors[r];
| |
| if(!n)
| |
| throw Error('DOMAdaptor "' + r + '" is not defined (has it been loaded?)');
| |
| return n(e.MathJax.config[r])
| |
| }
| |
|
| |
| function M() {
| |
| var r, n, i = e.CONFIG.handler;
| |
| if(!i || "none" === i || !t.adaptor) return null;
| |
| var s = t.constructors[i];
| |
| if(!s) throw Error('Handler "' + i + '" is not defined (has it been loaded?)');
| |
| var a = new s(t.adaptor, 5);
| |
| try {
| |
| for(var l = o(u), c = l.next(); !c.done; c = l.next()) {
| |
| a = c.value.item(a)
| |
| }
| |
| } catch(t) {
| |
| r = {
| |
| error: t
| |
| }
| |
| } finally {
| |
| try {
| |
| c && !c.done && (n = l.return) && n.call(l)
| |
| } finally {
| |
| if(r) throw r.error
| |
| }
| |
| }
| |
| return a
| |
| }
| |
|
| |
| function O(r) {
| |
| return
| |
| void 0 === r &&
| |
| (r = null),
| |
| l.document(
| |
| r || e.CONFIG.document, n(
| |
| n({}, e.MathJax.config.options), {
| |
| InputJax: t.input,
| |
| OutputJax: t.output
| |
| }
| |
| )
| |
| )
| |
| }
| |
| t.constructors = {},
| |
| t.input = [],
| |
| t.output = null,
| |
| t.handler = null,
| |
| t.adaptor = null,
| |
| t.elements = null,
| |
| t.document = null,
| |
| t.promise = new Promise((function(e, r) {
| |
| t.promiseResolve = e, t.promiseReject = r
| |
| })),
| |
| t.pagePromise = new Promise((function(t, e) {
| |
| var n = r.g.document;
| |
| if(n && n.readyState && "complete" !== n.readyState && "interactive" !== n.readyState) {
| |
| var o = function() {
| |
| return t()
| |
| };
| |
| n.defaultView.addEventListener("load", o, !0),
| |
| n.defaultView.addEventListener("DOMContentLoaded", o, !0)
| |
| } else t()
| |
| })),
| |
| t.toMML = h, t.registerConstructor = function(e, r) {
| |
| t.constructors[e] = r
| |
| },
| |
| t.useHandler = function(t, r) {
| |
| void 0 === r && (r = !1), e.CONFIG.handler && !r || (e.CONFIG.handler = t)
| |
| },
| |
| t.useAdaptor = function(t, r) {
| |
| void 0 === r && (r = !1), e.CONFIG.adaptor && !r || (e.CONFIG.adaptor = t)
| |
| },
| |
| t.useInput = function(t, r) {
| |
| void 0 === r && (r = !1), p && !r || e.CONFIG.input.push(t)
| |
| },
| |
| t.useOutput = function(t, r) {
| |
| void 0 === r && (r = !1), e.CONFIG.output && !r || (e.CONFIG.output = t)
| |
| },
| |
| t.extendHandler = function(t, e) {
| |
| void 0 === e && (e = 10), u.add(t, e)
| |
| },
| |
| t.defaultReady = function() {
| |
| f(),
| |
| d(),
| |
| t.pagePromise.then((function() {
| |
| return e.CONFIG.pageReady()
| |
| })).
| |
| then((function() {
| |
| return t.promiseResolve()
| |
| })).
| |
| catch((function(e) {
| |
| return t.promiseReject(e)
| |
| }))
| |
| },
| |
| t.defaultPageReady = function() {
| |
| return e.CONFIG.typeset &&
| |
| e.MathJax.typesetPromise ?
| |
| e.MathJax.typesetPromise(e.CONFIG.elements)
| |
| :
| |
| Promise.resolve()
| |
| },
| |
| t.getComponents = f,
| |
| t.makeMethods = d,
| |
| t.makeTypesetMethods = m,
| |
| t.makeOutputMethods = y,
| |
| t.makeMmlMethods = g,
| |
| t.makeResetMethod = b,
| |
| t.getInputJax = v,
| |
| t.getOutputJax = _,
| |
| t.getAdaptor = S,
| |
| t.getHandler = M,
| |
| t.getDocument = O
| |
| }(a = e.Startup || (e.Startup = {})),
| |
| e.MathJax = l.MathJax, void 0 === e.MathJax._.startup &&
| |
| ((0, l.combineDefaults)(e.MathJax.config, "startup", {
| |
| input: [],
| |
| output: "",
| |
| handler: null,
| |
| adaptor: null,
| |
| document: "undefined" == typeof document ? "" : document,
| |
| elements: null,
| |
| typeset: !0,
| |
| ready: a.defaultReady.bind(a),
| |
| pageReady: a.defaultPageReady.bind(a)
| |
| }),
| |
| (0, l.combineWithMathJax)({
| |
| startup: a,
| |
| options: {}
| |
| }),
| |
| e.MathJax.config.startup.invalidOption &&
| |
| (u.OPTIONS.invalidOption = e.MathJax.config.startup.invalidOption),
| |
| e.MathJax.config.startup.optionError &&
| |
| (u.OPTIONS.optionError = e.MathJax.config.startup.optionError)),
| |
| e.CONFIG = e.MathJax.config.startup;
| |
| var p = 0 !== e.CONFIG.input.length
| |
| },
| |
| </syntaxhighlight> | | </syntaxhighlight> |
|
| |
|
