You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3109 lines
74 KiB
3109 lines
74 KiB
import katex from '../katex.mjs'; |
|
|
|
/* 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.__defineMacro("\\ce", function (context) { |
|
return chemParse(context.consumeArgs(1)[0], "ce"); |
|
}); |
|
|
|
katex.__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.__defineMacro("\\tripledash", "{\\vphantom{-}\\raisebox{2.56mu}{$\\mkern2mu" + "\\tiny\\text{-}\\mkern1mu\\text{-}\\mkern1mu\\text{-}\\mkern2mu$}}"); |
|
// This is the main function for handing the \ce and \pu commands. |
|
// It takes the argument to \ce or \pu and returns the corresponding TeX string. |
|
// |
|
|
|
var chemParse = function chemParse(tokens, stateMachine) { |
|
// Recreate the argument string from KaTeX's array of tokens. |
|
var str = ""; |
|
var expectedLoc = tokens.length && tokens[tokens.length - 1].loc.start; |
|
|
|
for (var i = tokens.length - 1; i >= 0; i--) { |
|
if (tokens[i].loc.start > expectedLoc) { |
|
// context.consumeArgs has eaten a space. |
|
str += " "; |
|
expectedLoc = tokens[i].loc.start; |
|
} |
|
|
|
str += tokens[i].text; |
|
expectedLoc += tokens[i].text.length; |
|
} |
|
|
|
var tex = texify.go(mhchemParser.go(str, stateMachine)); |
|
return tex; |
|
}; // |
|
// Core parser for mhchem syntax (recursive) |
|
// |
|
|
|
/** @type {MhchemParser} */ |
|
|
|
|
|
var mhchemParser = { |
|
// |
|
// Parses mchem \ce syntax |
|
// |
|
// Call like |
|
// go("H2O"); |
|
// |
|
go: function go(input, stateMachine) { |
|
if (!input) { |
|
return []; |
|
} |
|
|
|
if (stateMachine === undefined) { |
|
stateMachine = 'ce'; |
|
} |
|
|
|
var state = '0'; // |
|
// String buffers for parsing: |
|
// |
|
// buffer.a == amount |
|
// buffer.o == element |
|
// buffer.b == left-side superscript |
|
// buffer.p == left-side subscript |
|
// buffer.q == right-side subscript |
|
// buffer.d == right-side superscript |
|
// |
|
// buffer.r == arrow |
|
// buffer.rdt == arrow, script above, type |
|
// buffer.rd == arrow, script above, content |
|
// buffer.rqt == arrow, script below, type |
|
// buffer.rq == arrow, script below, content |
|
// |
|
// buffer.text_ |
|
// buffer.rm |
|
// etc. |
|
// |
|
// buffer.parenthesisLevel == int, starting at 0 |
|
// buffer.sb == bool, space before |
|
// buffer.beginsWithBond == bool |
|
// |
|
// These letters are also used as state names. |
|
// |
|
// Other states: |
|
// 0 == begin of main part (arrow/operator unlikely) |
|
// 1 == next entity |
|
// 2 == next entity (arrow/operator unlikely) |
|
// 3 == next atom |
|
// c == macro |
|
// |
|
|
|
/** @type {Buffer} */ |
|
|
|
var buffer = {}; |
|
buffer['parenthesisLevel'] = 0; |
|
input = input.replace(/\n/g, " "); |
|
input = input.replace(/[\u2212\u2013\u2014\u2010]/g, "-"); |
|
input = input.replace(/[\u2026]/g, "..."); // |
|
// Looks through mhchemParser.transitions, to execute a matching action |
|
// (recursive) |
|
// |
|
|
|
var lastInput; |
|
var watchdog = 10; |
|
/** @type {ParserOutput[]} */ |
|
|
|
var output = []; |
|
|
|
while (true) { |
|
if (lastInput !== input) { |
|
watchdog = 10; |
|
lastInput = input; |
|
} else { |
|
watchdog--; |
|
} // |
|
// Find actions in transition table |
|
// |
|
|
|
|
|
var machine = mhchemParser.stateMachines[stateMachine]; |
|
var t = machine.transitions[state] || machine.transitions['*']; |
|
|
|
iterateTransitions: for (var i = 0; i < t.length; i++) { |
|
var matches = mhchemParser.patterns.match_(t[i].pattern, input); |
|
|
|
if (matches) { |
|
// |
|
// Execute actions |
|
// |
|
var task = t[i].task; |
|
|
|
for (var iA = 0; iA < task.action_.length; iA++) { |
|
var o; // |
|
// Find and execute action |
|
// |
|
|
|
if (machine.actions[task.action_[iA].type_]) { |
|
o = machine.actions[task.action_[iA].type_](buffer, matches.match_, task.action_[iA].option); |
|
} else if (mhchemParser.actions[task.action_[iA].type_]) { |
|
o = mhchemParser.actions[task.action_[iA].type_](buffer, matches.match_, task.action_[iA].option); |
|
} else { |
|
throw ["MhchemBugA", "mhchem bug A. Please report. (" + task.action_[iA].type_ + ")"]; // Trying to use non-existing action |
|
} // |
|
// Add output |
|
// |
|
|
|
|
|
mhchemParser.concatArray(output, o); |
|
} // |
|
// Set next state, |
|
// Shorten input, |
|
// Continue with next character |
|
// (= apply only one transition per position) |
|
// |
|
|
|
|
|
state = task.nextState || state; |
|
|
|
if (input.length > 0) { |
|
if (!task.revisit) { |
|
input = matches.remainder; |
|
} |
|
|
|
if (!task.toContinue) { |
|
break iterateTransitions; |
|
} |
|
} else { |
|
return output; |
|
} |
|
} |
|
} // |
|
// Prevent infinite loop |
|
// |
|
|
|
|
|
if (watchdog <= 0) { |
|
throw ["MhchemBugU", "mhchem bug U. Please report."]; // Unexpected character |
|
} |
|
} |
|
}, |
|
concatArray: function concatArray(a, b) { |
|
if (b) { |
|
if (Array.isArray(b)) { |
|
for (var iB = 0; iB < b.length; iB++) { |
|
a.push(b[iB]); |
|
} |
|
} else { |
|
a.push(b); |
|
} |
|
} |
|
}, |
|
patterns: { |
|
// |
|
// Matching patterns |
|
// either regexps or function that return null or {match_:"a", remainder:"bc"} |
|
// |
|
patterns: { |
|
// property names must not look like integers ("2") for correct property traversal order, later on |
|
'empty': /^$/, |
|
'else': /^./, |
|
'else2': /^./, |
|
'space': /^\s/, |
|
'space A': /^\s(?=[A-Z\\$])/, |
|
'space$': /^\s$/, |
|
'a-z': /^[a-z]/, |
|
'x': /^x/, |
|
'x$': /^x$/, |
|
'i$': /^i$/, |
|
'letters': /^(?:[a-zA-Z\u03B1-\u03C9\u0391-\u03A9?@]|(?:\\(?:alpha|beta|gamma|delta|epsilon|zeta|eta|theta|iota|kappa|lambda|mu|nu|xi|omicron|pi|rho|sigma|tau|upsilon|phi|chi|psi|omega|Gamma|Delta|Theta|Lambda|Xi|Pi|Sigma|Upsilon|Phi|Psi|Omega)(?:\s+|\{\}|(?![a-zA-Z]))))+/, |
|
'\\greek': /^\\(?:alpha|beta|gamma|delta|epsilon|zeta|eta|theta|iota|kappa|lambda|mu|nu|xi|omicron|pi|rho|sigma|tau|upsilon|phi|chi|psi|omega|Gamma|Delta|Theta|Lambda|Xi|Pi|Sigma|Upsilon|Phi|Psi|Omega)(?:\s+|\{\}|(?![a-zA-Z]))/, |
|
'one lowercase latin letter $': /^(?:([a-z])(?:$|[^a-zA-Z]))$/, |
|
'$one lowercase latin letter$ $': /^\$(?:([a-z])(?:$|[^a-zA-Z]))\$$/, |
|
'one lowercase greek letter $': /^(?:\$?[\u03B1-\u03C9]\$?|\$?\\(?:alpha|beta|gamma|delta|epsilon|zeta|eta|theta|iota|kappa|lambda|mu|nu|xi|omicron|pi|rho|sigma|tau|upsilon|phi|chi|psi|omega)\s*\$?)(?:\s+|\{\}|(?![a-zA-Z]))$/, |
|
'digits': /^[0-9]+/, |
|
'-9.,9': /^[+\-]?(?:[0-9]+(?:[,.][0-9]+)?|[0-9]*(?:\.[0-9]+))/, |
|
'-9.,9 no missing 0': /^[+\-]?[0-9]+(?:[.,][0-9]+)?/, |
|
'(-)(9.,9)(e)(99)': function e99(input) { |
|
var m = input.match(/^(\+\-|\+\/\-|\+|\-|\\pm\s?)?([0-9]+(?:[,.][0-9]+)?|[0-9]*(?:\.[0-9]+))?(\((?:[0-9]+(?:[,.][0-9]+)?|[0-9]*(?:\.[0-9]+))\))?(?:([eE]|\s*(\*|x|\\times|\u00D7)\s*10\^)([+\-]?[0-9]+|\{[+\-]?[0-9]+\}))?/); |
|
|
|
if (m && m[0]) { |
|
return { |
|
match_: m.splice(1), |
|
remainder: input.substr(m[0].length) |
|
}; |
|
} |
|
|
|
return null; |
|
}, |
|
'(-)(9)^(-9)': function _(input) { |
|
var m = input.match(/^(\+\-|\+\/\-|\+|\-|\\pm\s?)?([0-9]+(?:[,.][0-9]+)?|[0-9]*(?:\.[0-9]+)?)\^([+\-]?[0-9]+|\{[+\-]?[0-9]+\})/); |
|
|
|
if (m && m[0]) { |
|
return { |
|
match_: m.splice(1), |
|
remainder: input.substr(m[0].length) |
|
}; |
|
} |
|
|
|
return null; |
|
}, |
|
'state of aggregation $': function stateOfAggregation$(input) { |
|
// ... or crystal system |
|
var a = mhchemParser.patterns.findObserveGroups(input, "", /^\([a-z]{1,3}(?=[\),])/, ")", ""); // (aq), (aq,$\infty$), (aq, sat) |
|
|
|
if (a && a.remainder.match(/^($|[\s,;\)\]\}])/)) { |
|
return a; |
|
} // AND end of 'phrase' |
|
|
|
|
|
var m = input.match(/^(?:\((?:\\ca\s?)?\$[amothc]\$\))/); // OR crystal system ($o$) (\ca$c$) |
|
|
|
if (m) { |
|
return { |
|
match_: m[0], |
|
remainder: input.substr(m[0].length) |
|
}; |
|
} |
|
|
|
return null; |
|
}, |
|
'_{(state of aggregation)}$': /^_\{(\([a-z]{1,3}\))\}/, |
|
'{[(': /^(?:\\\{|\[|\()/, |
|
')]}': /^(?:\)|\]|\\\})/, |
|
', ': /^[,;]\s*/, |
|
',': /^[,;]/, |
|
'.': /^[.]/, |
|
'. ': /^([.\u22C5\u00B7\u2022])\s*/, |
|
'...': /^\.\.\.(?=$|[^.])/, |
|
'* ': /^([*])\s*/, |
|
'^{(...)}': function _(input) { |
|
return mhchemParser.patterns.findObserveGroups(input, "^{", "", "", "}"); |
|
}, |
|
'^($...$)': function $$(input) { |
|
return mhchemParser.patterns.findObserveGroups(input, "^", "$", "$", ""); |
|
}, |
|
'^a': /^\^([0-9]+|[^\\_])/, |
|
'^\\x{}{}': function x(input) { |
|
return mhchemParser.patterns.findObserveGroups(input, "^", /^\\[a-zA-Z]+\{/, "}", "", "", "{", "}", "", true); |
|
}, |
|
'^\\x{}': function x(input) { |
|
return mhchemParser.patterns.findObserveGroups(input, "^", /^\\[a-zA-Z]+\{/, "}", ""); |
|
}, |
|
'^\\x': /^\^(\\[a-zA-Z]+)\s*/, |
|
'^(-1)': /^\^(-?\d+)/, |
|
'\'': /^'/, |
|
'_{(...)}': function _(input) { |
|
return mhchemParser.patterns.findObserveGroups(input, "_{", "", "", "}"); |
|
}, |
|
'_($...$)': function _$$(input) { |
|
return mhchemParser.patterns.findObserveGroups(input, "_", "$", "$", ""); |
|
}, |
|
'_9': /^_([+\-]?[0-9]+|[^\\])/, |
|
'_\\x{}{}': function _X(input) { |
|
return mhchemParser.patterns.findObserveGroups(input, "_", /^\\[a-zA-Z]+\{/, "}", "", "", "{", "}", "", true); |
|
}, |
|
'_\\x{}': function _X(input) { |
|
return mhchemParser.patterns.findObserveGroups(input, "_", /^\\[a-zA-Z]+\{/, "}", ""); |
|
}, |
|
'_\\x': /^_(\\[a-zA-Z]+)\s*/, |
|
'^_': /^(?:\^(?=_)|\_(?=\^)|[\^_]$)/, |
|
'{}': /^\{\}/, |
|
'{...}': function _(input) { |
|
return mhchemParser.patterns.findObserveGroups(input, "", "{", "}", ""); |
|
}, |
|
'{(...)}': function _(input) { |
|
return mhchemParser.patterns.findObserveGroups(input, "{", "", "", "}"); |
|
}, |
|
'$...$': function $$(input) { |
|
return mhchemParser.patterns.findObserveGroups(input, "", "$", "$", ""); |
|
}, |
|
'${(...)}$': function $$(input) { |
|
return mhchemParser.patterns.findObserveGroups(input, "${", "", "", "}$"); |
|
}, |
|
'$(...)$': function $$(input) { |
|
return mhchemParser.patterns.findObserveGroups(input, "$", "", "", "$"); |
|
}, |
|
'=<>': /^[=<>]/, |
|
'#': /^[#\u2261]/, |
|
'+': /^\+/, |
|
'-$': /^-(?=[\s_},;\]/]|$|\([a-z]+\))/, |
|
// -space -, -; -] -/ -$ -state-of-aggregation |
|
'-9': /^-(?=[0-9])/, |
|
'- orbital overlap': /^-(?=(?:[spd]|sp)(?:$|[\s,;\)\]\}]))/, |
|
'-': /^-/, |
|
'pm-operator': /^(?:\\pm|\$\\pm\$|\+-|\+\/-)/, |
|
'operator': /^(?:\+|(?:[\-=<>]|<<|>>|\\approx|\$\\approx\$)(?=\s|$|-?[0-9]))/, |
|
'arrowUpDown': /^(?:v|\(v\)|\^|\(\^\))(?=$|[\s,;\)\]\}])/, |
|
'\\bond{(...)}': function bond(input) { |
|
return mhchemParser.patterns.findObserveGroups(input, "\\bond{", "", "", "}"); |
|
}, |
|
'->': /^(?:<->|<-->|->|<-|<=>>|<<=>|<=>|[\u2192\u27F6\u21CC])/, |
|
'CMT': /^[CMT](?=\[)/, |
|
'[(...)]': function _(input) { |
|
return mhchemParser.patterns.findObserveGroups(input, "[", "", "", "]"); |
|
}, |
|
'1st-level escape': /^(&|\\\\|\\hline)\s*/, |
|
'\\,': /^(?:\\[,\ ;:])/, |
|
// \\x - but output no space before |
|
'\\x{}{}': function x(input) { |
|
return mhchemParser.patterns.findObserveGroups(input, "", /^\\[a-zA-Z]+\{/, "}", "", "", "{", "}", "", true); |
|
}, |
|
'\\x{}': function x(input) { |
|
return mhchemParser.patterns.findObserveGroups(input, "", /^\\[a-zA-Z]+\{/, "}", ""); |
|
}, |
|
'\\ca': /^\\ca(?:\s+|(?![a-zA-Z]))/, |
|
'\\x': /^(?:\\[a-zA-Z]+\s*|\\[_&{}%])/, |
|
'orbital': /^(?:[0-9]{1,2}[spdfgh]|[0-9]{0,2}sp)(?=$|[^a-zA-Z])/, |
|
// only those with numbers in front, because the others will be formatted correctly anyway |
|
'others': /^[\/~|]/, |
|
'\\frac{(...)}': function frac(input) { |
|
return mhchemParser.patterns.findObserveGroups(input, "\\frac{", "", "", "}", "{", "", "", "}"); |
|
}, |
|
'\\overset{(...)}': function overset(input) { |
|
return mhchemParser.patterns.findObserveGroups(input, "\\overset{", "", "", "}", "{", "", "", "}"); |
|
}, |
|
'\\underset{(...)}': function underset(input) { |
|
return mhchemParser.patterns.findObserveGroups(input, "\\underset{", "", "", "}", "{", "", "", "}"); |
|
}, |
|
'\\underbrace{(...)}': function underbrace(input) { |
|
return mhchemParser.patterns.findObserveGroups(input, "\\underbrace{", "", "", "}_", "{", "", "", "}"); |
|
}, |
|
'\\color{(...)}0': function color0(input) { |
|
return mhchemParser.patterns.findObserveGroups(input, "\\color{", "", "", "}"); |
|
}, |
|
'\\color{(...)}{(...)}1': function color1(input) { |
|
return mhchemParser.patterns.findObserveGroups(input, "\\color{", "", "", "}", "{", "", "", "}"); |
|
}, |
|
'\\color(...){(...)}2': function color2(input) { |
|
return mhchemParser.patterns.findObserveGroups(input, "\\color", "\\", "", /^(?=\{)/, "{", "", "", "}"); |
|
}, |
|
'\\ce{(...)}': function ce(input) { |
|
return mhchemParser.patterns.findObserveGroups(input, "\\ce{", "", "", "}"); |
|
}, |
|
'oxidation$': /^(?:[+-][IVX]+|\\pm\s*0|\$\\pm\$\s*0)$/, |
|
'd-oxidation$': /^(?:[+-]?\s?[IVX]+|\\pm\s*0|\$\\pm\$\s*0)$/, |
|
// 0 could be oxidation or charge |
|
'roman numeral': /^[IVX]+/, |
|
'1/2$': /^[+\-]?(?:[0-9]+|\$[a-z]\$|[a-z])\/[0-9]+(?:\$[a-z]\$|[a-z])?$/, |
|
'amount': function amount(input) { |
|
var match; // e.g. 2, 0.5, 1/2, -2, n/2, +; $a$ could be added later in parsing |
|
|
|
match = input.match(/^(?:(?:(?:\([+\-]?[0-9]+\/[0-9]+\)|[+\-]?(?:[0-9]+|\$[a-z]\$|[a-z])\/[0-9]+|[+\-]?[0-9]+[.,][0-9]+|[+\-]?\.[0-9]+|[+\-]?[0-9]+)(?:[a-z](?=\s*[A-Z]))?)|[+\-]?[a-z](?=\s*[A-Z])|\+(?!\s))/); |
|
|
|
if (match) { |
|
return { |
|
match_: match[0], |
|
remainder: input.substr(match[0].length) |
|
}; |
|
} |
|
|
|
var a = mhchemParser.patterns.findObserveGroups(input, "", "$", "$", ""); |
|
|
|
if (a) { |
|
// e.g. $2n-1$, $-$ |
|
match = a.match_.match(/^\$(?:\(?[+\-]?(?:[0-9]*[a-z]?[+\-])?[0-9]*[a-z](?:[+\-][0-9]*[a-z]?)?\)?|\+|-)\$$/); |
|
|
|
if (match) { |
|
return { |
|
match_: match[0], |
|
remainder: input.substr(match[0].length) |
|
}; |
|
} |
|
} |
|
|
|
return null; |
|
}, |
|
'amount2': function amount2(input) { |
|
return this['amount'](input); |
|
}, |
|
'(KV letters),': /^(?:[A-Z][a-z]{0,2}|i)(?=,)/, |
|
'formula$': function formula$(input) { |
|
if (input.match(/^\([a-z]+\)$/)) { |
|
return null; |
|
} // state of aggregation = no formula |
|
|
|
|
|
var match = input.match(/^(?:[a-z]|(?:[0-9\ \+\-\,\.\(\)]+[a-z])+[0-9\ \+\-\,\.\(\)]*|(?:[a-z][0-9\ \+\-\,\.\(\)]+)+[a-z]?)$/); |
|
|
|
if (match) { |
|
return { |
|
match_: match[0], |
|
remainder: input.substr(match[0].length) |
|
}; |
|
} |
|
|
|
return null; |
|
}, |
|
'uprightEntities': /^(?:pH|pOH|pC|pK|iPr|iBu)(?=$|[^a-zA-Z])/, |
|
'/': /^\s*(\/)\s*/, |
|
'//': /^\s*(\/\/)\s*/, |
|
'*': /^\s*[*.]\s*/ |
|
}, |
|
findObserveGroups: function findObserveGroups(input, begExcl, begIncl, endIncl, endExcl, beg2Excl, beg2Incl, end2Incl, end2Excl, combine) { |
|
/** @type {{(input: string, pattern: string | RegExp): string | string[] | null;}} */ |
|
var _match = function _match(input, pattern) { |
|
if (typeof pattern === "string") { |
|
if (input.indexOf(pattern) !== 0) { |
|
return null; |
|
} |
|
|
|
return pattern; |
|
} else { |
|
var match = input.match(pattern); |
|
|
|
if (!match) { |
|
return null; |
|
} |
|
|
|
return match[0]; |
|
} |
|
}; |
|
/** @type {{(input: string, i: number, endChars: string | RegExp): {endMatchBegin: number, endMatchEnd: number} | null;}} */ |
|
|
|
|
|
var _findObserveGroups = function _findObserveGroups(input, i, endChars) { |
|
var braces = 0; |
|
|
|
while (i < input.length) { |
|
var a = input.charAt(i); |
|
|
|
var match = _match(input.substr(i), endChars); |
|
|
|
if (match !== null && braces === 0) { |
|
return { |
|
endMatchBegin: i, |
|
endMatchEnd: i + match.length |
|
}; |
|
} else if (a === "{") { |
|
braces++; |
|
} else if (a === "}") { |
|
if (braces === 0) { |
|
throw ["ExtraCloseMissingOpen", "Extra close brace or missing open brace"]; |
|
} else { |
|
braces--; |
|
} |
|
} |
|
|
|
i++; |
|
} |
|
|
|
if (braces > 0) { |
|
return null; |
|
} |
|
|
|
return null; |
|
}; |
|
|
|
var match = _match(input, begExcl); |
|
|
|
if (match === null) { |
|
return null; |
|
} |
|
|
|
input = input.substr(match.length); |
|
match = _match(input, begIncl); |
|
|
|
if (match === null) { |
|
return null; |
|
} |
|
|
|
var e = _findObserveGroups(input, match.length, endIncl || endExcl); |
|
|
|
if (e === null) { |
|
return null; |
|
} |
|
|
|
var match1 = input.substring(0, endIncl ? e.endMatchEnd : e.endMatchBegin); |
|
|
|
if (!(beg2Excl || beg2Incl)) { |
|
return { |
|
match_: match1, |
|
remainder: input.substr(e.endMatchEnd) |
|
}; |
|
} else { |
|
var group2 = this.findObserveGroups(input.substr(e.endMatchEnd), beg2Excl, beg2Incl, end2Incl, end2Excl); |
|
|
|
if (group2 === null) { |
|
return null; |
|
} |
|
/** @type {string[]} */ |
|
|
|
|
|
var matchRet = [match1, group2.match_]; |
|
return { |
|
match_: combine ? matchRet.join("") : matchRet, |
|
remainder: group2.remainder |
|
}; |
|
} |
|
}, |
|
// |
|
// Matching function |
|
// e.g. match("a", input) will look for the regexp called "a" and see if it matches |
|
// returns null or {match_:"a", remainder:"bc"} |
|
// |
|
match_: function match_(m, input) { |
|
var pattern = mhchemParser.patterns.patterns[m]; |
|
|
|
if (pattern === undefined) { |
|
throw ["MhchemBugP", "mhchem bug P. Please report. (" + m + ")"]; // Trying to use non-existing pattern |
|
} else if (typeof pattern === "function") { |
|
return mhchemParser.patterns.patterns[m](input); // cannot use cached var pattern here, because some pattern functions need this===mhchemParser |
|
} else { |
|
// RegExp |
|
var match = input.match(pattern); |
|
|
|
if (match) { |
|
var mm; |
|
|
|
if (match[2]) { |
|
mm = [match[1], match[2]]; |
|
} else if (match[1]) { |
|
mm = match[1]; |
|
} else { |
|
mm = match[0]; |
|
} |
|
|
|
return { |
|
match_: mm, |
|
remainder: input.substr(match[0].length) |
|
}; |
|
} |
|
|
|
return null; |
|
} |
|
} |
|
}, |
|
// |
|
// Generic state machine actions |
|
// |
|
actions: { |
|
'a=': function a(buffer, m) { |
|
buffer.a = (buffer.a || "") + m; |
|
}, |
|
'b=': function b(buffer, m) { |
|
buffer.b = (buffer.b || "") + m; |
|
}, |
|
'p=': function p(buffer, m) { |
|
buffer.p = (buffer.p || "") + m; |
|
}, |
|
'o=': function o(buffer, m) { |
|
buffer.o = (buffer.o || "") + m; |
|
}, |
|
'q=': function q(buffer, m) { |
|
buffer.q = (buffer.q || "") + m; |
|
}, |
|
'd=': function d(buffer, m) { |
|
buffer.d = (buffer.d || "") + m; |
|
}, |
|
'rm=': function rm(buffer, m) { |
|
buffer.rm = (buffer.rm || "") + m; |
|
}, |
|
'text=': function text(buffer, m) { |
|
buffer.text_ = (buffer.text_ || "") + m; |
|
}, |
|
'insert': function insert(buffer, m, a) { |
|
return { |
|
type_: a |
|
}; |
|
}, |
|
'insert+p1': function insertP1(buffer, m, a) { |
|
return { |
|
type_: a, |
|
p1: m |
|
}; |
|
}, |
|
'insert+p1+p2': function insertP1P2(buffer, m, a) { |
|
return { |
|
type_: a, |
|
p1: m[0], |
|
p2: m[1] |
|
}; |
|
}, |
|
'copy': function copy(buffer, m) { |
|
return m; |
|
}, |
|
'rm': function rm(buffer, m) { |
|
return { |
|
type_: 'rm', |
|
p1: m || "" |
|
}; |
|
}, |
|
'text': function text(buffer, m) { |
|
return mhchemParser.go(m, 'text'); |
|
}, |
|
'{text}': function text(buffer, m) { |
|
var ret = ["{"]; |
|
mhchemParser.concatArray(ret, mhchemParser.go(m, 'text')); |
|
ret.push("}"); |
|
return ret; |
|
}, |
|
'tex-math': function texMath(buffer, m) { |
|
return mhchemParser.go(m, 'tex-math'); |
|
}, |
|
'tex-math tight': function texMathTight(buffer, m) { |
|
return mhchemParser.go(m, 'tex-math tight'); |
|
}, |
|
'bond': function bond(buffer, m, k) { |
|
return { |
|
type_: 'bond', |
|
kind_: k || m |
|
}; |
|
}, |
|
'color0-output': function color0Output(buffer, m) { |
|
return { |
|
type_: 'color0', |
|
color: m[0] |
|
}; |
|
}, |
|
'ce': function ce(buffer, m) { |
|
return mhchemParser.go(m); |
|
}, |
|
'1/2': function _(buffer, m) { |
|
/** @type {ParserOutput[]} */ |
|
var ret = []; |
|
|
|
if (m.match(/^[+\-]/)) { |
|
ret.push(m.substr(0, 1)); |
|
m = m.substr(1); |
|
} |
|
|
|
var n = m.match(/^([0-9]+|\$[a-z]\$|[a-z])\/([0-9]+)(\$[a-z]\$|[a-z])?$/); |
|
n[1] = n[1].replace(/\$/g, ""); |
|
ret.push({ |
|
type_: 'frac', |
|
p1: n[1], |
|
p2: n[2] |
|
}); |
|
|
|
if (n[3]) { |
|
n[3] = n[3].replace(/\$/g, ""); |
|
ret.push({ |
|
type_: 'tex-math', |
|
p1: n[3] |
|
}); |
|
} |
|
|
|
return ret; |
|
}, |
|
'9,9': function _(buffer, m) { |
|
return mhchemParser.go(m, '9,9'); |
|
} |
|
}, |
|
// |
|
// createTransitions |
|
// convert { 'letter': { 'state': { action_: 'output' } } } to { 'state' => [ { pattern: 'letter', task: { action_: [{type_: 'output'}] } } ] } |
|
// with expansion of 'a|b' to 'a' and 'b' (at 2 places) |
|
// |
|
createTransitions: function createTransitions(o) { |
|
var pattern, state; |
|
/** @type {string[]} */ |
|
|
|
var stateArray; |
|
var i; // |
|
// 1. Collect all states |
|
// |
|
|
|
/** @type {Transitions} */ |
|
|
|
var transitions = {}; |
|
|
|
for (pattern in o) { |
|
for (state in o[pattern]) { |
|
stateArray = state.split("|"); |
|
o[pattern][state].stateArray = stateArray; |
|
|
|
for (i = 0; i < stateArray.length; i++) { |
|
transitions[stateArray[i]] = []; |
|
} |
|
} |
|
} // |
|
// 2. Fill states |
|
// |
|
|
|
|
|
for (pattern in o) { |
|
for (state in o[pattern]) { |
|
stateArray = o[pattern][state].stateArray || []; |
|
|
|
for (i = 0; i < stateArray.length; i++) { |
|
// |
|
// 2a. Normalize actions into array: 'text=' ==> [{type_:'text='}] |
|
// (Note to myself: Resolving the function here would be problematic. It would need .bind (for *this*) and currying (for *option*).) |
|
// |
|
|
|
/** @type {any} */ |
|
var p = o[pattern][state]; |
|
|
|
if (p.action_) { |
|
p.action_ = [].concat(p.action_); |
|
|
|
for (var k = 0; k < p.action_.length; k++) { |
|
if (typeof p.action_[k] === "string") { |
|
p.action_[k] = { |
|
type_: p.action_[k] |
|
}; |
|
} |
|
} |
|
} else { |
|
p.action_ = []; |
|
} // |
|
// 2.b Multi-insert |
|
// |
|
|
|
|
|
var patternArray = pattern.split("|"); |
|
|
|
for (var j = 0; j < patternArray.length; j++) { |
|
if (stateArray[i] === '*') { |
|
// insert into all |
|
for (var t in transitions) { |
|
transitions[t].push({ |
|
pattern: patternArray[j], |
|
task: p |
|
}); |
|
} |
|
} else { |
|
transitions[stateArray[i]].push({ |
|
pattern: patternArray[j], |
|
task: p |
|
}); |
|
} |
|
} |
|
} |
|
} |
|
} |
|
|
|
return transitions; |
|
}, |
|
stateMachines: {} |
|
}; // |
|
// Definition of state machines |
|
// |
|
|
|
mhchemParser.stateMachines = { |
|
// |
|
// \ce state machines |
|
// |
|
//#region ce |
|
'ce': { |
|
// main parser |
|
transitions: mhchemParser.createTransitions({ |
|
'empty': { |
|
'*': { |
|
action_: 'output' |
|
} |
|
}, |
|
'else': { |
|
'0|1|2': { |
|
action_: 'beginsWithBond=false', |
|
revisit: true, |
|
toContinue: true |
|
} |
|
}, |
|
'oxidation$': { |
|
'0': { |
|
action_: 'oxidation-output' |
|
} |
|
}, |
|
'CMT': { |
|
'r': { |
|
action_: 'rdt=', |
|
nextState: 'rt' |
|
}, |
|
'rd': { |
|
action_: 'rqt=', |
|
nextState: 'rdt' |
|
} |
|
}, |
|
'arrowUpDown': { |
|
'0|1|2|as': { |
|
action_: ['sb=false', 'output', 'operator'], |
|
nextState: '1' |
|
} |
|
}, |
|
'uprightEntities': { |
|
'0|1|2': { |
|
action_: ['o=', 'output'], |
|
nextState: '1' |
|
} |
|
}, |
|
'orbital': { |
|
'0|1|2|3': { |
|
action_: 'o=', |
|
nextState: 'o' |
|
} |
|
}, |
|
'->': { |
|
'0|1|2|3': { |
|
action_: 'r=', |
|
nextState: 'r' |
|
}, |
|
'a|as': { |
|
action_: ['output', 'r='], |
|
nextState: 'r' |
|
}, |
|
'*': { |
|
action_: ['output', 'r='], |
|
nextState: 'r' |
|
} |
|
}, |
|
'+': { |
|
'o': { |
|
action_: 'd= kv', |
|
nextState: 'd' |
|
}, |
|
'd|D': { |
|
action_: 'd=', |
|
nextState: 'd' |
|
}, |
|
'q': { |
|
action_: 'd=', |
|
nextState: 'qd' |
|
}, |
|
'qd|qD': { |
|
action_: 'd=', |
|
nextState: 'qd' |
|
}, |
|
'dq': { |
|
action_: ['output', 'd='], |
|
nextState: 'd' |
|
}, |
|
'3': { |
|
action_: ['sb=false', 'output', 'operator'], |
|
nextState: '0' |
|
} |
|
}, |
|
'amount': { |
|
'0|2': { |
|
action_: 'a=', |
|
nextState: 'a' |
|
} |
|
}, |
|
'pm-operator': { |
|
'0|1|2|a|as': { |
|
action_: ['sb=false', 'output', { |
|
type_: 'operator', |
|
option: '\\pm' |
|
}], |
|
nextState: '0' |
|
} |
|
}, |
|
'operator': { |
|
'0|1|2|a|as': { |
|
action_: ['sb=false', 'output', 'operator'], |
|
nextState: '0' |
|
} |
|
}, |
|
'-$': { |
|
'o|q': { |
|
action_: ['charge or bond', 'output'], |
|
nextState: 'qd' |
|
}, |
|
'd': { |
|
action_: 'd=', |
|
nextState: 'd' |
|
}, |
|
'D': { |
|
action_: ['output', { |
|
type_: 'bond', |
|
option: "-" |
|
}], |
|
nextState: '3' |
|
}, |
|
'q': { |
|
action_: 'd=', |
|
nextState: 'qd' |
|
}, |
|
'qd': { |
|
action_: 'd=', |
|
nextState: 'qd' |
|
}, |
|
'qD|dq': { |
|
action_: ['output', { |
|
type_: 'bond', |
|
option: "-" |
|
}], |
|
nextState: '3' |
|
} |
|
}, |
|
'-9': { |
|
'3|o': { |
|
action_: ['output', { |
|
type_: 'insert', |
|
option: 'hyphen' |
|
}], |
|
nextState: '3' |
|
} |
|
}, |
|
'- orbital overlap': { |
|
'o': { |
|
action_: ['output', { |
|
type_: 'insert', |
|
option: 'hyphen' |
|
}], |
|
nextState: '2' |
|
}, |
|
'd': { |
|
action_: ['output', { |
|
type_: 'insert', |
|
option: 'hyphen' |
|
}], |
|
nextState: '2' |
|
} |
|
}, |
|
'-': { |
|
'0|1|2': { |
|
action_: [{ |
|
type_: 'output', |
|
option: 1 |
|
}, 'beginsWithBond=true', { |
|
type_: 'bond', |
|
option: "-" |
|
}], |
|
nextState: '3' |
|
}, |
|
'3': { |
|
action_: { |
|
type_: 'bond', |
|
option: "-" |
|
} |
|
}, |
|
'a': { |
|
action_: ['output', { |
|
type_: 'insert', |
|
option: 'hyphen' |
|
}], |
|
nextState: '2' |
|
}, |
|
'as': { |
|
action_: [{ |
|
type_: 'output', |
|
option: 2 |
|
}, { |
|
type_: 'bond', |
|
option: "-" |
|
}], |
|
nextState: '3' |
|
}, |
|
'b': { |
|
action_: 'b=' |
|
}, |
|
'o': { |
|
action_: { |
|
type_: '- after o/d', |
|
option: false |
|
}, |
|
nextState: '2' |
|
}, |
|
'q': { |
|
action_: { |
|
type_: '- after o/d', |
|
option: false |
|
}, |
|
nextState: '2' |
|
}, |
|
'd|qd|dq': { |
|
action_: { |
|
type_: '- after o/d', |
|
option: true |
|
}, |
|
nextState: '2' |
|
}, |
|
'D|qD|p': { |
|
action_: ['output', { |
|
type_: 'bond', |
|
option: "-" |
|
}], |
|
nextState: '3' |
|
} |
|
}, |
|
'amount2': { |
|
'1|3': { |
|
action_: 'a=', |
|
nextState: 'a' |
|
} |
|
}, |
|
'letters': { |
|
'0|1|2|3|a|as|b|p|bp|o': { |
|
action_: 'o=', |
|
nextState: 'o' |
|
}, |
|
'q|dq': { |
|
action_: ['output', 'o='], |
|
nextState: 'o' |
|
}, |
|
'd|D|qd|qD': { |
|
action_: 'o after d', |
|
nextState: 'o' |
|
} |
|
}, |
|
'digits': { |
|
'o': { |
|
action_: 'q=', |
|
nextState: 'q' |
|
}, |
|
'd|D': { |
|
action_: 'q=', |
|
nextState: 'dq' |
|
}, |
|
'q': { |
|
action_: ['output', 'o='], |
|
nextState: 'o' |
|
}, |
|
'a': { |
|
action_: 'o=', |
|
nextState: 'o' |
|
} |
|
}, |
|
'space A': { |
|
'b|p|bp': {} |
|
}, |
|
'space': { |
|
'a': { |
|
nextState: 'as' |
|
}, |
|
'0': { |
|
action_: 'sb=false' |
|
}, |
|
'1|2': { |
|
action_: 'sb=true' |
|
}, |
|
'r|rt|rd|rdt|rdq': { |
|
action_: 'output', |
|
nextState: '0' |
|
}, |
|
'*': { |
|
action_: ['output', 'sb=true'], |
|
nextState: '1' |
|
} |
|
}, |
|
'1st-level escape': { |
|
'1|2': { |
|
action_: ['output', { |
|
type_: 'insert+p1', |
|
option: '1st-level escape' |
|
}] |
|
}, |
|
'*': { |
|
action_: ['output', { |
|
type_: 'insert+p1', |
|
option: '1st-level escape' |
|
}], |
|
nextState: '0' |
|
} |
|
}, |
|
'[(...)]': { |
|
'r|rt': { |
|
action_: 'rd=', |
|
nextState: 'rd' |
|
}, |
|
'rd|rdt': { |
|
action_: 'rq=', |
|
nextState: 'rdq' |
|
} |
|
}, |
|
'...': { |
|
'o|d|D|dq|qd|qD': { |
|
action_: ['output', { |
|
type_: 'bond', |
|
option: "..." |
|
}], |
|
nextState: '3' |
|
}, |
|
'*': { |
|
action_: [{ |
|
type_: 'output', |
|
option: 1 |
|
}, { |
|
type_: 'insert', |
|
option: 'ellipsis' |
|
}], |
|
nextState: '1' |
|
} |
|
}, |
|
'. |* ': { |
|
'*': { |
|
action_: ['output', { |
|
type_: 'insert', |
|
option: 'addition compound' |
|
}], |
|
nextState: '1' |
|
} |
|
}, |
|
'state of aggregation $': { |
|
'*': { |
|
action_: ['output', 'state of aggregation'], |
|
nextState: '1' |
|
} |
|
}, |
|
'{[(': { |
|
'a|as|o': { |
|
action_: ['o=', 'output', 'parenthesisLevel++'], |
|
nextState: '2' |
|
}, |
|
'0|1|2|3': { |
|
action_: ['o=', 'output', 'parenthesisLevel++'], |
|
nextState: '2' |
|
}, |
|
'*': { |
|
action_: ['output', 'o=', 'output', 'parenthesisLevel++'], |
|
nextState: '2' |
|
} |
|
}, |
|
')]}': { |
|
'0|1|2|3|b|p|bp|o': { |
|
action_: ['o=', 'parenthesisLevel--'], |
|
nextState: 'o' |
|
}, |
|
'a|as|d|D|q|qd|qD|dq': { |
|
action_: ['output', 'o=', 'parenthesisLevel--'], |
|
nextState: 'o' |
|
} |
|
}, |
|
', ': { |
|
'*': { |
|
action_: ['output', 'comma'], |
|
nextState: '0' |
|
} |
|
}, |
|
'^_': { |
|
// ^ and _ without a sensible argument |
|
'*': {} |
|
}, |
|
'^{(...)}|^($...$)': { |
|
'0|1|2|as': { |
|
action_: 'b=', |
|
nextState: 'b' |
|
}, |
|
'p': { |
|
action_: 'b=', |
|
nextState: 'bp' |
|
}, |
|
'3|o': { |
|
action_: 'd= kv', |
|
nextState: 'D' |
|
}, |
|
'q': { |
|
action_: 'd=', |
|
nextState: 'qD' |
|
}, |
|
'd|D|qd|qD|dq': { |
|
action_: ['output', 'd='], |
|
nextState: 'D' |
|
} |
|
}, |
|
'^a|^\\x{}{}|^\\x{}|^\\x|\'': { |
|
'0|1|2|as': { |
|
action_: 'b=', |
|
nextState: 'b' |
|
}, |
|
'p': { |
|
action_: 'b=', |
|
nextState: 'bp' |
|
}, |
|
'3|o': { |
|
action_: 'd= kv', |
|
nextState: 'd' |
|
}, |
|
'q': { |
|
action_: 'd=', |
|
nextState: 'qd' |
|
}, |
|
'd|qd|D|qD': { |
|
action_: 'd=' |
|
}, |
|
'dq': { |
|
action_: ['output', 'd='], |
|
nextState: 'd' |
|
} |
|
}, |
|
'_{(state of aggregation)}$': { |
|
'd|D|q|qd|qD|dq': { |
|
action_: ['output', 'q='], |
|
nextState: 'q' |
|
} |
|
}, |
|
'_{(...)}|_($...$)|_9|_\\x{}{}|_\\x{}|_\\x': { |
|
'0|1|2|as': { |
|
action_: 'p=', |
|
nextState: 'p' |
|
}, |
|
'b': { |
|
action_: 'p=', |
|
nextState: 'bp' |
|
}, |
|
'3|o': { |
|
action_: 'q=', |
|
nextState: 'q' |
|
}, |
|
'd|D': { |
|
action_: 'q=', |
|
nextState: 'dq' |
|
}, |
|
'q|qd|qD|dq': { |
|
action_: ['output', 'q='], |
|
nextState: 'q' |
|
} |
|
}, |
|
'=<>': { |
|
'0|1|2|3|a|as|o|q|d|D|qd|qD|dq': { |
|
action_: [{ |
|
type_: 'output', |
|
option: 2 |
|
}, 'bond'], |
|
nextState: '3' |
|
} |
|
}, |
|
'#': { |
|
'0|1|2|3|a|as|o': { |
|
action_: [{ |
|
type_: 'output', |
|
option: 2 |
|
}, { |
|
type_: 'bond', |
|
option: "#" |
|
}], |
|
nextState: '3' |
|
} |
|
}, |
|
'{}': { |
|
'*': { |
|
action_: { |
|
type_: 'output', |
|
option: 1 |
|
}, |
|
nextState: '1' |
|
} |
|
}, |
|
'{...}': { |
|
'0|1|2|3|a|as|b|p|bp': { |
|
action_: 'o=', |
|
nextState: 'o' |
|
}, |
|
'o|d|D|q|qd|qD|dq': { |
|
action_: ['output', 'o='], |
|
nextState: 'o' |
|
} |
|
}, |
|
'$...$': { |
|
'a': { |
|
action_: 'a=' |
|
}, |
|
// 2$n$ |
|
'0|1|2|3|as|b|p|bp|o': { |
|
action_: 'o=', |
|
nextState: 'o' |
|
}, |
|
// not 'amount' |
|
'as|o': { |
|
action_: 'o=' |
|
}, |
|
'q|d|D|qd|qD|dq': { |
|
action_: ['output', 'o='], |
|
nextState: 'o' |
|
} |
|
}, |
|
'\\bond{(...)}': { |
|
'*': { |
|
action_: [{ |
|
type_: 'output', |
|
option: 2 |
|
}, 'bond'], |
|
nextState: "3" |
|
} |
|
}, |
|
'\\frac{(...)}': { |
|
'*': { |
|
action_: [{ |
|
type_: 'output', |
|
option: 1 |
|
}, 'frac-output'], |
|
nextState: '3' |
|
} |
|
}, |
|
'\\overset{(...)}': { |
|
'*': { |
|
action_: [{ |
|
type_: 'output', |
|
option: 2 |
|
}, 'overset-output'], |
|
nextState: '3' |
|
} |
|
}, |
|
'\\underset{(...)}': { |
|
'*': { |
|
action_: [{ |
|
type_: 'output', |
|
option: 2 |
|
}, 'underset-output'], |
|
nextState: '3' |
|
} |
|
}, |
|
'\\underbrace{(...)}': { |
|
'*': { |
|
action_: [{ |
|
type_: 'output', |
|
option: 2 |
|
}, 'underbrace-output'], |
|
nextState: '3' |
|
} |
|
}, |
|
'\\color{(...)}{(...)}1|\\color(...){(...)}2': { |
|
'*': { |
|
action_: [{ |
|
type_: 'output', |
|
option: 2 |
|
}, 'color-output'], |
|
nextState: '3' |
|
} |
|
}, |
|
'\\color{(...)}0': { |
|
'*': { |
|
action_: [{ |
|
type_: 'output', |
|
option: 2 |
|
}, 'color0-output'] |
|
} |
|
}, |
|
'\\ce{(...)}': { |
|
'*': { |
|
action_: [{ |
|
type_: 'output', |
|
option: 2 |
|
}, 'ce'], |
|
nextState: '3' |
|
} |
|
}, |
|
'\\,': { |
|
'*': { |
|
action_: [{ |
|
type_: 'output', |
|
option: 1 |
|
}, 'copy'], |
|
nextState: '1' |
|
} |
|
}, |
|
'\\x{}{}|\\x{}|\\x': { |
|
'0|1|2|3|a|as|b|p|bp|o|c0': { |
|
action_: ['o=', 'output'], |
|
nextState: '3' |
|
}, |
|
'*': { |
|
action_: ['output', 'o=', 'output'], |
|
nextState: '3' |
|
} |
|
}, |
|
'others': { |
|
'*': { |
|
action_: [{ |
|
type_: 'output', |
|
option: 1 |
|
}, 'copy'], |
|
nextState: '3' |
|
} |
|
}, |
|
'else2': { |
|
'a': { |
|
action_: 'a to o', |
|
nextState: 'o', |
|
revisit: true |
|
}, |
|
'as': { |
|
action_: ['output', 'sb=true'], |
|
nextState: '1', |
|
revisit: true |
|
}, |
|
'r|rt|rd|rdt|rdq': { |
|
action_: ['output'], |
|
nextState: '0', |
|
revisit: true |
|
}, |
|
'*': { |
|
action_: ['output', 'copy'], |
|
nextState: '3' |
|
} |
|
} |
|
}), |
|
actions: { |
|
'o after d': function oAfterD(buffer, m) { |
|
var ret; |
|
|
|
if ((buffer.d || "").match(/^[0-9]+$/)) { |
|
var tmp = buffer.d; |
|
buffer.d = undefined; |
|
ret = this['output'](buffer); |
|
buffer.b = tmp; |
|
} else { |
|
ret = this['output'](buffer); |
|
} |
|
|
|
mhchemParser.actions['o='](buffer, m); |
|
return ret; |
|
}, |
|
'd= kv': function dKv(buffer, m) { |
|
buffer.d = m; |
|
buffer.dType = 'kv'; |
|
}, |
|
'charge or bond': function chargeOrBond(buffer, m) { |
|
if (buffer['beginsWithBond']) { |
|
/** @type {ParserOutput[]} */ |
|
var ret = []; |
|
mhchemParser.concatArray(ret, this['output'](buffer)); |
|
mhchemParser.concatArray(ret, mhchemParser.actions['bond'](buffer, m, "-")); |
|
return ret; |
|
} else { |
|
buffer.d = m; |
|
} |
|
}, |
|
'- after o/d': function afterOD(buffer, m, isAfterD) { |
|
var c1 = mhchemParser.patterns.match_('orbital', buffer.o || ""); |
|
var c2 = mhchemParser.patterns.match_('one lowercase greek letter $', buffer.o || ""); |
|
var c3 = mhchemParser.patterns.match_('one lowercase latin letter $', buffer.o || ""); |
|
var c4 = mhchemParser.patterns.match_('$one lowercase latin letter$ $', buffer.o || ""); |
|
var hyphenFollows = m === "-" && (c1 && c1.remainder === "" || c2 || c3 || c4); |
|
|
|
if (hyphenFollows && !buffer.a && !buffer.b && !buffer.p && !buffer.d && !buffer.q && !c1 && c3) { |
|
buffer.o = '$' + buffer.o + '$'; |
|
} |
|
/** @type {ParserOutput[]} */ |
|
|
|
|
|
var ret = []; |
|
|
|
if (hyphenFollows) { |
|
mhchemParser.concatArray(ret, this['output'](buffer)); |
|
ret.push({ |
|
type_: 'hyphen' |
|
}); |
|
} else { |
|
c1 = mhchemParser.patterns.match_('digits', buffer.d || ""); |
|
|
|
if (isAfterD && c1 && c1.remainder === '') { |
|
mhchemParser.concatArray(ret, mhchemParser.actions['d='](buffer, m)); |
|
mhchemParser.concatArray(ret, this['output'](buffer)); |
|
} else { |
|
mhchemParser.concatArray(ret, this['output'](buffer)); |
|
mhchemParser.concatArray(ret, mhchemParser.actions['bond'](buffer, m, "-")); |
|
} |
|
} |
|
|
|
return ret; |
|
}, |
|
'a to o': function aToO(buffer) { |
|
buffer.o = buffer.a; |
|
buffer.a = undefined; |
|
}, |
|
'sb=true': function sbTrue(buffer) { |
|
buffer.sb = true; |
|
}, |
|
'sb=false': function sbFalse(buffer) { |
|
buffer.sb = false; |
|
}, |
|
'beginsWithBond=true': function beginsWithBondTrue(buffer) { |
|
buffer['beginsWithBond'] = true; |
|
}, |
|
'beginsWithBond=false': function beginsWithBondFalse(buffer) { |
|
buffer['beginsWithBond'] = false; |
|
}, |
|
'parenthesisLevel++': function parenthesisLevel(buffer) { |
|
buffer['parenthesisLevel']++; |
|
}, |
|
'parenthesisLevel--': function parenthesisLevel(buffer) { |
|
buffer['parenthesisLevel']--; |
|
}, |
|
'state of aggregation': function stateOfAggregation(buffer, m) { |
|
return { |
|
type_: 'state of aggregation', |
|
p1: mhchemParser.go(m, 'o') |
|
}; |
|
}, |
|
'comma': function comma(buffer, m) { |
|
var a = m.replace(/\s*$/, ''); |
|
var withSpace = a !== m; |
|
|
|
if (withSpace && buffer['parenthesisLevel'] === 0) { |
|
return { |
|
type_: 'comma enumeration L', |
|
p1: a |
|
}; |
|
} else { |
|
return { |
|
type_: 'comma enumeration M', |
|
p1: a |
|
}; |
|
} |
|
}, |
|
'output': function output(buffer, m, entityFollows) { |
|
// entityFollows: |
|
// undefined = if we have nothing else to output, also ignore the just read space (buffer.sb) |
|
// 1 = an entity follows, never omit the space if there was one just read before (can only apply to state 1) |
|
// 2 = 1 + the entity can have an amount, so output a\, instead of converting it to o (can only apply to states a|as) |
|
|
|
/** @type {ParserOutput | ParserOutput[]} */ |
|
var ret; |
|
|
|
if (!buffer.r) { |
|
ret = []; |
|
|
|
if (!buffer.a && !buffer.b && !buffer.p && !buffer.o && !buffer.q && !buffer.d && !entityFollows) ; 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: |
|
throw ["MhchemBugT", "mhchem bug T. Please report."]; |
|
// Missing texify rule or unknown MhchemParser output |
|
} |
|
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: |
|
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: |
|
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: |
|
throw ["MhchemBugT", "mhchem bug T. Please report."]; |
|
} |
|
} |
|
}; //
|
|
|