| 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[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."]; |
| } |
| } |
| }; // |
