TnSb/contrast-hugo
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
ba427a30a7
contrast-hugo/static/katex/contrib/mhchem.js

3215 lines
78 KiB
JavaScript
Raw Normal View History

merge upstream
2021-02-28 15:34:43 -05:00
(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];
}
merge upstream
2021-03-11 15:55:04 -05:00
})((typeof self !== 'undefined' ? self : this), function(__WEBPACK_EXTERNAL_MODULE__974__) {
return /******/ (function() { // webpackBootstrap
/******/ "use strict";
/******/ var __webpack_modules__ = ({
/***/ 974:
/***/ (function(module) {
module.exports = __WEBPACK_EXTERNAL_MODULE__974__;
/***/ })
/******/ });
/************************************************************************/
merge upstream
2021-02-28 15:34:43 -05:00
/******/ // The module cache
merge upstream
2021-03-11 15:55:04 -05:00
/******/ var __webpack_module_cache__ = {};
/******/
merge upstream
2021-02-28 15:34:43 -05:00
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/ // Check if module is in cache
merge upstream
2021-03-11 15:55:04 -05:00
/******/ if(__webpack_module_cache__[moduleId]) {
/******/ return __webpack_module_cache__[moduleId].exports;
merge upstream
2021-02-28 15:34:43 -05:00
/******/ }
/******/ // Create a new module (and put it into the cache)
merge upstream
2021-03-11 15:55:04 -05:00
/******/ var module = __webpack_module_cache__[moduleId] = {
/******/ // no module.id needed
/******/ // no module.loaded needed
merge upstream
2021-02-28 15:34:43 -05:00
/******/ exports: {}
/******/ };
merge upstream
2021-03-11 15:55:04 -05:00
/******/
merge upstream
2021-02-28 15:34:43 -05:00
/******/ // Execute the module function
merge upstream
2021-03-11 15:55:04 -05:00
/******/ __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
/******/
merge upstream
2021-02-28 15:34:43 -05:00
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
merge upstream
2021-03-11 15:55:04 -05:00
/******/
merge upstream
2021-02-28 15:34:43 -05:00
/************************************************************************/
merge upstream
2021-03-11 15:55:04 -05:00
/******/ /* 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__(974);
merge upstream
2021-02-28 15:34:43 -05:00
/* 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.
merge upstream
2021-03-11 15:55:04 -05:00
katex__WEBPACK_IMPORTED_MODULE_0___default().__defineMacro("\\ce", function (context) {
merge upstream
2021-02-28 15:34:43 -05:00
return chemParse(context.consumeArgs(1)[0], "ce");
});
merge upstream
2021-03-11 15:55:04 -05:00
katex__WEBPACK_IMPORTED_MODULE_0___default().__defineMacro("\\pu", function (context) {
merge upstream
2021-02-28 15:34:43 -05:00
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.
merge upstream
2021-03-11 15:55:04 -05:00
katex__WEBPACK_IMPORTED_MODULE_0___default().__defineMacro("\\tripledash", "{\\vphantom{-}\\raisebox{2.56mu}{$\\mkern2mu" + "\\tiny\\text{-}\\mkern1mu\\text{-}\\mkern1mu\\text{-}\\mkern2mu$}}");
merge upstream
2021-02-28 15:34:43 -05:00
//
// 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[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;
}
merge upstream
2021-03-11 15:55:04 -05:00
}
} //#endregion
merge upstream
2021-02-28 15:34:43 -05:00
}; //
// 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) {}
merge upstream
2021-03-11 15:55:04 -05:00
}();
__webpack_exports__ = __webpack_exports__.default;
/******/ return __webpack_exports__;
/******/ })()
;
merge upstream
2021-02-28 15:34:43 -05:00
});
Reference in New Issue Copy Permalink