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.
810 lines
31 KiB
JavaScript
810 lines
31 KiB
JavaScript
"use strict";
|
|
(self["webpackChunk_JUPYTERLAB_CORE_OUTPUT"] = self["webpackChunk_JUPYTERLAB_CORE_OUTPUT"] || []).push([[7582],{
|
|
|
|
/***/ 9103:
|
|
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
exports.AbstractFindMath = void 0;
|
|
var Options_js_1 = __webpack_require__(4498);
|
|
var AbstractFindMath = (function () {
|
|
function AbstractFindMath(options) {
|
|
var CLASS = this.constructor;
|
|
this.options = (0, Options_js_1.userOptions)((0, Options_js_1.defaultOptions)({}, CLASS.OPTIONS), options);
|
|
}
|
|
AbstractFindMath.OPTIONS = {};
|
|
return AbstractFindMath;
|
|
}());
|
|
exports.AbstractFindMath = AbstractFindMath;
|
|
//# sourceMappingURL=FindMath.js.map
|
|
|
|
/***/ }),
|
|
|
|
/***/ 76771:
|
|
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
exports.AbstractInputJax = void 0;
|
|
var Options_js_1 = __webpack_require__(4498);
|
|
var FunctionList_js_1 = __webpack_require__(18341);
|
|
var AbstractInputJax = (function () {
|
|
function AbstractInputJax(options) {
|
|
if (options === void 0) { options = {}; }
|
|
this.adaptor = null;
|
|
this.mmlFactory = null;
|
|
var CLASS = this.constructor;
|
|
this.options = (0, Options_js_1.userOptions)((0, Options_js_1.defaultOptions)({}, CLASS.OPTIONS), options);
|
|
this.preFilters = new FunctionList_js_1.FunctionList();
|
|
this.postFilters = new FunctionList_js_1.FunctionList();
|
|
}
|
|
Object.defineProperty(AbstractInputJax.prototype, "name", {
|
|
get: function () {
|
|
return this.constructor.NAME;
|
|
},
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
AbstractInputJax.prototype.setAdaptor = function (adaptor) {
|
|
this.adaptor = adaptor;
|
|
};
|
|
AbstractInputJax.prototype.setMmlFactory = function (mmlFactory) {
|
|
this.mmlFactory = mmlFactory;
|
|
};
|
|
AbstractInputJax.prototype.initialize = function () {
|
|
};
|
|
AbstractInputJax.prototype.reset = function () {
|
|
var _args = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
_args[_i] = arguments[_i];
|
|
}
|
|
};
|
|
Object.defineProperty(AbstractInputJax.prototype, "processStrings", {
|
|
get: function () {
|
|
return true;
|
|
},
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
AbstractInputJax.prototype.findMath = function (_node, _options) {
|
|
return [];
|
|
};
|
|
AbstractInputJax.prototype.executeFilters = function (filters, math, document, data) {
|
|
var args = { math: math, document: document, data: data };
|
|
filters.execute(args);
|
|
return args.data;
|
|
};
|
|
AbstractInputJax.NAME = 'generic';
|
|
AbstractInputJax.OPTIONS = {};
|
|
return AbstractInputJax;
|
|
}());
|
|
exports.AbstractInputJax = AbstractInputJax;
|
|
//# sourceMappingURL=InputJax.js.map
|
|
|
|
/***/ }),
|
|
|
|
/***/ 21605:
|
|
/***/ ((__unused_webpack_module, exports) => {
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
exports.newState = exports.STATE = exports.AbstractMathItem = exports.protoItem = void 0;
|
|
function protoItem(open, math, close, n, start, end, display) {
|
|
if (display === void 0) { display = null; }
|
|
var item = { open: open, math: math, close: close,
|
|
n: n, start: { n: start }, end: { n: end }, display: display };
|
|
return item;
|
|
}
|
|
exports.protoItem = protoItem;
|
|
var AbstractMathItem = (function () {
|
|
function AbstractMathItem(math, jax, display, start, end) {
|
|
if (display === void 0) { display = true; }
|
|
if (start === void 0) { start = { i: 0, n: 0, delim: '' }; }
|
|
if (end === void 0) { end = { i: 0, n: 0, delim: '' }; }
|
|
this.root = null;
|
|
this.typesetRoot = null;
|
|
this.metrics = {};
|
|
this.inputData = {};
|
|
this.outputData = {};
|
|
this._state = exports.STATE.UNPROCESSED;
|
|
this.math = math;
|
|
this.inputJax = jax;
|
|
this.display = display;
|
|
this.start = start;
|
|
this.end = end;
|
|
this.root = null;
|
|
this.typesetRoot = null;
|
|
this.metrics = {};
|
|
this.inputData = {};
|
|
this.outputData = {};
|
|
}
|
|
Object.defineProperty(AbstractMathItem.prototype, "isEscaped", {
|
|
get: function () {
|
|
return this.display === null;
|
|
},
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
AbstractMathItem.prototype.render = function (document) {
|
|
document.renderActions.renderMath(this, document);
|
|
};
|
|
AbstractMathItem.prototype.rerender = function (document, start) {
|
|
if (start === void 0) { start = exports.STATE.RERENDER; }
|
|
if (this.state() >= start) {
|
|
this.state(start - 1);
|
|
}
|
|
document.renderActions.renderMath(this, document, start);
|
|
};
|
|
AbstractMathItem.prototype.convert = function (document, end) {
|
|
if (end === void 0) { end = exports.STATE.LAST; }
|
|
document.renderActions.renderConvert(this, document, end);
|
|
};
|
|
AbstractMathItem.prototype.compile = function (document) {
|
|
if (this.state() < exports.STATE.COMPILED) {
|
|
this.root = this.inputJax.compile(this, document);
|
|
this.state(exports.STATE.COMPILED);
|
|
}
|
|
};
|
|
AbstractMathItem.prototype.typeset = function (document) {
|
|
if (this.state() < exports.STATE.TYPESET) {
|
|
this.typesetRoot = document.outputJax[this.isEscaped ? 'escaped' : 'typeset'](this, document);
|
|
this.state(exports.STATE.TYPESET);
|
|
}
|
|
};
|
|
AbstractMathItem.prototype.updateDocument = function (_document) { };
|
|
AbstractMathItem.prototype.removeFromDocument = function (_restore) {
|
|
if (_restore === void 0) { _restore = false; }
|
|
};
|
|
AbstractMathItem.prototype.setMetrics = function (em, ex, cwidth, lwidth, scale) {
|
|
this.metrics = {
|
|
em: em, ex: ex,
|
|
containerWidth: cwidth,
|
|
lineWidth: lwidth,
|
|
scale: scale
|
|
};
|
|
};
|
|
AbstractMathItem.prototype.state = function (state, restore) {
|
|
if (state === void 0) { state = null; }
|
|
if (restore === void 0) { restore = false; }
|
|
if (state != null) {
|
|
if (state < exports.STATE.INSERTED && this._state >= exports.STATE.INSERTED) {
|
|
this.removeFromDocument(restore);
|
|
}
|
|
if (state < exports.STATE.TYPESET && this._state >= exports.STATE.TYPESET) {
|
|
this.outputData = {};
|
|
}
|
|
if (state < exports.STATE.COMPILED && this._state >= exports.STATE.COMPILED) {
|
|
this.inputData = {};
|
|
}
|
|
this._state = state;
|
|
}
|
|
return this._state;
|
|
};
|
|
AbstractMathItem.prototype.reset = function (restore) {
|
|
if (restore === void 0) { restore = false; }
|
|
this.state(exports.STATE.UNPROCESSED, restore);
|
|
};
|
|
return AbstractMathItem;
|
|
}());
|
|
exports.AbstractMathItem = AbstractMathItem;
|
|
exports.STATE = {
|
|
UNPROCESSED: 0,
|
|
FINDMATH: 10,
|
|
COMPILED: 20,
|
|
CONVERT: 100,
|
|
METRICS: 110,
|
|
RERENDER: 125,
|
|
TYPESET: 150,
|
|
INSERTED: 200,
|
|
LAST: 10000
|
|
};
|
|
function newState(name, state) {
|
|
if (name in exports.STATE) {
|
|
throw Error('State ' + name + ' already exists');
|
|
}
|
|
exports.STATE[name] = state;
|
|
}
|
|
exports.newState = newState;
|
|
//# sourceMappingURL=MathItem.js.map
|
|
|
|
/***/ }),
|
|
|
|
/***/ 27582:
|
|
/***/ (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 __assign = (this && this.__assign) || function () {
|
|
__assign = Object.assign || function(t) {
|
|
for (var s, i = 1, n = arguments.length; i < n; i++) {
|
|
s = arguments[i];
|
|
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
|
|
t[p] = s[p];
|
|
}
|
|
return t;
|
|
};
|
|
return __assign.apply(this, arguments);
|
|
};
|
|
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 __importDefault = (this && this.__importDefault) || function (mod) {
|
|
return (mod && mod.__esModule) ? mod : { "default": mod };
|
|
};
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
exports.TeX = void 0;
|
|
var InputJax_js_1 = __webpack_require__(76771);
|
|
var Options_js_1 = __webpack_require__(4498);
|
|
var FindTeX_js_1 = __webpack_require__(73703);
|
|
var FilterUtil_js_1 = __importDefault(__webpack_require__(9514));
|
|
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 ParseOptions_js_1 = __importDefault(__webpack_require__(55661));
|
|
var Tags_js_1 = __webpack_require__(75723);
|
|
var Configuration_js_1 = __webpack_require__(63401);
|
|
__webpack_require__(32742);
|
|
var TeX = (function (_super) {
|
|
__extends(TeX, _super);
|
|
function TeX(options) {
|
|
if (options === void 0) { options = {}; }
|
|
var _this = this;
|
|
var _a = __read((0, Options_js_1.separateOptions)(options, TeX.OPTIONS, FindTeX_js_1.FindTeX.OPTIONS), 3), rest = _a[0], tex = _a[1], find = _a[2];
|
|
_this = _super.call(this, tex) || this;
|
|
_this.findTeX = _this.options['FindTeX'] || new FindTeX_js_1.FindTeX(find);
|
|
var packages = _this.options.packages;
|
|
var configuration = _this.configuration = TeX.configure(packages);
|
|
var parseOptions = _this._parseOptions =
|
|
new ParseOptions_js_1.default(configuration, [_this.options, Tags_js_1.TagsFactory.OPTIONS]);
|
|
(0, Options_js_1.userOptions)(parseOptions.options, rest);
|
|
configuration.config(_this);
|
|
TeX.tags(parseOptions, configuration);
|
|
_this.postFilters.add(FilterUtil_js_1.default.cleanSubSup, -6);
|
|
_this.postFilters.add(FilterUtil_js_1.default.setInherited, -5);
|
|
_this.postFilters.add(FilterUtil_js_1.default.moveLimits, -4);
|
|
_this.postFilters.add(FilterUtil_js_1.default.cleanStretchy, -3);
|
|
_this.postFilters.add(FilterUtil_js_1.default.cleanAttributes, -2);
|
|
_this.postFilters.add(FilterUtil_js_1.default.combineRelations, -1);
|
|
return _this;
|
|
}
|
|
TeX.configure = function (packages) {
|
|
var configuration = new Configuration_js_1.ParserConfiguration(packages, ['tex']);
|
|
configuration.init();
|
|
return configuration;
|
|
};
|
|
TeX.tags = function (options, configuration) {
|
|
Tags_js_1.TagsFactory.addTags(configuration.tags);
|
|
Tags_js_1.TagsFactory.setDefault(options.options.tags);
|
|
options.tags = Tags_js_1.TagsFactory.getDefault();
|
|
options.tags.configuration = options;
|
|
};
|
|
TeX.prototype.setMmlFactory = function (mmlFactory) {
|
|
_super.prototype.setMmlFactory.call(this, mmlFactory);
|
|
this._parseOptions.nodeFactory.setMmlFactory(mmlFactory);
|
|
};
|
|
Object.defineProperty(TeX.prototype, "parseOptions", {
|
|
get: function () {
|
|
return this._parseOptions;
|
|
},
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
TeX.prototype.reset = function (tag) {
|
|
if (tag === void 0) { tag = 0; }
|
|
this.parseOptions.tags.reset(tag);
|
|
};
|
|
TeX.prototype.compile = function (math, document) {
|
|
this.parseOptions.clear();
|
|
this.executeFilters(this.preFilters, math, document, this.parseOptions);
|
|
var display = math.display;
|
|
this.latex = math.math;
|
|
var node;
|
|
this.parseOptions.tags.startEquation(math);
|
|
var globalEnv;
|
|
try {
|
|
var parser = new TexParser_js_1.default(this.latex, { display: display, isInner: false }, this.parseOptions);
|
|
node = parser.mml();
|
|
globalEnv = parser.stack.global;
|
|
}
|
|
catch (err) {
|
|
if (!(err instanceof TexError_js_1.default)) {
|
|
throw err;
|
|
}
|
|
this.parseOptions.error = true;
|
|
node = this.options.formatError(this, err);
|
|
}
|
|
node = this.parseOptions.nodeFactory.create('node', 'math', [node]);
|
|
if (globalEnv === null || globalEnv === void 0 ? void 0 : globalEnv.indentalign) {
|
|
NodeUtil_js_1.default.setAttribute(node, 'indentalign', globalEnv.indentalign);
|
|
}
|
|
if (display) {
|
|
NodeUtil_js_1.default.setAttribute(node, 'display', 'block');
|
|
}
|
|
this.parseOptions.tags.finishEquation(math);
|
|
this.parseOptions.root = node;
|
|
this.executeFilters(this.postFilters, math, document, this.parseOptions);
|
|
this.mathNode = this.parseOptions.root;
|
|
return this.mathNode;
|
|
};
|
|
TeX.prototype.findMath = function (strings) {
|
|
return this.findTeX.findMath(strings);
|
|
};
|
|
TeX.prototype.formatError = function (err) {
|
|
var message = err.message.replace(/\n.*/, '');
|
|
return this.parseOptions.nodeFactory.create('error', message, err.id, this.latex);
|
|
};
|
|
TeX.NAME = 'TeX';
|
|
TeX.OPTIONS = __assign(__assign({}, InputJax_js_1.AbstractInputJax.OPTIONS), { FindTeX: null, packages: ['base'], digits: /^(?:[0-9]+(?:\{,\}[0-9]{3})*(?:\.[0-9]*)?|\.[0-9]+)/, maxBuffer: 5 * 1024, formatError: function (jax, err) { return jax.formatError(err); } });
|
|
return TeX;
|
|
}(InputJax_js_1.AbstractInputJax));
|
|
exports.TeX = TeX;
|
|
//# sourceMappingURL=tex.js.map
|
|
|
|
/***/ }),
|
|
|
|
/***/ 9514:
|
|
/***/ (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 __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 FilterUtil;
|
|
(function (FilterUtil) {
|
|
FilterUtil.cleanStretchy = function (arg) {
|
|
var e_1, _a;
|
|
var options = arg.data;
|
|
try {
|
|
for (var _b = __values(options.getList('fixStretchy')), _c = _b.next(); !_c.done; _c = _b.next()) {
|
|
var mo = _c.value;
|
|
if (NodeUtil_js_1.default.getProperty(mo, 'fixStretchy')) {
|
|
var symbol = NodeUtil_js_1.default.getForm(mo);
|
|
if (symbol && symbol[3] && symbol[3]['stretchy']) {
|
|
NodeUtil_js_1.default.setAttribute(mo, 'stretchy', false);
|
|
}
|
|
var parent_1 = mo.parent;
|
|
if (!NodeUtil_js_1.default.getTexClass(mo) && (!symbol || !symbol[2])) {
|
|
var texAtom = options.nodeFactory.create('node', 'TeXAtom', [mo]);
|
|
parent_1.replaceChild(texAtom, mo);
|
|
texAtom.inheritAttributesFrom(mo);
|
|
}
|
|
NodeUtil_js_1.default.removeProperties(mo, 'fixStretchy');
|
|
}
|
|
}
|
|
}
|
|
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; }
|
|
}
|
|
};
|
|
FilterUtil.cleanAttributes = function (arg) {
|
|
var node = arg.data.root;
|
|
node.walkTree(function (mml, _d) {
|
|
var e_2, _a;
|
|
var attribs = mml.attributes;
|
|
if (!attribs) {
|
|
return;
|
|
}
|
|
var keep = new Set((attribs.get('mjx-keep-attrs') || '').split(/ /));
|
|
delete (attribs.getAllAttributes())['mjx-keep-attrs'];
|
|
try {
|
|
for (var _b = __values(attribs.getExplicitNames()), _c = _b.next(); !_c.done; _c = _b.next()) {
|
|
var key = _c.value;
|
|
if (!keep.has(key) && attribs.attributes[key] === mml.attributes.getInherited(key)) {
|
|
delete attribs.attributes[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; }
|
|
}
|
|
}, {});
|
|
};
|
|
FilterUtil.combineRelations = function (arg) {
|
|
var e_3, _a, e_4, _b;
|
|
var remove = [];
|
|
try {
|
|
for (var _c = __values(arg.data.getList('mo')), _e = _c.next(); !_e.done; _e = _c.next()) {
|
|
var mo = _e.value;
|
|
if (mo.getProperty('relationsCombined') || !mo.parent ||
|
|
(mo.parent && !NodeUtil_js_1.default.isType(mo.parent, 'mrow')) ||
|
|
NodeUtil_js_1.default.getTexClass(mo) !== MmlNode_js_1.TEXCLASS.REL) {
|
|
continue;
|
|
}
|
|
var mml = mo.parent;
|
|
var m2 = void 0;
|
|
var children = mml.childNodes;
|
|
var next = children.indexOf(mo) + 1;
|
|
var variantForm = NodeUtil_js_1.default.getProperty(mo, 'variantForm');
|
|
while (next < children.length && (m2 = children[next]) &&
|
|
NodeUtil_js_1.default.isType(m2, 'mo') &&
|
|
NodeUtil_js_1.default.getTexClass(m2) === MmlNode_js_1.TEXCLASS.REL) {
|
|
if (variantForm === NodeUtil_js_1.default.getProperty(m2, 'variantForm') &&
|
|
_compareExplicit(mo, m2)) {
|
|
NodeUtil_js_1.default.appendChildren(mo, NodeUtil_js_1.default.getChildren(m2));
|
|
_copyExplicit(['stretchy', 'rspace'], mo, m2);
|
|
try {
|
|
for (var _f = (e_4 = void 0, __values(m2.getPropertyNames())), _g = _f.next(); !_g.done; _g = _f.next()) {
|
|
var name_1 = _g.value;
|
|
mo.setProperty(name_1, m2.getProperty(name_1));
|
|
}
|
|
}
|
|
catch (e_4_1) { e_4 = { error: e_4_1 }; }
|
|
finally {
|
|
try {
|
|
if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
|
|
}
|
|
finally { if (e_4) throw e_4.error; }
|
|
}
|
|
children.splice(next, 1);
|
|
remove.push(m2);
|
|
m2.parent = null;
|
|
m2.setProperty('relationsCombined', true);
|
|
}
|
|
else {
|
|
if (mo.attributes.getExplicit('rspace') == null) {
|
|
NodeUtil_js_1.default.setAttribute(mo, 'rspace', '0pt');
|
|
}
|
|
if (m2.attributes.getExplicit('lspace') == null) {
|
|
NodeUtil_js_1.default.setAttribute(m2, 'lspace', '0pt');
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
mo.attributes.setInherited('form', mo.getForms()[0]);
|
|
}
|
|
}
|
|
catch (e_3_1) { e_3 = { error: e_3_1 }; }
|
|
finally {
|
|
try {
|
|
if (_e && !_e.done && (_a = _c.return)) _a.call(_c);
|
|
}
|
|
finally { if (e_3) throw e_3.error; }
|
|
}
|
|
arg.data.removeFromList('mo', remove);
|
|
};
|
|
var _copyExplicit = function (attrs, node1, node2) {
|
|
var attr1 = node1.attributes;
|
|
var attr2 = node2.attributes;
|
|
attrs.forEach(function (x) {
|
|
var attr = attr2.getExplicit(x);
|
|
if (attr != null) {
|
|
attr1.set(x, attr);
|
|
}
|
|
});
|
|
};
|
|
var _compareExplicit = function (node1, node2) {
|
|
var e_5, _a;
|
|
var filter = function (attr, space) {
|
|
var exp = attr.getExplicitNames();
|
|
return exp.filter(function (x) {
|
|
return x !== space &&
|
|
(x !== 'stretchy' ||
|
|
attr.getExplicit('stretchy'));
|
|
});
|
|
};
|
|
var attr1 = node1.attributes;
|
|
var attr2 = node2.attributes;
|
|
var exp1 = filter(attr1, 'lspace');
|
|
var exp2 = filter(attr2, 'rspace');
|
|
if (exp1.length !== exp2.length) {
|
|
return false;
|
|
}
|
|
try {
|
|
for (var exp1_1 = __values(exp1), exp1_1_1 = exp1_1.next(); !exp1_1_1.done; exp1_1_1 = exp1_1.next()) {
|
|
var name_2 = exp1_1_1.value;
|
|
if (attr1.getExplicit(name_2) !== attr2.getExplicit(name_2)) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
catch (e_5_1) { e_5 = { error: e_5_1 }; }
|
|
finally {
|
|
try {
|
|
if (exp1_1_1 && !exp1_1_1.done && (_a = exp1_1.return)) _a.call(exp1_1);
|
|
}
|
|
finally { if (e_5) throw e_5.error; }
|
|
}
|
|
return true;
|
|
};
|
|
var _cleanSubSup = function (options, low, up) {
|
|
var e_6, _a;
|
|
var remove = [];
|
|
try {
|
|
for (var _b = __values(options.getList('m' + low + up)), _c = _b.next(); !_c.done; _c = _b.next()) {
|
|
var mml = _c.value;
|
|
var children = mml.childNodes;
|
|
if (children[mml[low]] && children[mml[up]]) {
|
|
continue;
|
|
}
|
|
var parent_2 = mml.parent;
|
|
var newNode = (children[mml[low]] ?
|
|
options.nodeFactory.create('node', 'm' + low, [children[mml.base], children[mml[low]]]) :
|
|
options.nodeFactory.create('node', 'm' + up, [children[mml.base], children[mml[up]]]));
|
|
NodeUtil_js_1.default.copyAttributes(mml, newNode);
|
|
if (parent_2) {
|
|
parent_2.replaceChild(newNode, mml);
|
|
}
|
|
else {
|
|
options.root = newNode;
|
|
}
|
|
remove.push(mml);
|
|
}
|
|
}
|
|
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; }
|
|
}
|
|
options.removeFromList('m' + low + up, remove);
|
|
};
|
|
FilterUtil.cleanSubSup = function (arg) {
|
|
var options = arg.data;
|
|
if (options.error) {
|
|
return;
|
|
}
|
|
_cleanSubSup(options, 'sub', 'sup');
|
|
_cleanSubSup(options, 'under', 'over');
|
|
};
|
|
var _moveLimits = function (options, underover, subsup) {
|
|
var e_7, _a;
|
|
var remove = [];
|
|
try {
|
|
for (var _b = __values(options.getList(underover)), _c = _b.next(); !_c.done; _c = _b.next()) {
|
|
var mml = _c.value;
|
|
if (mml.attributes.get('displaystyle')) {
|
|
continue;
|
|
}
|
|
var base = mml.childNodes[mml.base];
|
|
var mo = base.coreMO();
|
|
if (base.getProperty('movablelimits') && !mo.attributes.getExplicit('movablelimits')) {
|
|
var node = options.nodeFactory.create('node', subsup, mml.childNodes);
|
|
NodeUtil_js_1.default.copyAttributes(mml, node);
|
|
if (mml.parent) {
|
|
mml.parent.replaceChild(node, mml);
|
|
}
|
|
else {
|
|
options.root = node;
|
|
}
|
|
remove.push(mml);
|
|
}
|
|
}
|
|
}
|
|
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; }
|
|
}
|
|
options.removeFromList(underover, remove);
|
|
};
|
|
FilterUtil.moveLimits = function (arg) {
|
|
var options = arg.data;
|
|
_moveLimits(options, 'munderover', 'msubsup');
|
|
_moveLimits(options, 'munder', 'msub');
|
|
_moveLimits(options, 'mover', 'msup');
|
|
};
|
|
FilterUtil.setInherited = function (arg) {
|
|
arg.data.root.setInheritedAttributes({}, arg.math['display'], 0, false);
|
|
};
|
|
})(FilterUtil || (FilterUtil = {}));
|
|
exports["default"] = FilterUtil;
|
|
//# sourceMappingURL=FilterUtil.js.map
|
|
|
|
/***/ }),
|
|
|
|
/***/ 73703:
|
|
/***/ (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;
|
|
};
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
exports.FindTeX = void 0;
|
|
var FindMath_js_1 = __webpack_require__(9103);
|
|
var string_js_1 = __webpack_require__(55089);
|
|
var MathItem_js_1 = __webpack_require__(21605);
|
|
var FindTeX = (function (_super) {
|
|
__extends(FindTeX, _super);
|
|
function FindTeX(options) {
|
|
var _this = _super.call(this, options) || this;
|
|
_this.getPatterns();
|
|
return _this;
|
|
}
|
|
FindTeX.prototype.getPatterns = function () {
|
|
var _this = this;
|
|
var options = this.options;
|
|
var starts = [], parts = [], subparts = [];
|
|
this.end = {};
|
|
this.env = this.sub = 0;
|
|
var i = 1;
|
|
options['inlineMath'].forEach(function (delims) { return _this.addPattern(starts, delims, false); });
|
|
options['displayMath'].forEach(function (delims) { return _this.addPattern(starts, delims, true); });
|
|
if (starts.length) {
|
|
parts.push(starts.sort(string_js_1.sortLength).join('|'));
|
|
}
|
|
if (options['processEnvironments']) {
|
|
parts.push('\\\\begin\\s*\\{([^}]*)\\}');
|
|
this.env = i;
|
|
i++;
|
|
}
|
|
if (options['processEscapes']) {
|
|
subparts.push('\\\\([\\\\$])');
|
|
}
|
|
if (options['processRefs']) {
|
|
subparts.push('(\\\\(?:eq)?ref\\s*\\{[^}]*\\})');
|
|
}
|
|
if (subparts.length) {
|
|
parts.push('(' + subparts.join('|') + ')');
|
|
this.sub = i;
|
|
}
|
|
this.start = new RegExp(parts.join('|'), 'g');
|
|
this.hasPatterns = (parts.length > 0);
|
|
};
|
|
FindTeX.prototype.addPattern = function (starts, delims, display) {
|
|
var _a = __read(delims, 2), open = _a[0], close = _a[1];
|
|
starts.push((0, string_js_1.quotePattern)(open));
|
|
this.end[open] = [close, display, this.endPattern(close)];
|
|
};
|
|
FindTeX.prototype.endPattern = function (end, endp) {
|
|
return new RegExp((endp || (0, string_js_1.quotePattern)(end)) + '|\\\\(?:[a-zA-Z]|.)|[{}]', 'g');
|
|
};
|
|
FindTeX.prototype.findEnd = function (text, n, start, end) {
|
|
var _a = __read(end, 3), close = _a[0], display = _a[1], pattern = _a[2];
|
|
var i = pattern.lastIndex = start.index + start[0].length;
|
|
var match, braces = 0;
|
|
while ((match = pattern.exec(text))) {
|
|
if ((match[1] || match[0]) === close && braces === 0) {
|
|
return (0, MathItem_js_1.protoItem)(start[0], text.substr(i, match.index - i), match[0], n, start.index, match.index + match[0].length, display);
|
|
}
|
|
else if (match[0] === '{') {
|
|
braces++;
|
|
}
|
|
else if (match[0] === '}' && braces) {
|
|
braces--;
|
|
}
|
|
}
|
|
return null;
|
|
};
|
|
FindTeX.prototype.findMathInString = function (math, n, text) {
|
|
var start, match;
|
|
this.start.lastIndex = 0;
|
|
while ((start = this.start.exec(text))) {
|
|
if (start[this.env] !== undefined && this.env) {
|
|
var end = '\\\\end\\s*(\\{' + (0, string_js_1.quotePattern)(start[this.env]) + '\\})';
|
|
match = this.findEnd(text, n, start, ['{' + start[this.env] + '}', true, this.endPattern(null, end)]);
|
|
if (match) {
|
|
match.math = match.open + match.math + match.close;
|
|
match.open = match.close = '';
|
|
}
|
|
}
|
|
else if (start[this.sub] !== undefined && this.sub) {
|
|
var math_1 = start[this.sub];
|
|
var end = start.index + start[this.sub].length;
|
|
if (math_1.length === 2) {
|
|
match = (0, MathItem_js_1.protoItem)('', math_1.substr(1), '', n, start.index, end);
|
|
}
|
|
else {
|
|
match = (0, MathItem_js_1.protoItem)('', math_1, '', n, start.index, end, false);
|
|
}
|
|
}
|
|
else {
|
|
match = this.findEnd(text, n, start, this.end[start[0]]);
|
|
}
|
|
if (match) {
|
|
math.push(match);
|
|
this.start.lastIndex = match.end.n;
|
|
}
|
|
}
|
|
};
|
|
FindTeX.prototype.findMath = function (strings) {
|
|
var math = [];
|
|
if (this.hasPatterns) {
|
|
for (var i = 0, m = strings.length; i < m; i++) {
|
|
this.findMathInString(math, i, strings[i]);
|
|
}
|
|
}
|
|
return math;
|
|
};
|
|
FindTeX.OPTIONS = {
|
|
inlineMath: [
|
|
['\\(', '\\)']
|
|
],
|
|
displayMath: [
|
|
['$$', '$$'],
|
|
['\\[', '\\]']
|
|
],
|
|
processEscapes: true,
|
|
processEnvironments: true,
|
|
processRefs: true,
|
|
};
|
|
return FindTeX;
|
|
}(FindMath_js_1.AbstractFindMath));
|
|
exports.FindTeX = FindTeX;
|
|
//# sourceMappingURL=FindTeX.js.map
|
|
|
|
/***/ })
|
|
|
|
}]);
|
|
//# sourceMappingURL=7582.5611b71499b0becf7b6a.js.map?v=5611b71499b0becf7b6a
|