You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3261 lines
110 KiB
JavaScript
3261 lines
110 KiB
JavaScript
"use strict";
|
|
(self["webpackChunk_JUPYTERLAB_CORE_OUTPUT"] = self["webpackChunk_JUPYTERLAB_CORE_OUTPUT"] || []).push([[5115,4971],{
|
|
|
|
/***/ 27573:
|
|
/***/ ((__unused_webpack_module, exports) => {
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
exports.VERSION = void 0;
|
|
exports.VERSION = '3.2.2';
|
|
//# sourceMappingURL=version.js.map
|
|
|
|
/***/ }),
|
|
|
|
/***/ 12514:
|
|
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
|
|
|
|
|
|
var __extends = (this && this.__extends) || (function () {
|
|
var extendStatics = function (d, b) {
|
|
extendStatics = Object.setPrototypeOf ||
|
|
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
|
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
|
|
return extendStatics(d, b);
|
|
};
|
|
return function (d, b) {
|
|
if (typeof b !== "function" && b !== null)
|
|
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
|
|
extendStatics(d, b);
|
|
function __() { this.constructor = d; }
|
|
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
|
};
|
|
})();
|
|
var __values = (this && this.__values) || function(o) {
|
|
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
|
|
if (m) return m.call(o);
|
|
if (o && typeof o.length === "number") return {
|
|
next: function () {
|
|
if (o && i >= o.length) o = void 0;
|
|
return { value: o && o[i++], done: !o };
|
|
}
|
|
};
|
|
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
|
|
};
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
exports.HandlerList = void 0;
|
|
var PrioritizedList_js_1 = __webpack_require__(98721);
|
|
var HandlerList = (function (_super) {
|
|
__extends(HandlerList, _super);
|
|
function HandlerList() {
|
|
return _super !== null && _super.apply(this, arguments) || this;
|
|
}
|
|
HandlerList.prototype.register = function (handler) {
|
|
return this.add(handler, handler.priority);
|
|
};
|
|
HandlerList.prototype.unregister = function (handler) {
|
|
this.remove(handler);
|
|
};
|
|
HandlerList.prototype.handlesDocument = function (document) {
|
|
var e_1, _a;
|
|
try {
|
|
for (var _b = __values(this), _c = _b.next(); !_c.done; _c = _b.next()) {
|
|
var item = _c.value;
|
|
var handler = item.item;
|
|
if (handler.handlesDocument(document)) {
|
|
return handler;
|
|
}
|
|
}
|
|
}
|
|
catch (e_1_1) { e_1 = { error: e_1_1 }; }
|
|
finally {
|
|
try {
|
|
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
|
|
}
|
|
finally { if (e_1) throw e_1.error; }
|
|
}
|
|
throw new Error("Can't find handler for document");
|
|
};
|
|
HandlerList.prototype.document = function (document, options) {
|
|
if (options === void 0) { options = null; }
|
|
return this.handlesDocument(document).create(document, options);
|
|
};
|
|
return HandlerList;
|
|
}(PrioritizedList_js_1.PrioritizedList));
|
|
exports.HandlerList = HandlerList;
|
|
//# sourceMappingURL=HandlerList.js.map
|
|
|
|
/***/ }),
|
|
|
|
/***/ 63401:
|
|
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
|
|
|
|
|
|
var __values = (this && this.__values) || function(o) {
|
|
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
|
|
if (m) return m.call(o);
|
|
if (o && typeof o.length === "number") return {
|
|
next: function () {
|
|
if (o && i >= o.length) o = void 0;
|
|
return { value: o && o[i++], done: !o };
|
|
}
|
|
};
|
|
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
|
|
};
|
|
var __read = (this && this.__read) || function (o, n) {
|
|
var m = typeof Symbol === "function" && o[Symbol.iterator];
|
|
if (!m) return o;
|
|
var i = m.call(o), r, ar = [], e;
|
|
try {
|
|
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
|
|
}
|
|
catch (error) { e = { error: error }; }
|
|
finally {
|
|
try {
|
|
if (r && !r.done && (m = i["return"])) m.call(i);
|
|
}
|
|
finally { if (e) throw e.error; }
|
|
}
|
|
return ar;
|
|
};
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
exports.ParserConfiguration = exports.ConfigurationHandler = exports.Configuration = void 0;
|
|
var Options_js_1 = __webpack_require__(4498);
|
|
var MapHandler_js_1 = __webpack_require__(21683);
|
|
var FunctionList_js_1 = __webpack_require__(18341);
|
|
var PrioritizedList_js_1 = __webpack_require__(98721);
|
|
var Tags_js_1 = __webpack_require__(75723);
|
|
var Configuration = (function () {
|
|
function Configuration(name, handler, fallback, items, tags, options, nodes, preprocessors, postprocessors, initMethod, configMethod, priority, parser) {
|
|
if (handler === void 0) { handler = {}; }
|
|
if (fallback === void 0) { fallback = {}; }
|
|
if (items === void 0) { items = {}; }
|
|
if (tags === void 0) { tags = {}; }
|
|
if (options === void 0) { options = {}; }
|
|
if (nodes === void 0) { nodes = {}; }
|
|
if (preprocessors === void 0) { preprocessors = []; }
|
|
if (postprocessors === void 0) { postprocessors = []; }
|
|
if (initMethod === void 0) { initMethod = null; }
|
|
if (configMethod === void 0) { configMethod = null; }
|
|
this.name = name;
|
|
this.handler = handler;
|
|
this.fallback = fallback;
|
|
this.items = items;
|
|
this.tags = tags;
|
|
this.options = options;
|
|
this.nodes = nodes;
|
|
this.preprocessors = preprocessors;
|
|
this.postprocessors = postprocessors;
|
|
this.initMethod = initMethod;
|
|
this.configMethod = configMethod;
|
|
this.priority = priority;
|
|
this.parser = parser;
|
|
this.handler = Object.assign({ character: [], delimiter: [], macro: [], environment: [] }, handler);
|
|
}
|
|
Configuration.makeProcessor = function (func, priority) {
|
|
return Array.isArray(func) ? func : [func, priority];
|
|
};
|
|
Configuration._create = function (name, config) {
|
|
var _this = this;
|
|
if (config === void 0) { config = {}; }
|
|
var priority = config.priority || PrioritizedList_js_1.PrioritizedList.DEFAULTPRIORITY;
|
|
var init = config.init ? this.makeProcessor(config.init, priority) : null;
|
|
var conf = config.config ? this.makeProcessor(config.config, priority) : null;
|
|
var preprocessors = (config.preprocessors || []).map(function (pre) { return _this.makeProcessor(pre, priority); });
|
|
var postprocessors = (config.postprocessors || []).map(function (post) { return _this.makeProcessor(post, priority); });
|
|
var parser = config.parser || 'tex';
|
|
return new Configuration(name, config.handler || {}, config.fallback || {}, config.items || {}, config.tags || {}, config.options || {}, config.nodes || {}, preprocessors, postprocessors, init, conf, priority, parser);
|
|
};
|
|
Configuration.create = function (name, config) {
|
|
if (config === void 0) { config = {}; }
|
|
var configuration = Configuration._create(name, config);
|
|
ConfigurationHandler.set(name, configuration);
|
|
return configuration;
|
|
};
|
|
Configuration.local = function (config) {
|
|
if (config === void 0) { config = {}; }
|
|
return Configuration._create('', config);
|
|
};
|
|
Object.defineProperty(Configuration.prototype, "init", {
|
|
get: function () {
|
|
return this.initMethod ? this.initMethod[0] : null;
|
|
},
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(Configuration.prototype, "config", {
|
|
get: function () {
|
|
return this.configMethod ? this.configMethod[0] : null;
|
|
},
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
return Configuration;
|
|
}());
|
|
exports.Configuration = Configuration;
|
|
var ConfigurationHandler;
|
|
(function (ConfigurationHandler) {
|
|
var maps = new Map();
|
|
ConfigurationHandler.set = function (name, map) {
|
|
maps.set(name, map);
|
|
};
|
|
ConfigurationHandler.get = function (name) {
|
|
return maps.get(name);
|
|
};
|
|
ConfigurationHandler.keys = function () {
|
|
return maps.keys();
|
|
};
|
|
})(ConfigurationHandler = exports.ConfigurationHandler || (exports.ConfigurationHandler = {}));
|
|
var ParserConfiguration = (function () {
|
|
function ParserConfiguration(packages, parsers) {
|
|
var e_1, _a, e_2, _b;
|
|
if (parsers === void 0) { parsers = ['tex']; }
|
|
this.initMethod = new FunctionList_js_1.FunctionList();
|
|
this.configMethod = new FunctionList_js_1.FunctionList();
|
|
this.configurations = new PrioritizedList_js_1.PrioritizedList();
|
|
this.parsers = [];
|
|
this.handlers = new MapHandler_js_1.SubHandlers();
|
|
this.items = {};
|
|
this.tags = {};
|
|
this.options = {};
|
|
this.nodes = {};
|
|
this.parsers = parsers;
|
|
try {
|
|
for (var _c = __values(packages.slice().reverse()), _d = _c.next(); !_d.done; _d = _c.next()) {
|
|
var pkg = _d.value;
|
|
this.addPackage(pkg);
|
|
}
|
|
}
|
|
catch (e_1_1) { e_1 = { error: e_1_1 }; }
|
|
finally {
|
|
try {
|
|
if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
|
|
}
|
|
finally { if (e_1) throw e_1.error; }
|
|
}
|
|
try {
|
|
for (var _e = __values(this.configurations), _f = _e.next(); !_f.done; _f = _e.next()) {
|
|
var _g = _f.value, config = _g.item, priority = _g.priority;
|
|
this.append(config, priority);
|
|
}
|
|
}
|
|
catch (e_2_1) { e_2 = { error: e_2_1 }; }
|
|
finally {
|
|
try {
|
|
if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
|
|
}
|
|
finally { if (e_2) throw e_2.error; }
|
|
}
|
|
}
|
|
ParserConfiguration.prototype.init = function () {
|
|
this.initMethod.execute(this);
|
|
};
|
|
ParserConfiguration.prototype.config = function (jax) {
|
|
var e_3, _a;
|
|
this.configMethod.execute(this, jax);
|
|
try {
|
|
for (var _b = __values(this.configurations), _c = _b.next(); !_c.done; _c = _b.next()) {
|
|
var config = _c.value;
|
|
this.addFilters(jax, config.item);
|
|
}
|
|
}
|
|
catch (e_3_1) { e_3 = { error: e_3_1 }; }
|
|
finally {
|
|
try {
|
|
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
|
|
}
|
|
finally { if (e_3) throw e_3.error; }
|
|
}
|
|
};
|
|
ParserConfiguration.prototype.addPackage = function (pkg) {
|
|
var name = typeof pkg === 'string' ? pkg : pkg[0];
|
|
var conf = this.getPackage(name);
|
|
conf && this.configurations.add(conf, typeof pkg === 'string' ? conf.priority : pkg[1]);
|
|
};
|
|
ParserConfiguration.prototype.add = function (name, jax, options) {
|
|
var e_4, _a;
|
|
if (options === void 0) { options = {}; }
|
|
var config = this.getPackage(name);
|
|
this.append(config);
|
|
this.configurations.add(config, config.priority);
|
|
this.init();
|
|
var parser = jax.parseOptions;
|
|
parser.nodeFactory.setCreators(config.nodes);
|
|
try {
|
|
for (var _b = __values(Object.keys(config.items)), _c = _b.next(); !_c.done; _c = _b.next()) {
|
|
var kind = _c.value;
|
|
parser.itemFactory.setNodeClass(kind, config.items[kind]);
|
|
}
|
|
}
|
|
catch (e_4_1) { e_4 = { error: e_4_1 }; }
|
|
finally {
|
|
try {
|
|
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
|
|
}
|
|
finally { if (e_4) throw e_4.error; }
|
|
}
|
|
Tags_js_1.TagsFactory.addTags(config.tags);
|
|
(0, Options_js_1.defaultOptions)(parser.options, config.options);
|
|
(0, Options_js_1.userOptions)(parser.options, options);
|
|
this.addFilters(jax, config);
|
|
if (config.config) {
|
|
config.config(this, jax);
|
|
}
|
|
};
|
|
ParserConfiguration.prototype.getPackage = function (name) {
|
|
var config = ConfigurationHandler.get(name);
|
|
if (config && this.parsers.indexOf(config.parser) < 0) {
|
|
throw Error("Package ".concat(name, " doesn't target the proper parser"));
|
|
}
|
|
return config;
|
|
};
|
|
ParserConfiguration.prototype.append = function (config, priority) {
|
|
priority = priority || config.priority;
|
|
if (config.initMethod) {
|
|
this.initMethod.add(config.initMethod[0], config.initMethod[1]);
|
|
}
|
|
if (config.configMethod) {
|
|
this.configMethod.add(config.configMethod[0], config.configMethod[1]);
|
|
}
|
|
this.handlers.add(config.handler, config.fallback, priority);
|
|
Object.assign(this.items, config.items);
|
|
Object.assign(this.tags, config.tags);
|
|
(0, Options_js_1.defaultOptions)(this.options, config.options);
|
|
Object.assign(this.nodes, config.nodes);
|
|
};
|
|
ParserConfiguration.prototype.addFilters = function (jax, config) {
|
|
var e_5, _a, e_6, _b;
|
|
try {
|
|
for (var _c = __values(config.preprocessors), _d = _c.next(); !_d.done; _d = _c.next()) {
|
|
var _e = __read(_d.value, 2), pre = _e[0], priority = _e[1];
|
|
jax.preFilters.add(pre, priority);
|
|
}
|
|
}
|
|
catch (e_5_1) { e_5 = { error: e_5_1 }; }
|
|
finally {
|
|
try {
|
|
if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
|
|
}
|
|
finally { if (e_5) throw e_5.error; }
|
|
}
|
|
try {
|
|
for (var _f = __values(config.postprocessors), _g = _f.next(); !_g.done; _g = _f.next()) {
|
|
var _h = __read(_g.value, 2), post = _h[0], priority = _h[1];
|
|
jax.postFilters.add(post, priority);
|
|
}
|
|
}
|
|
catch (e_6_1) { e_6 = { error: e_6_1 }; }
|
|
finally {
|
|
try {
|
|
if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
|
|
}
|
|
finally { if (e_6) throw e_6.error; }
|
|
}
|
|
};
|
|
return ParserConfiguration;
|
|
}());
|
|
exports.ParserConfiguration = ParserConfiguration;
|
|
//# sourceMappingURL=Configuration.js.map
|
|
|
|
/***/ }),
|
|
|
|
/***/ 21683:
|
|
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
|
|
|
|
|
|
var __values = (this && this.__values) || function(o) {
|
|
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
|
|
if (m) return m.call(o);
|
|
if (o && typeof o.length === "number") return {
|
|
next: function () {
|
|
if (o && i >= o.length) o = void 0;
|
|
return { value: o && o[i++], done: !o };
|
|
}
|
|
};
|
|
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
|
|
};
|
|
var __read = (this && this.__read) || function (o, n) {
|
|
var m = typeof Symbol === "function" && o[Symbol.iterator];
|
|
if (!m) return o;
|
|
var i = m.call(o), r, ar = [], e;
|
|
try {
|
|
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
|
|
}
|
|
catch (error) { e = { error: error }; }
|
|
finally {
|
|
try {
|
|
if (r && !r.done && (m = i["return"])) m.call(i);
|
|
}
|
|
finally { if (e) throw e.error; }
|
|
}
|
|
return ar;
|
|
};
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
exports.SubHandlers = exports.SubHandler = exports.MapHandler = void 0;
|
|
var PrioritizedList_js_1 = __webpack_require__(98721);
|
|
var FunctionList_js_1 = __webpack_require__(18341);
|
|
var MapHandler;
|
|
(function (MapHandler) {
|
|
var maps = new Map();
|
|
MapHandler.register = function (map) {
|
|
maps.set(map.name, map);
|
|
};
|
|
MapHandler.getMap = function (name) {
|
|
return maps.get(name);
|
|
};
|
|
})(MapHandler = exports.MapHandler || (exports.MapHandler = {}));
|
|
var SubHandler = (function () {
|
|
function SubHandler() {
|
|
this._configuration = new PrioritizedList_js_1.PrioritizedList();
|
|
this._fallback = new FunctionList_js_1.FunctionList();
|
|
}
|
|
SubHandler.prototype.add = function (maps, fallback, priority) {
|
|
var e_1, _a;
|
|
if (priority === void 0) { priority = PrioritizedList_js_1.PrioritizedList.DEFAULTPRIORITY; }
|
|
try {
|
|
for (var _b = __values(maps.slice().reverse()), _c = _b.next(); !_c.done; _c = _b.next()) {
|
|
var name_1 = _c.value;
|
|
var map = MapHandler.getMap(name_1);
|
|
if (!map) {
|
|
this.warn('Configuration ' + name_1 + ' not found! Omitted.');
|
|
return;
|
|
}
|
|
this._configuration.add(map, priority);
|
|
}
|
|
}
|
|
catch (e_1_1) { e_1 = { error: e_1_1 }; }
|
|
finally {
|
|
try {
|
|
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
|
|
}
|
|
finally { if (e_1) throw e_1.error; }
|
|
}
|
|
if (fallback) {
|
|
this._fallback.add(fallback, priority);
|
|
}
|
|
};
|
|
SubHandler.prototype.parse = function (input) {
|
|
var e_2, _a;
|
|
try {
|
|
for (var _b = __values(this._configuration), _c = _b.next(); !_c.done; _c = _b.next()) {
|
|
var map = _c.value.item;
|
|
var result = map.parse(input);
|
|
if (result) {
|
|
return result;
|
|
}
|
|
}
|
|
}
|
|
catch (e_2_1) { e_2 = { error: e_2_1 }; }
|
|
finally {
|
|
try {
|
|
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
|
|
}
|
|
finally { if (e_2) throw e_2.error; }
|
|
}
|
|
var _d = __read(input, 2), env = _d[0], symbol = _d[1];
|
|
Array.from(this._fallback)[0].item(env, symbol);
|
|
};
|
|
SubHandler.prototype.lookup = function (symbol) {
|
|
var map = this.applicable(symbol);
|
|
return map ? map.lookup(symbol) : null;
|
|
};
|
|
SubHandler.prototype.contains = function (symbol) {
|
|
return this.applicable(symbol) ? true : false;
|
|
};
|
|
SubHandler.prototype.toString = function () {
|
|
var e_3, _a;
|
|
var names = [];
|
|
try {
|
|
for (var _b = __values(this._configuration), _c = _b.next(); !_c.done; _c = _b.next()) {
|
|
var map = _c.value.item;
|
|
names.push(map.name);
|
|
}
|
|
}
|
|
catch (e_3_1) { e_3 = { error: e_3_1 }; }
|
|
finally {
|
|
try {
|
|
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
|
|
}
|
|
finally { if (e_3) throw e_3.error; }
|
|
}
|
|
return names.join(', ');
|
|
};
|
|
SubHandler.prototype.applicable = function (symbol) {
|
|
var e_4, _a;
|
|
try {
|
|
for (var _b = __values(this._configuration), _c = _b.next(); !_c.done; _c = _b.next()) {
|
|
var map = _c.value.item;
|
|
if (map.contains(symbol)) {
|
|
return map;
|
|
}
|
|
}
|
|
}
|
|
catch (e_4_1) { e_4 = { error: e_4_1 }; }
|
|
finally {
|
|
try {
|
|
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
|
|
}
|
|
finally { if (e_4) throw e_4.error; }
|
|
}
|
|
return null;
|
|
};
|
|
SubHandler.prototype.retrieve = function (name) {
|
|
var e_5, _a;
|
|
try {
|
|
for (var _b = __values(this._configuration), _c = _b.next(); !_c.done; _c = _b.next()) {
|
|
var map = _c.value.item;
|
|
if (map.name === name) {
|
|
return map;
|
|
}
|
|
}
|
|
}
|
|
catch (e_5_1) { e_5 = { error: e_5_1 }; }
|
|
finally {
|
|
try {
|
|
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
|
|
}
|
|
finally { if (e_5) throw e_5.error; }
|
|
}
|
|
return null;
|
|
};
|
|
SubHandler.prototype.warn = function (message) {
|
|
console.log('TexParser Warning: ' + message);
|
|
};
|
|
return SubHandler;
|
|
}());
|
|
exports.SubHandler = SubHandler;
|
|
var SubHandlers = (function () {
|
|
function SubHandlers() {
|
|
this.map = new Map();
|
|
}
|
|
SubHandlers.prototype.add = function (handlers, fallbacks, priority) {
|
|
var e_6, _a;
|
|
if (priority === void 0) { priority = PrioritizedList_js_1.PrioritizedList.DEFAULTPRIORITY; }
|
|
try {
|
|
for (var _b = __values(Object.keys(handlers)), _c = _b.next(); !_c.done; _c = _b.next()) {
|
|
var key = _c.value;
|
|
var name_2 = key;
|
|
var subHandler = this.get(name_2);
|
|
if (!subHandler) {
|
|
subHandler = new SubHandler();
|
|
this.set(name_2, subHandler);
|
|
}
|
|
subHandler.add(handlers[name_2], fallbacks[name_2], priority);
|
|
}
|
|
}
|
|
catch (e_6_1) { e_6 = { error: e_6_1 }; }
|
|
finally {
|
|
try {
|
|
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
|
|
}
|
|
finally { if (e_6) throw e_6.error; }
|
|
}
|
|
};
|
|
SubHandlers.prototype.set = function (name, subHandler) {
|
|
this.map.set(name, subHandler);
|
|
};
|
|
SubHandlers.prototype.get = function (name) {
|
|
return this.map.get(name);
|
|
};
|
|
SubHandlers.prototype.retrieve = function (name) {
|
|
var e_7, _a;
|
|
try {
|
|
for (var _b = __values(this.map.values()), _c = _b.next(); !_c.done; _c = _b.next()) {
|
|
var handler = _c.value;
|
|
var map = handler.retrieve(name);
|
|
if (map) {
|
|
return map;
|
|
}
|
|
}
|
|
}
|
|
catch (e_7_1) { e_7 = { error: e_7_1 }; }
|
|
finally {
|
|
try {
|
|
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
|
|
}
|
|
finally { if (e_7) throw e_7.error; }
|
|
}
|
|
return null;
|
|
};
|
|
SubHandlers.prototype.keys = function () {
|
|
return this.map.keys();
|
|
};
|
|
return SubHandlers;
|
|
}());
|
|
exports.SubHandlers = SubHandlers;
|
|
//# sourceMappingURL=MapHandler.js.map
|
|
|
|
/***/ }),
|
|
|
|
/***/ 53972:
|
|
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
|
|
|
|
|
|
var __values = (this && this.__values) || function(o) {
|
|
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
|
|
if (m) return m.call(o);
|
|
if (o && typeof o.length === "number") return {
|
|
next: function () {
|
|
if (o && i >= o.length) o = void 0;
|
|
return { value: o && o[i++], done: !o };
|
|
}
|
|
};
|
|
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
|
|
};
|
|
var __read = (this && this.__read) || function (o, n) {
|
|
var m = typeof Symbol === "function" && o[Symbol.iterator];
|
|
if (!m) return o;
|
|
var i = m.call(o), r, ar = [], e;
|
|
try {
|
|
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
|
|
}
|
|
catch (error) { e = { error: error }; }
|
|
finally {
|
|
try {
|
|
if (r && !r.done && (m = i["return"])) m.call(i);
|
|
}
|
|
finally { if (e) throw e.error; }
|
|
}
|
|
return ar;
|
|
};
|
|
var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
|
|
if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
|
|
if (ar || !(i in from)) {
|
|
if (!ar) ar = Array.prototype.slice.call(from, 0, i);
|
|
ar[i] = from[i];
|
|
}
|
|
}
|
|
return to.concat(ar || Array.prototype.slice.call(from));
|
|
};
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
var MmlNode_js_1 = __webpack_require__(83045);
|
|
var mo_js_1 = __webpack_require__(19625);
|
|
var NodeUtil;
|
|
(function (NodeUtil) {
|
|
var attrs = new Map([
|
|
['autoOP', true],
|
|
['fnOP', true],
|
|
['movesupsub', true],
|
|
['subsupOK', true],
|
|
['texprimestyle', true],
|
|
['useHeight', true],
|
|
['variantForm', true],
|
|
['withDelims', true],
|
|
['mathaccent', true],
|
|
['open', true],
|
|
['close', true]
|
|
]);
|
|
function createEntity(code) {
|
|
return String.fromCodePoint(parseInt(code, 16));
|
|
}
|
|
NodeUtil.createEntity = createEntity;
|
|
function getChildren(node) {
|
|
return node.childNodes;
|
|
}
|
|
NodeUtil.getChildren = getChildren;
|
|
function getText(node) {
|
|
return node.getText();
|
|
}
|
|
NodeUtil.getText = getText;
|
|
function appendChildren(node, children) {
|
|
var e_1, _a;
|
|
try {
|
|
for (var children_1 = __values(children), children_1_1 = children_1.next(); !children_1_1.done; children_1_1 = children_1.next()) {
|
|
var child = children_1_1.value;
|
|
node.appendChild(child);
|
|
}
|
|
}
|
|
catch (e_1_1) { e_1 = { error: e_1_1 }; }
|
|
finally {
|
|
try {
|
|
if (children_1_1 && !children_1_1.done && (_a = children_1.return)) _a.call(children_1);
|
|
}
|
|
finally { if (e_1) throw e_1.error; }
|
|
}
|
|
}
|
|
NodeUtil.appendChildren = appendChildren;
|
|
function setAttribute(node, attribute, value) {
|
|
node.attributes.set(attribute, value);
|
|
}
|
|
NodeUtil.setAttribute = setAttribute;
|
|
function setProperty(node, property, value) {
|
|
node.setProperty(property, value);
|
|
}
|
|
NodeUtil.setProperty = setProperty;
|
|
function setProperties(node, properties) {
|
|
var e_2, _a;
|
|
try {
|
|
for (var _b = __values(Object.keys(properties)), _c = _b.next(); !_c.done; _c = _b.next()) {
|
|
var name_1 = _c.value;
|
|
var value = properties[name_1];
|
|
if (name_1 === 'texClass') {
|
|
node.texClass = value;
|
|
node.setProperty(name_1, value);
|
|
}
|
|
else if (name_1 === 'movablelimits') {
|
|
node.setProperty('movablelimits', value);
|
|
if (node.isKind('mo') || node.isKind('mstyle')) {
|
|
node.attributes.set('movablelimits', value);
|
|
}
|
|
}
|
|
else if (name_1 === 'inferred') {
|
|
}
|
|
else if (attrs.has(name_1)) {
|
|
node.setProperty(name_1, value);
|
|
}
|
|
else {
|
|
node.attributes.set(name_1, value);
|
|
}
|
|
}
|
|
}
|
|
catch (e_2_1) { e_2 = { error: e_2_1 }; }
|
|
finally {
|
|
try {
|
|
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
|
|
}
|
|
finally { if (e_2) throw e_2.error; }
|
|
}
|
|
}
|
|
NodeUtil.setProperties = setProperties;
|
|
function getProperty(node, property) {
|
|
return node.getProperty(property);
|
|
}
|
|
NodeUtil.getProperty = getProperty;
|
|
function getAttribute(node, attr) {
|
|
return node.attributes.get(attr);
|
|
}
|
|
NodeUtil.getAttribute = getAttribute;
|
|
function removeProperties(node) {
|
|
var properties = [];
|
|
for (var _i = 1; _i < arguments.length; _i++) {
|
|
properties[_i - 1] = arguments[_i];
|
|
}
|
|
node.removeProperty.apply(node, __spreadArray([], __read(properties), false));
|
|
}
|
|
NodeUtil.removeProperties = removeProperties;
|
|
function getChildAt(node, position) {
|
|
return node.childNodes[position];
|
|
}
|
|
NodeUtil.getChildAt = getChildAt;
|
|
function setChild(node, position, child) {
|
|
var children = node.childNodes;
|
|
children[position] = child;
|
|
if (child) {
|
|
child.parent = node;
|
|
}
|
|
}
|
|
NodeUtil.setChild = setChild;
|
|
function copyChildren(oldNode, newNode) {
|
|
var children = oldNode.childNodes;
|
|
for (var i = 0; i < children.length; i++) {
|
|
setChild(newNode, i, children[i]);
|
|
}
|
|
}
|
|
NodeUtil.copyChildren = copyChildren;
|
|
function copyAttributes(oldNode, newNode) {
|
|
newNode.attributes = oldNode.attributes;
|
|
setProperties(newNode, oldNode.getAllProperties());
|
|
}
|
|
NodeUtil.copyAttributes = copyAttributes;
|
|
function isType(node, kind) {
|
|
return node.isKind(kind);
|
|
}
|
|
NodeUtil.isType = isType;
|
|
function isEmbellished(node) {
|
|
return node.isEmbellished;
|
|
}
|
|
NodeUtil.isEmbellished = isEmbellished;
|
|
function getTexClass(node) {
|
|
return node.texClass;
|
|
}
|
|
NodeUtil.getTexClass = getTexClass;
|
|
function getCoreMO(node) {
|
|
return node.coreMO();
|
|
}
|
|
NodeUtil.getCoreMO = getCoreMO;
|
|
function isNode(item) {
|
|
return item instanceof MmlNode_js_1.AbstractMmlNode || item instanceof MmlNode_js_1.AbstractMmlEmptyNode;
|
|
}
|
|
NodeUtil.isNode = isNode;
|
|
function isInferred(node) {
|
|
return node.isInferred;
|
|
}
|
|
NodeUtil.isInferred = isInferred;
|
|
function getForm(node) {
|
|
var e_3, _a;
|
|
if (!isType(node, 'mo')) {
|
|
return null;
|
|
}
|
|
var mo = node;
|
|
var forms = mo.getForms();
|
|
try {
|
|
for (var forms_1 = __values(forms), forms_1_1 = forms_1.next(); !forms_1_1.done; forms_1_1 = forms_1.next()) {
|
|
var form = forms_1_1.value;
|
|
var symbol = mo_js_1.MmlMo.OPTABLE[form][mo.getText()];
|
|
if (symbol) {
|
|
return symbol;
|
|
}
|
|
}
|
|
}
|
|
catch (e_3_1) { e_3 = { error: e_3_1 }; }
|
|
finally {
|
|
try {
|
|
if (forms_1_1 && !forms_1_1.done && (_a = forms_1.return)) _a.call(forms_1);
|
|
}
|
|
finally { if (e_3) throw e_3.error; }
|
|
}
|
|
return null;
|
|
}
|
|
NodeUtil.getForm = getForm;
|
|
})(NodeUtil || (NodeUtil = {}));
|
|
exports["default"] = NodeUtil;
|
|
//# sourceMappingURL=NodeUtil.js.map
|
|
|
|
/***/ }),
|
|
|
|
/***/ 55038:
|
|
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
|
|
|
|
|
|
var __read = (this && this.__read) || function (o, n) {
|
|
var m = typeof Symbol === "function" && o[Symbol.iterator];
|
|
if (!m) return o;
|
|
var i = m.call(o), r, ar = [], e;
|
|
try {
|
|
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
|
|
}
|
|
catch (error) { e = { error: error }; }
|
|
finally {
|
|
try {
|
|
if (r && !r.done && (m = i["return"])) m.call(i);
|
|
}
|
|
finally { if (e) throw e.error; }
|
|
}
|
|
return ar;
|
|
};
|
|
var __values = (this && this.__values) || function(o) {
|
|
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
|
|
if (m) return m.call(o);
|
|
if (o && typeof o.length === "number") return {
|
|
next: function () {
|
|
if (o && i >= o.length) o = void 0;
|
|
return { value: o && o[i++], done: !o };
|
|
}
|
|
};
|
|
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
|
|
};
|
|
var __importDefault = (this && this.__importDefault) || function (mod) {
|
|
return (mod && mod.__esModule) ? mod : { "default": mod };
|
|
};
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
var MmlNode_js_1 = __webpack_require__(83045);
|
|
var NodeUtil_js_1 = __importDefault(__webpack_require__(53972));
|
|
var TexParser_js_1 = __importDefault(__webpack_require__(94032));
|
|
var TexError_js_1 = __importDefault(__webpack_require__(54420));
|
|
var Entities_js_1 = __webpack_require__(61051);
|
|
var ParseUtil;
|
|
(function (ParseUtil) {
|
|
var emPerInch = 7.2;
|
|
var pxPerInch = 72;
|
|
var UNIT_CASES = {
|
|
'em': function (m) { return m; },
|
|
'ex': function (m) { return m * .43; },
|
|
'pt': function (m) { return m / 10; },
|
|
'pc': function (m) { return m * 1.2; },
|
|
'px': function (m) { return m * emPerInch / pxPerInch; },
|
|
'in': function (m) { return m * emPerInch; },
|
|
'cm': function (m) { return m * emPerInch / 2.54; },
|
|
'mm': function (m) { return m * emPerInch / 25.4; },
|
|
'mu': function (m) { return m / 18; },
|
|
};
|
|
var num = '([-+]?([.,]\\d+|\\d+([.,]\\d*)?))';
|
|
var unit = '(pt|em|ex|mu|px|mm|cm|in|pc)';
|
|
var dimenEnd = RegExp('^\\s*' + num + '\\s*' + unit + '\\s*$');
|
|
var dimenRest = RegExp('^\\s*' + num + '\\s*' + unit + ' ?');
|
|
function matchDimen(dim, rest) {
|
|
if (rest === void 0) { rest = false; }
|
|
var match = dim.match(rest ? dimenRest : dimenEnd);
|
|
return match ?
|
|
muReplace([match[1].replace(/,/, '.'), match[4], match[0].length]) :
|
|
[null, null, 0];
|
|
}
|
|
ParseUtil.matchDimen = matchDimen;
|
|
function muReplace(_a) {
|
|
var _b = __read(_a, 3), value = _b[0], unit = _b[1], length = _b[2];
|
|
if (unit !== 'mu') {
|
|
return [value, unit, length];
|
|
}
|
|
var em = Em(UNIT_CASES[unit](parseFloat(value || '1')));
|
|
return [em.slice(0, -2), 'em', length];
|
|
}
|
|
function dimen2em(dim) {
|
|
var _a = __read(matchDimen(dim), 2), value = _a[0], unit = _a[1];
|
|
var m = parseFloat(value || '1');
|
|
var func = UNIT_CASES[unit];
|
|
return func ? func(m) : 0;
|
|
}
|
|
ParseUtil.dimen2em = dimen2em;
|
|
function Em(m) {
|
|
if (Math.abs(m) < .0006) {
|
|
return '0em';
|
|
}
|
|
return m.toFixed(3).replace(/\.?0+$/, '') + 'em';
|
|
}
|
|
ParseUtil.Em = Em;
|
|
function cols() {
|
|
var W = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
W[_i] = arguments[_i];
|
|
}
|
|
return W.map(function (n) { return Em(n); }).join(' ');
|
|
}
|
|
ParseUtil.cols = cols;
|
|
function fenced(configuration, open, mml, close, big, color) {
|
|
if (big === void 0) { big = ''; }
|
|
if (color === void 0) { color = ''; }
|
|
var nf = configuration.nodeFactory;
|
|
var mrow = nf.create('node', 'mrow', [], { open: open, close: close, texClass: MmlNode_js_1.TEXCLASS.INNER });
|
|
var mo;
|
|
if (big) {
|
|
mo = new TexParser_js_1.default('\\' + big + 'l' + open, configuration.parser.stack.env, configuration).mml();
|
|
}
|
|
else {
|
|
var openNode = nf.create('text', open);
|
|
mo = nf.create('node', 'mo', [], { fence: true, stretchy: true, symmetric: true, texClass: MmlNode_js_1.TEXCLASS.OPEN }, openNode);
|
|
}
|
|
NodeUtil_js_1.default.appendChildren(mrow, [mo, mml]);
|
|
if (big) {
|
|
mo = new TexParser_js_1.default('\\' + big + 'r' + close, configuration.parser.stack.env, configuration).mml();
|
|
}
|
|
else {
|
|
var closeNode = nf.create('text', close);
|
|
mo = nf.create('node', 'mo', [], { fence: true, stretchy: true, symmetric: true, texClass: MmlNode_js_1.TEXCLASS.CLOSE }, closeNode);
|
|
}
|
|
color && mo.attributes.set('mathcolor', color);
|
|
NodeUtil_js_1.default.appendChildren(mrow, [mo]);
|
|
return mrow;
|
|
}
|
|
ParseUtil.fenced = fenced;
|
|
function fixedFence(configuration, open, mml, close) {
|
|
var mrow = configuration.nodeFactory.create('node', 'mrow', [], { open: open, close: close, texClass: MmlNode_js_1.TEXCLASS.ORD });
|
|
if (open) {
|
|
NodeUtil_js_1.default.appendChildren(mrow, [mathPalette(configuration, open, 'l')]);
|
|
}
|
|
if (NodeUtil_js_1.default.isType(mml, 'mrow')) {
|
|
NodeUtil_js_1.default.appendChildren(mrow, NodeUtil_js_1.default.getChildren(mml));
|
|
}
|
|
else {
|
|
NodeUtil_js_1.default.appendChildren(mrow, [mml]);
|
|
}
|
|
if (close) {
|
|
NodeUtil_js_1.default.appendChildren(mrow, [mathPalette(configuration, close, 'r')]);
|
|
}
|
|
return mrow;
|
|
}
|
|
ParseUtil.fixedFence = fixedFence;
|
|
function mathPalette(configuration, fence, side) {
|
|
if (fence === '{' || fence === '}') {
|
|
fence = '\\' + fence;
|
|
}
|
|
var D = '{\\bigg' + side + ' ' + fence + '}';
|
|
var T = '{\\big' + side + ' ' + fence + '}';
|
|
return new TexParser_js_1.default('\\mathchoice' + D + T + T + T, {}, configuration).mml();
|
|
}
|
|
ParseUtil.mathPalette = mathPalette;
|
|
function fixInitialMO(configuration, nodes) {
|
|
for (var i = 0, m = nodes.length; i < m; i++) {
|
|
var child = nodes[i];
|
|
if (child && (!NodeUtil_js_1.default.isType(child, 'mspace') &&
|
|
(!NodeUtil_js_1.default.isType(child, 'TeXAtom') ||
|
|
(NodeUtil_js_1.default.getChildren(child)[0] &&
|
|
NodeUtil_js_1.default.getChildren(NodeUtil_js_1.default.getChildren(child)[0]).length)))) {
|
|
if (NodeUtil_js_1.default.isEmbellished(child) ||
|
|
(NodeUtil_js_1.default.isType(child, 'TeXAtom') && NodeUtil_js_1.default.getTexClass(child) === MmlNode_js_1.TEXCLASS.REL)) {
|
|
var mi = configuration.nodeFactory.create('node', 'mi');
|
|
nodes.unshift(mi);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
ParseUtil.fixInitialMO = fixInitialMO;
|
|
function internalMath(parser, text, level, font) {
|
|
if (parser.configuration.options.internalMath) {
|
|
return parser.configuration.options.internalMath(parser, text, level, font);
|
|
}
|
|
var mathvariant = font || parser.stack.env.font;
|
|
var def = (mathvariant ? { mathvariant: mathvariant } : {});
|
|
var mml = [], i = 0, k = 0, c, node, match = '', braces = 0;
|
|
if (text.match(/\\?[${}\\]|\\\(|\\(eq)?ref\s*\{/)) {
|
|
while (i < text.length) {
|
|
c = text.charAt(i++);
|
|
if (c === '$') {
|
|
if (match === '$' && braces === 0) {
|
|
node = parser.create('node', 'TeXAtom', [(new TexParser_js_1.default(text.slice(k, i - 1), {}, parser.configuration)).mml()]);
|
|
mml.push(node);
|
|
match = '';
|
|
k = i;
|
|
}
|
|
else if (match === '') {
|
|
if (k < i - 1) {
|
|
mml.push(internalText(parser, text.slice(k, i - 1), def));
|
|
}
|
|
match = '$';
|
|
k = i;
|
|
}
|
|
}
|
|
else if (c === '{' && match !== '') {
|
|
braces++;
|
|
}
|
|
else if (c === '}') {
|
|
if (match === '}' && braces === 0) {
|
|
var atom = (new TexParser_js_1.default(text.slice(k, i), {}, parser.configuration)).mml();
|
|
node = parser.create('node', 'TeXAtom', [atom], def);
|
|
mml.push(node);
|
|
match = '';
|
|
k = i;
|
|
}
|
|
else if (match !== '') {
|
|
if (braces) {
|
|
braces--;
|
|
}
|
|
}
|
|
}
|
|
else if (c === '\\') {
|
|
if (match === '' && text.substr(i).match(/^(eq)?ref\s*\{/)) {
|
|
var len = RegExp['$&'].length;
|
|
if (k < i - 1) {
|
|
mml.push(internalText(parser, text.slice(k, i - 1), def));
|
|
}
|
|
match = '}';
|
|
k = i - 1;
|
|
i += len;
|
|
}
|
|
else {
|
|
c = text.charAt(i++);
|
|
if (c === '(' && match === '') {
|
|
if (k < i - 2) {
|
|
mml.push(internalText(parser, text.slice(k, i - 2), def));
|
|
}
|
|
match = ')';
|
|
k = i;
|
|
}
|
|
else if (c === ')' && match === ')' && braces === 0) {
|
|
node = parser.create('node', 'TeXAtom', [(new TexParser_js_1.default(text.slice(k, i - 2), {}, parser.configuration)).mml()]);
|
|
mml.push(node);
|
|
match = '';
|
|
k = i;
|
|
}
|
|
else if (c.match(/[${}\\]/) && match === '') {
|
|
i--;
|
|
text = text.substr(0, i - 1) + text.substr(i);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (match !== '') {
|
|
throw new TexError_js_1.default('MathNotTerminated', 'Math not terminated in text box');
|
|
}
|
|
}
|
|
if (k < text.length) {
|
|
mml.push(internalText(parser, text.slice(k), def));
|
|
}
|
|
if (level != null) {
|
|
mml = [parser.create('node', 'mstyle', mml, { displaystyle: false, scriptlevel: level })];
|
|
}
|
|
else if (mml.length > 1) {
|
|
mml = [parser.create('node', 'mrow', mml)];
|
|
}
|
|
return mml;
|
|
}
|
|
ParseUtil.internalMath = internalMath;
|
|
function internalText(parser, text, def) {
|
|
text = text.replace(/^\s+/, Entities_js_1.entities.nbsp).replace(/\s+$/, Entities_js_1.entities.nbsp);
|
|
var textNode = parser.create('text', text);
|
|
return parser.create('node', 'mtext', [], def, textNode);
|
|
}
|
|
ParseUtil.internalText = internalText;
|
|
function underOver(parser, base, script, pos, stack) {
|
|
ParseUtil.checkMovableLimits(base);
|
|
if (NodeUtil_js_1.default.isType(base, 'munderover') && NodeUtil_js_1.default.isEmbellished(base)) {
|
|
NodeUtil_js_1.default.setProperties(NodeUtil_js_1.default.getCoreMO(base), { lspace: 0, rspace: 0 });
|
|
var mo = parser.create('node', 'mo', [], { rspace: 0 });
|
|
base = parser.create('node', 'mrow', [mo, base]);
|
|
}
|
|
var mml = parser.create('node', 'munderover', [base]);
|
|
NodeUtil_js_1.default.setChild(mml, pos === 'over' ? mml.over : mml.under, script);
|
|
var node = mml;
|
|
if (stack) {
|
|
node = parser.create('node', 'TeXAtom', [mml], { texClass: MmlNode_js_1.TEXCLASS.OP, movesupsub: true });
|
|
}
|
|
NodeUtil_js_1.default.setProperty(node, 'subsupOK', true);
|
|
return node;
|
|
}
|
|
ParseUtil.underOver = underOver;
|
|
function checkMovableLimits(base) {
|
|
var symbol = (NodeUtil_js_1.default.isType(base, 'mo') ? NodeUtil_js_1.default.getForm(base) : null);
|
|
if (NodeUtil_js_1.default.getProperty(base, 'movablelimits') || (symbol && symbol[3] && symbol[3].movablelimits)) {
|
|
NodeUtil_js_1.default.setProperties(base, { movablelimits: false });
|
|
}
|
|
}
|
|
ParseUtil.checkMovableLimits = checkMovableLimits;
|
|
function trimSpaces(text) {
|
|
if (typeof (text) !== 'string') {
|
|
return text;
|
|
}
|
|
var TEXT = text.trim();
|
|
if (TEXT.match(/\\$/) && text.match(/ $/)) {
|
|
TEXT += ' ';
|
|
}
|
|
return TEXT;
|
|
}
|
|
ParseUtil.trimSpaces = trimSpaces;
|
|
function setArrayAlign(array, align) {
|
|
align = ParseUtil.trimSpaces(align || '');
|
|
if (align === 't') {
|
|
array.arraydef.align = 'baseline 1';
|
|
}
|
|
else if (align === 'b') {
|
|
array.arraydef.align = 'baseline -1';
|
|
}
|
|
else if (align === 'c') {
|
|
array.arraydef.align = 'axis';
|
|
}
|
|
else if (align) {
|
|
array.arraydef.align = align;
|
|
}
|
|
return array;
|
|
}
|
|
ParseUtil.setArrayAlign = setArrayAlign;
|
|
function substituteArgs(parser, args, str) {
|
|
var text = '';
|
|
var newstring = '';
|
|
var i = 0;
|
|
while (i < str.length) {
|
|
var c = str.charAt(i++);
|
|
if (c === '\\') {
|
|
text += c + str.charAt(i++);
|
|
}
|
|
else if (c === '#') {
|
|
c = str.charAt(i++);
|
|
if (c === '#') {
|
|
text += c;
|
|
}
|
|
else {
|
|
if (!c.match(/[1-9]/) || parseInt(c, 10) > args.length) {
|
|
throw new TexError_js_1.default('IllegalMacroParam', 'Illegal macro parameter reference');
|
|
}
|
|
newstring = addArgs(parser, addArgs(parser, newstring, text), args[parseInt(c, 10) - 1]);
|
|
text = '';
|
|
}
|
|
}
|
|
else {
|
|
text += c;
|
|
}
|
|
}
|
|
return addArgs(parser, newstring, text);
|
|
}
|
|
ParseUtil.substituteArgs = substituteArgs;
|
|
function addArgs(parser, s1, s2) {
|
|
if (s2.match(/^[a-z]/i) && s1.match(/(^|[^\\])(\\\\)*\\[a-z]+$/i)) {
|
|
s1 += ' ';
|
|
}
|
|
if (s1.length + s2.length > parser.configuration.options['maxBuffer']) {
|
|
throw new TexError_js_1.default('MaxBufferSize', 'MathJax internal buffer size exceeded; is there a' +
|
|
' recursive macro call?');
|
|
}
|
|
return s1 + s2;
|
|
}
|
|
ParseUtil.addArgs = addArgs;
|
|
function checkMaxMacros(parser, isMacro) {
|
|
if (isMacro === void 0) { isMacro = true; }
|
|
if (++parser.macroCount <= parser.configuration.options['maxMacros']) {
|
|
return;
|
|
}
|
|
if (isMacro) {
|
|
throw new TexError_js_1.default('MaxMacroSub1', 'MathJax maximum macro substitution count exceeded; ' +
|
|
'is here a recursive macro call?');
|
|
}
|
|
else {
|
|
throw new TexError_js_1.default('MaxMacroSub2', 'MathJax maximum substitution count exceeded; ' +
|
|
'is there a recursive latex environment?');
|
|
}
|
|
}
|
|
ParseUtil.checkMaxMacros = checkMaxMacros;
|
|
function checkEqnEnv(parser) {
|
|
if (parser.stack.global.eqnenv) {
|
|
throw new TexError_js_1.default('ErroneousNestingEq', 'Erroneous nesting of equation structures');
|
|
}
|
|
parser.stack.global.eqnenv = true;
|
|
}
|
|
ParseUtil.checkEqnEnv = checkEqnEnv;
|
|
function copyNode(node, parser) {
|
|
var tree = node.copy();
|
|
var options = parser.configuration;
|
|
tree.walkTree(function (n) {
|
|
var e_1, _a;
|
|
options.addNode(n.kind, n);
|
|
var lists = (n.getProperty('in-lists') || '').split(/,/);
|
|
try {
|
|
for (var lists_1 = __values(lists), lists_1_1 = lists_1.next(); !lists_1_1.done; lists_1_1 = lists_1.next()) {
|
|
var list = lists_1_1.value;
|
|
list && options.addNode(list, n);
|
|
}
|
|
}
|
|
catch (e_1_1) { e_1 = { error: e_1_1 }; }
|
|
finally {
|
|
try {
|
|
if (lists_1_1 && !lists_1_1.done && (_a = lists_1.return)) _a.call(lists_1);
|
|
}
|
|
finally { if (e_1) throw e_1.error; }
|
|
}
|
|
});
|
|
return tree;
|
|
}
|
|
ParseUtil.copyNode = copyNode;
|
|
function MmlFilterAttribute(_parser, _name, value) {
|
|
return value;
|
|
}
|
|
ParseUtil.MmlFilterAttribute = MmlFilterAttribute;
|
|
function getFontDef(parser) {
|
|
var font = parser.stack.env['font'];
|
|
return (font ? { mathvariant: font } : {});
|
|
}
|
|
ParseUtil.getFontDef = getFontDef;
|
|
function keyvalOptions(attrib, allowed, error) {
|
|
var e_2, _a;
|
|
if (allowed === void 0) { allowed = null; }
|
|
if (error === void 0) { error = false; }
|
|
var def = readKeyval(attrib);
|
|
if (allowed) {
|
|
try {
|
|
for (var _b = __values(Object.keys(def)), _c = _b.next(); !_c.done; _c = _b.next()) {
|
|
var key = _c.value;
|
|
if (!allowed.hasOwnProperty(key)) {
|
|
if (error) {
|
|
throw new TexError_js_1.default('InvalidOption', 'Invalid option: %1', key);
|
|
}
|
|
delete def[key];
|
|
}
|
|
}
|
|
}
|
|
catch (e_2_1) { e_2 = { error: e_2_1 }; }
|
|
finally {
|
|
try {
|
|
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
|
|
}
|
|
finally { if (e_2) throw e_2.error; }
|
|
}
|
|
}
|
|
return def;
|
|
}
|
|
ParseUtil.keyvalOptions = keyvalOptions;
|
|
function readKeyval(text) {
|
|
var _a, _b;
|
|
var options = {};
|
|
var rest = text;
|
|
var end, key, val;
|
|
while (rest) {
|
|
_a = __read(readValue(rest, ['=', ',']), 3), key = _a[0], end = _a[1], rest = _a[2];
|
|
if (end === '=') {
|
|
_b = __read(readValue(rest, [',']), 3), val = _b[0], end = _b[1], rest = _b[2];
|
|
val = (val === 'false' || val === 'true') ?
|
|
JSON.parse(val) : val;
|
|
options[key] = val;
|
|
}
|
|
else if (key) {
|
|
options[key] = true;
|
|
}
|
|
}
|
|
return options;
|
|
}
|
|
function removeBraces(text, count) {
|
|
while (count > 0) {
|
|
text = text.trim().slice(1, -1);
|
|
count--;
|
|
}
|
|
return text.trim();
|
|
}
|
|
function readValue(text, end) {
|
|
var length = text.length;
|
|
var braces = 0;
|
|
var value = '';
|
|
var index = 0;
|
|
var start = 0;
|
|
var startCount = true;
|
|
var stopCount = false;
|
|
while (index < length) {
|
|
var c = text[index++];
|
|
switch (c) {
|
|
case ' ':
|
|
break;
|
|
case '{':
|
|
if (startCount) {
|
|
start++;
|
|
}
|
|
else {
|
|
stopCount = false;
|
|
if (start > braces) {
|
|
start = braces;
|
|
}
|
|
}
|
|
braces++;
|
|
break;
|
|
case '}':
|
|
if (braces) {
|
|
braces--;
|
|
}
|
|
if (startCount || stopCount) {
|
|
start--;
|
|
stopCount = true;
|
|
}
|
|
startCount = false;
|
|
break;
|
|
default:
|
|
if (!braces && end.indexOf(c) !== -1) {
|
|
return [stopCount ? 'true' :
|
|
removeBraces(value, start), c, text.slice(index)];
|
|
}
|
|
startCount = false;
|
|
stopCount = false;
|
|
}
|
|
value += c;
|
|
}
|
|
if (braces) {
|
|
throw new TexError_js_1.default('ExtraOpenMissingClose', 'Extra open brace or missing close brace');
|
|
}
|
|
return [stopCount ? 'true' : removeBraces(value, start), '', text.slice(index)];
|
|
}
|
|
})(ParseUtil || (ParseUtil = {}));
|
|
exports["default"] = ParseUtil;
|
|
//# sourceMappingURL=ParseUtil.js.map
|
|
|
|
/***/ }),
|
|
|
|
/***/ 35758:
|
|
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
|
|
|
|
|
|
var __values = (this && this.__values) || function(o) {
|
|
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
|
|
if (m) return m.call(o);
|
|
if (o && typeof o.length === "number") return {
|
|
next: function () {
|
|
if (o && i >= o.length) o = void 0;
|
|
return { value: o && o[i++], done: !o };
|
|
}
|
|
};
|
|
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
|
|
};
|
|
var __read = (this && this.__read) || function (o, n) {
|
|
var m = typeof Symbol === "function" && o[Symbol.iterator];
|
|
if (!m) return o;
|
|
var i = m.call(o), r, ar = [], e;
|
|
try {
|
|
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
|
|
}
|
|
catch (error) { e = { error: error }; }
|
|
finally {
|
|
try {
|
|
if (r && !r.done && (m = i["return"])) m.call(i);
|
|
}
|
|
finally { if (e) throw e.error; }
|
|
}
|
|
return ar;
|
|
};
|
|
var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
|
|
if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
|
|
if (ar || !(i in from)) {
|
|
if (!ar) ar = Array.prototype.slice.call(from, 0, i);
|
|
ar[i] = from[i];
|
|
}
|
|
}
|
|
return to.concat(ar || Array.prototype.slice.call(from));
|
|
};
|
|
var __importDefault = (this && this.__importDefault) || function (mod) {
|
|
return (mod && mod.__esModule) ? mod : { "default": mod };
|
|
};
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
var NodeUtil_js_1 = __importDefault(__webpack_require__(53972));
|
|
var Stack = (function () {
|
|
function Stack(_factory, _env, inner) {
|
|
this._factory = _factory;
|
|
this._env = _env;
|
|
this.global = {};
|
|
this.stack = [];
|
|
this.global = { isInner: inner };
|
|
this.stack = [this._factory.create('start', this.global)];
|
|
if (_env) {
|
|
this.stack[0].env = _env;
|
|
}
|
|
this.env = this.stack[0].env;
|
|
}
|
|
Object.defineProperty(Stack.prototype, "env", {
|
|
get: function () {
|
|
return this._env;
|
|
},
|
|
set: function (env) {
|
|
this._env = env;
|
|
},
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
Stack.prototype.Push = function () {
|
|
var e_1, _a;
|
|
var args = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
args[_i] = arguments[_i];
|
|
}
|
|
try {
|
|
for (var args_1 = __values(args), args_1_1 = args_1.next(); !args_1_1.done; args_1_1 = args_1.next()) {
|
|
var node = args_1_1.value;
|
|
if (!node) {
|
|
continue;
|
|
}
|
|
var item = NodeUtil_js_1.default.isNode(node) ?
|
|
this._factory.create('mml', node) : node;
|
|
item.global = this.global;
|
|
var _b = __read(this.stack.length ? this.Top().checkItem(item) : [null, true], 2), top_1 = _b[0], success = _b[1];
|
|
if (!success) {
|
|
continue;
|
|
}
|
|
if (top_1) {
|
|
this.Pop();
|
|
this.Push.apply(this, __spreadArray([], __read(top_1), false));
|
|
continue;
|
|
}
|
|
this.stack.push(item);
|
|
if (item.env) {
|
|
if (item.copyEnv) {
|
|
Object.assign(item.env, this.env);
|
|
}
|
|
this.env = item.env;
|
|
}
|
|
else {
|
|
item.env = this.env;
|
|
}
|
|
}
|
|
}
|
|
catch (e_1_1) { e_1 = { error: e_1_1 }; }
|
|
finally {
|
|
try {
|
|
if (args_1_1 && !args_1_1.done && (_a = args_1.return)) _a.call(args_1);
|
|
}
|
|
finally { if (e_1) throw e_1.error; }
|
|
}
|
|
};
|
|
Stack.prototype.Pop = function () {
|
|
var item = this.stack.pop();
|
|
if (!item.isOpen) {
|
|
delete item.env;
|
|
}
|
|
this.env = (this.stack.length ? this.Top().env : {});
|
|
return item;
|
|
};
|
|
Stack.prototype.Top = function (n) {
|
|
if (n === void 0) { n = 1; }
|
|
return this.stack.length < n ? null : this.stack[this.stack.length - n];
|
|
};
|
|
Stack.prototype.Prev = function (noPop) {
|
|
var top = this.Top();
|
|
return noPop ? top.First : top.Pop();
|
|
};
|
|
Stack.prototype.toString = function () {
|
|
return 'stack[\n ' + this.stack.join('\n ') + '\n]';
|
|
};
|
|
return Stack;
|
|
}());
|
|
exports["default"] = Stack;
|
|
//# sourceMappingURL=Stack.js.map
|
|
|
|
/***/ }),
|
|
|
|
/***/ 75735:
|
|
/***/ ((__unused_webpack_module, exports) => {
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
exports.Macro = exports.Symbol = void 0;
|
|
var Symbol = (function () {
|
|
function Symbol(_symbol, _char, _attributes) {
|
|
this._symbol = _symbol;
|
|
this._char = _char;
|
|
this._attributes = _attributes;
|
|
}
|
|
Object.defineProperty(Symbol.prototype, "symbol", {
|
|
get: function () {
|
|
return this._symbol;
|
|
},
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(Symbol.prototype, "char", {
|
|
get: function () {
|
|
return this._char;
|
|
},
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(Symbol.prototype, "attributes", {
|
|
get: function () {
|
|
return this._attributes;
|
|
},
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
return Symbol;
|
|
}());
|
|
exports.Symbol = Symbol;
|
|
var Macro = (function () {
|
|
function Macro(_symbol, _func, _args) {
|
|
if (_args === void 0) { _args = []; }
|
|
this._symbol = _symbol;
|
|
this._func = _func;
|
|
this._args = _args;
|
|
}
|
|
Object.defineProperty(Macro.prototype, "symbol", {
|
|
get: function () {
|
|
return this._symbol;
|
|
},
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(Macro.prototype, "func", {
|
|
get: function () {
|
|
return this._func;
|
|
},
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(Macro.prototype, "args", {
|
|
get: function () {
|
|
return this._args;
|
|
},
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
return Macro;
|
|
}());
|
|
exports.Macro = Macro;
|
|
//# sourceMappingURL=Symbol.js.map
|
|
|
|
/***/ }),
|
|
|
|
/***/ 65695:
|
|
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
|
|
|
|
|
|
var __extends = (this && this.__extends) || (function () {
|
|
var extendStatics = function (d, b) {
|
|
extendStatics = Object.setPrototypeOf ||
|
|
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
|
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
|
|
return extendStatics(d, b);
|
|
};
|
|
return function (d, b) {
|
|
if (typeof b !== "function" && b !== null)
|
|
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
|
|
extendStatics(d, b);
|
|
function __() { this.constructor = d; }
|
|
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
|
};
|
|
})();
|
|
var __read = (this && this.__read) || function (o, n) {
|
|
var m = typeof Symbol === "function" && o[Symbol.iterator];
|
|
if (!m) return o;
|
|
var i = m.call(o), r, ar = [], e;
|
|
try {
|
|
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
|
|
}
|
|
catch (error) { e = { error: error }; }
|
|
finally {
|
|
try {
|
|
if (r && !r.done && (m = i["return"])) m.call(i);
|
|
}
|
|
finally { if (e) throw e.error; }
|
|
}
|
|
return ar;
|
|
};
|
|
var __values = (this && this.__values) || function(o) {
|
|
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
|
|
if (m) return m.call(o);
|
|
if (o && typeof o.length === "number") return {
|
|
next: function () {
|
|
if (o && i >= o.length) o = void 0;
|
|
return { value: o && o[i++], done: !o };
|
|
}
|
|
};
|
|
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
|
|
};
|
|
var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
|
|
if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
|
|
if (ar || !(i in from)) {
|
|
if (!ar) ar = Array.prototype.slice.call(from, 0, i);
|
|
ar[i] = from[i];
|
|
}
|
|
}
|
|
return to.concat(ar || Array.prototype.slice.call(from));
|
|
};
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
exports.EnvironmentMap = exports.CommandMap = exports.MacroMap = exports.DelimiterMap = exports.CharacterMap = exports.AbstractParseMap = exports.RegExpMap = exports.AbstractSymbolMap = exports.parseResult = void 0;
|
|
var Symbol_js_1 = __webpack_require__(75735);
|
|
var MapHandler_js_1 = __webpack_require__(21683);
|
|
function parseResult(result) {
|
|
return result === void 0 ? true : result;
|
|
}
|
|
exports.parseResult = parseResult;
|
|
var AbstractSymbolMap = (function () {
|
|
function AbstractSymbolMap(_name, _parser) {
|
|
this._name = _name;
|
|
this._parser = _parser;
|
|
MapHandler_js_1.MapHandler.register(this);
|
|
}
|
|
Object.defineProperty(AbstractSymbolMap.prototype, "name", {
|
|
get: function () {
|
|
return this._name;
|
|
},
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
AbstractSymbolMap.prototype.parserFor = function (symbol) {
|
|
return this.contains(symbol) ? this.parser : null;
|
|
};
|
|
AbstractSymbolMap.prototype.parse = function (_a) {
|
|
var _b = __read(_a, 2), env = _b[0], symbol = _b[1];
|
|
var parser = this.parserFor(symbol);
|
|
var mapped = this.lookup(symbol);
|
|
return (parser && mapped) ? parseResult(parser(env, mapped)) : null;
|
|
};
|
|
Object.defineProperty(AbstractSymbolMap.prototype, "parser", {
|
|
get: function () {
|
|
return this._parser;
|
|
},
|
|
set: function (parser) {
|
|
this._parser = parser;
|
|
},
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
return AbstractSymbolMap;
|
|
}());
|
|
exports.AbstractSymbolMap = AbstractSymbolMap;
|
|
var RegExpMap = (function (_super) {
|
|
__extends(RegExpMap, _super);
|
|
function RegExpMap(name, parser, _regExp) {
|
|
var _this = _super.call(this, name, parser) || this;
|
|
_this._regExp = _regExp;
|
|
return _this;
|
|
}
|
|
RegExpMap.prototype.contains = function (symbol) {
|
|
return this._regExp.test(symbol);
|
|
};
|
|
RegExpMap.prototype.lookup = function (symbol) {
|
|
return this.contains(symbol) ? symbol : null;
|
|
};
|
|
return RegExpMap;
|
|
}(AbstractSymbolMap));
|
|
exports.RegExpMap = RegExpMap;
|
|
var AbstractParseMap = (function (_super) {
|
|
__extends(AbstractParseMap, _super);
|
|
function AbstractParseMap() {
|
|
var _this = _super !== null && _super.apply(this, arguments) || this;
|
|
_this.map = new Map();
|
|
return _this;
|
|
}
|
|
AbstractParseMap.prototype.lookup = function (symbol) {
|
|
return this.map.get(symbol);
|
|
};
|
|
AbstractParseMap.prototype.contains = function (symbol) {
|
|
return this.map.has(symbol);
|
|
};
|
|
AbstractParseMap.prototype.add = function (symbol, object) {
|
|
this.map.set(symbol, object);
|
|
};
|
|
AbstractParseMap.prototype.remove = function (symbol) {
|
|
this.map.delete(symbol);
|
|
};
|
|
return AbstractParseMap;
|
|
}(AbstractSymbolMap));
|
|
exports.AbstractParseMap = AbstractParseMap;
|
|
var CharacterMap = (function (_super) {
|
|
__extends(CharacterMap, _super);
|
|
function CharacterMap(name, parser, json) {
|
|
var e_1, _a;
|
|
var _this = _super.call(this, name, parser) || this;
|
|
try {
|
|
for (var _b = __values(Object.keys(json)), _c = _b.next(); !_c.done; _c = _b.next()) {
|
|
var key = _c.value;
|
|
var value = json[key];
|
|
var _d = __read((typeof (value) === 'string') ? [value, null] : value, 2), char = _d[0], attrs = _d[1];
|
|
var character = new Symbol_js_1.Symbol(key, char, attrs);
|
|
_this.add(key, character);
|
|
}
|
|
}
|
|
catch (e_1_1) { e_1 = { error: e_1_1 }; }
|
|
finally {
|
|
try {
|
|
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
|
|
}
|
|
finally { if (e_1) throw e_1.error; }
|
|
}
|
|
return _this;
|
|
}
|
|
return CharacterMap;
|
|
}(AbstractParseMap));
|
|
exports.CharacterMap = CharacterMap;
|
|
var DelimiterMap = (function (_super) {
|
|
__extends(DelimiterMap, _super);
|
|
function DelimiterMap() {
|
|
return _super !== null && _super.apply(this, arguments) || this;
|
|
}
|
|
DelimiterMap.prototype.parse = function (_a) {
|
|
var _b = __read(_a, 2), env = _b[0], symbol = _b[1];
|
|
return _super.prototype.parse.call(this, [env, '\\' + symbol]);
|
|
};
|
|
return DelimiterMap;
|
|
}(CharacterMap));
|
|
exports.DelimiterMap = DelimiterMap;
|
|
var MacroMap = (function (_super) {
|
|
__extends(MacroMap, _super);
|
|
function MacroMap(name, json, functionMap) {
|
|
var e_2, _a;
|
|
var _this = _super.call(this, name, null) || this;
|
|
try {
|
|
for (var _b = __values(Object.keys(json)), _c = _b.next(); !_c.done; _c = _b.next()) {
|
|
var key = _c.value;
|
|
var value = json[key];
|
|
var _d = __read((typeof (value) === 'string') ? [value] : value), func = _d[0], attrs = _d.slice(1);
|
|
var character = new Symbol_js_1.Macro(key, functionMap[func], attrs);
|
|
_this.add(key, character);
|
|
}
|
|
}
|
|
catch (e_2_1) { e_2 = { error: e_2_1 }; }
|
|
finally {
|
|
try {
|
|
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
|
|
}
|
|
finally { if (e_2) throw e_2.error; }
|
|
}
|
|
return _this;
|
|
}
|
|
MacroMap.prototype.parserFor = function (symbol) {
|
|
var macro = this.lookup(symbol);
|
|
return macro ? macro.func : null;
|
|
};
|
|
MacroMap.prototype.parse = function (_a) {
|
|
var _b = __read(_a, 2), env = _b[0], symbol = _b[1];
|
|
var macro = this.lookup(symbol);
|
|
var parser = this.parserFor(symbol);
|
|
if (!macro || !parser) {
|
|
return null;
|
|
}
|
|
return parseResult(parser.apply(void 0, __spreadArray([env, macro.symbol], __read(macro.args), false)));
|
|
};
|
|
return MacroMap;
|
|
}(AbstractParseMap));
|
|
exports.MacroMap = MacroMap;
|
|
var CommandMap = (function (_super) {
|
|
__extends(CommandMap, _super);
|
|
function CommandMap() {
|
|
return _super !== null && _super.apply(this, arguments) || this;
|
|
}
|
|
CommandMap.prototype.parse = function (_a) {
|
|
var _b = __read(_a, 2), env = _b[0], symbol = _b[1];
|
|
var macro = this.lookup(symbol);
|
|
var parser = this.parserFor(symbol);
|
|
if (!macro || !parser) {
|
|
return null;
|
|
}
|
|
var saveCommand = env.currentCS;
|
|
env.currentCS = '\\' + symbol;
|
|
var result = parser.apply(void 0, __spreadArray([env, '\\' + macro.symbol], __read(macro.args), false));
|
|
env.currentCS = saveCommand;
|
|
return parseResult(result);
|
|
};
|
|
return CommandMap;
|
|
}(MacroMap));
|
|
exports.CommandMap = CommandMap;
|
|
var EnvironmentMap = (function (_super) {
|
|
__extends(EnvironmentMap, _super);
|
|
function EnvironmentMap(name, parser, json, functionMap) {
|
|
var _this = _super.call(this, name, json, functionMap) || this;
|
|
_this.parser = parser;
|
|
return _this;
|
|
}
|
|
EnvironmentMap.prototype.parse = function (_a) {
|
|
var _b = __read(_a, 2), env = _b[0], symbol = _b[1];
|
|
var macro = this.lookup(symbol);
|
|
var envParser = this.parserFor(symbol);
|
|
if (!macro || !envParser) {
|
|
return null;
|
|
}
|
|
return parseResult(this.parser(env, macro.symbol, envParser, macro.args));
|
|
};
|
|
return EnvironmentMap;
|
|
}(MacroMap));
|
|
exports.EnvironmentMap = EnvironmentMap;
|
|
//# sourceMappingURL=SymbolMap.js.map
|
|
|
|
/***/ }),
|
|
|
|
/***/ 75723:
|
|
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
|
|
|
|
|
|
var __extends = (this && this.__extends) || (function () {
|
|
var extendStatics = function (d, b) {
|
|
extendStatics = Object.setPrototypeOf ||
|
|
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
|
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
|
|
return extendStatics(d, b);
|
|
};
|
|
return function (d, b) {
|
|
if (typeof b !== "function" && b !== null)
|
|
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
|
|
extendStatics(d, b);
|
|
function __() { this.constructor = d; }
|
|
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
|
};
|
|
})();
|
|
var __values = (this && this.__values) || function(o) {
|
|
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
|
|
if (m) return m.call(o);
|
|
if (o && typeof o.length === "number") return {
|
|
next: function () {
|
|
if (o && i >= o.length) o = void 0;
|
|
return { value: o && o[i++], done: !o };
|
|
}
|
|
};
|
|
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
|
|
};
|
|
var __importDefault = (this && this.__importDefault) || function (mod) {
|
|
return (mod && mod.__esModule) ? mod : { "default": mod };
|
|
};
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
exports.TagsFactory = exports.AllTags = exports.NoTags = exports.AbstractTags = exports.TagInfo = exports.Label = void 0;
|
|
var TexParser_js_1 = __importDefault(__webpack_require__(94032));
|
|
var Label = (function () {
|
|
function Label(tag, id) {
|
|
if (tag === void 0) { tag = '???'; }
|
|
if (id === void 0) { id = ''; }
|
|
this.tag = tag;
|
|
this.id = id;
|
|
}
|
|
return Label;
|
|
}());
|
|
exports.Label = Label;
|
|
var TagInfo = (function () {
|
|
function TagInfo(env, taggable, defaultTags, tag, tagId, tagFormat, noTag, labelId) {
|
|
if (env === void 0) { env = ''; }
|
|
if (taggable === void 0) { taggable = false; }
|
|
if (defaultTags === void 0) { defaultTags = false; }
|
|
if (tag === void 0) { tag = null; }
|
|
if (tagId === void 0) { tagId = ''; }
|
|
if (tagFormat === void 0) { tagFormat = ''; }
|
|
if (noTag === void 0) { noTag = false; }
|
|
if (labelId === void 0) { labelId = ''; }
|
|
this.env = env;
|
|
this.taggable = taggable;
|
|
this.defaultTags = defaultTags;
|
|
this.tag = tag;
|
|
this.tagId = tagId;
|
|
this.tagFormat = tagFormat;
|
|
this.noTag = noTag;
|
|
this.labelId = labelId;
|
|
}
|
|
return TagInfo;
|
|
}());
|
|
exports.TagInfo = TagInfo;
|
|
var AbstractTags = (function () {
|
|
function AbstractTags() {
|
|
this.counter = 0;
|
|
this.allCounter = 0;
|
|
this.configuration = null;
|
|
this.ids = {};
|
|
this.allIds = {};
|
|
this.labels = {};
|
|
this.allLabels = {};
|
|
this.redo = false;
|
|
this.refUpdate = false;
|
|
this.currentTag = new TagInfo();
|
|
this.history = [];
|
|
this.stack = [];
|
|
this.enTag = function (node, tag) {
|
|
var nf = this.configuration.nodeFactory;
|
|
var cell = nf.create('node', 'mtd', [node]);
|
|
var row = nf.create('node', 'mlabeledtr', [tag, cell]);
|
|
var table = nf.create('node', 'mtable', [row], {
|
|
side: this.configuration.options['tagSide'],
|
|
minlabelspacing: this.configuration.options['tagIndent'],
|
|
displaystyle: true
|
|
});
|
|
return table;
|
|
};
|
|
}
|
|
AbstractTags.prototype.start = function (env, taggable, defaultTags) {
|
|
if (this.currentTag) {
|
|
this.stack.push(this.currentTag);
|
|
}
|
|
this.currentTag = new TagInfo(env, taggable, defaultTags);
|
|
};
|
|
Object.defineProperty(AbstractTags.prototype, "env", {
|
|
get: function () {
|
|
return this.currentTag.env;
|
|
},
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
AbstractTags.prototype.end = function () {
|
|
this.history.push(this.currentTag);
|
|
this.currentTag = this.stack.pop();
|
|
};
|
|
AbstractTags.prototype.tag = function (tag, noFormat) {
|
|
this.currentTag.tag = tag;
|
|
this.currentTag.tagFormat = noFormat ? tag : this.formatTag(tag);
|
|
this.currentTag.noTag = false;
|
|
};
|
|
AbstractTags.prototype.notag = function () {
|
|
this.tag('', true);
|
|
this.currentTag.noTag = true;
|
|
};
|
|
Object.defineProperty(AbstractTags.prototype, "noTag", {
|
|
get: function () {
|
|
return this.currentTag.noTag;
|
|
},
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(AbstractTags.prototype, "label", {
|
|
get: function () {
|
|
return this.currentTag.labelId;
|
|
},
|
|
set: function (label) {
|
|
this.currentTag.labelId = label;
|
|
},
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
AbstractTags.prototype.formatUrl = function (id, base) {
|
|
return base + '#' + encodeURIComponent(id);
|
|
};
|
|
AbstractTags.prototype.formatTag = function (tag) {
|
|
return '(' + tag + ')';
|
|
};
|
|
AbstractTags.prototype.formatId = function (id) {
|
|
return 'mjx-eqn:' + id.replace(/\s/g, '_');
|
|
};
|
|
AbstractTags.prototype.formatNumber = function (n) {
|
|
return n.toString();
|
|
};
|
|
AbstractTags.prototype.autoTag = function () {
|
|
if (this.currentTag.tag == null) {
|
|
this.counter++;
|
|
this.tag(this.formatNumber(this.counter), false);
|
|
}
|
|
};
|
|
AbstractTags.prototype.clearTag = function () {
|
|
this.label = '';
|
|
this.tag(null, true);
|
|
this.currentTag.tagId = '';
|
|
};
|
|
AbstractTags.prototype.getTag = function (force) {
|
|
if (force === void 0) { force = false; }
|
|
if (force) {
|
|
this.autoTag();
|
|
return this.makeTag();
|
|
}
|
|
var ct = this.currentTag;
|
|
if (ct.taggable && !ct.noTag) {
|
|
if (ct.defaultTags) {
|
|
this.autoTag();
|
|
}
|
|
if (ct.tag) {
|
|
return this.makeTag();
|
|
}
|
|
}
|
|
return null;
|
|
};
|
|
AbstractTags.prototype.resetTag = function () {
|
|
this.history = [];
|
|
this.redo = false;
|
|
this.refUpdate = false;
|
|
this.clearTag();
|
|
};
|
|
AbstractTags.prototype.reset = function (offset) {
|
|
if (offset === void 0) { offset = 0; }
|
|
this.resetTag();
|
|
this.counter = this.allCounter = offset;
|
|
this.allLabels = {};
|
|
this.allIds = {};
|
|
};
|
|
AbstractTags.prototype.startEquation = function (math) {
|
|
this.history = [];
|
|
this.stack = [];
|
|
this.clearTag();
|
|
this.currentTag = new TagInfo('', undefined, undefined);
|
|
this.labels = {};
|
|
this.ids = {};
|
|
this.counter = this.allCounter;
|
|
this.redo = false;
|
|
var recompile = math.inputData.recompile;
|
|
if (recompile) {
|
|
this.refUpdate = true;
|
|
this.counter = recompile.counter;
|
|
}
|
|
};
|
|
AbstractTags.prototype.finishEquation = function (math) {
|
|
if (this.redo) {
|
|
math.inputData.recompile = {
|
|
state: math.state(),
|
|
counter: this.allCounter
|
|
};
|
|
}
|
|
if (!this.refUpdate) {
|
|
this.allCounter = this.counter;
|
|
}
|
|
Object.assign(this.allIds, this.ids);
|
|
Object.assign(this.allLabels, this.labels);
|
|
};
|
|
AbstractTags.prototype.finalize = function (node, env) {
|
|
if (!env.display || this.currentTag.env ||
|
|
this.currentTag.tag == null) {
|
|
return node;
|
|
}
|
|
var tag = this.makeTag();
|
|
var table = this.enTag(node, tag);
|
|
return table;
|
|
};
|
|
AbstractTags.prototype.makeId = function () {
|
|
this.currentTag.tagId = this.formatId(this.configuration.options['useLabelIds'] ?
|
|
(this.label || this.currentTag.tag) : this.currentTag.tag);
|
|
};
|
|
AbstractTags.prototype.makeTag = function () {
|
|
this.makeId();
|
|
if (this.label) {
|
|
this.labels[this.label] = new Label(this.currentTag.tag, this.currentTag.tagId);
|
|
}
|
|
var mml = new TexParser_js_1.default('\\text{' + this.currentTag.tagFormat + '}', {}, this.configuration).mml();
|
|
return this.configuration.nodeFactory.create('node', 'mtd', [mml], { id: this.currentTag.tagId });
|
|
};
|
|
return AbstractTags;
|
|
}());
|
|
exports.AbstractTags = AbstractTags;
|
|
var NoTags = (function (_super) {
|
|
__extends(NoTags, _super);
|
|
function NoTags() {
|
|
return _super !== null && _super.apply(this, arguments) || this;
|
|
}
|
|
NoTags.prototype.autoTag = function () { };
|
|
NoTags.prototype.getTag = function () {
|
|
return !this.currentTag.tag ? null : _super.prototype.getTag.call(this);
|
|
};
|
|
return NoTags;
|
|
}(AbstractTags));
|
|
exports.NoTags = NoTags;
|
|
var AllTags = (function (_super) {
|
|
__extends(AllTags, _super);
|
|
function AllTags() {
|
|
return _super !== null && _super.apply(this, arguments) || this;
|
|
}
|
|
AllTags.prototype.finalize = function (node, env) {
|
|
if (!env.display || this.history.find(function (x) { return x.taggable; })) {
|
|
return node;
|
|
}
|
|
var tag = this.getTag(true);
|
|
return this.enTag(node, tag);
|
|
};
|
|
return AllTags;
|
|
}(AbstractTags));
|
|
exports.AllTags = AllTags;
|
|
var TagsFactory;
|
|
(function (TagsFactory) {
|
|
var tagsMapping = new Map([
|
|
['none', NoTags],
|
|
['all', AllTags]
|
|
]);
|
|
var defaultTags = 'none';
|
|
TagsFactory.OPTIONS = {
|
|
tags: defaultTags,
|
|
tagSide: 'right',
|
|
tagIndent: '0.8em',
|
|
useLabelIds: true,
|
|
ignoreDuplicateLabels: false
|
|
};
|
|
TagsFactory.add = function (name, constr) {
|
|
tagsMapping.set(name, constr);
|
|
};
|
|
TagsFactory.addTags = function (tags) {
|
|
var e_1, _a;
|
|
try {
|
|
for (var _b = __values(Object.keys(tags)), _c = _b.next(); !_c.done; _c = _b.next()) {
|
|
var key = _c.value;
|
|
TagsFactory.add(key, tags[key]);
|
|
}
|
|
}
|
|
catch (e_1_1) { e_1 = { error: e_1_1 }; }
|
|
finally {
|
|
try {
|
|
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
|
|
}
|
|
finally { if (e_1) throw e_1.error; }
|
|
}
|
|
};
|
|
TagsFactory.create = function (name) {
|
|
var constr = tagsMapping.get(name) || tagsMapping.get(defaultTags);
|
|
if (!constr) {
|
|
throw Error('Unknown tags class');
|
|
}
|
|
return new constr();
|
|
};
|
|
TagsFactory.setDefault = function (name) {
|
|
defaultTags = name;
|
|
};
|
|
TagsFactory.getDefault = function () {
|
|
return TagsFactory.create(defaultTags);
|
|
};
|
|
})(TagsFactory = exports.TagsFactory || (exports.TagsFactory = {}));
|
|
//# sourceMappingURL=Tags.js.map
|
|
|
|
/***/ }),
|
|
|
|
/***/ 54420:
|
|
/***/ ((__unused_webpack_module, exports) => {
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
var TexError = (function () {
|
|
function TexError(id, message) {
|
|
var rest = [];
|
|
for (var _i = 2; _i < arguments.length; _i++) {
|
|
rest[_i - 2] = arguments[_i];
|
|
}
|
|
this.id = id;
|
|
this.message = TexError.processString(message, rest);
|
|
}
|
|
TexError.processString = function (str, args) {
|
|
var parts = str.split(TexError.pattern);
|
|
for (var i = 1, m = parts.length; i < m; i += 2) {
|
|
var c = parts[i].charAt(0);
|
|
if (c >= '0' && c <= '9') {
|
|
parts[i] = args[parseInt(parts[i], 10) - 1];
|
|
if (typeof parts[i] === 'number') {
|
|
parts[i] = parts[i].toString();
|
|
}
|
|
}
|
|
else if (c === '{') {
|
|
c = parts[i].substr(1);
|
|
if (c >= '0' && c <= '9') {
|
|
parts[i] = args[parseInt(parts[i].substr(1, parts[i].length - 2), 10) - 1];
|
|
if (typeof parts[i] === 'number') {
|
|
parts[i] = parts[i].toString();
|
|
}
|
|
}
|
|
else {
|
|
var match = parts[i].match(/^\{([a-z]+):%(\d+)\|(.*)\}$/);
|
|
if (match) {
|
|
parts[i] = '%' + parts[i];
|
|
}
|
|
}
|
|
}
|
|
if (parts[i] == null) {
|
|
parts[i] = '???';
|
|
}
|
|
}
|
|
return parts.join('');
|
|
};
|
|
TexError.pattern = /%(\d+|\{\d+\}|\{[a-z]+:\%\d+(?:\|(?:%\{\d+\}|%.|[^\}])*)+\}|.)/g;
|
|
return TexError;
|
|
}());
|
|
exports["default"] = TexError;
|
|
//# sourceMappingURL=TexError.js.map
|
|
|
|
/***/ }),
|
|
|
|
/***/ 94032:
|
|
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
|
|
|
|
|
|
var __values = (this && this.__values) || function(o) {
|
|
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
|
|
if (m) return m.call(o);
|
|
if (o && typeof o.length === "number") return {
|
|
next: function () {
|
|
if (o && i >= o.length) o = void 0;
|
|
return { value: o && o[i++], done: !o };
|
|
}
|
|
};
|
|
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
|
|
};
|
|
var __read = (this && this.__read) || function (o, n) {
|
|
var m = typeof Symbol === "function" && o[Symbol.iterator];
|
|
if (!m) return o;
|
|
var i = m.call(o), r, ar = [], e;
|
|
try {
|
|
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
|
|
}
|
|
catch (error) { e = { error: error }; }
|
|
finally {
|
|
try {
|
|
if (r && !r.done && (m = i["return"])) m.call(i);
|
|
}
|
|
finally { if (e) throw e.error; }
|
|
}
|
|
return ar;
|
|
};
|
|
var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
|
|
if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
|
|
if (ar || !(i in from)) {
|
|
if (!ar) ar = Array.prototype.slice.call(from, 0, i);
|
|
ar[i] = from[i];
|
|
}
|
|
}
|
|
return to.concat(ar || Array.prototype.slice.call(from));
|
|
};
|
|
var __importDefault = (this && this.__importDefault) || function (mod) {
|
|
return (mod && mod.__esModule) ? mod : { "default": mod };
|
|
};
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
var ParseUtil_js_1 = __importDefault(__webpack_require__(55038));
|
|
var Stack_js_1 = __importDefault(__webpack_require__(35758));
|
|
var TexError_js_1 = __importDefault(__webpack_require__(54420));
|
|
var MmlNode_js_1 = __webpack_require__(83045);
|
|
var TexParser = (function () {
|
|
function TexParser(_string, env, configuration) {
|
|
var e_1, _a;
|
|
this._string = _string;
|
|
this.configuration = configuration;
|
|
this.macroCount = 0;
|
|
this.i = 0;
|
|
this.currentCS = '';
|
|
var inner = env.hasOwnProperty('isInner');
|
|
var isInner = env['isInner'];
|
|
delete env['isInner'];
|
|
var ENV;
|
|
if (env) {
|
|
ENV = {};
|
|
try {
|
|
for (var _b = __values(Object.keys(env)), _c = _b.next(); !_c.done; _c = _b.next()) {
|
|
var id = _c.value;
|
|
ENV[id] = env[id];
|
|
}
|
|
}
|
|
catch (e_1_1) { e_1 = { error: e_1_1 }; }
|
|
finally {
|
|
try {
|
|
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
|
|
}
|
|
finally { if (e_1) throw e_1.error; }
|
|
}
|
|
}
|
|
this.configuration.pushParser(this);
|
|
this.stack = new Stack_js_1.default(this.itemFactory, ENV, inner ? isInner : true);
|
|
this.Parse();
|
|
this.Push(this.itemFactory.create('stop'));
|
|
}
|
|
Object.defineProperty(TexParser.prototype, "options", {
|
|
get: function () {
|
|
return this.configuration.options;
|
|
},
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(TexParser.prototype, "itemFactory", {
|
|
get: function () {
|
|
return this.configuration.itemFactory;
|
|
},
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(TexParser.prototype, "tags", {
|
|
get: function () {
|
|
return this.configuration.tags;
|
|
},
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(TexParser.prototype, "string", {
|
|
get: function () {
|
|
return this._string;
|
|
},
|
|
set: function (str) {
|
|
this._string = str;
|
|
},
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
TexParser.prototype.parse = function (kind, input) {
|
|
return this.configuration.handlers.get(kind).parse(input);
|
|
};
|
|
TexParser.prototype.lookup = function (kind, symbol) {
|
|
return this.configuration.handlers.get(kind).lookup(symbol);
|
|
};
|
|
TexParser.prototype.contains = function (kind, symbol) {
|
|
return this.configuration.handlers.get(kind).contains(symbol);
|
|
};
|
|
TexParser.prototype.toString = function () {
|
|
var e_2, _a;
|
|
var str = '';
|
|
try {
|
|
for (var _b = __values(Array.from(this.configuration.handlers.keys())), _c = _b.next(); !_c.done; _c = _b.next()) {
|
|
var config = _c.value;
|
|
str += config + ': ' +
|
|
this.configuration.handlers.get(config) + '\n';
|
|
}
|
|
}
|
|
catch (e_2_1) { e_2 = { error: e_2_1 }; }
|
|
finally {
|
|
try {
|
|
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
|
|
}
|
|
finally { if (e_2) throw e_2.error; }
|
|
}
|
|
return str;
|
|
};
|
|
TexParser.prototype.Parse = function () {
|
|
var c;
|
|
while (this.i < this.string.length) {
|
|
c = this.getCodePoint();
|
|
this.i += c.length;
|
|
this.parse('character', [this, c]);
|
|
}
|
|
};
|
|
TexParser.prototype.Push = function (arg) {
|
|
if (arg instanceof MmlNode_js_1.AbstractMmlNode && arg.isInferred) {
|
|
this.PushAll(arg.childNodes);
|
|
}
|
|
else {
|
|
this.stack.Push(arg);
|
|
}
|
|
};
|
|
TexParser.prototype.PushAll = function (args) {
|
|
var e_3, _a;
|
|
try {
|
|
for (var args_1 = __values(args), args_1_1 = args_1.next(); !args_1_1.done; args_1_1 = args_1.next()) {
|
|
var arg = args_1_1.value;
|
|
this.stack.Push(arg);
|
|
}
|
|
}
|
|
catch (e_3_1) { e_3 = { error: e_3_1 }; }
|
|
finally {
|
|
try {
|
|
if (args_1_1 && !args_1_1.done && (_a = args_1.return)) _a.call(args_1);
|
|
}
|
|
finally { if (e_3) throw e_3.error; }
|
|
}
|
|
};
|
|
TexParser.prototype.mml = function () {
|
|
if (!this.stack.Top().isKind('mml')) {
|
|
return null;
|
|
}
|
|
var node = this.stack.Top().First;
|
|
this.configuration.popParser();
|
|
return node;
|
|
};
|
|
TexParser.prototype.convertDelimiter = function (c) {
|
|
var symbol = this.lookup('delimiter', c);
|
|
return symbol ? symbol.char : null;
|
|
};
|
|
TexParser.prototype.getCodePoint = function () {
|
|
var code = this.string.codePointAt(this.i);
|
|
return code === undefined ? '' : String.fromCodePoint(code);
|
|
};
|
|
TexParser.prototype.nextIsSpace = function () {
|
|
return !!this.string.charAt(this.i).match(/\s/);
|
|
};
|
|
TexParser.prototype.GetNext = function () {
|
|
while (this.nextIsSpace()) {
|
|
this.i++;
|
|
}
|
|
return this.getCodePoint();
|
|
};
|
|
TexParser.prototype.GetCS = function () {
|
|
var CS = this.string.slice(this.i).match(/^(([a-z]+) ?|[\uD800-\uDBFF].|.)/i);
|
|
if (CS) {
|
|
this.i += CS[0].length;
|
|
return CS[2] || CS[1];
|
|
}
|
|
else {
|
|
this.i++;
|
|
return ' ';
|
|
}
|
|
};
|
|
TexParser.prototype.GetArgument = function (_name, noneOK) {
|
|
switch (this.GetNext()) {
|
|
case '':
|
|
if (!noneOK) {
|
|
throw new TexError_js_1.default('MissingArgFor', 'Missing argument for %1', this.currentCS);
|
|
}
|
|
return null;
|
|
case '}':
|
|
if (!noneOK) {
|
|
throw new TexError_js_1.default('ExtraCloseMissingOpen', 'Extra close brace or missing open brace');
|
|
}
|
|
return null;
|
|
case '\\':
|
|
this.i++;
|
|
return '\\' + this.GetCS();
|
|
case '{':
|
|
var j = ++this.i, parens = 1;
|
|
while (this.i < this.string.length) {
|
|
switch (this.string.charAt(this.i++)) {
|
|
case '\\':
|
|
this.i++;
|
|
break;
|
|
case '{':
|
|
parens++;
|
|
break;
|
|
case '}':
|
|
if (--parens === 0) {
|
|
return this.string.slice(j, this.i - 1);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
throw new TexError_js_1.default('MissingCloseBrace', 'Missing close brace');
|
|
}
|
|
var c = this.getCodePoint();
|
|
this.i += c.length;
|
|
return c;
|
|
};
|
|
TexParser.prototype.GetBrackets = function (_name, def) {
|
|
if (this.GetNext() !== '[') {
|
|
return def;
|
|
}
|
|
var j = ++this.i, parens = 0;
|
|
while (this.i < this.string.length) {
|
|
switch (this.string.charAt(this.i++)) {
|
|
case '{':
|
|
parens++;
|
|
break;
|
|
case '\\':
|
|
this.i++;
|
|
break;
|
|
case '}':
|
|
if (parens-- <= 0) {
|
|
throw new TexError_js_1.default('ExtraCloseLooking', 'Extra close brace while looking for %1', '\']\'');
|
|
}
|
|
break;
|
|
case ']':
|
|
if (parens === 0) {
|
|
return this.string.slice(j, this.i - 1);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
throw new TexError_js_1.default('MissingCloseBracket', 'Could not find closing \']\' for argument to %1', this.currentCS);
|
|
};
|
|
TexParser.prototype.GetDelimiter = function (name, braceOK) {
|
|
var c = this.GetNext();
|
|
this.i += c.length;
|
|
if (this.i <= this.string.length) {
|
|
if (c === '\\') {
|
|
c += this.GetCS();
|
|
}
|
|
else if (c === '{' && braceOK) {
|
|
this.i--;
|
|
c = this.GetArgument(name).trim();
|
|
}
|
|
if (this.contains('delimiter', c)) {
|
|
return this.convertDelimiter(c);
|
|
}
|
|
}
|
|
throw new TexError_js_1.default('MissingOrUnrecognizedDelim', 'Missing or unrecognized delimiter for %1', this.currentCS);
|
|
};
|
|
TexParser.prototype.GetDimen = function (name) {
|
|
if (this.GetNext() === '{') {
|
|
var dimen = this.GetArgument(name);
|
|
var _a = __read(ParseUtil_js_1.default.matchDimen(dimen), 2), value = _a[0], unit = _a[1];
|
|
if (value) {
|
|
return value + unit;
|
|
}
|
|
}
|
|
else {
|
|
var dimen = this.string.slice(this.i);
|
|
var _b = __read(ParseUtil_js_1.default.matchDimen(dimen, true), 3), value = _b[0], unit = _b[1], length_1 = _b[2];
|
|
if (value) {
|
|
this.i += length_1;
|
|
return value + unit;
|
|
}
|
|
}
|
|
throw new TexError_js_1.default('MissingDimOrUnits', 'Missing dimension or its units for %1', this.currentCS);
|
|
};
|
|
TexParser.prototype.GetUpTo = function (_name, token) {
|
|
while (this.nextIsSpace()) {
|
|
this.i++;
|
|
}
|
|
var j = this.i;
|
|
var parens = 0;
|
|
while (this.i < this.string.length) {
|
|
var k = this.i;
|
|
var c = this.GetNext();
|
|
this.i += c.length;
|
|
switch (c) {
|
|
case '\\':
|
|
c += this.GetCS();
|
|
break;
|
|
case '{':
|
|
parens++;
|
|
break;
|
|
case '}':
|
|
if (parens === 0) {
|
|
throw new TexError_js_1.default('ExtraCloseLooking', 'Extra close brace while looking for %1', token);
|
|
}
|
|
parens--;
|
|
break;
|
|
}
|
|
if (parens === 0 && c === token) {
|
|
return this.string.slice(j, k);
|
|
}
|
|
}
|
|
throw new TexError_js_1.default('TokenNotFoundForCommand', 'Could not find %1 for %2', token, this.currentCS);
|
|
};
|
|
TexParser.prototype.ParseArg = function (name) {
|
|
return new TexParser(this.GetArgument(name), this.stack.env, this.configuration).mml();
|
|
};
|
|
TexParser.prototype.ParseUpTo = function (name, token) {
|
|
return new TexParser(this.GetUpTo(name, token), this.stack.env, this.configuration).mml();
|
|
};
|
|
TexParser.prototype.GetDelimiterArg = function (name) {
|
|
var c = ParseUtil_js_1.default.trimSpaces(this.GetArgument(name));
|
|
if (c === '') {
|
|
return null;
|
|
}
|
|
if (this.contains('delimiter', c)) {
|
|
return c;
|
|
}
|
|
throw new TexError_js_1.default('MissingOrUnrecognizedDelim', 'Missing or unrecognized delimiter for %1', this.currentCS);
|
|
};
|
|
TexParser.prototype.GetStar = function () {
|
|
var star = (this.GetNext() === '*');
|
|
if (star) {
|
|
this.i++;
|
|
}
|
|
return star;
|
|
};
|
|
TexParser.prototype.create = function (kind) {
|
|
var _a;
|
|
var rest = [];
|
|
for (var _i = 1; _i < arguments.length; _i++) {
|
|
rest[_i - 1] = arguments[_i];
|
|
}
|
|
return (_a = this.configuration.nodeFactory).create.apply(_a, __spreadArray([kind], __read(rest), false));
|
|
};
|
|
return TexParser;
|
|
}());
|
|
exports["default"] = TexParser;
|
|
//# sourceMappingURL=TexParser.js.map
|
|
|
|
/***/ }),
|
|
|
|
/***/ 44971:
|
|
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
exports.mathjax = void 0;
|
|
var version_js_1 = __webpack_require__(27573);
|
|
var HandlerList_js_1 = __webpack_require__(12514);
|
|
var Retries_js_1 = __webpack_require__(10956);
|
|
exports.mathjax = {
|
|
version: version_js_1.VERSION,
|
|
handlers: new HandlerList_js_1.HandlerList(),
|
|
document: function (document, options) {
|
|
return exports.mathjax.handlers.document(document, options);
|
|
},
|
|
handleRetriesFor: Retries_js_1.handleRetriesFor,
|
|
retryAfter: Retries_js_1.retryAfter,
|
|
asyncLoad: null,
|
|
};
|
|
//# sourceMappingURL=mathjax.js.map
|
|
|
|
/***/ }),
|
|
|
|
/***/ 20757:
|
|
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
exports.asyncLoad = void 0;
|
|
var mathjax_js_1 = __webpack_require__(44971);
|
|
function asyncLoad(name) {
|
|
if (!mathjax_js_1.mathjax.asyncLoad) {
|
|
return Promise.reject("Can't load '".concat(name, "': No asyncLoad method specified"));
|
|
}
|
|
return new Promise(function (ok, fail) {
|
|
var result = mathjax_js_1.mathjax.asyncLoad(name);
|
|
if (result instanceof Promise) {
|
|
result.then(function (value) { return ok(value); }).catch(function (err) { return fail(err); });
|
|
}
|
|
else {
|
|
ok(result);
|
|
}
|
|
});
|
|
}
|
|
exports.asyncLoad = asyncLoad;
|
|
//# sourceMappingURL=AsyncLoad.js.map
|
|
|
|
/***/ }),
|
|
|
|
/***/ 61051:
|
|
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
exports.numeric = exports.translate = exports.remove = exports.add = exports.entities = exports.options = void 0;
|
|
var Retries_js_1 = __webpack_require__(10956);
|
|
var AsyncLoad_js_1 = __webpack_require__(20757);
|
|
exports.options = {
|
|
loadMissingEntities: true
|
|
};
|
|
exports.entities = {
|
|
ApplyFunction: '\u2061',
|
|
Backslash: '\u2216',
|
|
Because: '\u2235',
|
|
Breve: '\u02D8',
|
|
Cap: '\u22D2',
|
|
CenterDot: '\u00B7',
|
|
CircleDot: '\u2299',
|
|
CircleMinus: '\u2296',
|
|
CirclePlus: '\u2295',
|
|
CircleTimes: '\u2297',
|
|
Congruent: '\u2261',
|
|
ContourIntegral: '\u222E',
|
|
Coproduct: '\u2210',
|
|
Cross: '\u2A2F',
|
|
Cup: '\u22D3',
|
|
CupCap: '\u224D',
|
|
Dagger: '\u2021',
|
|
Del: '\u2207',
|
|
Delta: '\u0394',
|
|
Diamond: '\u22C4',
|
|
DifferentialD: '\u2146',
|
|
DotEqual: '\u2250',
|
|
DoubleDot: '\u00A8',
|
|
DoubleRightTee: '\u22A8',
|
|
DoubleVerticalBar: '\u2225',
|
|
DownArrow: '\u2193',
|
|
DownLeftVector: '\u21BD',
|
|
DownRightVector: '\u21C1',
|
|
DownTee: '\u22A4',
|
|
Downarrow: '\u21D3',
|
|
Element: '\u2208',
|
|
EqualTilde: '\u2242',
|
|
Equilibrium: '\u21CC',
|
|
Exists: '\u2203',
|
|
ExponentialE: '\u2147',
|
|
FilledVerySmallSquare: '\u25AA',
|
|
ForAll: '\u2200',
|
|
Gamma: '\u0393',
|
|
Gg: '\u22D9',
|
|
GreaterEqual: '\u2265',
|
|
GreaterEqualLess: '\u22DB',
|
|
GreaterFullEqual: '\u2267',
|
|
GreaterLess: '\u2277',
|
|
GreaterSlantEqual: '\u2A7E',
|
|
GreaterTilde: '\u2273',
|
|
Hacek: '\u02C7',
|
|
Hat: '\u005E',
|
|
HumpDownHump: '\u224E',
|
|
HumpEqual: '\u224F',
|
|
Im: '\u2111',
|
|
ImaginaryI: '\u2148',
|
|
Integral: '\u222B',
|
|
Intersection: '\u22C2',
|
|
InvisibleComma: '\u2063',
|
|
InvisibleTimes: '\u2062',
|
|
Lambda: '\u039B',
|
|
Larr: '\u219E',
|
|
LeftAngleBracket: '\u27E8',
|
|
LeftArrow: '\u2190',
|
|
LeftArrowRightArrow: '\u21C6',
|
|
LeftCeiling: '\u2308',
|
|
LeftDownVector: '\u21C3',
|
|
LeftFloor: '\u230A',
|
|
LeftRightArrow: '\u2194',
|
|
LeftTee: '\u22A3',
|
|
LeftTriangle: '\u22B2',
|
|
LeftTriangleEqual: '\u22B4',
|
|
LeftUpVector: '\u21BF',
|
|
LeftVector: '\u21BC',
|
|
Leftarrow: '\u21D0',
|
|
Leftrightarrow: '\u21D4',
|
|
LessEqualGreater: '\u22DA',
|
|
LessFullEqual: '\u2266',
|
|
LessGreater: '\u2276',
|
|
LessSlantEqual: '\u2A7D',
|
|
LessTilde: '\u2272',
|
|
Ll: '\u22D8',
|
|
Lleftarrow: '\u21DA',
|
|
LongLeftArrow: '\u27F5',
|
|
LongLeftRightArrow: '\u27F7',
|
|
LongRightArrow: '\u27F6',
|
|
Longleftarrow: '\u27F8',
|
|
Longleftrightarrow: '\u27FA',
|
|
Longrightarrow: '\u27F9',
|
|
Lsh: '\u21B0',
|
|
MinusPlus: '\u2213',
|
|
NestedGreaterGreater: '\u226B',
|
|
NestedLessLess: '\u226A',
|
|
NotDoubleVerticalBar: '\u2226',
|
|
NotElement: '\u2209',
|
|
NotEqual: '\u2260',
|
|
NotExists: '\u2204',
|
|
NotGreater: '\u226F',
|
|
NotGreaterEqual: '\u2271',
|
|
NotLeftTriangle: '\u22EA',
|
|
NotLeftTriangleEqual: '\u22EC',
|
|
NotLess: '\u226E',
|
|
NotLessEqual: '\u2270',
|
|
NotPrecedes: '\u2280',
|
|
NotPrecedesSlantEqual: '\u22E0',
|
|
NotRightTriangle: '\u22EB',
|
|
NotRightTriangleEqual: '\u22ED',
|
|
NotSubsetEqual: '\u2288',
|
|
NotSucceeds: '\u2281',
|
|
NotSucceedsSlantEqual: '\u22E1',
|
|
NotSupersetEqual: '\u2289',
|
|
NotTilde: '\u2241',
|
|
NotVerticalBar: '\u2224',
|
|
Omega: '\u03A9',
|
|
OverBar: '\u203E',
|
|
OverBrace: '\u23DE',
|
|
PartialD: '\u2202',
|
|
Phi: '\u03A6',
|
|
Pi: '\u03A0',
|
|
PlusMinus: '\u00B1',
|
|
Precedes: '\u227A',
|
|
PrecedesEqual: '\u2AAF',
|
|
PrecedesSlantEqual: '\u227C',
|
|
PrecedesTilde: '\u227E',
|
|
Product: '\u220F',
|
|
Proportional: '\u221D',
|
|
Psi: '\u03A8',
|
|
Rarr: '\u21A0',
|
|
Re: '\u211C',
|
|
ReverseEquilibrium: '\u21CB',
|
|
RightAngleBracket: '\u27E9',
|
|
RightArrow: '\u2192',
|
|
RightArrowLeftArrow: '\u21C4',
|
|
RightCeiling: '\u2309',
|
|
RightDownVector: '\u21C2',
|
|
RightFloor: '\u230B',
|
|
RightTee: '\u22A2',
|
|
RightTeeArrow: '\u21A6',
|
|
RightTriangle: '\u22B3',
|
|
RightTriangleEqual: '\u22B5',
|
|
RightUpVector: '\u21BE',
|
|
RightVector: '\u21C0',
|
|
Rightarrow: '\u21D2',
|
|
Rrightarrow: '\u21DB',
|
|
Rsh: '\u21B1',
|
|
Sigma: '\u03A3',
|
|
SmallCircle: '\u2218',
|
|
Sqrt: '\u221A',
|
|
Square: '\u25A1',
|
|
SquareIntersection: '\u2293',
|
|
SquareSubset: '\u228F',
|
|
SquareSubsetEqual: '\u2291',
|
|
SquareSuperset: '\u2290',
|
|
SquareSupersetEqual: '\u2292',
|
|
SquareUnion: '\u2294',
|
|
Star: '\u22C6',
|
|
Subset: '\u22D0',
|
|
SubsetEqual: '\u2286',
|
|
Succeeds: '\u227B',
|
|
SucceedsEqual: '\u2AB0',
|
|
SucceedsSlantEqual: '\u227D',
|
|
SucceedsTilde: '\u227F',
|
|
SuchThat: '\u220B',
|
|
Sum: '\u2211',
|
|
Superset: '\u2283',
|
|
SupersetEqual: '\u2287',
|
|
Supset: '\u22D1',
|
|
Therefore: '\u2234',
|
|
Theta: '\u0398',
|
|
Tilde: '\u223C',
|
|
TildeEqual: '\u2243',
|
|
TildeFullEqual: '\u2245',
|
|
TildeTilde: '\u2248',
|
|
UnderBar: '\u005F',
|
|
UnderBrace: '\u23DF',
|
|
Union: '\u22C3',
|
|
UnionPlus: '\u228E',
|
|
UpArrow: '\u2191',
|
|
UpDownArrow: '\u2195',
|
|
UpTee: '\u22A5',
|
|
Uparrow: '\u21D1',
|
|
Updownarrow: '\u21D5',
|
|
Upsilon: '\u03A5',
|
|
Vdash: '\u22A9',
|
|
Vee: '\u22C1',
|
|
VerticalBar: '\u2223',
|
|
VerticalTilde: '\u2240',
|
|
Vvdash: '\u22AA',
|
|
Wedge: '\u22C0',
|
|
Xi: '\u039E',
|
|
amp: '\u0026',
|
|
acute: '\u00B4',
|
|
aleph: '\u2135',
|
|
alpha: '\u03B1',
|
|
amalg: '\u2A3F',
|
|
and: '\u2227',
|
|
ang: '\u2220',
|
|
angmsd: '\u2221',
|
|
angsph: '\u2222',
|
|
ape: '\u224A',
|
|
backprime: '\u2035',
|
|
backsim: '\u223D',
|
|
backsimeq: '\u22CD',
|
|
beta: '\u03B2',
|
|
beth: '\u2136',
|
|
between: '\u226C',
|
|
bigcirc: '\u25EF',
|
|
bigodot: '\u2A00',
|
|
bigoplus: '\u2A01',
|
|
bigotimes: '\u2A02',
|
|
bigsqcup: '\u2A06',
|
|
bigstar: '\u2605',
|
|
bigtriangledown: '\u25BD',
|
|
bigtriangleup: '\u25B3',
|
|
biguplus: '\u2A04',
|
|
blacklozenge: '\u29EB',
|
|
blacktriangle: '\u25B4',
|
|
blacktriangledown: '\u25BE',
|
|
blacktriangleleft: '\u25C2',
|
|
bowtie: '\u22C8',
|
|
boxdl: '\u2510',
|
|
boxdr: '\u250C',
|
|
boxminus: '\u229F',
|
|
boxplus: '\u229E',
|
|
boxtimes: '\u22A0',
|
|
boxul: '\u2518',
|
|
boxur: '\u2514',
|
|
bsol: '\u005C',
|
|
bull: '\u2022',
|
|
cap: '\u2229',
|
|
check: '\u2713',
|
|
chi: '\u03C7',
|
|
circ: '\u02C6',
|
|
circeq: '\u2257',
|
|
circlearrowleft: '\u21BA',
|
|
circlearrowright: '\u21BB',
|
|
circledR: '\u00AE',
|
|
circledS: '\u24C8',
|
|
circledast: '\u229B',
|
|
circledcirc: '\u229A',
|
|
circleddash: '\u229D',
|
|
clubs: '\u2663',
|
|
colon: '\u003A',
|
|
comp: '\u2201',
|
|
ctdot: '\u22EF',
|
|
cuepr: '\u22DE',
|
|
cuesc: '\u22DF',
|
|
cularr: '\u21B6',
|
|
cup: '\u222A',
|
|
curarr: '\u21B7',
|
|
curlyvee: '\u22CE',
|
|
curlywedge: '\u22CF',
|
|
dagger: '\u2020',
|
|
daleth: '\u2138',
|
|
ddarr: '\u21CA',
|
|
deg: '\u00B0',
|
|
delta: '\u03B4',
|
|
digamma: '\u03DD',
|
|
div: '\u00F7',
|
|
divideontimes: '\u22C7',
|
|
dot: '\u02D9',
|
|
doteqdot: '\u2251',
|
|
dotplus: '\u2214',
|
|
dotsquare: '\u22A1',
|
|
dtdot: '\u22F1',
|
|
ecir: '\u2256',
|
|
efDot: '\u2252',
|
|
egs: '\u2A96',
|
|
ell: '\u2113',
|
|
els: '\u2A95',
|
|
empty: '\u2205',
|
|
epsi: '\u03B5',
|
|
epsiv: '\u03F5',
|
|
erDot: '\u2253',
|
|
eta: '\u03B7',
|
|
eth: '\u00F0',
|
|
flat: '\u266D',
|
|
fork: '\u22D4',
|
|
frown: '\u2322',
|
|
gEl: '\u2A8C',
|
|
gamma: '\u03B3',
|
|
gap: '\u2A86',
|
|
gimel: '\u2137',
|
|
gnE: '\u2269',
|
|
gnap: '\u2A8A',
|
|
gne: '\u2A88',
|
|
gnsim: '\u22E7',
|
|
gt: '\u003E',
|
|
gtdot: '\u22D7',
|
|
harrw: '\u21AD',
|
|
hbar: '\u210F',
|
|
hellip: '\u2026',
|
|
hookleftarrow: '\u21A9',
|
|
hookrightarrow: '\u21AA',
|
|
imath: '\u0131',
|
|
infin: '\u221E',
|
|
intcal: '\u22BA',
|
|
iota: '\u03B9',
|
|
jmath: '\u0237',
|
|
kappa: '\u03BA',
|
|
kappav: '\u03F0',
|
|
lEg: '\u2A8B',
|
|
lambda: '\u03BB',
|
|
lap: '\u2A85',
|
|
larrlp: '\u21AB',
|
|
larrtl: '\u21A2',
|
|
lbrace: '\u007B',
|
|
lbrack: '\u005B',
|
|
le: '\u2264',
|
|
leftleftarrows: '\u21C7',
|
|
leftthreetimes: '\u22CB',
|
|
lessdot: '\u22D6',
|
|
lmoust: '\u23B0',
|
|
lnE: '\u2268',
|
|
lnap: '\u2A89',
|
|
lne: '\u2A87',
|
|
lnsim: '\u22E6',
|
|
longmapsto: '\u27FC',
|
|
looparrowright: '\u21AC',
|
|
lowast: '\u2217',
|
|
loz: '\u25CA',
|
|
lt: '\u003C',
|
|
ltimes: '\u22C9',
|
|
ltri: '\u25C3',
|
|
macr: '\u00AF',
|
|
malt: '\u2720',
|
|
mho: '\u2127',
|
|
mu: '\u03BC',
|
|
multimap: '\u22B8',
|
|
nLeftarrow: '\u21CD',
|
|
nLeftrightarrow: '\u21CE',
|
|
nRightarrow: '\u21CF',
|
|
nVDash: '\u22AF',
|
|
nVdash: '\u22AE',
|
|
natur: '\u266E',
|
|
nearr: '\u2197',
|
|
nharr: '\u21AE',
|
|
nlarr: '\u219A',
|
|
not: '\u00AC',
|
|
nrarr: '\u219B',
|
|
nu: '\u03BD',
|
|
nvDash: '\u22AD',
|
|
nvdash: '\u22AC',
|
|
nwarr: '\u2196',
|
|
omega: '\u03C9',
|
|
omicron: '\u03BF',
|
|
or: '\u2228',
|
|
osol: '\u2298',
|
|
period: '\u002E',
|
|
phi: '\u03C6',
|
|
phiv: '\u03D5',
|
|
pi: '\u03C0',
|
|
piv: '\u03D6',
|
|
prap: '\u2AB7',
|
|
precnapprox: '\u2AB9',
|
|
precneqq: '\u2AB5',
|
|
precnsim: '\u22E8',
|
|
prime: '\u2032',
|
|
psi: '\u03C8',
|
|
quot: '\u0022',
|
|
rarrtl: '\u21A3',
|
|
rbrace: '\u007D',
|
|
rbrack: '\u005D',
|
|
rho: '\u03C1',
|
|
rhov: '\u03F1',
|
|
rightrightarrows: '\u21C9',
|
|
rightthreetimes: '\u22CC',
|
|
ring: '\u02DA',
|
|
rmoust: '\u23B1',
|
|
rtimes: '\u22CA',
|
|
rtri: '\u25B9',
|
|
scap: '\u2AB8',
|
|
scnE: '\u2AB6',
|
|
scnap: '\u2ABA',
|
|
scnsim: '\u22E9',
|
|
sdot: '\u22C5',
|
|
searr: '\u2198',
|
|
sect: '\u00A7',
|
|
sharp: '\u266F',
|
|
sigma: '\u03C3',
|
|
sigmav: '\u03C2',
|
|
simne: '\u2246',
|
|
smile: '\u2323',
|
|
spades: '\u2660',
|
|
sub: '\u2282',
|
|
subE: '\u2AC5',
|
|
subnE: '\u2ACB',
|
|
subne: '\u228A',
|
|
supE: '\u2AC6',
|
|
supnE: '\u2ACC',
|
|
supne: '\u228B',
|
|
swarr: '\u2199',
|
|
tau: '\u03C4',
|
|
theta: '\u03B8',
|
|
thetav: '\u03D1',
|
|
tilde: '\u02DC',
|
|
times: '\u00D7',
|
|
triangle: '\u25B5',
|
|
triangleq: '\u225C',
|
|
upsi: '\u03C5',
|
|
upuparrows: '\u21C8',
|
|
veebar: '\u22BB',
|
|
vellip: '\u22EE',
|
|
weierp: '\u2118',
|
|
xi: '\u03BE',
|
|
yen: '\u00A5',
|
|
zeta: '\u03B6',
|
|
zigrarr: '\u21DD',
|
|
nbsp: '\u00A0',
|
|
rsquo: '\u2019',
|
|
lsquo: '\u2018'
|
|
};
|
|
var loaded = {};
|
|
function add(additions, file) {
|
|
Object.assign(exports.entities, additions);
|
|
loaded[file] = true;
|
|
}
|
|
exports.add = add;
|
|
function remove(entity) {
|
|
delete exports.entities[entity];
|
|
}
|
|
exports.remove = remove;
|
|
function translate(text) {
|
|
return text.replace(/&([a-z][a-z0-9]*|#(?:[0-9]+|x[0-9a-f]+));/ig, replace);
|
|
}
|
|
exports.translate = translate;
|
|
function replace(match, entity) {
|
|
if (entity.charAt(0) === '#') {
|
|
return numeric(entity.slice(1));
|
|
}
|
|
if (exports.entities[entity]) {
|
|
return exports.entities[entity];
|
|
}
|
|
if (exports.options['loadMissingEntities']) {
|
|
var file = (entity.match(/^[a-zA-Z](fr|scr|opf)$/) ? RegExp.$1 : entity.charAt(0).toLowerCase());
|
|
if (!loaded[file]) {
|
|
loaded[file] = true;
|
|
(0, Retries_js_1.retryAfter)((0, AsyncLoad_js_1.asyncLoad)('./util/entities/' + file + '.js'));
|
|
}
|
|
}
|
|
return match;
|
|
}
|
|
function numeric(entity) {
|
|
var n = (entity.charAt(0) === 'x' ?
|
|
parseInt(entity.slice(1), 16) :
|
|
parseInt(entity));
|
|
return String.fromCodePoint(n);
|
|
}
|
|
exports.numeric = numeric;
|
|
//# sourceMappingURL=Entities.js.map
|
|
|
|
/***/ }),
|
|
|
|
/***/ 18341:
|
|
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
|
|
|
|
|
|
var __extends = (this && this.__extends) || (function () {
|
|
var extendStatics = function (d, b) {
|
|
extendStatics = Object.setPrototypeOf ||
|
|
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
|
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
|
|
return extendStatics(d, b);
|
|
};
|
|
return function (d, b) {
|
|
if (typeof b !== "function" && b !== null)
|
|
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
|
|
extendStatics(d, b);
|
|
function __() { this.constructor = d; }
|
|
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
|
};
|
|
})();
|
|
var __values = (this && this.__values) || function(o) {
|
|
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
|
|
if (m) return m.call(o);
|
|
if (o && typeof o.length === "number") return {
|
|
next: function () {
|
|
if (o && i >= o.length) o = void 0;
|
|
return { value: o && o[i++], done: !o };
|
|
}
|
|
};
|
|
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
|
|
};
|
|
var __read = (this && this.__read) || function (o, n) {
|
|
var m = typeof Symbol === "function" && o[Symbol.iterator];
|
|
if (!m) return o;
|
|
var i = m.call(o), r, ar = [], e;
|
|
try {
|
|
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
|
|
}
|
|
catch (error) { e = { error: error }; }
|
|
finally {
|
|
try {
|
|
if (r && !r.done && (m = i["return"])) m.call(i);
|
|
}
|
|
finally { if (e) throw e.error; }
|
|
}
|
|
return ar;
|
|
};
|
|
var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
|
|
if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
|
|
if (ar || !(i in from)) {
|
|
if (!ar) ar = Array.prototype.slice.call(from, 0, i);
|
|
ar[i] = from[i];
|
|
}
|
|
}
|
|
return to.concat(ar || Array.prototype.slice.call(from));
|
|
};
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
exports.FunctionList = void 0;
|
|
var PrioritizedList_js_1 = __webpack_require__(98721);
|
|
var FunctionList = (function (_super) {
|
|
__extends(FunctionList, _super);
|
|
function FunctionList() {
|
|
return _super !== null && _super.apply(this, arguments) || this;
|
|
}
|
|
FunctionList.prototype.execute = function () {
|
|
var e_1, _a;
|
|
var data = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
data[_i] = arguments[_i];
|
|
}
|
|
try {
|
|
for (var _b = __values(this), _c = _b.next(); !_c.done; _c = _b.next()) {
|
|
var item = _c.value;
|
|
var result = item.item.apply(item, __spreadArray([], __read(data), false));
|
|
if (result === false) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
catch (e_1_1) { e_1 = { error: e_1_1 }; }
|
|
finally {
|
|
try {
|
|
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
|
|
}
|
|
finally { if (e_1) throw e_1.error; }
|
|
}
|
|
return true;
|
|
};
|
|
FunctionList.prototype.asyncExecute = function () {
|
|
var data = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
data[_i] = arguments[_i];
|
|
}
|
|
var i = -1;
|
|
var items = this.items;
|
|
return new Promise(function (ok, fail) {
|
|
(function execute() {
|
|
var _a;
|
|
while (++i < items.length) {
|
|
var result = (_a = items[i]).item.apply(_a, __spreadArray([], __read(data), false));
|
|
if (result instanceof Promise) {
|
|
result.then(execute).catch(function (err) { return fail(err); });
|
|
return;
|
|
}
|
|
if (result === false) {
|
|
ok(false);
|
|
return;
|
|
}
|
|
}
|
|
ok(true);
|
|
})();
|
|
});
|
|
};
|
|
return FunctionList;
|
|
}(PrioritizedList_js_1.PrioritizedList));
|
|
exports.FunctionList = FunctionList;
|
|
//# sourceMappingURL=FunctionList.js.map
|
|
|
|
/***/ }),
|
|
|
|
/***/ 98721:
|
|
/***/ ((__unused_webpack_module, exports) => {
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
exports.PrioritizedList = void 0;
|
|
var PrioritizedList = (function () {
|
|
function PrioritizedList() {
|
|
this.items = [];
|
|
this.items = [];
|
|
}
|
|
PrioritizedList.prototype[Symbol.iterator] = function () {
|
|
var i = 0;
|
|
var items = this.items;
|
|
return {
|
|
next: function () {
|
|
return { value: items[i++], done: (i > items.length) };
|
|
}
|
|
};
|
|
};
|
|
PrioritizedList.prototype.add = function (item, priority) {
|
|
if (priority === void 0) { priority = PrioritizedList.DEFAULTPRIORITY; }
|
|
var i = this.items.length;
|
|
do {
|
|
i--;
|
|
} while (i >= 0 && priority < this.items[i].priority);
|
|
this.items.splice(i + 1, 0, { item: item, priority: priority });
|
|
return item;
|
|
};
|
|
PrioritizedList.prototype.remove = function (item) {
|
|
var i = this.items.length;
|
|
do {
|
|
i--;
|
|
} while (i >= 0 && this.items[i].item !== item);
|
|
if (i >= 0) {
|
|
this.items.splice(i, 1);
|
|
}
|
|
};
|
|
PrioritizedList.DEFAULTPRIORITY = 5;
|
|
return PrioritizedList;
|
|
}());
|
|
exports.PrioritizedList = PrioritizedList;
|
|
//# sourceMappingURL=PrioritizedList.js.map
|
|
|
|
/***/ }),
|
|
|
|
/***/ 10956:
|
|
/***/ ((__unused_webpack_module, exports) => {
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
exports.retryAfter = exports.handleRetriesFor = void 0;
|
|
function handleRetriesFor(code) {
|
|
return new Promise(function run(ok, fail) {
|
|
try {
|
|
ok(code());
|
|
}
|
|
catch (err) {
|
|
if (err.retry && err.retry instanceof Promise) {
|
|
err.retry.then(function () { return run(ok, fail); })
|
|
.catch(function (perr) { return fail(perr); });
|
|
}
|
|
else if (err.restart && err.restart.isCallback) {
|
|
MathJax.Callback.After(function () { return run(ok, fail); }, err.restart);
|
|
}
|
|
else {
|
|
fail(err);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
exports.handleRetriesFor = handleRetriesFor;
|
|
function retryAfter(promise) {
|
|
var err = new Error('MathJax retry');
|
|
err.retry = promise;
|
|
throw err;
|
|
}
|
|
exports.retryAfter = retryAfter;
|
|
//# sourceMappingURL=Retries.js.map
|
|
|
|
/***/ })
|
|
|
|
}]);
|
|
//# sourceMappingURL=5115.722cf90a473016a17ba7.js.map?v=722cf90a473016a17ba7
|