|
@@ -1,3216 +0,0 @@
|
|
|
-(function webpackUniversalModuleDefinition(root, factory) {
|
|
|
- if(typeof exports === 'object' && typeof module === 'object')
|
|
|
- module.exports = factory(require("katex"));
|
|
|
- else if(typeof define === 'function' && define.amd)
|
|
|
- define(["katex"], factory);
|
|
|
- else {
|
|
|
- var a = typeof exports === 'object' ? factory(require("katex")) : factory(root["katex"]);
|
|
|
- for(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];
|
|
|
- }
|
|
|
-})((typeof self !== 'undefined' ? self : this), function(__WEBPACK_EXTERNAL_MODULE__771__) {
|
|
|
-return /******/ (function() { // webpackBootstrap
|
|
|
-/******/ "use strict";
|
|
|
-/******/ var __webpack_modules__ = ({
|
|
|
-
|
|
|
-/***/ 771:
|
|
|
-/***/ (function(module) {
|
|
|
-
|
|
|
-module.exports = __WEBPACK_EXTERNAL_MODULE__771__;
|
|
|
-
|
|
|
-/***/ })
|
|
|
-
|
|
|
-/******/ });
|
|
|
-/************************************************************************/
|
|
|
-/******/ // The module cache
|
|
|
-/******/ var __webpack_module_cache__ = {};
|
|
|
-/******/
|
|
|
-/******/ // The require function
|
|
|
-/******/ function __webpack_require__(moduleId) {
|
|
|
-/******/ // Check if module is in cache
|
|
|
-/******/ var cachedModule = __webpack_module_cache__[moduleId];
|
|
|
-/******/ if (cachedModule !== undefined) {
|
|
|
-/******/ return cachedModule.exports;
|
|
|
-/******/ }
|
|
|
-/******/ // Create a new module (and put it into the cache)
|
|
|
-/******/ var module = __webpack_module_cache__[moduleId] = {
|
|
|
-/******/ // no module.id needed
|
|
|
-/******/ // no module.loaded needed
|
|
|
-/******/ exports: {}
|
|
|
-/******/ };
|
|
|
-/******/
|
|
|
-/******/ // Execute the module function
|
|
|
-/******/ __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
|
|
|
-/******/
|
|
|
-/******/ // Return the exports of the module
|
|
|
-/******/ return module.exports;
|
|
|
-/******/ }
|
|
|
-/******/
|
|
|
-/************************************************************************/
|
|
|
-/******/ /* webpack/runtime/compat get default export */
|
|
|
-/******/ !function() {
|
|
|
-/******/ // getDefaultExport function for compatibility with non-harmony modules
|
|
|
-/******/ __webpack_require__.n = function(module) {
|
|
|
-/******/ var getter = module && module.__esModule ?
|
|
|
-/******/ function() { return module['default']; } :
|
|
|
-/******/ function() { return module; };
|
|
|
-/******/ __webpack_require__.d(getter, { a: getter });
|
|
|
-/******/ return getter;
|
|
|
-/******/ };
|
|
|
-/******/ }();
|
|
|
-/******/
|
|
|
-/******/ /* webpack/runtime/define property getters */
|
|
|
-/******/ !function() {
|
|
|
-/******/ // define getter functions for harmony exports
|
|
|
-/******/ __webpack_require__.d = function(exports, definition) {
|
|
|
-/******/ for(var key in definition) {
|
|
|
-/******/ if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
|
|
|
-/******/ Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
|
|
|
-/******/ }
|
|
|
-/******/ }
|
|
|
-/******/ };
|
|
|
-/******/ }();
|
|
|
-/******/
|
|
|
-/******/ /* webpack/runtime/hasOwnProperty shorthand */
|
|
|
-/******/ !function() {
|
|
|
-/******/ __webpack_require__.o = function(obj, prop) { return Object.prototype.hasOwnProperty.call(obj, prop); }
|
|
|
-/******/ }();
|
|
|
-/******/
|
|
|
-/************************************************************************/
|
|
|
-var __webpack_exports__ = {};
|
|
|
-// This entry need to be wrapped in an IIFE because it need to be isolated against other modules in the chunk.
|
|
|
-!function() {
|
|
|
-/* harmony import */ var katex__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(771);
|
|
|
-/* harmony import */ var katex__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(katex__WEBPACK_IMPORTED_MODULE_0__);
|
|
|
-/* eslint-disable */
|
|
|
-
|
|
|
-/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
|
|
|
-
|
|
|
-/* vim: set ts=2 et sw=2 tw=80: */
|
|
|
-
|
|
|
-/*************************************************************
|
|
|
- *
|
|
|
- * KaTeX mhchem.js
|
|
|
- *
|
|
|
- * This file implements a KaTeX version of mhchem version 3.3.0.
|
|
|
- * It is adapted from MathJax/extensions/TeX/mhchem.js
|
|
|
- * It differs from the MathJax version as follows:
|
|
|
- * 1. The interface is changed so that it can be called from KaTeX, not MathJax.
|
|
|
- * 2. \rlap and \llap are replaced with \mathrlap and \mathllap.
|
|
|
- * 3. Four lines of code are edited in order to use \raisebox instead of \raise.
|
|
|
- * 4. The reaction arrow code is simplified. All reaction arrows are rendered
|
|
|
- * using KaTeX extensible arrows instead of building non-extensible arrows.
|
|
|
- * 5. \tripledash vertical alignment is slightly adjusted.
|
|
|
- *
|
|
|
- * This code, as other KaTeX code, is released under the MIT license.
|
|
|
- *
|
|
|
- * /*************************************************************
|
|
|
- *
|
|
|
- * MathJax/extensions/TeX/mhchem.js
|
|
|
- *
|
|
|
- * Implements the \ce command for handling chemical formulas
|
|
|
- * from the mhchem LaTeX package.
|
|
|
- *
|
|
|
- * ---------------------------------------------------------------------
|
|
|
- *
|
|
|
- * Copyright (c) 2011-2015 The MathJax Consortium
|
|
|
- * Copyright (c) 2015-2018 Martin Hensel
|
|
|
- *
|
|
|
- * Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
- * you may not use this file except in compliance with the License.
|
|
|
- * You may obtain a copy of the License at
|
|
|
- *
|
|
|
- * http://www.apache.org/licenses/LICENSE-2.0
|
|
|
- *
|
|
|
- * Unless required by applicable law or agreed to in writing, software
|
|
|
- * distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
- * See the License for the specific language governing permissions and
|
|
|
- * limitations under the License.
|
|
|
- */
|
|
|
-//
|
|
|
-// Coding Style
|
|
|
-// - use '' for identifiers that can by minified/uglified
|
|
|
-// - use "" for strings that need to stay untouched
|
|
|
-// version: "3.3.0" for MathJax and KaTeX
|
|
|
-// Add \ce, \pu, and \tripledash to the KaTeX macros.
|
|
|
-katex__WEBPACK_IMPORTED_MODULE_0___default().__defineMacro("\\ce", function (context) {
|
|
|
- return chemParse(context.consumeArgs(1)[0], "ce");
|
|
|
-});
|
|
|
-
|
|
|
-katex__WEBPACK_IMPORTED_MODULE_0___default().__defineMacro("\\pu", function (context) {
|
|
|
- return chemParse(context.consumeArgs(1)[0], "pu");
|
|
|
-}); // Needed for \bond for the ~ forms
|
|
|
-// Raise by 2.56mu, not 2mu. We're raising a hyphen-minus, U+002D, not
|
|
|
-// a mathematical minus, U+2212. So we need that extra 0.56.
|
|
|
-
|
|
|
-
|
|
|
-katex__WEBPACK_IMPORTED_MODULE_0___default().__defineMacro("\\tripledash", "{\\vphantom{-}\\raisebox{2.56mu}{$\\mkern2mu" + "\\tiny\\text{-}\\mkern1mu\\text{-}\\mkern1mu\\text{-}\\mkern2mu$}}");
|
|
|
-
|
|
|
- //
|
|
|
-// This is the main function for handing the \ce and \pu commands.
|
|
|
-// It takes the argument to \ce or \pu and returns the corresponding TeX string.
|
|
|
-//
|
|
|
-
|
|
|
-var chemParse = function chemParse(tokens, stateMachine) {
|
|
|
- // Recreate the argument string from KaTeX's array of tokens.
|
|
|
- var str = "";
|
|
|
- var expectedLoc = tokens.length && tokens[tokens.length - 1].loc.start;
|
|
|
-
|
|
|
- for (var i = tokens.length - 1; i >= 0; i--) {
|
|
|
- if (tokens[i].loc.start > expectedLoc) {
|
|
|
- // context.consumeArgs has eaten a space.
|
|
|
- str += " ";
|
|
|
- expectedLoc = tokens[i].loc.start;
|
|
|
- }
|
|
|
-
|
|
|
- str += tokens[i].text;
|
|
|
- expectedLoc += tokens[i].text.length;
|
|
|
- }
|
|
|
-
|
|
|
- var tex = texify.go(mhchemParser.go(str, stateMachine));
|
|
|
- return tex;
|
|
|
-}; //
|
|
|
-// Core parser for mhchem syntax (recursive)
|
|
|
-//
|
|
|
-
|
|
|
-/** @type {MhchemParser} */
|
|
|
-
|
|
|
-
|
|
|
-var mhchemParser = {
|
|
|
- //
|
|
|
- // Parses mchem \ce syntax
|
|
|
- //
|
|
|
- // Call like
|
|
|
- // go("H2O");
|
|
|
- //
|
|
|
- go: function go(input, stateMachine) {
|
|
|
- if (!input) {
|
|
|
- return [];
|
|
|
- }
|
|
|
-
|
|
|
- if (stateMachine === undefined) {
|
|
|
- stateMachine = 'ce';
|
|
|
- }
|
|
|
-
|
|
|
- var state = '0'; //
|
|
|
- // String buffers for parsing:
|
|
|
- //
|
|
|
- // buffer.a == amount
|
|
|
- // buffer.o == element
|
|
|
- // buffer.b == left-side superscript
|
|
|
- // buffer.p == left-side subscript
|
|
|
- // buffer.q == right-side subscript
|
|
|
- // buffer.d == right-side superscript
|
|
|
- //
|
|
|
- // buffer.r == arrow
|
|
|
- // buffer.rdt == arrow, script above, type
|
|
|
- // buffer.rd == arrow, script above, content
|
|
|
- // buffer.rqt == arrow, script below, type
|
|
|
- // buffer.rq == arrow, script below, content
|
|
|
- //
|
|
|
- // buffer.text_
|
|
|
- // buffer.rm
|
|
|
- // etc.
|
|
|
- //
|
|
|
- // buffer.parenthesisLevel == int, starting at 0
|
|
|
- // buffer.sb == bool, space before
|
|
|
- // buffer.beginsWithBond == bool
|
|
|
- //
|
|
|
- // These letters are also used as state names.
|
|
|
- //
|
|
|
- // Other states:
|
|
|
- // 0 == begin of main part (arrow/operator unlikely)
|
|
|
- // 1 == next entity
|
|
|
- // 2 == next entity (arrow/operator unlikely)
|
|
|
- // 3 == next atom
|
|
|
- // c == macro
|
|
|
- //
|
|
|
-
|
|
|
- /** @type {Buffer} */
|
|
|
-
|
|
|
- var buffer = {};
|
|
|
- buffer['parenthesisLevel'] = 0;
|
|
|
- input = input.replace(/\n/g, " ");
|
|
|
- input = input.replace(/[\u2212\u2013\u2014\u2010]/g, "-");
|
|
|
- input = input.replace(/[\u2026]/g, "..."); //
|
|
|
- // Looks through mhchemParser.transitions, to execute a matching action
|
|
|
- // (recursive)
|
|
|
- //
|
|
|
-
|
|
|
- var lastInput;
|
|
|
- var watchdog = 10;
|
|
|
- /** @type {ParserOutput[]} */
|
|
|
-
|
|
|
- var output = [];
|
|
|
-
|
|
|
- while (true) {
|
|
|
- if (lastInput !== input) {
|
|
|
- watchdog = 10;
|
|
|
- lastInput = input;
|
|
|
- } else {
|
|
|
- watchdog--;
|
|
|
- } //
|
|
|
- // Find actions in transition table
|
|
|
- //
|
|
|
-
|
|
|
-
|
|
|
- var machine = mhchemParser.stateMachines[stateMachine];
|
|
|
- var t = machine.transitions[state] || machine.transitions['*'];
|
|
|
-
|
|
|
- iterateTransitions: for (var i = 0; i < t.length; i++) {
|
|
|
- var matches = mhchemParser.patterns.match_(t[i].pattern, input);
|
|
|
-
|
|
|
- if (matches) {
|
|
|
- //
|
|
|
- // Execute actions
|
|
|
- //
|
|
|
- var task = t[i].task;
|
|
|
-
|
|
|
- for (var iA = 0; iA < task.action_.length; iA++) {
|
|
|
- var o; //
|
|
|
- // Find and execute action
|
|
|
- //
|
|
|
-
|
|
|
- if (machine.actions[task.action_[iA].type_]) {
|
|
|
- o = machine.actions[task.action_[iA].type_](buffer, matches.match_, task.action_[iA].option);
|
|
|
- } else if (mhchemParser.actions[task.action_[iA].type_]) {
|
|
|
- o = mhchemParser.actions[task.action_[iA].type_](buffer, matches.match_, task.action_[iA].option);
|
|
|
- } else {
|
|
|
- throw ["MhchemBugA", "mhchem bug A. Please report. (" + task.action_[iA].type_ + ")"]; // Trying to use non-existing action
|
|
|
- } //
|
|
|
- // Add output
|
|
|
- //
|
|
|
-
|
|
|
-
|
|
|
- mhchemParser.concatArray(output, o);
|
|
|
- } //
|
|
|
- // Set next state,
|
|
|
- // Shorten input,
|
|
|
- // Continue with next character
|
|
|
- // (= apply only one transition per position)
|
|
|
- //
|
|
|
-
|
|
|
-
|
|
|
- state = task.nextState || state;
|
|
|
-
|
|
|
- if (input.length > 0) {
|
|
|
- if (!task.revisit) {
|
|
|
- input = matches.remainder;
|
|
|
- }
|
|
|
-
|
|
|
- if (!task.toContinue) {
|
|
|
- break iterateTransitions;
|
|
|
- }
|
|
|
- } else {
|
|
|
- return output;
|
|
|
- }
|
|
|
- }
|
|
|
- } //
|
|
|
- // Prevent infinite loop
|
|
|
- //
|
|
|
-
|
|
|
-
|
|
|
- if (watchdog <= 0) {
|
|
|
- throw ["MhchemBugU", "mhchem bug U. Please report."]; // Unexpected character
|
|
|
- }
|
|
|
- }
|
|
|
- },
|
|
|
- concatArray: function concatArray(a, b) {
|
|
|
- if (b) {
|
|
|
- if (Array.isArray(b)) {
|
|
|
- for (var iB = 0; iB < b.length; iB++) {
|
|
|
- a.push(b[iB]);
|
|
|
- }
|
|
|
- } else {
|
|
|
- a.push(b);
|
|
|
- }
|
|
|
- }
|
|
|
- },
|
|
|
- patterns: {
|
|
|
- //
|
|
|
- // Matching patterns
|
|
|
- // either regexps or function that return null or {match_:"a", remainder:"bc"}
|
|
|
- //
|
|
|
- patterns: {
|
|
|
- // property names must not look like integers ("2") for correct property traversal order, later on
|
|
|
- 'empty': /^$/,
|
|
|
- 'else': /^./,
|
|
|
- 'else2': /^./,
|
|
|
- 'space': /^\s/,
|
|
|
- 'space A': /^\s(?=[A-Z\\$])/,
|
|
|
- 'space$': /^\s$/,
|
|
|
- 'a-z': /^[a-z]/,
|
|
|
- 'x': /^x/,
|
|
|
- 'x$': /^x$/,
|
|
|
- 'i$': /^i$/,
|
|
|
- 'letters': /^(?:[a-zA-Z\u03B1-\u03C9\u0391-\u03A9?@]|(?:\\(?:alpha|beta|gamma|delta|epsilon|zeta|eta|theta|iota|kappa|lambda|mu|nu|xi|omicron|pi|rho|sigma|tau|upsilon|phi|chi|psi|omega|Gamma|Delta|Theta|Lambda|Xi|Pi|Sigma|Upsilon|Phi|Psi|Omega)(?:\s+|\{\}|(?![a-zA-Z]))))+/,
|
|
|
- '\\greek': /^\\(?:alpha|beta|gamma|delta|epsilon|zeta|eta|theta|iota|kappa|lambda|mu|nu|xi|omicron|pi|rho|sigma|tau|upsilon|phi|chi|psi|omega|Gamma|Delta|Theta|Lambda|Xi|Pi|Sigma|Upsilon|Phi|Psi|Omega)(?:\s+|\{\}|(?![a-zA-Z]))/,
|
|
|
- 'one lowercase latin letter $': /^(?:([a-z])(?:$|[^a-zA-Z]))$/,
|
|
|
- '$one lowercase latin letter$ $': /^\$(?:([a-z])(?:$|[^a-zA-Z]))\$$/,
|
|
|
- 'one lowercase greek letter $': /^(?:\$?[\u03B1-\u03C9]\$?|\$?\\(?:alpha|beta|gamma|delta|epsilon|zeta|eta|theta|iota|kappa|lambda|mu|nu|xi|omicron|pi|rho|sigma|tau|upsilon|phi|chi|psi|omega)\s*\$?)(?:\s+|\{\}|(?![a-zA-Z]))$/,
|
|
|
- 'digits': /^[0-9]+/,
|
|
|
- '-9.,9': /^[+\-]?(?:[0-9]+(?:[,.][0-9]+)?|[0-9]*(?:\.[0-9]+))/,
|
|
|
- '-9.,9 no missing 0': /^[+\-]?[0-9]+(?:[.,][0-9]+)?/,
|
|
|
- '(-)(9.,9)(e)(99)': function e99(input) {
|
|
|
- var m = input.match(/^(\+\-|\+\/\-|\+|\-|\\pm\s?)?([0-9]+(?:[,.][0-9]+)?|[0-9]*(?:\.[0-9]+))?(\((?:[0-9]+(?:[,.][0-9]+)?|[0-9]*(?:\.[0-9]+))\))?(?:([eE]|\s*(\*|x|\\times|\u00D7)\s*10\^)([+\-]?[0-9]+|\{[+\-]?[0-9]+\}))?/);
|
|
|
-
|
|
|
- if (m && m[0]) {
|
|
|
- return {
|
|
|
- match_: m.splice(1),
|
|
|
- remainder: input.substr(m[0].length)
|
|
|
- };
|
|
|
- }
|
|
|
-
|
|
|
- return null;
|
|
|
- },
|
|
|
- '(-)(9)^(-9)': function _(input) {
|
|
|
- var m = input.match(/^(\+\-|\+\/\-|\+|\-|\\pm\s?)?([0-9]+(?:[,.][0-9]+)?|[0-9]*(?:\.[0-9]+)?)\^([+\-]?[0-9]+|\{[+\-]?[0-9]+\})/);
|
|
|
-
|
|
|
- if (m && m[0]) {
|
|
|
- return {
|
|
|
- match_: m.splice(1),
|
|
|
- remainder: input.substr(m[0].length)
|
|
|
- };
|
|
|
- }
|
|
|
-
|
|
|
- return null;
|
|
|
- },
|
|
|
- 'state of aggregation $': function stateOfAggregation$(input) {
|
|
|
- // ... or crystal system
|
|
|
- var a = mhchemParser.patterns.findObserveGroups(input, "", /^\([a-z]{1,3}(?=[\),])/, ")", ""); // (aq), (aq,$\infty$), (aq, sat)
|
|
|
-
|
|
|
- if (a && a.remainder.match(/^($|[\s,;\)\]\}])/)) {
|
|
|
- return a;
|
|
|
- } // AND end of 'phrase'
|
|
|
-
|
|
|
-
|
|
|
- var m = input.match(/^(?:\((?:\\ca\s?)?\$[amothc]\$\))/); // OR crystal system ($o$) (\ca$c$)
|
|
|
-
|
|
|
- if (m) {
|
|
|
- return {
|
|
|
- match_: m[0],
|
|
|
- remainder: input.substr(m[0].length)
|
|
|
- };
|
|
|
- }
|
|
|
-
|
|
|
- return null;
|
|
|
- },
|
|
|
- '_{(state of aggregation)}$': /^_\{(\([a-z]{1,3}\))\}/,
|
|
|
- '{[(': /^(?:\\\{|\[|\()/,
|
|
|
- ')]}': /^(?:\)|\]|\\\})/,
|
|
|
- ', ': /^[,;]\s*/,
|
|
|
- ',': /^[,;]/,
|
|
|
- '.': /^[.]/,
|
|
|
- '. ': /^([.\u22C5\u00B7\u2022])\s*/,
|
|
|
- '...': /^\.\.\.(?=$|[^.])/,
|
|
|
- '* ': /^([*])\s*/,
|
|
|
- '^{(...)}': function _(input) {
|
|
|
- return mhchemParser.patterns.findObserveGroups(input, "^{", "", "", "}");
|
|
|
- },
|
|
|
- '^($...$)': function $$(input) {
|
|
|
- return mhchemParser.patterns.findObserveGroups(input, "^", "$", "$", "");
|
|
|
- },
|
|
|
- '^a': /^\^([0-9]+|[^\\_])/,
|
|
|
- '^\\x{}{}': function x(input) {
|
|
|
- return mhchemParser.patterns.findObserveGroups(input, "^", /^\\[a-zA-Z]+\{/, "}", "", "", "{", "}", "", true);
|
|
|
- },
|
|
|
- '^\\x{}': function x(input) {
|
|
|
- return mhchemParser.patterns.findObserveGroups(input, "^", /^\\[a-zA-Z]+\{/, "}", "");
|
|
|
- },
|
|
|
- '^\\x': /^\^(\\[a-zA-Z]+)\s*/,
|
|
|
- '^(-1)': /^\^(-?\d+)/,
|
|
|
- '\'': /^'/,
|
|
|
- '_{(...)}': function _(input) {
|
|
|
- return mhchemParser.patterns.findObserveGroups(input, "_{", "", "", "}");
|
|
|
- },
|
|
|
- '_($...$)': function _$$(input) {
|
|
|
- return mhchemParser.patterns.findObserveGroups(input, "_", "$", "$", "");
|
|
|
- },
|
|
|
- '_9': /^_([+\-]?[0-9]+|[^\\])/,
|
|
|
- '_\\x{}{}': function _X(input) {
|
|
|
- return mhchemParser.patterns.findObserveGroups(input, "_", /^\\[a-zA-Z]+\{/, "}", "", "", "{", "}", "", true);
|
|
|
- },
|
|
|
- '_\\x{}': function _X(input) {
|
|
|
- return mhchemParser.patterns.findObserveGroups(input, "_", /^\\[a-zA-Z]+\{/, "}", "");
|
|
|
- },
|
|
|
- '_\\x': /^_(\\[a-zA-Z]+)\s*/,
|
|
|
- '^_': /^(?:\^(?=_)|\_(?=\^)|[\^_]$)/,
|
|
|
- '{}': /^\{\}/,
|
|
|
- '{...}': function _(input) {
|
|
|
- return mhchemParser.patterns.findObserveGroups(input, "", "{", "}", "");
|
|
|
- },
|
|
|
- '{(...)}': function _(input) {
|
|
|
- return mhchemParser.patterns.findObserveGroups(input, "{", "", "", "}");
|
|
|
- },
|
|
|
- '$...$': function $$(input) {
|
|
|
- return mhchemParser.patterns.findObserveGroups(input, "", "$", "$", "");
|
|
|
- },
|
|
|
- '${(...)}$': function $$(input) {
|
|
|
- return mhchemParser.patterns.findObserveGroups(input, "${", "", "", "}$");
|
|
|
- },
|
|
|
- '$(...)$': function $$(input) {
|
|
|
- return mhchemParser.patterns.findObserveGroups(input, "$", "", "", "$");
|
|
|
- },
|
|
|
- '=<>': /^[=<>]/,
|
|
|
- '#': /^[#\u2261]/,
|
|
|
- '+': /^\+/,
|
|
|
- '-$': /^-(?=[\s_},;\]/]|$|\([a-z]+\))/,
|
|
|
- // -space -, -; -] -/ -$ -state-of-aggregation
|
|
|
- '-9': /^-(?=[0-9])/,
|
|
|
- '- orbital overlap': /^-(?=(?:[spd]|sp)(?:$|[\s,;\)\]\}]))/,
|
|
|
- '-': /^-/,
|
|
|
- 'pm-operator': /^(?:\\pm|\$\\pm\$|\+-|\+\/-)/,
|
|
|
- 'operator': /^(?:\+|(?:[\-=<>]|<<|>>|\\approx|\$\\approx\$)(?=\s|$|-?[0-9]))/,
|
|
|
- 'arrowUpDown': /^(?:v|\(v\)|\^|\(\^\))(?=$|[\s,;\)\]\}])/,
|
|
|
- '\\bond{(...)}': function bond(input) {
|
|
|
- return mhchemParser.patterns.findObserveGroups(input, "\\bond{", "", "", "}");
|
|
|
- },
|
|
|
- '->': /^(?:<->|<-->|->|<-|<=>>|<<=>|<=>|[\u2192\u27F6\u21CC])/,
|
|
|
- 'CMT': /^[CMT](?=\[)/,
|
|
|
- '[(...)]': function _(input) {
|
|
|
- return mhchemParser.patterns.findObserveGroups(input, "[", "", "", "]");
|
|
|
- },
|
|
|
- '1st-level escape': /^(&|\\\\|\\hline)\s*/,
|
|
|
- '\\,': /^(?:\\[,\ ;:])/,
|
|
|
- // \\x - but output no space before
|
|
|
- '\\x{}{}': function x(input) {
|
|
|
- return mhchemParser.patterns.findObserveGroups(input, "", /^\\[a-zA-Z]+\{/, "}", "", "", "{", "}", "", true);
|
|
|
- },
|
|
|
- '\\x{}': function x(input) {
|
|
|
- return mhchemParser.patterns.findObserveGroups(input, "", /^\\[a-zA-Z]+\{/, "}", "");
|
|
|
- },
|
|
|
- '\\ca': /^\\ca(?:\s+|(?![a-zA-Z]))/,
|
|
|
- '\\x': /^(?:\\[a-zA-Z]+\s*|\\[_&{}%])/,
|
|
|
- 'orbital': /^(?:[0-9]{1,2}[spdfgh]|[0-9]{0,2}sp)(?=$|[^a-zA-Z])/,
|
|
|
- // only those with numbers in front, because the others will be formatted correctly anyway
|
|
|
- 'others': /^[\/~|]/,
|
|
|
- '\\frac{(...)}': function frac(input) {
|
|
|
- return mhchemParser.patterns.findObserveGroups(input, "\\frac{", "", "", "}", "{", "", "", "}");
|
|
|
- },
|
|
|
- '\\overset{(...)}': function overset(input) {
|
|
|
- return mhchemParser.patterns.findObserveGroups(input, "\\overset{", "", "", "}", "{", "", "", "}");
|
|
|
- },
|
|
|
- "\\underset{(...)}": function underset(input) {
|
|
|
- return mhchemParser.patterns.findObserveGroups(input, "\\underset{", "", "", "}", "{", "", "", "}");
|
|
|
- },
|
|
|
- "\\underbrace{(...)}": function underbrace(input) {
|
|
|
- return mhchemParser.patterns.findObserveGroups(input, "\\underbrace{", "", "", "}_", "{", "", "", "}");
|
|
|
- },
|
|
|
- '\\color{(...)}0': function color0(input) {
|
|
|
- return mhchemParser.patterns.findObserveGroups(input, "\\color{", "", "", "}");
|
|
|
- },
|
|
|
- '\\color{(...)}{(...)}1': function color1(input) {
|
|
|
- return mhchemParser.patterns.findObserveGroups(input, "\\color{", "", "", "}", "{", "", "", "}");
|
|
|
- },
|
|
|
- '\\color(...){(...)}2': function color2(input) {
|
|
|
- return mhchemParser.patterns.findObserveGroups(input, "\\color", "\\", "", /^(?=\{)/, "{", "", "", "}");
|
|
|
- },
|
|
|
- '\\ce{(...)}': function ce(input) {
|
|
|
- return mhchemParser.patterns.findObserveGroups(input, "\\ce{", "", "", "}");
|
|
|
- },
|
|
|
- 'oxidation$': /^(?:[+-][IVX]+|\\pm\s*0|\$\\pm\$\s*0)$/,
|
|
|
- 'd-oxidation$': /^(?:[+-]?\s?[IVX]+|\\pm\s*0|\$\\pm\$\s*0)$/,
|
|
|
- // 0 could be oxidation or charge
|
|
|
- 'roman numeral': /^[IVX]+/,
|
|
|
- '1/2$': /^[+\-]?(?:[0-9]+|\$[a-z]\$|[a-z])\/[0-9]+(?:\$[a-z]\$|[a-z])?$/,
|
|
|
- 'amount': function amount(input) {
|
|
|
- var match; // e.g. 2, 0.5, 1/2, -2, n/2, +; $a$ could be added later in parsing
|
|
|
-
|
|
|
- match = input.match(/^(?:(?:(?:\([+\-]?[0-9]+\/[0-9]+\)|[+\-]?(?:[0-9]+|\$[a-z]\$|[a-z])\/[0-9]+|[+\-]?[0-9]+[.,][0-9]+|[+\-]?\.[0-9]+|[+\-]?[0-9]+)(?:[a-z](?=\s*[A-Z]))?)|[+\-]?[a-z](?=\s*[A-Z])|\+(?!\s))/);
|
|
|
-
|
|
|
- if (match) {
|
|
|
- return {
|
|
|
- match_: match[0],
|
|
|
- remainder: input.substr(match[0].length)
|
|
|
- };
|
|
|
- }
|
|
|
-
|
|
|
- var a = mhchemParser.patterns.findObserveGroups(input, "", "$", "$", "");
|
|
|
-
|
|
|
- if (a) {
|
|
|
- // e.g. $2n-1$, $-$
|
|
|
- match = a.match_.match(/^\$(?:\(?[+\-]?(?:[0-9]*[a-z]?[+\-])?[0-9]*[a-z](?:[+\-][0-9]*[a-z]?)?\)?|\+|-)\$$/);
|
|
|
-
|
|
|
- if (match) {
|
|
|
- return {
|
|
|
- match_: match[0],
|
|
|
- remainder: input.substr(match[0].length)
|
|
|
- };
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- return null;
|
|
|
- },
|
|
|
- 'amount2': function amount2(input) {
|
|
|
- return this['amount'](input);
|
|
|
- },
|
|
|
- '(KV letters),': /^(?:[A-Z][a-z]{0,2}|i)(?=,)/,
|
|
|
- 'formula$': function formula$(input) {
|
|
|
- if (input.match(/^\([a-z]+\)$/)) {
|
|
|
- return null;
|
|
|
- } // state of aggregation = no formula
|
|
|
-
|
|
|
-
|
|
|
- var match = input.match(/^(?:[a-z]|(?:[0-9\ \+\-\,\.\(\)]+[a-z])+[0-9\ \+\-\,\.\(\)]*|(?:[a-z][0-9\ \+\-\,\.\(\)]+)+[a-z]?)$/);
|
|
|
-
|
|
|
- if (match) {
|
|
|
- return {
|
|
|
- match_: match[0],
|
|
|
- remainder: input.substr(match[0].length)
|
|
|
- };
|
|
|
- }
|
|
|
-
|
|
|
- return null;
|
|
|
- },
|
|
|
- 'uprightEntities': /^(?:pH|pOH|pC|pK|iPr|iBu)(?=$|[^a-zA-Z])/,
|
|
|
- '/': /^\s*(\/)\s*/,
|
|
|
- '//': /^\s*(\/\/)\s*/,
|
|
|
- '*': /^\s*[*.]\s*/
|
|
|
- },
|
|
|
- findObserveGroups: function findObserveGroups(input, begExcl, begIncl, endIncl, endExcl, beg2Excl, beg2Incl, end2Incl, end2Excl, combine) {
|
|
|
- /** @type {{(input: string, pattern: string | RegExp): string | string[] | null;}} */
|
|
|
- var _match = function _match(input, pattern) {
|
|
|
- if (typeof pattern === "string") {
|
|
|
- if (input.indexOf(pattern) !== 0) {
|
|
|
- return null;
|
|
|
- }
|
|
|
-
|
|
|
- return pattern;
|
|
|
- } else {
|
|
|
- var match = input.match(pattern);
|
|
|
-
|
|
|
- if (!match) {
|
|
|
- return null;
|
|
|
- }
|
|
|
-
|
|
|
- return match[0];
|
|
|
- }
|
|
|
- };
|
|
|
- /** @type {{(input: string, i: number, endChars: string | RegExp): {endMatchBegin: number, endMatchEnd: number} | null;}} */
|
|
|
-
|
|
|
-
|
|
|
- var _findObserveGroups = function _findObserveGroups(input, i, endChars) {
|
|
|
- var braces = 0;
|
|
|
-
|
|
|
- while (i < input.length) {
|
|
|
- var a = input.charAt(i);
|
|
|
-
|
|
|
- var match = _match(input.substr(i), endChars);
|
|
|
-
|
|
|
- if (match !== null && braces === 0) {
|
|
|
- return {
|
|
|
- endMatchBegin: i,
|
|
|
- endMatchEnd: i + match.length
|
|
|
- };
|
|
|
- } else if (a === "{") {
|
|
|
- braces++;
|
|
|
- } else if (a === "}") {
|
|
|
- if (braces === 0) {
|
|
|
- throw ["ExtraCloseMissingOpen", "Extra close brace or missing open brace"];
|
|
|
- } else {
|
|
|
- braces--;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- i++;
|
|
|
- }
|
|
|
-
|
|
|
- if (braces > 0) {
|
|
|
- return null;
|
|
|
- }
|
|
|
-
|
|
|
- return null;
|
|
|
- };
|
|
|
-
|
|
|
- var match = _match(input, begExcl);
|
|
|
-
|
|
|
- if (match === null) {
|
|
|
- return null;
|
|
|
- }
|
|
|
-
|
|
|
- input = input.substr(match.length);
|
|
|
- match = _match(input, begIncl);
|
|
|
-
|
|
|
- if (match === null) {
|
|
|
- return null;
|
|
|
- }
|
|
|
-
|
|
|
- var e = _findObserveGroups(input, match.length, endIncl || endExcl);
|
|
|
-
|
|
|
- if (e === null) {
|
|
|
- return null;
|
|
|
- }
|
|
|
-
|
|
|
- var match1 = input.substring(0, endIncl ? e.endMatchEnd : e.endMatchBegin);
|
|
|
-
|
|
|
- if (!(beg2Excl || beg2Incl)) {
|
|
|
- return {
|
|
|
- match_: match1,
|
|
|
- remainder: input.substr(e.endMatchEnd)
|
|
|
- };
|
|
|
- } else {
|
|
|
- var group2 = this.findObserveGroups(input.substr(e.endMatchEnd), beg2Excl, beg2Incl, end2Incl, end2Excl);
|
|
|
-
|
|
|
- if (group2 === null) {
|
|
|
- return null;
|
|
|
- }
|
|
|
- /** @type {string[]} */
|
|
|
-
|
|
|
-
|
|
|
- var matchRet = [match1, group2.match_];
|
|
|
- return {
|
|
|
- match_: combine ? matchRet.join("") : matchRet,
|
|
|
- remainder: group2.remainder
|
|
|
- };
|
|
|
- }
|
|
|
- },
|
|
|
- //
|
|
|
- // Matching function
|
|
|
- // e.g. match("a", input) will look for the regexp called "a" and see if it matches
|
|
|
- // returns null or {match_:"a", remainder:"bc"}
|
|
|
- //
|
|
|
- match_: function match_(m, input) {
|
|
|
- var pattern = mhchemParser.patterns.patterns[m];
|
|
|
-
|
|
|
- if (pattern === undefined) {
|
|
|
- throw ["MhchemBugP", "mhchem bug P. Please report. (" + m + ")"]; // Trying to use non-existing pattern
|
|
|
- } else if (typeof pattern === "function") {
|
|
|
- return mhchemParser.patterns.patterns[m](input); // cannot use cached var pattern here, because some pattern functions need this===mhchemParser
|
|
|
- } else {
|
|
|
- // RegExp
|
|
|
- var match = input.match(pattern);
|
|
|
-
|
|
|
- if (match) {
|
|
|
- var mm;
|
|
|
-
|
|
|
- if (match[2]) {
|
|
|
- mm = [match[1], match[2]];
|
|
|
- } else if (match[1]) {
|
|
|
- mm = match[1];
|
|
|
- } else {
|
|
|
- mm = match[0];
|
|
|
- }
|
|
|
-
|
|
|
- return {
|
|
|
- match_: mm,
|
|
|
- remainder: input.substr(match[0].length)
|
|
|
- };
|
|
|
- }
|
|
|
-
|
|
|
- return null;
|
|
|
- }
|
|
|
- }
|
|
|
- },
|
|
|
- //
|
|
|
- // Generic state machine actions
|
|
|
- //
|
|
|
- actions: {
|
|
|
- 'a=': function a(buffer, m) {
|
|
|
- buffer.a = (buffer.a || "") + m;
|
|
|
- },
|
|
|
- 'b=': function b(buffer, m) {
|
|
|
- buffer.b = (buffer.b || "") + m;
|
|
|
- },
|
|
|
- 'p=': function p(buffer, m) {
|
|
|
- buffer.p = (buffer.p || "") + m;
|
|
|
- },
|
|
|
- 'o=': function o(buffer, m) {
|
|
|
- buffer.o = (buffer.o || "") + m;
|
|
|
- },
|
|
|
- 'q=': function q(buffer, m) {
|
|
|
- buffer.q = (buffer.q || "") + m;
|
|
|
- },
|
|
|
- 'd=': function d(buffer, m) {
|
|
|
- buffer.d = (buffer.d || "") + m;
|
|
|
- },
|
|
|
- 'rm=': function rm(buffer, m) {
|
|
|
- buffer.rm = (buffer.rm || "") + m;
|
|
|
- },
|
|
|
- 'text=': function text(buffer, m) {
|
|
|
- buffer.text_ = (buffer.text_ || "") + m;
|
|
|
- },
|
|
|
- 'insert': function insert(buffer, m, a) {
|
|
|
- return {
|
|
|
- type_: a
|
|
|
- };
|
|
|
- },
|
|
|
- 'insert+p1': function insertP1(buffer, m, a) {
|
|
|
- return {
|
|
|
- type_: a,
|
|
|
- p1: m
|
|
|
- };
|
|
|
- },
|
|
|
- 'insert+p1+p2': function insertP1P2(buffer, m, a) {
|
|
|
- return {
|
|
|
- type_: a,
|
|
|
- p1: m[0],
|
|
|
- p2: m[1]
|
|
|
- };
|
|
|
- },
|
|
|
- 'copy': function copy(buffer, m) {
|
|
|
- return m;
|
|
|
- },
|
|
|
- 'rm': function rm(buffer, m) {
|
|
|
- return {
|
|
|
- type_: 'rm',
|
|
|
- p1: m || ""
|
|
|
- };
|
|
|
- },
|
|
|
- 'text': function text(buffer, m) {
|
|
|
- return mhchemParser.go(m, 'text');
|
|
|
- },
|
|
|
- '{text}': function text(buffer, m) {
|
|
|
- var ret = ["{"];
|
|
|
- mhchemParser.concatArray(ret, mhchemParser.go(m, 'text'));
|
|
|
- ret.push("}");
|
|
|
- return ret;
|
|
|
- },
|
|
|
- 'tex-math': function texMath(buffer, m) {
|
|
|
- return mhchemParser.go(m, 'tex-math');
|
|
|
- },
|
|
|
- 'tex-math tight': function texMathTight(buffer, m) {
|
|
|
- return mhchemParser.go(m, 'tex-math tight');
|
|
|
- },
|
|
|
- 'bond': function bond(buffer, m, k) {
|
|
|
- return {
|
|
|
- type_: 'bond',
|
|
|
- kind_: k || m
|
|
|
- };
|
|
|
- },
|
|
|
- 'color0-output': function color0Output(buffer, m) {
|
|
|
- return {
|
|
|
- type_: 'color0',
|
|
|
- color: m[0]
|
|
|
- };
|
|
|
- },
|
|
|
- 'ce': function ce(buffer, m) {
|
|
|
- return mhchemParser.go(m);
|
|
|
- },
|
|
|
- '1/2': function _(buffer, m) {
|
|
|
- /** @type {ParserOutput[]} */
|
|
|
- var ret = [];
|
|
|
-
|
|
|
- if (m.match(/^[+\-]/)) {
|
|
|
- ret.push(m.substr(0, 1));
|
|
|
- m = m.substr(1);
|
|
|
- }
|
|
|
-
|
|
|
- var n = m.match(/^([0-9]+|\$[a-z]\$|[a-z])\/([0-9]+)(\$[a-z]\$|[a-z])?$/);
|
|
|
- n[1] = n[1].replace(/\$/g, "");
|
|
|
- ret.push({
|
|
|
- type_: 'frac',
|
|
|
- p1: n[1],
|
|
|
- p2: n[2]
|
|
|
- });
|
|
|
-
|
|
|
- if (n[3]) {
|
|
|
- n[3] = n[3].replace(/\$/g, "");
|
|
|
- ret.push({
|
|
|
- type_: 'tex-math',
|
|
|
- p1: n[3]
|
|
|
- });
|
|
|
- }
|
|
|
-
|
|
|
- return ret;
|
|
|
- },
|
|
|
- '9,9': function _(buffer, m) {
|
|
|
- return mhchemParser.go(m, '9,9');
|
|
|
- }
|
|
|
- },
|
|
|
- //
|
|
|
- // createTransitions
|
|
|
- // convert { 'letter': { 'state': { action_: 'output' } } } to { 'state' => [ { pattern: 'letter', task: { action_: [{type_: 'output'}] } } ] }
|
|
|
- // with expansion of 'a|b' to 'a' and 'b' (at 2 places)
|
|
|
- //
|
|
|
- createTransitions: function createTransitions(o) {
|
|
|
- var pattern, state;
|
|
|
- /** @type {string[]} */
|
|
|
-
|
|
|
- var stateArray;
|
|
|
- var i; //
|
|
|
- // 1. Collect all states
|
|
|
- //
|
|
|
-
|
|
|
- /** @type {Transitions} */
|
|
|
-
|
|
|
- var transitions = {};
|
|
|
-
|
|
|
- for (pattern in o) {
|
|
|
- for (state in o[pattern]) {
|
|
|
- stateArray = state.split("|");
|
|
|
- o[pattern][state].stateArray = stateArray;
|
|
|
-
|
|
|
- for (i = 0; i < stateArray.length; i++) {
|
|
|
- transitions[stateArray[i]] = [];
|
|
|
- }
|
|
|
- }
|
|
|
- } //
|
|
|
- // 2. Fill states
|
|
|
- //
|
|
|
-
|
|
|
-
|
|
|
- for (pattern in o) {
|
|
|
- for (state in o[pattern]) {
|
|
|
- stateArray = o[pattern][state].stateArray || [];
|
|
|
-
|
|
|
- for (i = 0; i < stateArray.length; i++) {
|
|
|
- //
|
|
|
- // 2a. Normalize actions into array: 'text=' ==> [{type_:'text='}]
|
|
|
- // (Note to myself: Resolving the function here would be problematic. It would need .bind (for *this*) and currying (for *option*).)
|
|
|
- //
|
|
|
-
|
|
|
- /** @type {any} */
|
|
|
- var p = o[pattern][state];
|
|
|
-
|
|
|
- if (p.action_) {
|
|
|
- p.action_ = [].concat(p.action_);
|
|
|
-
|
|
|
- for (var k = 0; k < p.action_.length; k++) {
|
|
|
- if (typeof p.action_[k] === "string") {
|
|
|
- p.action_[k] = {
|
|
|
- type_: p.action_[k]
|
|
|
- };
|
|
|
- }
|
|
|
- }
|
|
|
- } else {
|
|
|
- p.action_ = [];
|
|
|
- } //
|
|
|
- // 2.b Multi-insert
|
|
|
- //
|
|
|
-
|
|
|
-
|
|
|
- var patternArray = pattern.split("|");
|
|
|
-
|
|
|
- for (var j = 0; j < patternArray.length; j++) {
|
|
|
- if (stateArray[i] === '*') {
|
|
|
- // insert into all
|
|
|
- for (var t in transitions) {
|
|
|
- transitions[t].push({
|
|
|
- pattern: patternArray[j],
|
|
|
- task: p
|
|
|
- });
|
|
|
- }
|
|
|
- } else {
|
|
|
- transitions[stateArray[i]].push({
|
|
|
- pattern: patternArray[j],
|
|
|
- task: p
|
|
|
- });
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- return transitions;
|
|
|
- },
|
|
|
- stateMachines: {}
|
|
|
-}; //
|
|
|
-// Definition of state machines
|
|
|
-//
|
|
|
-
|
|
|
-mhchemParser.stateMachines = {
|
|
|
- //
|
|
|
- // \ce state machines
|
|
|
- //
|
|
|
- //#region ce
|
|
|
- 'ce': {
|
|
|
- // main parser
|
|
|
- transitions: mhchemParser.createTransitions({
|
|
|
- 'empty': {
|
|
|
- '*': {
|
|
|
- action_: 'output'
|
|
|
- }
|
|
|
- },
|
|
|
- 'else': {
|
|
|
- '0|1|2': {
|
|
|
- action_: 'beginsWithBond=false',
|
|
|
- revisit: true,
|
|
|
- toContinue: true
|
|
|
- }
|
|
|
- },
|
|
|
- 'oxidation$': {
|
|
|
- '0': {
|
|
|
- action_: 'oxidation-output'
|
|
|
- }
|
|
|
- },
|
|
|
- 'CMT': {
|
|
|
- 'r': {
|
|
|
- action_: 'rdt=',
|
|
|
- nextState: 'rt'
|
|
|
- },
|
|
|
- 'rd': {
|
|
|
- action_: 'rqt=',
|
|
|
- nextState: 'rdt'
|
|
|
- }
|
|
|
- },
|
|
|
- 'arrowUpDown': {
|
|
|
- '0|1|2|as': {
|
|
|
- action_: ['sb=false', 'output', 'operator'],
|
|
|
- nextState: '1'
|
|
|
- }
|
|
|
- },
|
|
|
- 'uprightEntities': {
|
|
|
- '0|1|2': {
|
|
|
- action_: ['o=', 'output'],
|
|
|
- nextState: '1'
|
|
|
- }
|
|
|
- },
|
|
|
- 'orbital': {
|
|
|
- '0|1|2|3': {
|
|
|
- action_: 'o=',
|
|
|
- nextState: 'o'
|
|
|
- }
|
|
|
- },
|
|
|
- '->': {
|
|
|
- '0|1|2|3': {
|
|
|
- action_: 'r=',
|
|
|
- nextState: 'r'
|
|
|
- },
|
|
|
- 'a|as': {
|
|
|
- action_: ['output', 'r='],
|
|
|
- nextState: 'r'
|
|
|
- },
|
|
|
- '*': {
|
|
|
- action_: ['output', 'r='],
|
|
|
- nextState: 'r'
|
|
|
- }
|
|
|
- },
|
|
|
- '+': {
|
|
|
- 'o': {
|
|
|
- action_: 'd= kv',
|
|
|
- nextState: 'd'
|
|
|
- },
|
|
|
- 'd|D': {
|
|
|
- action_: 'd=',
|
|
|
- nextState: 'd'
|
|
|
- },
|
|
|
- 'q': {
|
|
|
- action_: 'd=',
|
|
|
- nextState: 'qd'
|
|
|
- },
|
|
|
- 'qd|qD': {
|
|
|
- action_: 'd=',
|
|
|
- nextState: 'qd'
|
|
|
- },
|
|
|
- 'dq': {
|
|
|
- action_: ['output', 'd='],
|
|
|
- nextState: 'd'
|
|
|
- },
|
|
|
- '3': {
|
|
|
- action_: ['sb=false', 'output', 'operator'],
|
|
|
- nextState: '0'
|
|
|
- }
|
|
|
- },
|
|
|
- 'amount': {
|
|
|
- '0|2': {
|
|
|
- action_: 'a=',
|
|
|
- nextState: 'a'
|
|
|
- }
|
|
|
- },
|
|
|
- 'pm-operator': {
|
|
|
- '0|1|2|a|as': {
|
|
|
- action_: ['sb=false', 'output', {
|
|
|
- type_: 'operator',
|
|
|
- option: '\\pm'
|
|
|
- }],
|
|
|
- nextState: '0'
|
|
|
- }
|
|
|
- },
|
|
|
- 'operator': {
|
|
|
- '0|1|2|a|as': {
|
|
|
- action_: ['sb=false', 'output', 'operator'],
|
|
|
- nextState: '0'
|
|
|
- }
|
|
|
- },
|
|
|
- '-$': {
|
|
|
- 'o|q': {
|
|
|
- action_: ['charge or bond', 'output'],
|
|
|
- nextState: 'qd'
|
|
|
- },
|
|
|
- 'd': {
|
|
|
- action_: 'd=',
|
|
|
- nextState: 'd'
|
|
|
- },
|
|
|
- 'D': {
|
|
|
- action_: ['output', {
|
|
|
- type_: 'bond',
|
|
|
- option: "-"
|
|
|
- }],
|
|
|
- nextState: '3'
|
|
|
- },
|
|
|
- 'q': {
|
|
|
- action_: 'd=',
|
|
|
- nextState: 'qd'
|
|
|
- },
|
|
|
- 'qd': {
|
|
|
- action_: 'd=',
|
|
|
- nextState: 'qd'
|
|
|
- },
|
|
|
- 'qD|dq': {
|
|
|
- action_: ['output', {
|
|
|
- type_: 'bond',
|
|
|
- option: "-"
|
|
|
- }],
|
|
|
- nextState: '3'
|
|
|
- }
|
|
|
- },
|
|
|
- '-9': {
|
|
|
- '3|o': {
|
|
|
- action_: ['output', {
|
|
|
- type_: 'insert',
|
|
|
- option: 'hyphen'
|
|
|
- }],
|
|
|
- nextState: '3'
|
|
|
- }
|
|
|
- },
|
|
|
- '- orbital overlap': {
|
|
|
- 'o': {
|
|
|
- action_: ['output', {
|
|
|
- type_: 'insert',
|
|
|
- option: 'hyphen'
|
|
|
- }],
|
|
|
- nextState: '2'
|
|
|
- },
|
|
|
- 'd': {
|
|
|
- action_: ['output', {
|
|
|
- type_: 'insert',
|
|
|
- option: 'hyphen'
|
|
|
- }],
|
|
|
- nextState: '2'
|
|
|
- }
|
|
|
- },
|
|
|
- '-': {
|
|
|
- '0|1|2': {
|
|
|
- action_: [{
|
|
|
- type_: 'output',
|
|
|
- option: 1
|
|
|
- }, 'beginsWithBond=true', {
|
|
|
- type_: 'bond',
|
|
|
- option: "-"
|
|
|
- }],
|
|
|
- nextState: '3'
|
|
|
- },
|
|
|
- '3': {
|
|
|
- action_: {
|
|
|
- type_: 'bond',
|
|
|
- option: "-"
|
|
|
- }
|
|
|
- },
|
|
|
- 'a': {
|
|
|
- action_: ['output', {
|
|
|
- type_: 'insert',
|
|
|
- option: 'hyphen'
|
|
|
- }],
|
|
|
- nextState: '2'
|
|
|
- },
|
|
|
- 'as': {
|
|
|
- action_: [{
|
|
|
- type_: 'output',
|
|
|
- option: 2
|
|
|
- }, {
|
|
|
- type_: 'bond',
|
|
|
- option: "-"
|
|
|
- }],
|
|
|
- nextState: '3'
|
|
|
- },
|
|
|
- 'b': {
|
|
|
- action_: 'b='
|
|
|
- },
|
|
|
- 'o': {
|
|
|
- action_: {
|
|
|
- type_: '- after o/d',
|
|
|
- option: false
|
|
|
- },
|
|
|
- nextState: '2'
|
|
|
- },
|
|
|
- 'q': {
|
|
|
- action_: {
|
|
|
- type_: '- after o/d',
|
|
|
- option: false
|
|
|
- },
|
|
|
- nextState: '2'
|
|
|
- },
|
|
|
- 'd|qd|dq': {
|
|
|
- action_: {
|
|
|
- type_: '- after o/d',
|
|
|
- option: true
|
|
|
- },
|
|
|
- nextState: '2'
|
|
|
- },
|
|
|
- 'D|qD|p': {
|
|
|
- action_: ['output', {
|
|
|
- type_: 'bond',
|
|
|
- option: "-"
|
|
|
- }],
|
|
|
- nextState: '3'
|
|
|
- }
|
|
|
- },
|
|
|
- 'amount2': {
|
|
|
- '1|3': {
|
|
|
- action_: 'a=',
|
|
|
- nextState: 'a'
|
|
|
- }
|
|
|
- },
|
|
|
- 'letters': {
|
|
|
- '0|1|2|3|a|as|b|p|bp|o': {
|
|
|
- action_: 'o=',
|
|
|
- nextState: 'o'
|
|
|
- },
|
|
|
- 'q|dq': {
|
|
|
- action_: ['output', 'o='],
|
|
|
- nextState: 'o'
|
|
|
- },
|
|
|
- 'd|D|qd|qD': {
|
|
|
- action_: 'o after d',
|
|
|
- nextState: 'o'
|
|
|
- }
|
|
|
- },
|
|
|
- 'digits': {
|
|
|
- 'o': {
|
|
|
- action_: 'q=',
|
|
|
- nextState: 'q'
|
|
|
- },
|
|
|
- 'd|D': {
|
|
|
- action_: 'q=',
|
|
|
- nextState: 'dq'
|
|
|
- },
|
|
|
- 'q': {
|
|
|
- action_: ['output', 'o='],
|
|
|
- nextState: 'o'
|
|
|
- },
|
|
|
- 'a': {
|
|
|
- action_: 'o=',
|
|
|
- nextState: 'o'
|
|
|
- }
|
|
|
- },
|
|
|
- 'space A': {
|
|
|
- 'b|p|bp': {}
|
|
|
- },
|
|
|
- 'space': {
|
|
|
- 'a': {
|
|
|
- nextState: 'as'
|
|
|
- },
|
|
|
- '0': {
|
|
|
- action_: 'sb=false'
|
|
|
- },
|
|
|
- '1|2': {
|
|
|
- action_: 'sb=true'
|
|
|
- },
|
|
|
- 'r|rt|rd|rdt|rdq': {
|
|
|
- action_: 'output',
|
|
|
- nextState: '0'
|
|
|
- },
|
|
|
- '*': {
|
|
|
- action_: ['output', 'sb=true'],
|
|
|
- nextState: '1'
|
|
|
- }
|
|
|
- },
|
|
|
- '1st-level escape': {
|
|
|
- '1|2': {
|
|
|
- action_: ['output', {
|
|
|
- type_: 'insert+p1',
|
|
|
- option: '1st-level escape'
|
|
|
- }]
|
|
|
- },
|
|
|
- '*': {
|
|
|
- action_: ['output', {
|
|
|
- type_: 'insert+p1',
|
|
|
- option: '1st-level escape'
|
|
|
- }],
|
|
|
- nextState: '0'
|
|
|
- }
|
|
|
- },
|
|
|
- '[(...)]': {
|
|
|
- 'r|rt': {
|
|
|
- action_: 'rd=',
|
|
|
- nextState: 'rd'
|
|
|
- },
|
|
|
- 'rd|rdt': {
|
|
|
- action_: 'rq=',
|
|
|
- nextState: 'rdq'
|
|
|
- }
|
|
|
- },
|
|
|
- '...': {
|
|
|
- 'o|d|D|dq|qd|qD': {
|
|
|
- action_: ['output', {
|
|
|
- type_: 'bond',
|
|
|
- option: "..."
|
|
|
- }],
|
|
|
- nextState: '3'
|
|
|
- },
|
|
|
- '*': {
|
|
|
- action_: [{
|
|
|
- type_: 'output',
|
|
|
- option: 1
|
|
|
- }, {
|
|
|
- type_: 'insert',
|
|
|
- option: 'ellipsis'
|
|
|
- }],
|
|
|
- nextState: '1'
|
|
|
- }
|
|
|
- },
|
|
|
- '. |* ': {
|
|
|
- '*': {
|
|
|
- action_: ['output', {
|
|
|
- type_: 'insert',
|
|
|
- option: 'addition compound'
|
|
|
- }],
|
|
|
- nextState: '1'
|
|
|
- }
|
|
|
- },
|
|
|
- 'state of aggregation $': {
|
|
|
- '*': {
|
|
|
- action_: ['output', 'state of aggregation'],
|
|
|
- nextState: '1'
|
|
|
- }
|
|
|
- },
|
|
|
- '{[(': {
|
|
|
- 'a|as|o': {
|
|
|
- action_: ['o=', 'output', 'parenthesisLevel++'],
|
|
|
- nextState: '2'
|
|
|
- },
|
|
|
- '0|1|2|3': {
|
|
|
- action_: ['o=', 'output', 'parenthesisLevel++'],
|
|
|
- nextState: '2'
|
|
|
- },
|
|
|
- '*': {
|
|
|
- action_: ['output', 'o=', 'output', 'parenthesisLevel++'],
|
|
|
- nextState: '2'
|
|
|
- }
|
|
|
- },
|
|
|
- ')]}': {
|
|
|
- '0|1|2|3|b|p|bp|o': {
|
|
|
- action_: ['o=', 'parenthesisLevel--'],
|
|
|
- nextState: 'o'
|
|
|
- },
|
|
|
- 'a|as|d|D|q|qd|qD|dq': {
|
|
|
- action_: ['output', 'o=', 'parenthesisLevel--'],
|
|
|
- nextState: 'o'
|
|
|
- }
|
|
|
- },
|
|
|
- ', ': {
|
|
|
- '*': {
|
|
|
- action_: ['output', 'comma'],
|
|
|
- nextState: '0'
|
|
|
- }
|
|
|
- },
|
|
|
- '^_': {
|
|
|
- // ^ and _ without a sensible argument
|
|
|
- '*': {}
|
|
|
- },
|
|
|
- '^{(...)}|^($...$)': {
|
|
|
- '0|1|2|as': {
|
|
|
- action_: 'b=',
|
|
|
- nextState: 'b'
|
|
|
- },
|
|
|
- 'p': {
|
|
|
- action_: 'b=',
|
|
|
- nextState: 'bp'
|
|
|
- },
|
|
|
- '3|o': {
|
|
|
- action_: 'd= kv',
|
|
|
- nextState: 'D'
|
|
|
- },
|
|
|
- 'q': {
|
|
|
- action_: 'd=',
|
|
|
- nextState: 'qD'
|
|
|
- },
|
|
|
- 'd|D|qd|qD|dq': {
|
|
|
- action_: ['output', 'd='],
|
|
|
- nextState: 'D'
|
|
|
- }
|
|
|
- },
|
|
|
- '^a|^\\x{}{}|^\\x{}|^\\x|\'': {
|
|
|
- '0|1|2|as': {
|
|
|
- action_: 'b=',
|
|
|
- nextState: 'b'
|
|
|
- },
|
|
|
- 'p': {
|
|
|
- action_: 'b=',
|
|
|
- nextState: 'bp'
|
|
|
- },
|
|
|
- '3|o': {
|
|
|
- action_: 'd= kv',
|
|
|
- nextState: 'd'
|
|
|
- },
|
|
|
- 'q': {
|
|
|
- action_: 'd=',
|
|
|
- nextState: 'qd'
|
|
|
- },
|
|
|
- 'd|qd|D|qD': {
|
|
|
- action_: 'd='
|
|
|
- },
|
|
|
- 'dq': {
|
|
|
- action_: ['output', 'd='],
|
|
|
- nextState: 'd'
|
|
|
- }
|
|
|
- },
|
|
|
- '_{(state of aggregation)}$': {
|
|
|
- 'd|D|q|qd|qD|dq': {
|
|
|
- action_: ['output', 'q='],
|
|
|
- nextState: 'q'
|
|
|
- }
|
|
|
- },
|
|
|
- '_{(...)}|_($...$)|_9|_\\x{}{}|_\\x{}|_\\x': {
|
|
|
- '0|1|2|as': {
|
|
|
- action_: 'p=',
|
|
|
- nextState: 'p'
|
|
|
- },
|
|
|
- 'b': {
|
|
|
- action_: 'p=',
|
|
|
- nextState: 'bp'
|
|
|
- },
|
|
|
- '3|o': {
|
|
|
- action_: 'q=',
|
|
|
- nextState: 'q'
|
|
|
- },
|
|
|
- 'd|D': {
|
|
|
- action_: 'q=',
|
|
|
- nextState: 'dq'
|
|
|
- },
|
|
|
- 'q|qd|qD|dq': {
|
|
|
- action_: ['output', 'q='],
|
|
|
- nextState: 'q'
|
|
|
- }
|
|
|
- },
|
|
|
- '=<>': {
|
|
|
- '0|1|2|3|a|as|o|q|d|D|qd|qD|dq': {
|
|
|
- action_: [{
|
|
|
- type_: 'output',
|
|
|
- option: 2
|
|
|
- }, 'bond'],
|
|
|
- nextState: '3'
|
|
|
- }
|
|
|
- },
|
|
|
- '#': {
|
|
|
- '0|1|2|3|a|as|o': {
|
|
|
- action_: [{
|
|
|
- type_: 'output',
|
|
|
- option: 2
|
|
|
- }, {
|
|
|
- type_: 'bond',
|
|
|
- option: "#"
|
|
|
- }],
|
|
|
- nextState: '3'
|
|
|
- }
|
|
|
- },
|
|
|
- '{}': {
|
|
|
- '*': {
|
|
|
- action_: {
|
|
|
- type_: 'output',
|
|
|
- option: 1
|
|
|
- },
|
|
|
- nextState: '1'
|
|
|
- }
|
|
|
- },
|
|
|
- '{...}': {
|
|
|
- '0|1|2|3|a|as|b|p|bp': {
|
|
|
- action_: 'o=',
|
|
|
- nextState: 'o'
|
|
|
- },
|
|
|
- 'o|d|D|q|qd|qD|dq': {
|
|
|
- action_: ['output', 'o='],
|
|
|
- nextState: 'o'
|
|
|
- }
|
|
|
- },
|
|
|
- '$...$': {
|
|
|
- 'a': {
|
|
|
- action_: 'a='
|
|
|
- },
|
|
|
- // 2$n$
|
|
|
- '0|1|2|3|as|b|p|bp|o': {
|
|
|
- action_: 'o=',
|
|
|
- nextState: 'o'
|
|
|
- },
|
|
|
- // not 'amount'
|
|
|
- 'as|o': {
|
|
|
- action_: 'o='
|
|
|
- },
|
|
|
- 'q|d|D|qd|qD|dq': {
|
|
|
- action_: ['output', 'o='],
|
|
|
- nextState: 'o'
|
|
|
- }
|
|
|
- },
|
|
|
- '\\bond{(...)}': {
|
|
|
- '*': {
|
|
|
- action_: [{
|
|
|
- type_: 'output',
|
|
|
- option: 2
|
|
|
- }, 'bond'],
|
|
|
- nextState: "3"
|
|
|
- }
|
|
|
- },
|
|
|
- '\\frac{(...)}': {
|
|
|
- '*': {
|
|
|
- action_: [{
|
|
|
- type_: 'output',
|
|
|
- option: 1
|
|
|
- }, 'frac-output'],
|
|
|
- nextState: '3'
|
|
|
- }
|
|
|
- },
|
|
|
- '\\overset{(...)}': {
|
|
|
- '*': {
|
|
|
- action_: [{
|
|
|
- type_: 'output',
|
|
|
- option: 2
|
|
|
- }, 'overset-output'],
|
|
|
- nextState: '3'
|
|
|
- }
|
|
|
- },
|
|
|
- "\\underset{(...)}": {
|
|
|
- '*': {
|
|
|
- action_: [{
|
|
|
- type_: 'output',
|
|
|
- option: 2
|
|
|
- }, 'underset-output'],
|
|
|
- nextState: '3'
|
|
|
- }
|
|
|
- },
|
|
|
- "\\underbrace{(...)}": {
|
|
|
- '*': {
|
|
|
- action_: [{
|
|
|
- type_: 'output',
|
|
|
- option: 2
|
|
|
- }, 'underbrace-output'],
|
|
|
- nextState: '3'
|
|
|
- }
|
|
|
- },
|
|
|
- '\\color{(...)}{(...)}1|\\color(...){(...)}2': {
|
|
|
- '*': {
|
|
|
- action_: [{
|
|
|
- type_: 'output',
|
|
|
- option: 2
|
|
|
- }, 'color-output'],
|
|
|
- nextState: '3'
|
|
|
- }
|
|
|
- },
|
|
|
- '\\color{(...)}0': {
|
|
|
- '*': {
|
|
|
- action_: [{
|
|
|
- type_: 'output',
|
|
|
- option: 2
|
|
|
- }, 'color0-output']
|
|
|
- }
|
|
|
- },
|
|
|
- '\\ce{(...)}': {
|
|
|
- '*': {
|
|
|
- action_: [{
|
|
|
- type_: 'output',
|
|
|
- option: 2
|
|
|
- }, 'ce'],
|
|
|
- nextState: '3'
|
|
|
- }
|
|
|
- },
|
|
|
- '\\,': {
|
|
|
- '*': {
|
|
|
- action_: [{
|
|
|
- type_: 'output',
|
|
|
- option: 1
|
|
|
- }, 'copy'],
|
|
|
- nextState: '1'
|
|
|
- }
|
|
|
- },
|
|
|
- '\\x{}{}|\\x{}|\\x': {
|
|
|
- '0|1|2|3|a|as|b|p|bp|o|c0': {
|
|
|
- action_: ['o=', 'output'],
|
|
|
- nextState: '3'
|
|
|
- },
|
|
|
- '*': {
|
|
|
- action_: ['output', 'o=', 'output'],
|
|
|
- nextState: '3'
|
|
|
- }
|
|
|
- },
|
|
|
- 'others': {
|
|
|
- '*': {
|
|
|
- action_: [{
|
|
|
- type_: 'output',
|
|
|
- option: 1
|
|
|
- }, 'copy'],
|
|
|
- nextState: '3'
|
|
|
- }
|
|
|
- },
|
|
|
- 'else2': {
|
|
|
- 'a': {
|
|
|
- action_: 'a to o',
|
|
|
- nextState: 'o',
|
|
|
- revisit: true
|
|
|
- },
|
|
|
- 'as': {
|
|
|
- action_: ['output', 'sb=true'],
|
|
|
- nextState: '1',
|
|
|
- revisit: true
|
|
|
- },
|
|
|
- 'r|rt|rd|rdt|rdq': {
|
|
|
- action_: ['output'],
|
|
|
- nextState: '0',
|
|
|
- revisit: true
|
|
|
- },
|
|
|
- '*': {
|
|
|
- action_: ['output', 'copy'],
|
|
|
- nextState: '3'
|
|
|
- }
|
|
|
- }
|
|
|
- }),
|
|
|
- actions: {
|
|
|
- 'o after d': function oAfterD(buffer, m) {
|
|
|
- var ret;
|
|
|
-
|
|
|
- if ((buffer.d || "").match(/^[0-9]+$/)) {
|
|
|
- var tmp = buffer.d;
|
|
|
- buffer.d = undefined;
|
|
|
- ret = this['output'](buffer);
|
|
|
- buffer.b = tmp;
|
|
|
- } else {
|
|
|
- ret = this['output'](buffer);
|
|
|
- }
|
|
|
-
|
|
|
- mhchemParser.actions['o='](buffer, m);
|
|
|
- return ret;
|
|
|
- },
|
|
|
- 'd= kv': function dKv(buffer, m) {
|
|
|
- buffer.d = m;
|
|
|
- buffer.dType = 'kv';
|
|
|
- },
|
|
|
- 'charge or bond': function chargeOrBond(buffer, m) {
|
|
|
- if (buffer['beginsWithBond']) {
|
|
|
- /** @type {ParserOutput[]} */
|
|
|
- var ret = [];
|
|
|
- mhchemParser.concatArray(ret, this['output'](buffer));
|
|
|
- mhchemParser.concatArray(ret, mhchemParser.actions['bond'](buffer, m, "-"));
|
|
|
- return ret;
|
|
|
- } else {
|
|
|
- buffer.d = m;
|
|
|
- }
|
|
|
- },
|
|
|
- '- after o/d': function afterOD(buffer, m, isAfterD) {
|
|
|
- var c1 = mhchemParser.patterns.match_('orbital', buffer.o || "");
|
|
|
- var c2 = mhchemParser.patterns.match_('one lowercase greek letter $', buffer.o || "");
|
|
|
- var c3 = mhchemParser.patterns.match_('one lowercase latin letter $', buffer.o || "");
|
|
|
- var c4 = mhchemParser.patterns.match_('$one lowercase latin letter$ $', buffer.o || "");
|
|
|
- var hyphenFollows = m === "-" && (c1 && c1.remainder === "" || c2 || c3 || c4);
|
|
|
-
|
|
|
- if (hyphenFollows && !buffer.a && !buffer.b && !buffer.p && !buffer.d && !buffer.q && !c1 && c3) {
|
|
|
- buffer.o = '$' + buffer.o + '$';
|
|
|
- }
|
|
|
- /** @type {ParserOutput[]} */
|
|
|
-
|
|
|
-
|
|
|
- var ret = [];
|
|
|
-
|
|
|
- if (hyphenFollows) {
|
|
|
- mhchemParser.concatArray(ret, this['output'](buffer));
|
|
|
- ret.push({
|
|
|
- type_: 'hyphen'
|
|
|
- });
|
|
|
- } else {
|
|
|
- c1 = mhchemParser.patterns.match_('digits', buffer.d || "");
|
|
|
-
|
|
|
- if (isAfterD && c1 && c1.remainder === '') {
|
|
|
- mhchemParser.concatArray(ret, mhchemParser.actions['d='](buffer, m));
|
|
|
- mhchemParser.concatArray(ret, this['output'](buffer));
|
|
|
- } else {
|
|
|
- mhchemParser.concatArray(ret, this['output'](buffer));
|
|
|
- mhchemParser.concatArray(ret, mhchemParser.actions['bond'](buffer, m, "-"));
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- return ret;
|
|
|
- },
|
|
|
- 'a to o': function aToO(buffer) {
|
|
|
- buffer.o = buffer.a;
|
|
|
- buffer.a = undefined;
|
|
|
- },
|
|
|
- 'sb=true': function sbTrue(buffer) {
|
|
|
- buffer.sb = true;
|
|
|
- },
|
|
|
- 'sb=false': function sbFalse(buffer) {
|
|
|
- buffer.sb = false;
|
|
|
- },
|
|
|
- 'beginsWithBond=true': function beginsWithBondTrue(buffer) {
|
|
|
- buffer['beginsWithBond'] = true;
|
|
|
- },
|
|
|
- 'beginsWithBond=false': function beginsWithBondFalse(buffer) {
|
|
|
- buffer['beginsWithBond'] = false;
|
|
|
- },
|
|
|
- 'parenthesisLevel++': function parenthesisLevel(buffer) {
|
|
|
- buffer['parenthesisLevel']++;
|
|
|
- },
|
|
|
- 'parenthesisLevel--': function parenthesisLevel(buffer) {
|
|
|
- buffer['parenthesisLevel']--;
|
|
|
- },
|
|
|
- 'state of aggregation': function stateOfAggregation(buffer, m) {
|
|
|
- return {
|
|
|
- type_: 'state of aggregation',
|
|
|
- p1: mhchemParser.go(m, 'o')
|
|
|
- };
|
|
|
- },
|
|
|
- 'comma': function comma(buffer, m) {
|
|
|
- var a = m.replace(/\s*$/, '');
|
|
|
- var withSpace = a !== m;
|
|
|
-
|
|
|
- if (withSpace && buffer['parenthesisLevel'] === 0) {
|
|
|
- return {
|
|
|
- type_: 'comma enumeration L',
|
|
|
- p1: a
|
|
|
- };
|
|
|
- } else {
|
|
|
- return {
|
|
|
- type_: 'comma enumeration M',
|
|
|
- p1: a
|
|
|
- };
|
|
|
- }
|
|
|
- },
|
|
|
- 'output': function output(buffer, m, entityFollows) {
|
|
|
- // entityFollows:
|
|
|
- // undefined = if we have nothing else to output, also ignore the just read space (buffer.sb)
|
|
|
- // 1 = an entity follows, never omit the space if there was one just read before (can only apply to state 1)
|
|
|
- // 2 = 1 + the entity can have an amount, so output a\, instead of converting it to o (can only apply to states a|as)
|
|
|
-
|
|
|
- /** @type {ParserOutput | ParserOutput[]} */
|
|
|
- var ret;
|
|
|
-
|
|
|
- if (!buffer.r) {
|
|
|
- ret = [];
|
|
|
-
|
|
|
- if (!buffer.a && !buffer.b && !buffer.p && !buffer.o && !buffer.q && !buffer.d && !entityFollows) {//ret = [];
|
|
|
- } else {
|
|
|
- if (buffer.sb) {
|
|
|
- ret.push({
|
|
|
- type_: 'entitySkip'
|
|
|
- });
|
|
|
- }
|
|
|
-
|
|
|
- if (!buffer.o && !buffer.q && !buffer.d && !buffer.b && !buffer.p && entityFollows !== 2) {
|
|
|
- buffer.o = buffer.a;
|
|
|
- buffer.a = undefined;
|
|
|
- } else if (!buffer.o && !buffer.q && !buffer.d && (buffer.b || buffer.p)) {
|
|
|
- buffer.o = buffer.a;
|
|
|
- buffer.d = buffer.b;
|
|
|
- buffer.q = buffer.p;
|
|
|
- buffer.a = buffer.b = buffer.p = undefined;
|
|
|
- } else {
|
|
|
- if (buffer.o && buffer.dType === 'kv' && mhchemParser.patterns.match_('d-oxidation$', buffer.d || "")) {
|
|
|
- buffer.dType = 'oxidation';
|
|
|
- } else if (buffer.o && buffer.dType === 'kv' && !buffer.q) {
|
|
|
- buffer.dType = undefined;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- ret.push({
|
|
|
- type_: 'chemfive',
|
|
|
- a: mhchemParser.go(buffer.a, 'a'),
|
|
|
- b: mhchemParser.go(buffer.b, 'bd'),
|
|
|
- p: mhchemParser.go(buffer.p, 'pq'),
|
|
|
- o: mhchemParser.go(buffer.o, 'o'),
|
|
|
- q: mhchemParser.go(buffer.q, 'pq'),
|
|
|
- d: mhchemParser.go(buffer.d, buffer.dType === 'oxidation' ? 'oxidation' : 'bd'),
|
|
|
- dType: buffer.dType
|
|
|
- });
|
|
|
- }
|
|
|
- } else {
|
|
|
- // r
|
|
|
-
|
|
|
- /** @type {ParserOutput[]} */
|
|
|
- var rd;
|
|
|
-
|
|
|
- if (buffer.rdt === 'M') {
|
|
|
- rd = mhchemParser.go(buffer.rd, 'tex-math');
|
|
|
- } else if (buffer.rdt === 'T') {
|
|
|
- rd = [{
|
|
|
- type_: 'text',
|
|
|
- p1: buffer.rd || ""
|
|
|
- }];
|
|
|
- } else {
|
|
|
- rd = mhchemParser.go(buffer.rd);
|
|
|
- }
|
|
|
- /** @type {ParserOutput[]} */
|
|
|
-
|
|
|
-
|
|
|
- var rq;
|
|
|
-
|
|
|
- if (buffer.rqt === 'M') {
|
|
|
- rq = mhchemParser.go(buffer.rq, 'tex-math');
|
|
|
- } else if (buffer.rqt === 'T') {
|
|
|
- rq = [{
|
|
|
- type_: 'text',
|
|
|
- p1: buffer.rq || ""
|
|
|
- }];
|
|
|
- } else {
|
|
|
- rq = mhchemParser.go(buffer.rq);
|
|
|
- }
|
|
|
-
|
|
|
- ret = {
|
|
|
- type_: 'arrow',
|
|
|
- r: buffer.r,
|
|
|
- rd: rd,
|
|
|
- rq: rq
|
|
|
- };
|
|
|
- }
|
|
|
-
|
|
|
- for (var p in buffer) {
|
|
|
- if (p !== 'parenthesisLevel' && p !== 'beginsWithBond') {
|
|
|
- delete buffer[p];
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- return ret;
|
|
|
- },
|
|
|
- 'oxidation-output': function oxidationOutput(buffer, m) {
|
|
|
- var ret = ["{"];
|
|
|
- mhchemParser.concatArray(ret, mhchemParser.go(m, 'oxidation'));
|
|
|
- ret.push("}");
|
|
|
- return ret;
|
|
|
- },
|
|
|
- 'frac-output': function fracOutput(buffer, m) {
|
|
|
- return {
|
|
|
- type_: 'frac-ce',
|
|
|
- p1: mhchemParser.go(m[0]),
|
|
|
- p2: mhchemParser.go(m[1])
|
|
|
- };
|
|
|
- },
|
|
|
- 'overset-output': function oversetOutput(buffer, m) {
|
|
|
- return {
|
|
|
- type_: 'overset',
|
|
|
- p1: mhchemParser.go(m[0]),
|
|
|
- p2: mhchemParser.go(m[1])
|
|
|
- };
|
|
|
- },
|
|
|
- 'underset-output': function undersetOutput(buffer, m) {
|
|
|
- return {
|
|
|
- type_: 'underset',
|
|
|
- p1: mhchemParser.go(m[0]),
|
|
|
- p2: mhchemParser.go(m[1])
|
|
|
- };
|
|
|
- },
|
|
|
- 'underbrace-output': function underbraceOutput(buffer, m) {
|
|
|
- return {
|
|
|
- type_: 'underbrace',
|
|
|
- p1: mhchemParser.go(m[0]),
|
|
|
- p2: mhchemParser.go(m[1])
|
|
|
- };
|
|
|
- },
|
|
|
- 'color-output': function colorOutput(buffer, m) {
|
|
|
- return {
|
|
|
- type_: 'color',
|
|
|
- color1: m[0],
|
|
|
- color2: mhchemParser.go(m[1])
|
|
|
- };
|
|
|
- },
|
|
|
- 'r=': function r(buffer, m) {
|
|
|
- buffer.r = m;
|
|
|
- },
|
|
|
- 'rdt=': function rdt(buffer, m) {
|
|
|
- buffer.rdt = m;
|
|
|
- },
|
|
|
- 'rd=': function rd(buffer, m) {
|
|
|
- buffer.rd = m;
|
|
|
- },
|
|
|
- 'rqt=': function rqt(buffer, m) {
|
|
|
- buffer.rqt = m;
|
|
|
- },
|
|
|
- 'rq=': function rq(buffer, m) {
|
|
|
- buffer.rq = m;
|
|
|
- },
|
|
|
- 'operator': function operator(buffer, m, p1) {
|
|
|
- return {
|
|
|
- type_: 'operator',
|
|
|
- kind_: p1 || m
|
|
|
- };
|
|
|
- }
|
|
|
- }
|
|
|
- },
|
|
|
- 'a': {
|
|
|
- transitions: mhchemParser.createTransitions({
|
|
|
- 'empty': {
|
|
|
- '*': {}
|
|
|
- },
|
|
|
- '1/2$': {
|
|
|
- '0': {
|
|
|
- action_: '1/2'
|
|
|
- }
|
|
|
- },
|
|
|
- 'else': {
|
|
|
- '0': {
|
|
|
- nextState: '1',
|
|
|
- revisit: true
|
|
|
- }
|
|
|
- },
|
|
|
- '$(...)$': {
|
|
|
- '*': {
|
|
|
- action_: 'tex-math tight',
|
|
|
- nextState: '1'
|
|
|
- }
|
|
|
- },
|
|
|
- ',': {
|
|
|
- '*': {
|
|
|
- action_: {
|
|
|
- type_: 'insert',
|
|
|
- option: 'commaDecimal'
|
|
|
- }
|
|
|
- }
|
|
|
- },
|
|
|
- 'else2': {
|
|
|
- '*': {
|
|
|
- action_: 'copy'
|
|
|
- }
|
|
|
- }
|
|
|
- }),
|
|
|
- actions: {}
|
|
|
- },
|
|
|
- 'o': {
|
|
|
- transitions: mhchemParser.createTransitions({
|
|
|
- 'empty': {
|
|
|
- '*': {}
|
|
|
- },
|
|
|
- '1/2$': {
|
|
|
- '0': {
|
|
|
- action_: '1/2'
|
|
|
- }
|
|
|
- },
|
|
|
- 'else': {
|
|
|
- '0': {
|
|
|
- nextState: '1',
|
|
|
- revisit: true
|
|
|
- }
|
|
|
- },
|
|
|
- 'letters': {
|
|
|
- '*': {
|
|
|
- action_: 'rm'
|
|
|
- }
|
|
|
- },
|
|
|
- '\\ca': {
|
|
|
- '*': {
|
|
|
- action_: {
|
|
|
- type_: 'insert',
|
|
|
- option: 'circa'
|
|
|
- }
|
|
|
- }
|
|
|
- },
|
|
|
- '\\x{}{}|\\x{}|\\x': {
|
|
|
- '*': {
|
|
|
- action_: 'copy'
|
|
|
- }
|
|
|
- },
|
|
|
- '${(...)}$|$(...)$': {
|
|
|
- '*': {
|
|
|
- action_: 'tex-math'
|
|
|
- }
|
|
|
- },
|
|
|
- '{(...)}': {
|
|
|
- '*': {
|
|
|
- action_: '{text}'
|
|
|
- }
|
|
|
- },
|
|
|
- 'else2': {
|
|
|
- '*': {
|
|
|
- action_: 'copy'
|
|
|
- }
|
|
|
- }
|
|
|
- }),
|
|
|
- actions: {}
|
|
|
- },
|
|
|
- 'text': {
|
|
|
- transitions: mhchemParser.createTransitions({
|
|
|
- 'empty': {
|
|
|
- '*': {
|
|
|
- action_: 'output'
|
|
|
- }
|
|
|
- },
|
|
|
- '{...}': {
|
|
|
- '*': {
|
|
|
- action_: 'text='
|
|
|
- }
|
|
|
- },
|
|
|
- '${(...)}$|$(...)$': {
|
|
|
- '*': {
|
|
|
- action_: 'tex-math'
|
|
|
- }
|
|
|
- },
|
|
|
- '\\greek': {
|
|
|
- '*': {
|
|
|
- action_: ['output', 'rm']
|
|
|
- }
|
|
|
- },
|
|
|
- '\\,|\\x{}{}|\\x{}|\\x': {
|
|
|
- '*': {
|
|
|
- action_: ['output', 'copy']
|
|
|
- }
|
|
|
- },
|
|
|
- 'else': {
|
|
|
- '*': {
|
|
|
- action_: 'text='
|
|
|
- }
|
|
|
- }
|
|
|
- }),
|
|
|
- actions: {
|
|
|
- 'output': function output(buffer) {
|
|
|
- if (buffer.text_) {
|
|
|
- /** @type {ParserOutput} */
|
|
|
- var ret = {
|
|
|
- type_: 'text',
|
|
|
- p1: buffer.text_
|
|
|
- };
|
|
|
-
|
|
|
- for (var p in buffer) {
|
|
|
- delete buffer[p];
|
|
|
- }
|
|
|
-
|
|
|
- return ret;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- },
|
|
|
- 'pq': {
|
|
|
- transitions: mhchemParser.createTransitions({
|
|
|
- 'empty': {
|
|
|
- '*': {}
|
|
|
- },
|
|
|
- 'state of aggregation $': {
|
|
|
- '*': {
|
|
|
- action_: 'state of aggregation'
|
|
|
- }
|
|
|
- },
|
|
|
- 'i$': {
|
|
|
- '0': {
|
|
|
- nextState: '!f',
|
|
|
- revisit: true
|
|
|
- }
|
|
|
- },
|
|
|
- '(KV letters),': {
|
|
|
- '0': {
|
|
|
- action_: 'rm',
|
|
|
- nextState: '0'
|
|
|
- }
|
|
|
- },
|
|
|
- 'formula$': {
|
|
|
- '0': {
|
|
|
- nextState: 'f',
|
|
|
- revisit: true
|
|
|
- }
|
|
|
- },
|
|
|
- '1/2$': {
|
|
|
- '0': {
|
|
|
- action_: '1/2'
|
|
|
- }
|
|
|
- },
|
|
|
- 'else': {
|
|
|
- '0': {
|
|
|
- nextState: '!f',
|
|
|
- revisit: true
|
|
|
- }
|
|
|
- },
|
|
|
- '${(...)}$|$(...)$': {
|
|
|
- '*': {
|
|
|
- action_: 'tex-math'
|
|
|
- }
|
|
|
- },
|
|
|
- '{(...)}': {
|
|
|
- '*': {
|
|
|
- action_: 'text'
|
|
|
- }
|
|
|
- },
|
|
|
- 'a-z': {
|
|
|
- 'f': {
|
|
|
- action_: 'tex-math'
|
|
|
- }
|
|
|
- },
|
|
|
- 'letters': {
|
|
|
- '*': {
|
|
|
- action_: 'rm'
|
|
|
- }
|
|
|
- },
|
|
|
- '-9.,9': {
|
|
|
- '*': {
|
|
|
- action_: '9,9'
|
|
|
- }
|
|
|
- },
|
|
|
- ',': {
|
|
|
- '*': {
|
|
|
- action_: {
|
|
|
- type_: 'insert+p1',
|
|
|
- option: 'comma enumeration S'
|
|
|
- }
|
|
|
- }
|
|
|
- },
|
|
|
- '\\color{(...)}{(...)}1|\\color(...){(...)}2': {
|
|
|
- '*': {
|
|
|
- action_: 'color-output'
|
|
|
- }
|
|
|
- },
|
|
|
- '\\color{(...)}0': {
|
|
|
- '*': {
|
|
|
- action_: 'color0-output'
|
|
|
- }
|
|
|
- },
|
|
|
- '\\ce{(...)}': {
|
|
|
- '*': {
|
|
|
- action_: 'ce'
|
|
|
- }
|
|
|
- },
|
|
|
- '\\,|\\x{}{}|\\x{}|\\x': {
|
|
|
- '*': {
|
|
|
- action_: 'copy'
|
|
|
- }
|
|
|
- },
|
|
|
- 'else2': {
|
|
|
- '*': {
|
|
|
- action_: 'copy'
|
|
|
- }
|
|
|
- }
|
|
|
- }),
|
|
|
- actions: {
|
|
|
- 'state of aggregation': function stateOfAggregation(buffer, m) {
|
|
|
- return {
|
|
|
- type_: 'state of aggregation subscript',
|
|
|
- p1: mhchemParser.go(m, 'o')
|
|
|
- };
|
|
|
- },
|
|
|
- 'color-output': function colorOutput(buffer, m) {
|
|
|
- return {
|
|
|
- type_: 'color',
|
|
|
- color1: m[0],
|
|
|
- color2: mhchemParser.go(m[1], 'pq')
|
|
|
- };
|
|
|
- }
|
|
|
- }
|
|
|
- },
|
|
|
- 'bd': {
|
|
|
- transitions: mhchemParser.createTransitions({
|
|
|
- 'empty': {
|
|
|
- '*': {}
|
|
|
- },
|
|
|
- 'x$': {
|
|
|
- '0': {
|
|
|
- nextState: '!f',
|
|
|
- revisit: true
|
|
|
- }
|
|
|
- },
|
|
|
- 'formula$': {
|
|
|
- '0': {
|
|
|
- nextState: 'f',
|
|
|
- revisit: true
|
|
|
- }
|
|
|
- },
|
|
|
- 'else': {
|
|
|
- '0': {
|
|
|
- nextState: '!f',
|
|
|
- revisit: true
|
|
|
- }
|
|
|
- },
|
|
|
- '-9.,9 no missing 0': {
|
|
|
- '*': {
|
|
|
- action_: '9,9'
|
|
|
- }
|
|
|
- },
|
|
|
- '.': {
|
|
|
- '*': {
|
|
|
- action_: {
|
|
|
- type_: 'insert',
|
|
|
- option: 'electron dot'
|
|
|
- }
|
|
|
- }
|
|
|
- },
|
|
|
- 'a-z': {
|
|
|
- 'f': {
|
|
|
- action_: 'tex-math'
|
|
|
- }
|
|
|
- },
|
|
|
- 'x': {
|
|
|
- '*': {
|
|
|
- action_: {
|
|
|
- type_: 'insert',
|
|
|
- option: 'KV x'
|
|
|
- }
|
|
|
- }
|
|
|
- },
|
|
|
- 'letters': {
|
|
|
- '*': {
|
|
|
- action_: 'rm'
|
|
|
- }
|
|
|
- },
|
|
|
- '\'': {
|
|
|
- '*': {
|
|
|
- action_: {
|
|
|
- type_: 'insert',
|
|
|
- option: 'prime'
|
|
|
- }
|
|
|
- }
|
|
|
- },
|
|
|
- '${(...)}$|$(...)$': {
|
|
|
- '*': {
|
|
|
- action_: 'tex-math'
|
|
|
- }
|
|
|
- },
|
|
|
- '{(...)}': {
|
|
|
- '*': {
|
|
|
- action_: 'text'
|
|
|
- }
|
|
|
- },
|
|
|
- '\\color{(...)}{(...)}1|\\color(...){(...)}2': {
|
|
|
- '*': {
|
|
|
- action_: 'color-output'
|
|
|
- }
|
|
|
- },
|
|
|
- '\\color{(...)}0': {
|
|
|
- '*': {
|
|
|
- action_: 'color0-output'
|
|
|
- }
|
|
|
- },
|
|
|
- '\\ce{(...)}': {
|
|
|
- '*': {
|
|
|
- action_: 'ce'
|
|
|
- }
|
|
|
- },
|
|
|
- '\\,|\\x{}{}|\\x{}|\\x': {
|
|
|
- '*': {
|
|
|
- action_: 'copy'
|
|
|
- }
|
|
|
- },
|
|
|
- 'else2': {
|
|
|
- '*': {
|
|
|
- action_: 'copy'
|
|
|
- }
|
|
|
- }
|
|
|
- }),
|
|
|
- actions: {
|
|
|
- 'color-output': function colorOutput(buffer, m) {
|
|
|
- return {
|
|
|
- type_: 'color',
|
|
|
- color1: m[0],
|
|
|
- color2: mhchemParser.go(m[1], 'bd')
|
|
|
- };
|
|
|
- }
|
|
|
- }
|
|
|
- },
|
|
|
- 'oxidation': {
|
|
|
- transitions: mhchemParser.createTransitions({
|
|
|
- 'empty': {
|
|
|
- '*': {}
|
|
|
- },
|
|
|
- 'roman numeral': {
|
|
|
- '*': {
|
|
|
- action_: 'roman-numeral'
|
|
|
- }
|
|
|
- },
|
|
|
- '${(...)}$|$(...)$': {
|
|
|
- '*': {
|
|
|
- action_: 'tex-math'
|
|
|
- }
|
|
|
- },
|
|
|
- 'else': {
|
|
|
- '*': {
|
|
|
- action_: 'copy'
|
|
|
- }
|
|
|
- }
|
|
|
- }),
|
|
|
- actions: {
|
|
|
- 'roman-numeral': function romanNumeral(buffer, m) {
|
|
|
- return {
|
|
|
- type_: 'roman numeral',
|
|
|
- p1: m || ""
|
|
|
- };
|
|
|
- }
|
|
|
- }
|
|
|
- },
|
|
|
- 'tex-math': {
|
|
|
- transitions: mhchemParser.createTransitions({
|
|
|
- 'empty': {
|
|
|
- '*': {
|
|
|
- action_: 'output'
|
|
|
- }
|
|
|
- },
|
|
|
- '\\ce{(...)}': {
|
|
|
- '*': {
|
|
|
- action_: ['output', 'ce']
|
|
|
- }
|
|
|
- },
|
|
|
- '{...}|\\,|\\x{}{}|\\x{}|\\x': {
|
|
|
- '*': {
|
|
|
- action_: 'o='
|
|
|
- }
|
|
|
- },
|
|
|
- 'else': {
|
|
|
- '*': {
|
|
|
- action_: 'o='
|
|
|
- }
|
|
|
- }
|
|
|
- }),
|
|
|
- actions: {
|
|
|
- 'output': function output(buffer) {
|
|
|
- if (buffer.o) {
|
|
|
- /** @type {ParserOutput} */
|
|
|
- var ret = {
|
|
|
- type_: 'tex-math',
|
|
|
- p1: buffer.o
|
|
|
- };
|
|
|
-
|
|
|
- for (var p in buffer) {
|
|
|
- delete buffer[p];
|
|
|
- }
|
|
|
-
|
|
|
- return ret;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- },
|
|
|
- 'tex-math tight': {
|
|
|
- transitions: mhchemParser.createTransitions({
|
|
|
- 'empty': {
|
|
|
- '*': {
|
|
|
- action_: 'output'
|
|
|
- }
|
|
|
- },
|
|
|
- '\\ce{(...)}': {
|
|
|
- '*': {
|
|
|
- action_: ['output', 'ce']
|
|
|
- }
|
|
|
- },
|
|
|
- '{...}|\\,|\\x{}{}|\\x{}|\\x': {
|
|
|
- '*': {
|
|
|
- action_: 'o='
|
|
|
- }
|
|
|
- },
|
|
|
- '-|+': {
|
|
|
- '*': {
|
|
|
- action_: 'tight operator'
|
|
|
- }
|
|
|
- },
|
|
|
- 'else': {
|
|
|
- '*': {
|
|
|
- action_: 'o='
|
|
|
- }
|
|
|
- }
|
|
|
- }),
|
|
|
- actions: {
|
|
|
- 'tight operator': function tightOperator(buffer, m) {
|
|
|
- buffer.o = (buffer.o || "") + "{" + m + "}";
|
|
|
- },
|
|
|
- 'output': function output(buffer) {
|
|
|
- if (buffer.o) {
|
|
|
- /** @type {ParserOutput} */
|
|
|
- var ret = {
|
|
|
- type_: 'tex-math',
|
|
|
- p1: buffer.o
|
|
|
- };
|
|
|
-
|
|
|
- for (var p in buffer) {
|
|
|
- delete buffer[p];
|
|
|
- }
|
|
|
-
|
|
|
- return ret;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- },
|
|
|
- '9,9': {
|
|
|
- transitions: mhchemParser.createTransitions({
|
|
|
- 'empty': {
|
|
|
- '*': {}
|
|
|
- },
|
|
|
- ',': {
|
|
|
- '*': {
|
|
|
- action_: 'comma'
|
|
|
- }
|
|
|
- },
|
|
|
- 'else': {
|
|
|
- '*': {
|
|
|
- action_: 'copy'
|
|
|
- }
|
|
|
- }
|
|
|
- }),
|
|
|
- actions: {
|
|
|
- 'comma': function comma() {
|
|
|
- return {
|
|
|
- type_: 'commaDecimal'
|
|
|
- };
|
|
|
- }
|
|
|
- }
|
|
|
- },
|
|
|
- //#endregion
|
|
|
- //
|
|
|
- // \pu state machines
|
|
|
- //
|
|
|
- //#region pu
|
|
|
- 'pu': {
|
|
|
- transitions: mhchemParser.createTransitions({
|
|
|
- 'empty': {
|
|
|
- '*': {
|
|
|
- action_: 'output'
|
|
|
- }
|
|
|
- },
|
|
|
- 'space$': {
|
|
|
- '*': {
|
|
|
- action_: ['output', 'space']
|
|
|
- }
|
|
|
- },
|
|
|
- '{[(|)]}': {
|
|
|
- '0|a': {
|
|
|
- action_: 'copy'
|
|
|
- }
|
|
|
- },
|
|
|
- '(-)(9)^(-9)': {
|
|
|
- '0': {
|
|
|
- action_: 'number^',
|
|
|
- nextState: 'a'
|
|
|
- }
|
|
|
- },
|
|
|
- '(-)(9.,9)(e)(99)': {
|
|
|
- '0': {
|
|
|
- action_: 'enumber',
|
|
|
- nextState: 'a'
|
|
|
- }
|
|
|
- },
|
|
|
- 'space': {
|
|
|
- '0|a': {}
|
|
|
- },
|
|
|
- 'pm-operator': {
|
|
|
- '0|a': {
|
|
|
- action_: {
|
|
|
- type_: 'operator',
|
|
|
- option: '\\pm'
|
|
|
- },
|
|
|
- nextState: '0'
|
|
|
- }
|
|
|
- },
|
|
|
- 'operator': {
|
|
|
- '0|a': {
|
|
|
- action_: 'copy',
|
|
|
- nextState: '0'
|
|
|
- }
|
|
|
- },
|
|
|
- '//': {
|
|
|
- 'd': {
|
|
|
- action_: 'o=',
|
|
|
- nextState: '/'
|
|
|
- }
|
|
|
- },
|
|
|
- '/': {
|
|
|
- 'd': {
|
|
|
- action_: 'o=',
|
|
|
- nextState: '/'
|
|
|
- }
|
|
|
- },
|
|
|
- '{...}|else': {
|
|
|
- '0|d': {
|
|
|
- action_: 'd=',
|
|
|
- nextState: 'd'
|
|
|
- },
|
|
|
- 'a': {
|
|
|
- action_: ['space', 'd='],
|
|
|
- nextState: 'd'
|
|
|
- },
|
|
|
- '/|q': {
|
|
|
- action_: 'q=',
|
|
|
- nextState: 'q'
|
|
|
- }
|
|
|
- }
|
|
|
- }),
|
|
|
- actions: {
|
|
|
- 'enumber': function enumber(buffer, m) {
|
|
|
- /** @type {ParserOutput[]} */
|
|
|
- var ret = [];
|
|
|
-
|
|
|
- if (m[0] === "+-" || m[0] === "+/-") {
|
|
|
- ret.push("\\pm ");
|
|
|
- } else if (m[0]) {
|
|
|
- ret.push(m[0]);
|
|
|
- }
|
|
|
-
|
|
|
- if (m[1]) {
|
|
|
- mhchemParser.concatArray(ret, mhchemParser.go(m[1], 'pu-9,9'));
|
|
|
-
|
|
|
- if (m[2]) {
|
|
|
- if (m[2].match(/[,.]/)) {
|
|
|
- mhchemParser.concatArray(ret, mhchemParser.go(m[2], 'pu-9,9'));
|
|
|
- } else {
|
|
|
- ret.push(m[2]);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- m[3] = m[4] || m[3];
|
|
|
-
|
|
|
- if (m[3]) {
|
|
|
- m[3] = m[3].trim();
|
|
|
-
|
|
|
- if (m[3] === "e" || m[3].substr(0, 1) === "*") {
|
|
|
- ret.push({
|
|
|
- type_: 'cdot'
|
|
|
- });
|
|
|
- } else {
|
|
|
- ret.push({
|
|
|
- type_: 'times'
|
|
|
- });
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if (m[3]) {
|
|
|
- ret.push("10^{" + m[5] + "}");
|
|
|
- }
|
|
|
-
|
|
|
- return ret;
|
|
|
- },
|
|
|
- 'number^': function number(buffer, m) {
|
|
|
- /** @type {ParserOutput[]} */
|
|
|
- var ret = [];
|
|
|
-
|
|
|
- if (m[0] === "+-" || m[0] === "+/-") {
|
|
|
- ret.push("\\pm ");
|
|
|
- } else if (m[0]) {
|
|
|
- ret.push(m[0]);
|
|
|
- }
|
|
|
-
|
|
|
- mhchemParser.concatArray(ret, mhchemParser.go(m[1], 'pu-9,9'));
|
|
|
- ret.push("^{" + m[2] + "}");
|
|
|
- return ret;
|
|
|
- },
|
|
|
- 'operator': function operator(buffer, m, p1) {
|
|
|
- return {
|
|
|
- type_: 'operator',
|
|
|
- kind_: p1 || m
|
|
|
- };
|
|
|
- },
|
|
|
- 'space': function space() {
|
|
|
- return {
|
|
|
- type_: 'pu-space-1'
|
|
|
- };
|
|
|
- },
|
|
|
- 'output': function output(buffer) {
|
|
|
- /** @type {ParserOutput | ParserOutput[]} */
|
|
|
- var ret;
|
|
|
- var md = mhchemParser.patterns.match_('{(...)}', buffer.d || "");
|
|
|
-
|
|
|
- if (md && md.remainder === '') {
|
|
|
- buffer.d = md.match_;
|
|
|
- }
|
|
|
-
|
|
|
- var mq = mhchemParser.patterns.match_('{(...)}', buffer.q || "");
|
|
|
-
|
|
|
- if (mq && mq.remainder === '') {
|
|
|
- buffer.q = mq.match_;
|
|
|
- }
|
|
|
-
|
|
|
- if (buffer.d) {
|
|
|
- buffer.d = buffer.d.replace(/\u00B0C|\^oC|\^{o}C/g, "{}^{\\circ}C");
|
|
|
- buffer.d = buffer.d.replace(/\u00B0F|\^oF|\^{o}F/g, "{}^{\\circ}F");
|
|
|
- }
|
|
|
-
|
|
|
- if (buffer.q) {
|
|
|
- // fraction
|
|
|
- buffer.q = buffer.q.replace(/\u00B0C|\^oC|\^{o}C/g, "{}^{\\circ}C");
|
|
|
- buffer.q = buffer.q.replace(/\u00B0F|\^oF|\^{o}F/g, "{}^{\\circ}F");
|
|
|
- var b5 = {
|
|
|
- d: mhchemParser.go(buffer.d, 'pu'),
|
|
|
- q: mhchemParser.go(buffer.q, 'pu')
|
|
|
- };
|
|
|
-
|
|
|
- if (buffer.o === '//') {
|
|
|
- ret = {
|
|
|
- type_: 'pu-frac',
|
|
|
- p1: b5.d,
|
|
|
- p2: b5.q
|
|
|
- };
|
|
|
- } else {
|
|
|
- ret = b5.d;
|
|
|
-
|
|
|
- if (b5.d.length > 1 || b5.q.length > 1) {
|
|
|
- ret.push({
|
|
|
- type_: ' / '
|
|
|
- });
|
|
|
- } else {
|
|
|
- ret.push({
|
|
|
- type_: '/'
|
|
|
- });
|
|
|
- }
|
|
|
-
|
|
|
- mhchemParser.concatArray(ret, b5.q);
|
|
|
- }
|
|
|
- } else {
|
|
|
- // no fraction
|
|
|
- ret = mhchemParser.go(buffer.d, 'pu-2');
|
|
|
- }
|
|
|
-
|
|
|
- for (var p in buffer) {
|
|
|
- delete buffer[p];
|
|
|
- }
|
|
|
-
|
|
|
- return ret;
|
|
|
- }
|
|
|
- }
|
|
|
- },
|
|
|
- 'pu-2': {
|
|
|
- transitions: mhchemParser.createTransitions({
|
|
|
- 'empty': {
|
|
|
- '*': {
|
|
|
- action_: 'output'
|
|
|
- }
|
|
|
- },
|
|
|
- '*': {
|
|
|
- '*': {
|
|
|
- action_: ['output', 'cdot'],
|
|
|
- nextState: '0'
|
|
|
- }
|
|
|
- },
|
|
|
- '\\x': {
|
|
|
- '*': {
|
|
|
- action_: 'rm='
|
|
|
- }
|
|
|
- },
|
|
|
- 'space': {
|
|
|
- '*': {
|
|
|
- action_: ['output', 'space'],
|
|
|
- nextState: '0'
|
|
|
- }
|
|
|
- },
|
|
|
- '^{(...)}|^(-1)': {
|
|
|
- '1': {
|
|
|
- action_: '^(-1)'
|
|
|
- }
|
|
|
- },
|
|
|
- '-9.,9': {
|
|
|
- '0': {
|
|
|
- action_: 'rm=',
|
|
|
- nextState: '0'
|
|
|
- },
|
|
|
- '1': {
|
|
|
- action_: '^(-1)',
|
|
|
- nextState: '0'
|
|
|
- }
|
|
|
- },
|
|
|
- '{...}|else': {
|
|
|
- '*': {
|
|
|
- action_: 'rm=',
|
|
|
- nextState: '1'
|
|
|
- }
|
|
|
- }
|
|
|
- }),
|
|
|
- actions: {
|
|
|
- 'cdot': function cdot() {
|
|
|
- return {
|
|
|
- type_: 'tight cdot'
|
|
|
- };
|
|
|
- },
|
|
|
- '^(-1)': function _(buffer, m) {
|
|
|
- buffer.rm += "^{" + m + "}";
|
|
|
- },
|
|
|
- 'space': function space() {
|
|
|
- return {
|
|
|
- type_: 'pu-space-2'
|
|
|
- };
|
|
|
- },
|
|
|
- 'output': function output(buffer) {
|
|
|
- /** @type {ParserOutput | ParserOutput[]} */
|
|
|
- var ret = [];
|
|
|
-
|
|
|
- if (buffer.rm) {
|
|
|
- var mrm = mhchemParser.patterns.match_('{(...)}', buffer.rm || "");
|
|
|
-
|
|
|
- if (mrm && mrm.remainder === '') {
|
|
|
- ret = mhchemParser.go(mrm.match_, 'pu');
|
|
|
- } else {
|
|
|
- ret = {
|
|
|
- type_: 'rm',
|
|
|
- p1: buffer.rm
|
|
|
- };
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- for (var p in buffer) {
|
|
|
- delete buffer[p];
|
|
|
- }
|
|
|
-
|
|
|
- return ret;
|
|
|
- }
|
|
|
- }
|
|
|
- },
|
|
|
- 'pu-9,9': {
|
|
|
- transitions: mhchemParser.createTransitions({
|
|
|
- 'empty': {
|
|
|
- '0': {
|
|
|
- action_: 'output-0'
|
|
|
- },
|
|
|
- 'o': {
|
|
|
- action_: 'output-o'
|
|
|
- }
|
|
|
- },
|
|
|
- ',': {
|
|
|
- '0': {
|
|
|
- action_: ['output-0', 'comma'],
|
|
|
- nextState: 'o'
|
|
|
- }
|
|
|
- },
|
|
|
- '.': {
|
|
|
- '0': {
|
|
|
- action_: ['output-0', 'copy'],
|
|
|
- nextState: 'o'
|
|
|
- }
|
|
|
- },
|
|
|
- 'else': {
|
|
|
- '*': {
|
|
|
- action_: 'text='
|
|
|
- }
|
|
|
- }
|
|
|
- }),
|
|
|
- actions: {
|
|
|
- 'comma': function comma() {
|
|
|
- return {
|
|
|
- type_: 'commaDecimal'
|
|
|
- };
|
|
|
- },
|
|
|
- 'output-0': function output0(buffer) {
|
|
|
- /** @type {ParserOutput[]} */
|
|
|
- var ret = [];
|
|
|
- buffer.text_ = buffer.text_ || "";
|
|
|
-
|
|
|
- if (buffer.text_.length > 4) {
|
|
|
- var a = buffer.text_.length % 3;
|
|
|
-
|
|
|
- if (a === 0) {
|
|
|
- a = 3;
|
|
|
- }
|
|
|
-
|
|
|
- for (var i = buffer.text_.length - 3; i > 0; i -= 3) {
|
|
|
- ret.push(buffer.text_.substr(i, 3));
|
|
|
- ret.push({
|
|
|
- type_: '1000 separator'
|
|
|
- });
|
|
|
- }
|
|
|
-
|
|
|
- ret.push(buffer.text_.substr(0, a));
|
|
|
- ret.reverse();
|
|
|
- } else {
|
|
|
- ret.push(buffer.text_);
|
|
|
- }
|
|
|
-
|
|
|
- for (var p in buffer) {
|
|
|
- delete buffer[p];
|
|
|
- }
|
|
|
-
|
|
|
- return ret;
|
|
|
- },
|
|
|
- 'output-o': function outputO(buffer) {
|
|
|
- /** @type {ParserOutput[]} */
|
|
|
- var ret = [];
|
|
|
- buffer.text_ = buffer.text_ || "";
|
|
|
-
|
|
|
- if (buffer.text_.length > 4) {
|
|
|
- var a = buffer.text_.length - 3;
|
|
|
-
|
|
|
- for (var i = 0; i < a; i += 3) {
|
|
|
- ret.push(buffer.text_.substr(i, 3));
|
|
|
- ret.push({
|
|
|
- type_: '1000 separator'
|
|
|
- });
|
|
|
- }
|
|
|
-
|
|
|
- ret.push(buffer.text_.substr(i));
|
|
|
- } else {
|
|
|
- ret.push(buffer.text_);
|
|
|
- }
|
|
|
-
|
|
|
- for (var p in buffer) {
|
|
|
- delete buffer[p];
|
|
|
- }
|
|
|
-
|
|
|
- return ret;
|
|
|
- }
|
|
|
- }
|
|
|
- } //#endregion
|
|
|
-
|
|
|
-}; //
|
|
|
-// texify: Take MhchemParser output and convert it to TeX
|
|
|
-//
|
|
|
-
|
|
|
-/** @type {Texify} */
|
|
|
-
|
|
|
-var texify = {
|
|
|
- go: function go(input, isInner) {
|
|
|
- // (recursive, max 4 levels)
|
|
|
- if (!input) {
|
|
|
- return "";
|
|
|
- }
|
|
|
-
|
|
|
- var res = "";
|
|
|
- var cee = false;
|
|
|
-
|
|
|
- for (var i = 0; i < input.length; i++) {
|
|
|
- var inputi = input[i];
|
|
|
-
|
|
|
- if (typeof inputi === "string") {
|
|
|
- res += inputi;
|
|
|
- } else {
|
|
|
- res += texify._go2(inputi);
|
|
|
-
|
|
|
- if (inputi.type_ === '1st-level escape') {
|
|
|
- cee = true;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if (!isInner && !cee && res) {
|
|
|
- res = "{" + res + "}";
|
|
|
- }
|
|
|
-
|
|
|
- return res;
|
|
|
- },
|
|
|
- _goInner: function _goInner(input) {
|
|
|
- if (!input) {
|
|
|
- return input;
|
|
|
- }
|
|
|
-
|
|
|
- return texify.go(input, true);
|
|
|
- },
|
|
|
- _go2: function _go2(buf) {
|
|
|
- /** @type {undefined | string} */
|
|
|
- var res;
|
|
|
-
|
|
|
- switch (buf.type_) {
|
|
|
- case 'chemfive':
|
|
|
- res = "";
|
|
|
- var b5 = {
|
|
|
- a: texify._goInner(buf.a),
|
|
|
- b: texify._goInner(buf.b),
|
|
|
- p: texify._goInner(buf.p),
|
|
|
- o: texify._goInner(buf.o),
|
|
|
- q: texify._goInner(buf.q),
|
|
|
- d: texify._goInner(buf.d)
|
|
|
- }; //
|
|
|
- // a
|
|
|
- //
|
|
|
-
|
|
|
- if (b5.a) {
|
|
|
- if (b5.a.match(/^[+\-]/)) {
|
|
|
- b5.a = "{" + b5.a + "}";
|
|
|
- }
|
|
|
-
|
|
|
- res += b5.a + "\\,";
|
|
|
- } //
|
|
|
- // b and p
|
|
|
- //
|
|
|
-
|
|
|
-
|
|
|
- if (b5.b || b5.p) {
|
|
|
- res += "{\\vphantom{X}}";
|
|
|
- res += "^{\\hphantom{" + (b5.b || "") + "}}_{\\hphantom{" + (b5.p || "") + "}}";
|
|
|
- res += "{\\vphantom{X}}";
|
|
|
- res += "^{\\smash[t]{\\vphantom{2}}\\mathllap{" + (b5.b || "") + "}}";
|
|
|
- res += "_{\\vphantom{2}\\mathllap{\\smash[t]{" + (b5.p || "") + "}}}";
|
|
|
- } //
|
|
|
- // o
|
|
|
- //
|
|
|
-
|
|
|
-
|
|
|
- if (b5.o) {
|
|
|
- if (b5.o.match(/^[+\-]/)) {
|
|
|
- b5.o = "{" + b5.o + "}";
|
|
|
- }
|
|
|
-
|
|
|
- res += b5.o;
|
|
|
- } //
|
|
|
- // q and d
|
|
|
- //
|
|
|
-
|
|
|
-
|
|
|
- if (buf.dType === 'kv') {
|
|
|
- if (b5.d || b5.q) {
|
|
|
- res += "{\\vphantom{X}}";
|
|
|
- }
|
|
|
-
|
|
|
- if (b5.d) {
|
|
|
- res += "^{" + b5.d + "}";
|
|
|
- }
|
|
|
-
|
|
|
- if (b5.q) {
|
|
|
- res += "_{\\smash[t]{" + b5.q + "}}";
|
|
|
- }
|
|
|
- } else if (buf.dType === 'oxidation') {
|
|
|
- if (b5.d) {
|
|
|
- res += "{\\vphantom{X}}";
|
|
|
- res += "^{" + b5.d + "}";
|
|
|
- }
|
|
|
-
|
|
|
- if (b5.q) {
|
|
|
- res += "{\\vphantom{X}}";
|
|
|
- res += "_{\\smash[t]{" + b5.q + "}}";
|
|
|
- }
|
|
|
- } else {
|
|
|
- if (b5.q) {
|
|
|
- res += "{\\vphantom{X}}";
|
|
|
- res += "_{\\smash[t]{" + b5.q + "}}";
|
|
|
- }
|
|
|
-
|
|
|
- if (b5.d) {
|
|
|
- res += "{\\vphantom{X}}";
|
|
|
- res += "^{" + b5.d + "}";
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- break;
|
|
|
-
|
|
|
- case 'rm':
|
|
|
- res = "\\mathrm{" + buf.p1 + "}";
|
|
|
- break;
|
|
|
-
|
|
|
- case 'text':
|
|
|
- if (buf.p1.match(/[\^_]/)) {
|
|
|
- buf.p1 = buf.p1.replace(" ", "~").replace("-", "\\text{-}");
|
|
|
- res = "\\mathrm{" + buf.p1 + "}";
|
|
|
- } else {
|
|
|
- res = "\\text{" + buf.p1 + "}";
|
|
|
- }
|
|
|
-
|
|
|
- break;
|
|
|
-
|
|
|
- case 'roman numeral':
|
|
|
- res = "\\mathrm{" + buf.p1 + "}";
|
|
|
- break;
|
|
|
-
|
|
|
- case 'state of aggregation':
|
|
|
- res = "\\mskip2mu " + texify._goInner(buf.p1);
|
|
|
- break;
|
|
|
-
|
|
|
- case 'state of aggregation subscript':
|
|
|
- res = "\\mskip1mu " + texify._goInner(buf.p1);
|
|
|
- break;
|
|
|
-
|
|
|
- case 'bond':
|
|
|
- res = texify._getBond(buf.kind_);
|
|
|
-
|
|
|
- if (!res) {
|
|
|
- throw ["MhchemErrorBond", "mhchem Error. Unknown bond type (" + buf.kind_ + ")"];
|
|
|
- }
|
|
|
-
|
|
|
- break;
|
|
|
-
|
|
|
- case 'frac':
|
|
|
- var c = "\\frac{" + buf.p1 + "}{" + buf.p2 + "}";
|
|
|
- res = "\\mathchoice{\\textstyle" + c + "}{" + c + "}{" + c + "}{" + c + "}";
|
|
|
- break;
|
|
|
-
|
|
|
- case 'pu-frac':
|
|
|
- var d = "\\frac{" + texify._goInner(buf.p1) + "}{" + texify._goInner(buf.p2) + "}";
|
|
|
- res = "\\mathchoice{\\textstyle" + d + "}{" + d + "}{" + d + "}{" + d + "}";
|
|
|
- break;
|
|
|
-
|
|
|
- case 'tex-math':
|
|
|
- res = buf.p1 + " ";
|
|
|
- break;
|
|
|
-
|
|
|
- case 'frac-ce':
|
|
|
- res = "\\frac{" + texify._goInner(buf.p1) + "}{" + texify._goInner(buf.p2) + "}";
|
|
|
- break;
|
|
|
-
|
|
|
- case 'overset':
|
|
|
- res = "\\overset{" + texify._goInner(buf.p1) + "}{" + texify._goInner(buf.p2) + "}";
|
|
|
- break;
|
|
|
-
|
|
|
- case 'underset':
|
|
|
- res = "\\underset{" + texify._goInner(buf.p1) + "}{" + texify._goInner(buf.p2) + "}";
|
|
|
- break;
|
|
|
-
|
|
|
- case 'underbrace':
|
|
|
- res = "\\underbrace{" + texify._goInner(buf.p1) + "}_{" + texify._goInner(buf.p2) + "}";
|
|
|
- break;
|
|
|
-
|
|
|
- case 'color':
|
|
|
- res = "{\\color{" + buf.color1 + "}{" + texify._goInner(buf.color2) + "}}";
|
|
|
- break;
|
|
|
-
|
|
|
- case 'color0':
|
|
|
- res = "\\color{" + buf.color + "}";
|
|
|
- break;
|
|
|
-
|
|
|
- case 'arrow':
|
|
|
- var b6 = {
|
|
|
- rd: texify._goInner(buf.rd),
|
|
|
- rq: texify._goInner(buf.rq)
|
|
|
- };
|
|
|
-
|
|
|
- var arrow = "\\x" + texify._getArrow(buf.r);
|
|
|
-
|
|
|
- if (b6.rq) {
|
|
|
- arrow += "[{" + b6.rq + "}]";
|
|
|
- }
|
|
|
-
|
|
|
- if (b6.rd) {
|
|
|
- arrow += "{" + b6.rd + "}";
|
|
|
- } else {
|
|
|
- arrow += "{}";
|
|
|
- }
|
|
|
-
|
|
|
- res = arrow;
|
|
|
- break;
|
|
|
-
|
|
|
- case 'operator':
|
|
|
- res = texify._getOperator(buf.kind_);
|
|
|
- break;
|
|
|
-
|
|
|
- case '1st-level escape':
|
|
|
- res = buf.p1 + " "; // &, \\\\, \\hlin
|
|
|
-
|
|
|
- break;
|
|
|
-
|
|
|
- case 'space':
|
|
|
- res = " ";
|
|
|
- break;
|
|
|
-
|
|
|
- case 'entitySkip':
|
|
|
- res = "~";
|
|
|
- break;
|
|
|
-
|
|
|
- case 'pu-space-1':
|
|
|
- res = "~";
|
|
|
- break;
|
|
|
-
|
|
|
- case 'pu-space-2':
|
|
|
- res = "\\mkern3mu ";
|
|
|
- break;
|
|
|
-
|
|
|
- case '1000 separator':
|
|
|
- res = "\\mkern2mu ";
|
|
|
- break;
|
|
|
-
|
|
|
- case 'commaDecimal':
|
|
|
- res = "{,}";
|
|
|
- break;
|
|
|
-
|
|
|
- case 'comma enumeration L':
|
|
|
- res = "{" + buf.p1 + "}\\mkern6mu ";
|
|
|
- break;
|
|
|
-
|
|
|
- case 'comma enumeration M':
|
|
|
- res = "{" + buf.p1 + "}\\mkern3mu ";
|
|
|
- break;
|
|
|
-
|
|
|
- case 'comma enumeration S':
|
|
|
- res = "{" + buf.p1 + "}\\mkern1mu ";
|
|
|
- break;
|
|
|
-
|
|
|
- case 'hyphen':
|
|
|
- res = "\\text{-}";
|
|
|
- break;
|
|
|
-
|
|
|
- case 'addition compound':
|
|
|
- res = "\\,{\\cdot}\\,";
|
|
|
- break;
|
|
|
-
|
|
|
- case 'electron dot':
|
|
|
- res = "\\mkern1mu \\bullet\\mkern1mu ";
|
|
|
- break;
|
|
|
-
|
|
|
- case 'KV x':
|
|
|
- res = "{\\times}";
|
|
|
- break;
|
|
|
-
|
|
|
- case 'prime':
|
|
|
- res = "\\prime ";
|
|
|
- break;
|
|
|
-
|
|
|
- case 'cdot':
|
|
|
- res = "\\cdot ";
|
|
|
- break;
|
|
|
-
|
|
|
- case 'tight cdot':
|
|
|
- res = "\\mkern1mu{\\cdot}\\mkern1mu ";
|
|
|
- break;
|
|
|
-
|
|
|
- case 'times':
|
|
|
- res = "\\times ";
|
|
|
- break;
|
|
|
-
|
|
|
- case 'circa':
|
|
|
- res = "{\\sim}";
|
|
|
- break;
|
|
|
-
|
|
|
- case '^':
|
|
|
- res = "uparrow";
|
|
|
- break;
|
|
|
-
|
|
|
- case 'v':
|
|
|
- res = "downarrow";
|
|
|
- break;
|
|
|
-
|
|
|
- case 'ellipsis':
|
|
|
- res = "\\ldots ";
|
|
|
- break;
|
|
|
-
|
|
|
- case '/':
|
|
|
- res = "/";
|
|
|
- break;
|
|
|
-
|
|
|
- case ' / ':
|
|
|
- res = "\\,/\\,";
|
|
|
- break;
|
|
|
-
|
|
|
- default:
|
|
|
- assertNever(buf);
|
|
|
- throw ["MhchemBugT", "mhchem bug T. Please report."];
|
|
|
- // Missing texify rule or unknown MhchemParser output
|
|
|
- }
|
|
|
-
|
|
|
- assertString(res);
|
|
|
- return res;
|
|
|
- },
|
|
|
- _getArrow: function _getArrow(a) {
|
|
|
- switch (a) {
|
|
|
- case "->":
|
|
|
- return "rightarrow";
|
|
|
-
|
|
|
- case "\u2192":
|
|
|
- return "rightarrow";
|
|
|
-
|
|
|
- case "\u27F6":
|
|
|
- return "rightarrow";
|
|
|
-
|
|
|
- case "<-":
|
|
|
- return "leftarrow";
|
|
|
-
|
|
|
- case "<->":
|
|
|
- return "leftrightarrow";
|
|
|
-
|
|
|
- case "<-->":
|
|
|
- return "rightleftarrows";
|
|
|
-
|
|
|
- case "<=>":
|
|
|
- return "rightleftharpoons";
|
|
|
-
|
|
|
- case "\u21CC":
|
|
|
- return "rightleftharpoons";
|
|
|
-
|
|
|
- case "<=>>":
|
|
|
- return "rightequilibrium";
|
|
|
-
|
|
|
- case "<<=>":
|
|
|
- return "leftequilibrium";
|
|
|
-
|
|
|
- default:
|
|
|
- assertNever(a);
|
|
|
- throw ["MhchemBugT", "mhchem bug T. Please report."];
|
|
|
- }
|
|
|
- },
|
|
|
- _getBond: function _getBond(a) {
|
|
|
- switch (a) {
|
|
|
- case "-":
|
|
|
- return "{-}";
|
|
|
-
|
|
|
- case "1":
|
|
|
- return "{-}";
|
|
|
-
|
|
|
- case "=":
|
|
|
- return "{=}";
|
|
|
-
|
|
|
- case "2":
|
|
|
- return "{=}";
|
|
|
-
|
|
|
- case "#":
|
|
|
- return "{\\equiv}";
|
|
|
-
|
|
|
- case "3":
|
|
|
- return "{\\equiv}";
|
|
|
-
|
|
|
- case "~":
|
|
|
- return "{\\tripledash}";
|
|
|
-
|
|
|
- case "~-":
|
|
|
- return "{\\mathrlap{\\raisebox{-.1em}{$-$}}\\raisebox{.1em}{$\\tripledash$}}";
|
|
|
-
|
|
|
- case "~=":
|
|
|
- return "{\\mathrlap{\\raisebox{-.2em}{$-$}}\\mathrlap{\\raisebox{.2em}{$\\tripledash$}}-}";
|
|
|
-
|
|
|
- case "~--":
|
|
|
- return "{\\mathrlap{\\raisebox{-.2em}{$-$}}\\mathrlap{\\raisebox{.2em}{$\\tripledash$}}-}";
|
|
|
-
|
|
|
- case "-~-":
|
|
|
- return "{\\mathrlap{\\raisebox{-.2em}{$-$}}\\mathrlap{\\raisebox{.2em}{$-$}}\\tripledash}";
|
|
|
-
|
|
|
- case "...":
|
|
|
- return "{{\\cdot}{\\cdot}{\\cdot}}";
|
|
|
-
|
|
|
- case "....":
|
|
|
- return "{{\\cdot}{\\cdot}{\\cdot}{\\cdot}}";
|
|
|
-
|
|
|
- case "->":
|
|
|
- return "{\\rightarrow}";
|
|
|
-
|
|
|
- case "<-":
|
|
|
- return "{\\leftarrow}";
|
|
|
-
|
|
|
- case "<":
|
|
|
- return "{<}";
|
|
|
-
|
|
|
- case ">":
|
|
|
- return "{>}";
|
|
|
-
|
|
|
- default:
|
|
|
- assertNever(a);
|
|
|
- throw ["MhchemBugT", "mhchem bug T. Please report."];
|
|
|
- }
|
|
|
- },
|
|
|
- _getOperator: function _getOperator(a) {
|
|
|
- switch (a) {
|
|
|
- case "+":
|
|
|
- return " {}+{} ";
|
|
|
-
|
|
|
- case "-":
|
|
|
- return " {}-{} ";
|
|
|
-
|
|
|
- case "=":
|
|
|
- return " {}={} ";
|
|
|
-
|
|
|
- case "<":
|
|
|
- return " {}<{} ";
|
|
|
-
|
|
|
- case ">":
|
|
|
- return " {}>{} ";
|
|
|
-
|
|
|
- case "<<":
|
|
|
- return " {}\\ll{} ";
|
|
|
-
|
|
|
- case ">>":
|
|
|
- return " {}\\gg{} ";
|
|
|
-
|
|
|
- case "\\pm":
|
|
|
- return " {}\\pm{} ";
|
|
|
-
|
|
|
- case "\\approx":
|
|
|
- return " {}\\approx{} ";
|
|
|
-
|
|
|
- case "$\\approx$":
|
|
|
- return " {}\\approx{} ";
|
|
|
-
|
|
|
- case "v":
|
|
|
- return " \\downarrow{} ";
|
|
|
-
|
|
|
- case "(v)":
|
|
|
- return " \\downarrow{} ";
|
|
|
-
|
|
|
- case "^":
|
|
|
- return " \\uparrow{} ";
|
|
|
-
|
|
|
- case "(^)":
|
|
|
- return " \\uparrow{} ";
|
|
|
-
|
|
|
- default:
|
|
|
- assertNever(a);
|
|
|
- throw ["MhchemBugT", "mhchem bug T. Please report."];
|
|
|
- }
|
|
|
- }
|
|
|
-}; //
|
|
|
-// Helpers for code anaylsis
|
|
|
-// Will show type error at calling position
|
|
|
-//
|
|
|
-
|
|
|
-/** @param {number} a */
|
|
|
-
|
|
|
-function assertNever(a) {}
|
|
|
-/** @param {string} a */
|
|
|
-
|
|
|
-
|
|
|
-function assertString(a) {}
|
|
|
-}();
|
|
|
-__webpack_exports__ = __webpack_exports__["default"];
|
|
|
-/******/ return __webpack_exports__;
|
|
|
-/******/ })()
|
|
|
-;
|
|
|
-});
|