3808 lines
88 KiB
JavaScript
3808 lines
88 KiB
JavaScript
(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__0__) {
|
|
return /******/ (function (modules) {
|
|
// webpackBootstrap
|
|
/******/ // The module cache
|
|
/******/ var installedModules = {};
|
|
/******/
|
|
/******/ // The require function
|
|
/******/ function __webpack_require__(moduleId) {
|
|
/******/
|
|
/******/ // Check if module is in cache
|
|
/******/ if (installedModules[moduleId]) {
|
|
/******/ return installedModules[moduleId].exports;
|
|
/******/
|
|
}
|
|
/******/ // Create a new module (and put it into the cache)
|
|
/******/ var module = (installedModules[moduleId] = {
|
|
/******/ i: moduleId,
|
|
/******/ l: false,
|
|
/******/ exports: {},
|
|
/******/
|
|
});
|
|
/******/
|
|
/******/ // Execute the module function
|
|
/******/ modules[moduleId].call(
|
|
module.exports,
|
|
module,
|
|
module.exports,
|
|
__webpack_require__,
|
|
);
|
|
/******/
|
|
/******/ // Flag the module as loaded
|
|
/******/ module.l = true;
|
|
/******/
|
|
/******/ // Return the exports of the module
|
|
/******/ return module.exports;
|
|
/******/
|
|
}
|
|
/******/
|
|
/******/
|
|
/******/ // expose the modules object (__webpack_modules__)
|
|
/******/ __webpack_require__.m = modules;
|
|
/******/
|
|
/******/ // expose the module cache
|
|
/******/ __webpack_require__.c = installedModules;
|
|
/******/
|
|
/******/ // define getter function for harmony exports
|
|
/******/ __webpack_require__.d = function (exports, name, getter) {
|
|
/******/ if (!__webpack_require__.o(exports, name)) {
|
|
/******/ Object.defineProperty(exports, name, {
|
|
enumerable: true,
|
|
get: getter,
|
|
});
|
|
/******/
|
|
}
|
|
/******/
|
|
};
|
|
/******/
|
|
/******/ // define __esModule on exports
|
|
/******/ __webpack_require__.r = function (exports) {
|
|
/******/ if (typeof Symbol !== "undefined" && Symbol.toStringTag) {
|
|
/******/ Object.defineProperty(exports, Symbol.toStringTag, {
|
|
value: "Module",
|
|
});
|
|
/******/
|
|
}
|
|
/******/ Object.defineProperty(exports, "__esModule", { value: true });
|
|
/******/
|
|
};
|
|
/******/
|
|
/******/ // create a fake namespace object
|
|
/******/ // mode & 1: value is a module id, require it
|
|
/******/ // mode & 2: merge all properties of value into the ns
|
|
/******/ // mode & 4: return value when already ns object
|
|
/******/ // mode & 8|1: behave like require
|
|
/******/ __webpack_require__.t = function (value, mode) {
|
|
/******/ if (mode & 1) value = __webpack_require__(value);
|
|
/******/ if (mode & 8) return value;
|
|
/******/ if (
|
|
mode & 4 &&
|
|
typeof value === "object" &&
|
|
value &&
|
|
value.__esModule
|
|
)
|
|
return value;
|
|
/******/ var ns = Object.create(null);
|
|
/******/ __webpack_require__.r(ns);
|
|
/******/ Object.defineProperty(ns, "default", {
|
|
enumerable: true,
|
|
value: value,
|
|
});
|
|
/******/ if (mode & 2 && typeof value != "string")
|
|
for (var key in value)
|
|
__webpack_require__.d(
|
|
ns,
|
|
key,
|
|
function (key) {
|
|
return value[key];
|
|
}.bind(null, key),
|
|
);
|
|
/******/ return ns;
|
|
/******/
|
|
};
|
|
/******/
|
|
/******/ // getDefaultExport function for compatibility with non-harmony modules
|
|
/******/ __webpack_require__.n = function (module) {
|
|
/******/ var getter =
|
|
module && module.__esModule
|
|
? /******/ function getDefault() {
|
|
return module["default"];
|
|
}
|
|
: /******/ function getModuleExports() {
|
|
return module;
|
|
};
|
|
/******/ __webpack_require__.d(getter, "a", getter);
|
|
/******/ return getter;
|
|
/******/
|
|
};
|
|
/******/
|
|
/******/ // Object.prototype.hasOwnProperty.call
|
|
/******/ __webpack_require__.o = function (object, property) {
|
|
return Object.prototype.hasOwnProperty.call(object, property);
|
|
};
|
|
/******/
|
|
/******/ // __webpack_public_path__
|
|
/******/ __webpack_require__.p = "";
|
|
/******/
|
|
/******/
|
|
/******/ // Load entry module and return exports
|
|
/******/ return __webpack_require__((__webpack_require__.s = 1));
|
|
/******/
|
|
})(
|
|
/************************************************************************/
|
|
/******/ [
|
|
/* 0 */
|
|
/***/ function (module, exports) {
|
|
module.exports = __WEBPACK_EXTERNAL_MODULE__0__;
|
|
|
|
/***/
|
|
},
|
|
/* 1 */
|
|
/***/ function (module, __webpack_exports__, __webpack_require__) {
|
|
"use strict";
|
|
__webpack_require__.r(__webpack_exports__);
|
|
/* harmony import */ var katex__WEBPACK_IMPORTED_MODULE_0__ =
|
|
__webpack_require__(0);
|
|
/* 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.a.__defineMacro(
|
|
"\\ce",
|
|
function (context) {
|
|
return chemParse(context.consumeArgs(1)[0], "ce");
|
|
},
|
|
);
|
|
|
|
katex__WEBPACK_IMPORTED_MODULE_0___default.a.__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.a.__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[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) {}
|
|
|
|
/***/
|
|
},
|
|
/******/
|
|
],
|
|
)["default"];
|
|
},
|
|
);
|