ParseUtil.js 20 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513
  1. "use strict";
  2. var __read = (this && this.__read) || function (o, n) {
  3. var m = typeof Symbol === "function" && o[Symbol.iterator];
  4. if (!m) return o;
  5. var i = m.call(o), r, ar = [], e;
  6. try {
  7. while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  8. }
  9. catch (error) { e = { error: error }; }
  10. finally {
  11. try {
  12. if (r && !r.done && (m = i["return"])) m.call(i);
  13. }
  14. finally { if (e) throw e.error; }
  15. }
  16. return ar;
  17. };
  18. var __values = (this && this.__values) || function(o) {
  19. var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
  20. if (m) return m.call(o);
  21. if (o && typeof o.length === "number") return {
  22. next: function () {
  23. if (o && i >= o.length) o = void 0;
  24. return { value: o && o[i++], done: !o };
  25. }
  26. };
  27. throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
  28. };
  29. var __importDefault = (this && this.__importDefault) || function (mod) {
  30. return (mod && mod.__esModule) ? mod : { "default": mod };
  31. };
  32. Object.defineProperty(exports, "__esModule", { value: true });
  33. var MmlNode_js_1 = require("../../core/MmlTree/MmlNode.js");
  34. var NodeUtil_js_1 = __importDefault(require("./NodeUtil.js"));
  35. var TexParser_js_1 = __importDefault(require("./TexParser.js"));
  36. var TexError_js_1 = __importDefault(require("./TexError.js"));
  37. var Entities_js_1 = require("../../util/Entities.js");
  38. var ParseUtil;
  39. (function (ParseUtil) {
  40. var emPerInch = 7.2;
  41. var pxPerInch = 72;
  42. var UNIT_CASES = {
  43. 'em': function (m) { return m; },
  44. 'ex': function (m) { return m * .43; },
  45. 'pt': function (m) { return m / 10; },
  46. 'pc': function (m) { return m * 1.2; },
  47. 'px': function (m) { return m * emPerInch / pxPerInch; },
  48. 'in': function (m) { return m * emPerInch; },
  49. 'cm': function (m) { return m * emPerInch / 2.54; },
  50. 'mm': function (m) { return m * emPerInch / 25.4; },
  51. 'mu': function (m) { return m / 18; },
  52. };
  53. var num = '([-+]?([.,]\\d+|\\d+([.,]\\d*)?))';
  54. var unit = '(pt|em|ex|mu|px|mm|cm|in|pc)';
  55. var dimenEnd = RegExp('^\\s*' + num + '\\s*' + unit + '\\s*$');
  56. var dimenRest = RegExp('^\\s*' + num + '\\s*' + unit + ' ?');
  57. function matchDimen(dim, rest) {
  58. if (rest === void 0) { rest = false; }
  59. var match = dim.match(rest ? dimenRest : dimenEnd);
  60. return match ?
  61. muReplace([match[1].replace(/,/, '.'), match[4], match[0].length]) :
  62. [null, null, 0];
  63. }
  64. ParseUtil.matchDimen = matchDimen;
  65. function muReplace(_a) {
  66. var _b = __read(_a, 3), value = _b[0], unit = _b[1], length = _b[2];
  67. if (unit !== 'mu') {
  68. return [value, unit, length];
  69. }
  70. var em = Em(UNIT_CASES[unit](parseFloat(value || '1')));
  71. return [em.slice(0, -2), 'em', length];
  72. }
  73. function dimen2em(dim) {
  74. var _a = __read(matchDimen(dim), 2), value = _a[0], unit = _a[1];
  75. var m = parseFloat(value || '1');
  76. var func = UNIT_CASES[unit];
  77. return func ? func(m) : 0;
  78. }
  79. ParseUtil.dimen2em = dimen2em;
  80. function Em(m) {
  81. if (Math.abs(m) < .0006) {
  82. return '0em';
  83. }
  84. return m.toFixed(3).replace(/\.?0+$/, '') + 'em';
  85. }
  86. ParseUtil.Em = Em;
  87. function cols() {
  88. var W = [];
  89. for (var _i = 0; _i < arguments.length; _i++) {
  90. W[_i] = arguments[_i];
  91. }
  92. return W.map(function (n) { return Em(n); }).join(' ');
  93. }
  94. ParseUtil.cols = cols;
  95. function fenced(configuration, open, mml, close, big, color) {
  96. if (big === void 0) { big = ''; }
  97. if (color === void 0) { color = ''; }
  98. var nf = configuration.nodeFactory;
  99. var mrow = nf.create('node', 'mrow', [], { open: open, close: close, texClass: MmlNode_js_1.TEXCLASS.INNER });
  100. var mo;
  101. if (big) {
  102. mo = new TexParser_js_1.default('\\' + big + 'l' + open, configuration.parser.stack.env, configuration).mml();
  103. }
  104. else {
  105. var openNode = nf.create('text', open);
  106. mo = nf.create('node', 'mo', [], { fence: true, stretchy: true, symmetric: true, texClass: MmlNode_js_1.TEXCLASS.OPEN }, openNode);
  107. }
  108. NodeUtil_js_1.default.appendChildren(mrow, [mo, mml]);
  109. if (big) {
  110. mo = new TexParser_js_1.default('\\' + big + 'r' + close, configuration.parser.stack.env, configuration).mml();
  111. }
  112. else {
  113. var closeNode = nf.create('text', close);
  114. mo = nf.create('node', 'mo', [], { fence: true, stretchy: true, symmetric: true, texClass: MmlNode_js_1.TEXCLASS.CLOSE }, closeNode);
  115. }
  116. color && mo.attributes.set('mathcolor', color);
  117. NodeUtil_js_1.default.appendChildren(mrow, [mo]);
  118. return mrow;
  119. }
  120. ParseUtil.fenced = fenced;
  121. function fixedFence(configuration, open, mml, close) {
  122. var mrow = configuration.nodeFactory.create('node', 'mrow', [], { open: open, close: close, texClass: MmlNode_js_1.TEXCLASS.ORD });
  123. if (open) {
  124. NodeUtil_js_1.default.appendChildren(mrow, [mathPalette(configuration, open, 'l')]);
  125. }
  126. if (NodeUtil_js_1.default.isType(mml, 'mrow')) {
  127. NodeUtil_js_1.default.appendChildren(mrow, NodeUtil_js_1.default.getChildren(mml));
  128. }
  129. else {
  130. NodeUtil_js_1.default.appendChildren(mrow, [mml]);
  131. }
  132. if (close) {
  133. NodeUtil_js_1.default.appendChildren(mrow, [mathPalette(configuration, close, 'r')]);
  134. }
  135. return mrow;
  136. }
  137. ParseUtil.fixedFence = fixedFence;
  138. function mathPalette(configuration, fence, side) {
  139. if (fence === '{' || fence === '}') {
  140. fence = '\\' + fence;
  141. }
  142. var D = '{\\bigg' + side + ' ' + fence + '}';
  143. var T = '{\\big' + side + ' ' + fence + '}';
  144. return new TexParser_js_1.default('\\mathchoice' + D + T + T + T, {}, configuration).mml();
  145. }
  146. ParseUtil.mathPalette = mathPalette;
  147. function fixInitialMO(configuration, nodes) {
  148. for (var i = 0, m = nodes.length; i < m; i++) {
  149. var child = nodes[i];
  150. if (child && (!NodeUtil_js_1.default.isType(child, 'mspace') &&
  151. (!NodeUtil_js_1.default.isType(child, 'TeXAtom') ||
  152. (NodeUtil_js_1.default.getChildren(child)[0] &&
  153. NodeUtil_js_1.default.getChildren(NodeUtil_js_1.default.getChildren(child)[0]).length)))) {
  154. if (NodeUtil_js_1.default.isEmbellished(child) ||
  155. (NodeUtil_js_1.default.isType(child, 'TeXAtom') && NodeUtil_js_1.default.getTexClass(child) === MmlNode_js_1.TEXCLASS.REL)) {
  156. var mi = configuration.nodeFactory.create('node', 'mi');
  157. nodes.unshift(mi);
  158. }
  159. break;
  160. }
  161. }
  162. }
  163. ParseUtil.fixInitialMO = fixInitialMO;
  164. function internalMath(parser, text, level, font) {
  165. if (parser.configuration.options.internalMath) {
  166. return parser.configuration.options.internalMath(parser, text, level, font);
  167. }
  168. var mathvariant = font || parser.stack.env.font;
  169. var def = (mathvariant ? { mathvariant: mathvariant } : {});
  170. var mml = [], i = 0, k = 0, c, node, match = '', braces = 0;
  171. if (text.match(/\\?[${}\\]|\\\(|\\(eq)?ref\s*\{/)) {
  172. while (i < text.length) {
  173. c = text.charAt(i++);
  174. if (c === '$') {
  175. if (match === '$' && braces === 0) {
  176. node = parser.create('node', 'TeXAtom', [(new TexParser_js_1.default(text.slice(k, i - 1), {}, parser.configuration)).mml()]);
  177. mml.push(node);
  178. match = '';
  179. k = i;
  180. }
  181. else if (match === '') {
  182. if (k < i - 1) {
  183. mml.push(internalText(parser, text.slice(k, i - 1), def));
  184. }
  185. match = '$';
  186. k = i;
  187. }
  188. }
  189. else if (c === '{' && match !== '') {
  190. braces++;
  191. }
  192. else if (c === '}') {
  193. if (match === '}' && braces === 0) {
  194. var atom = (new TexParser_js_1.default(text.slice(k, i), {}, parser.configuration)).mml();
  195. node = parser.create('node', 'TeXAtom', [atom], def);
  196. mml.push(node);
  197. match = '';
  198. k = i;
  199. }
  200. else if (match !== '') {
  201. if (braces) {
  202. braces--;
  203. }
  204. }
  205. }
  206. else if (c === '\\') {
  207. if (match === '' && text.substr(i).match(/^(eq)?ref\s*\{/)) {
  208. var len = RegExp['$&'].length;
  209. if (k < i - 1) {
  210. mml.push(internalText(parser, text.slice(k, i - 1), def));
  211. }
  212. match = '}';
  213. k = i - 1;
  214. i += len;
  215. }
  216. else {
  217. c = text.charAt(i++);
  218. if (c === '(' && match === '') {
  219. if (k < i - 2) {
  220. mml.push(internalText(parser, text.slice(k, i - 2), def));
  221. }
  222. match = ')';
  223. k = i;
  224. }
  225. else if (c === ')' && match === ')' && braces === 0) {
  226. node = parser.create('node', 'TeXAtom', [(new TexParser_js_1.default(text.slice(k, i - 2), {}, parser.configuration)).mml()]);
  227. mml.push(node);
  228. match = '';
  229. k = i;
  230. }
  231. else if (c.match(/[${}\\]/) && match === '') {
  232. i--;
  233. text = text.substr(0, i - 1) + text.substr(i);
  234. }
  235. }
  236. }
  237. }
  238. if (match !== '') {
  239. throw new TexError_js_1.default('MathNotTerminated', 'Math not terminated in text box');
  240. }
  241. }
  242. if (k < text.length) {
  243. mml.push(internalText(parser, text.slice(k), def));
  244. }
  245. if (level != null) {
  246. mml = [parser.create('node', 'mstyle', mml, { displaystyle: false, scriptlevel: level })];
  247. }
  248. else if (mml.length > 1) {
  249. mml = [parser.create('node', 'mrow', mml)];
  250. }
  251. return mml;
  252. }
  253. ParseUtil.internalMath = internalMath;
  254. function internalText(parser, text, def) {
  255. text = text.replace(/^\s+/, Entities_js_1.entities.nbsp).replace(/\s+$/, Entities_js_1.entities.nbsp);
  256. var textNode = parser.create('text', text);
  257. return parser.create('node', 'mtext', [], def, textNode);
  258. }
  259. ParseUtil.internalText = internalText;
  260. function underOver(parser, base, script, pos, stack) {
  261. ParseUtil.checkMovableLimits(base);
  262. if (NodeUtil_js_1.default.isType(base, 'munderover') && NodeUtil_js_1.default.isEmbellished(base)) {
  263. NodeUtil_js_1.default.setProperties(NodeUtil_js_1.default.getCoreMO(base), { lspace: 0, rspace: 0 });
  264. var mo = parser.create('node', 'mo', [], { rspace: 0 });
  265. base = parser.create('node', 'mrow', [mo, base]);
  266. }
  267. var mml = parser.create('node', 'munderover', [base]);
  268. NodeUtil_js_1.default.setChild(mml, pos === 'over' ? mml.over : mml.under, script);
  269. var node = mml;
  270. if (stack) {
  271. node = parser.create('node', 'TeXAtom', [mml], { texClass: MmlNode_js_1.TEXCLASS.OP, movesupsub: true });
  272. }
  273. NodeUtil_js_1.default.setProperty(node, 'subsupOK', true);
  274. return node;
  275. }
  276. ParseUtil.underOver = underOver;
  277. function checkMovableLimits(base) {
  278. var symbol = (NodeUtil_js_1.default.isType(base, 'mo') ? NodeUtil_js_1.default.getForm(base) : null);
  279. if (NodeUtil_js_1.default.getProperty(base, 'movablelimits') || (symbol && symbol[3] && symbol[3].movablelimits)) {
  280. NodeUtil_js_1.default.setProperties(base, { movablelimits: false });
  281. }
  282. }
  283. ParseUtil.checkMovableLimits = checkMovableLimits;
  284. function trimSpaces(text) {
  285. if (typeof (text) !== 'string') {
  286. return text;
  287. }
  288. var TEXT = text.trim();
  289. if (TEXT.match(/\\$/) && text.match(/ $/)) {
  290. TEXT += ' ';
  291. }
  292. return TEXT;
  293. }
  294. ParseUtil.trimSpaces = trimSpaces;
  295. function setArrayAlign(array, align) {
  296. align = ParseUtil.trimSpaces(align || '');
  297. if (align === 't') {
  298. array.arraydef.align = 'baseline 1';
  299. }
  300. else if (align === 'b') {
  301. array.arraydef.align = 'baseline -1';
  302. }
  303. else if (align === 'c') {
  304. array.arraydef.align = 'axis';
  305. }
  306. else if (align) {
  307. array.arraydef.align = align;
  308. }
  309. return array;
  310. }
  311. ParseUtil.setArrayAlign = setArrayAlign;
  312. function substituteArgs(parser, args, str) {
  313. var text = '';
  314. var newstring = '';
  315. var i = 0;
  316. while (i < str.length) {
  317. var c = str.charAt(i++);
  318. if (c === '\\') {
  319. text += c + str.charAt(i++);
  320. }
  321. else if (c === '#') {
  322. c = str.charAt(i++);
  323. if (c === '#') {
  324. text += c;
  325. }
  326. else {
  327. if (!c.match(/[1-9]/) || parseInt(c, 10) > args.length) {
  328. throw new TexError_js_1.default('IllegalMacroParam', 'Illegal macro parameter reference');
  329. }
  330. newstring = addArgs(parser, addArgs(parser, newstring, text), args[parseInt(c, 10) - 1]);
  331. text = '';
  332. }
  333. }
  334. else {
  335. text += c;
  336. }
  337. }
  338. return addArgs(parser, newstring, text);
  339. }
  340. ParseUtil.substituteArgs = substituteArgs;
  341. function addArgs(parser, s1, s2) {
  342. if (s2.match(/^[a-z]/i) && s1.match(/(^|[^\\])(\\\\)*\\[a-z]+$/i)) {
  343. s1 += ' ';
  344. }
  345. if (s1.length + s2.length > parser.configuration.options['maxBuffer']) {
  346. throw new TexError_js_1.default('MaxBufferSize', 'MathJax internal buffer size exceeded; is there a' +
  347. ' recursive macro call?');
  348. }
  349. return s1 + s2;
  350. }
  351. ParseUtil.addArgs = addArgs;
  352. function checkMaxMacros(parser, isMacro) {
  353. if (isMacro === void 0) { isMacro = true; }
  354. if (++parser.macroCount <= parser.configuration.options['maxMacros']) {
  355. return;
  356. }
  357. if (isMacro) {
  358. throw new TexError_js_1.default('MaxMacroSub1', 'MathJax maximum macro substitution count exceeded; ' +
  359. 'is here a recursive macro call?');
  360. }
  361. else {
  362. throw new TexError_js_1.default('MaxMacroSub2', 'MathJax maximum substitution count exceeded; ' +
  363. 'is there a recursive latex environment?');
  364. }
  365. }
  366. ParseUtil.checkMaxMacros = checkMaxMacros;
  367. function checkEqnEnv(parser) {
  368. if (parser.stack.global.eqnenv) {
  369. throw new TexError_js_1.default('ErroneousNestingEq', 'Erroneous nesting of equation structures');
  370. }
  371. parser.stack.global.eqnenv = true;
  372. }
  373. ParseUtil.checkEqnEnv = checkEqnEnv;
  374. function copyNode(node, parser) {
  375. var tree = node.copy();
  376. var options = parser.configuration;
  377. tree.walkTree(function (n) {
  378. var e_1, _a;
  379. options.addNode(n.kind, n);
  380. var lists = (n.getProperty('in-lists') || '').split(/,/);
  381. try {
  382. for (var lists_1 = __values(lists), lists_1_1 = lists_1.next(); !lists_1_1.done; lists_1_1 = lists_1.next()) {
  383. var list = lists_1_1.value;
  384. list && options.addNode(list, n);
  385. }
  386. }
  387. catch (e_1_1) { e_1 = { error: e_1_1 }; }
  388. finally {
  389. try {
  390. if (lists_1_1 && !lists_1_1.done && (_a = lists_1.return)) _a.call(lists_1);
  391. }
  392. finally { if (e_1) throw e_1.error; }
  393. }
  394. });
  395. return tree;
  396. }
  397. ParseUtil.copyNode = copyNode;
  398. function MmlFilterAttribute(_parser, _name, value) {
  399. return value;
  400. }
  401. ParseUtil.MmlFilterAttribute = MmlFilterAttribute;
  402. function getFontDef(parser) {
  403. var font = parser.stack.env['font'];
  404. return (font ? { mathvariant: font } : {});
  405. }
  406. ParseUtil.getFontDef = getFontDef;
  407. function keyvalOptions(attrib, allowed, error) {
  408. var e_2, _a;
  409. if (allowed === void 0) { allowed = null; }
  410. if (error === void 0) { error = false; }
  411. var def = readKeyval(attrib);
  412. if (allowed) {
  413. try {
  414. for (var _b = __values(Object.keys(def)), _c = _b.next(); !_c.done; _c = _b.next()) {
  415. var key = _c.value;
  416. if (!allowed.hasOwnProperty(key)) {
  417. if (error) {
  418. throw new TexError_js_1.default('InvalidOption', 'Invalid option: %1', key);
  419. }
  420. delete def[key];
  421. }
  422. }
  423. }
  424. catch (e_2_1) { e_2 = { error: e_2_1 }; }
  425. finally {
  426. try {
  427. if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
  428. }
  429. finally { if (e_2) throw e_2.error; }
  430. }
  431. }
  432. return def;
  433. }
  434. ParseUtil.keyvalOptions = keyvalOptions;
  435. function readKeyval(text) {
  436. var _a, _b;
  437. var options = {};
  438. var rest = text;
  439. var end, key, val;
  440. while (rest) {
  441. _a = __read(readValue(rest, ['=', ',']), 3), key = _a[0], end = _a[1], rest = _a[2];
  442. if (end === '=') {
  443. _b = __read(readValue(rest, [',']), 3), val = _b[0], end = _b[1], rest = _b[2];
  444. val = (val === 'false' || val === 'true') ?
  445. JSON.parse(val) : val;
  446. options[key] = val;
  447. }
  448. else if (key) {
  449. options[key] = true;
  450. }
  451. }
  452. return options;
  453. }
  454. function removeBraces(text, count) {
  455. while (count > 0) {
  456. text = text.trim().slice(1, -1);
  457. count--;
  458. }
  459. return text.trim();
  460. }
  461. function readValue(text, end) {
  462. var length = text.length;
  463. var braces = 0;
  464. var value = '';
  465. var index = 0;
  466. var start = 0;
  467. var startCount = true;
  468. var stopCount = false;
  469. while (index < length) {
  470. var c = text[index++];
  471. switch (c) {
  472. case ' ':
  473. break;
  474. case '{':
  475. if (startCount) {
  476. start++;
  477. }
  478. else {
  479. stopCount = false;
  480. if (start > braces) {
  481. start = braces;
  482. }
  483. }
  484. braces++;
  485. break;
  486. case '}':
  487. if (braces) {
  488. braces--;
  489. }
  490. if (startCount || stopCount) {
  491. start--;
  492. stopCount = true;
  493. }
  494. startCount = false;
  495. break;
  496. default:
  497. if (!braces && end.indexOf(c) !== -1) {
  498. return [stopCount ? 'true' :
  499. removeBraces(value, start), c, text.slice(index)];
  500. }
  501. startCount = false;
  502. stopCount = false;
  503. }
  504. value += c;
  505. }
  506. if (braces) {
  507. throw new TexError_js_1.default('ExtraOpenMissingClose', 'Extra open brace or missing close brace');
  508. }
  509. return [stopCount ? 'true' : removeBraces(value, start), '', text.slice(index)];
  510. }
  511. })(ParseUtil || (ParseUtil = {}));
  512. exports.default = ParseUtil;
  513. //# sourceMappingURL=ParseUtil.js.map