8265 lines
213 KiB
JavaScript
8265 lines
213 KiB
JavaScript
/*
|
||
* (c) Copyright Ascensio System SIA 2010-2024
|
||
*
|
||
* This program is a free software product. You can redistribute it and/or
|
||
* modify it under the terms of the GNU Affero General Public License (AGPL)
|
||
* version 3 as published by the Free Software Foundation. In accordance with
|
||
* Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect
|
||
* that Ascensio System SIA expressly excludes the warranty of non-infringement
|
||
* of any third-party rights.
|
||
*
|
||
* This program is distributed WITHOUT ANY WARRANTY; without even the implied
|
||
* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. For
|
||
* details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
|
||
*
|
||
* You can contact Ascensio System SIA at 20A-6 Ernesta Birznieka-Upish
|
||
* street, Riga, Latvia, EU, LV-1050.
|
||
*
|
||
* The interactive user interfaces in modified source and object code versions
|
||
* of the Program must display Appropriate Legal Notices, as required under
|
||
* Section 5 of the GNU AGPL version 3.
|
||
*
|
||
* Pursuant to Section 7(b) of the License you must retain the original Product
|
||
* logo when distributing the program. Pursuant to Section 7(e) we decline to
|
||
* grant you any rights under trademark law for use of our trademarks.
|
||
*
|
||
* All the Product's GUI elements, including illustrations and icon sets, as
|
||
* well as technical writing content are licensed under the terms of the
|
||
* Creative Commons Attribution-ShareAlike 4.0 International. See the License
|
||
* terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
|
||
*
|
||
*/
|
||
|
||
"use strict";
|
||
|
||
(function (window) {
|
||
|
||
let type = false;
|
||
let Paragraph = null;
|
||
let isAllowAutoCorrect = true;
|
||
|
||
let functionNames = [
|
||
'cos', 'acos', 'acosh', 'sin', 'tan', 'asin', 'asinh', 'sec',
|
||
'acsc', 'atan', 'atanh', 'acsch', 'arcsinh', 'cot', 'acot', 'def',
|
||
'arg', 'deg', 'det', 'dim', 'erf', 'acoth', 'csc', 'arcsin',
|
||
'gcd', 'inf', 'asec', 'ker', 'asech', 'arccos', 'hom', 'lg',
|
||
'arctan', 'sup', 'arcsec', 'arccot', 'arccsc', 'sinh', 'cosh',
|
||
'tanh', 'coth', 'sech', 'csch', 'srcsinh', 'arctanh', 'arcsech', 'arccosh',
|
||
'arccoth', 'arccsch', 'Pr', 'lin', 'exp', "sgn"
|
||
];
|
||
const limitFunctions = [
|
||
"lim", "min", "max", "log", "ln"
|
||
];
|
||
const limitFunctionsLaTeX = [
|
||
"lim", "min", "max", "liminf", "limup", 'sum', 'prod', 'coprod', 'bigcup',
|
||
'bigcap', 'bigsqcap', 'bigvee', 'bigwedge', 'bigodot', 'bigotimes', 'bigoplus'
|
||
];
|
||
const UnicodeSpecialScript = {
|
||
"⁰": "0",
|
||
"¹": "1",
|
||
"²": "2",
|
||
"³": "3",
|
||
"⁴": "4",
|
||
"⁵": "5",
|
||
"⁶": "6",
|
||
"⁷": "7",
|
||
"⁸": "8",
|
||
"⁹": "9",
|
||
"ⁱ": "i",
|
||
"ⁿ": "n",
|
||
"⁺": "+",
|
||
"⁻": "-",
|
||
"⁼": "=",
|
||
"⁽": "(",
|
||
"⁾": ")",
|
||
|
||
"₀": "0",
|
||
"₁": "1",
|
||
"₂": "2",
|
||
"₃": "3",
|
||
"₄": "4",
|
||
"₅": "5",
|
||
"₆": "6",
|
||
"₇": "7",
|
||
"₈": "8",
|
||
"₉": "9",
|
||
"₊": "+",
|
||
"₋": "-",
|
||
"₌": "=",
|
||
"₍": "(",
|
||
"₎": ")",
|
||
}
|
||
const oStandardFont = {
|
||
// Standart Word functions with higher proirity for linear format
|
||
"7" : "\\mathcal",
|
||
"3" : "\\mathsf",
|
||
"-1" : "\\mathrm",
|
||
//"1" : "\\mathit",
|
||
"9" : "\\mathfrak",
|
||
//"8" : "\\mathbfcal",
|
||
"0" : "\\mathbf",
|
||
"12" : "\\mathbb",
|
||
}
|
||
const GetTypeFont = {
|
||
// Standart Word functions with higher proirity for linear format
|
||
"\\mathcal": 7,
|
||
"\\mathsf": 3,
|
||
"\\mathrm": -1,
|
||
"\\mathit": 1,
|
||
"\\mathfrak": 9,
|
||
"\\mathbfcal": 8,
|
||
"\\mathbf": 0,
|
||
"\\mathbb": 12,
|
||
|
||
// other LaTeX functions
|
||
"\\sf": 3,
|
||
"\\script": 7,
|
||
"\\scr": 7,
|
||
"\\rm": -1,
|
||
"\\oldstyle": 7,
|
||
"\\mathtt": 11,
|
||
"\\mathsfit": 5,
|
||
"\\mathsfbfit": 6,
|
||
"\\mathsfbf": 4,
|
||
"\\mathbfit": 2,
|
||
"\\mathbffrak": 10,
|
||
"\\it": 1,
|
||
"\\fraktur": 9,
|
||
"\\frak": 9,
|
||
"\\double": 12,
|
||
}
|
||
|
||
function SetIsAllowAutoCorrect(isAllow)
|
||
{
|
||
isAllowAutoCorrect = isAllow;
|
||
}
|
||
function GetIsAllowAutoCorrect()
|
||
{
|
||
return isAllowAutoCorrect;
|
||
}
|
||
|
||
|
||
// List of MathFont
|
||
const GetMathFontChar = {
|
||
'A': { 0: '𝐀', 1: '𝐴', 2: '𝑨', 3: '𝖠', 4: '𝗔', 5: '𝘈', 6: '𝘼', 7: '𝒜', 8: '𝓐', 9: '𝔄', 10: '𝕬', 11: '𝙰', 12: '𝔸'},
|
||
'B': { 0: '𝐁', 1: '𝐵', 2: '𝑩', 3: '𝖡', 4: '𝗕', 5: '𝘉', 6: '𝘽', 7: 'ℬ', 8: '𝓑', 9: '𝔅', 10: '𝕭', 11: '𝙱', 12: '𝔹'},
|
||
'C': { 0: '𝐂', 1: '𝐶', 2: '𝑪', 3: '𝖢', 4: '𝗖', 5: '𝘊', 6: '𝘾', 7: '𝒞', 8: '𝓒', 9: 'ℭ', 10: '𝕮', 11: '𝙲', 12: 'ℂ'},
|
||
'D': { 0: '𝐃', 1: '𝐷', 2: '𝑫', 3: '𝖣', 4: '𝗗', 5: '𝘋', 6: '𝘿', 7: '𝒟', 8: '𝓓', 9: '𝔇', 10: '𝕯', 11: '𝙳', 12: '𝔻'},
|
||
'E': { 0: '𝐄', 1: '𝐸', 2: '𝑬', 3: '𝖤', 4: '𝗘', 5: '𝘌', 6: '𝙀', 7: 'ℰ', 8: '𝓔', 9: '𝔈', 10: '𝕰', 11: '𝙴', 12: '𝔼'},
|
||
'F': { 0: '𝐅', 1: '𝐹', 2: '𝑭', 3: '𝖥', 4: '𝗙', 5: '𝘍', 6: '𝙁', 7: 'ℱ', 8: '𝓕', 9: '𝔉', 10: '𝕱', 11: '𝙵', 12: '𝔽'},
|
||
'G': { 0: '𝐆', 1: '𝐺', 2: '𝑮', 3: '𝖦', 4: '𝗚', 5: '𝘎', 6: '𝙂', 7: '𝒢', 8: '𝓖', 9: '𝔊', 10: '𝕲', 11: '𝙶', 12: '𝔾'},
|
||
'H': { 0: '𝐇', 1: '𝐻', 2: '𝑯', 3: '𝖧', 4: '𝗛', 5: '𝘏', 6: '𝙃', 7: 'ℋ', 8: '𝓗', 9: 'ℌ', 10: '𝕳', 11: '𝙷', 12: 'ℍ'},
|
||
'I': { 0: '𝐈', 1: '𝐼', 2: '𝑰', 3: '𝖨', 4: '𝗜', 5: '𝘐', 6: '𝙄', 7: 'ℐ', 8: '𝓘', 9: 'ℑ', 10: '𝕴', 11: '𝙸', 12: '𝕀'},
|
||
'J': { 0: '𝐉', 1: '𝐽', 2: '𝑱', 3: '𝖩', 4: '𝗝', 5: '𝘑', 6: '𝙅', 7: '𝒥', 8: '𝓙', 9: '𝔍', 10: '𝕵', 11: '𝙹', 12: '𝕁'},
|
||
'K': { 0: '𝐊', 1: '𝐾', 2: '𝑲', 3: '𝖪', 4: '𝗞', 5: '𝘒', 6: '𝙆', 7: '𝒦', 8: '𝓚', 9: '𝔎', 10: '𝕶', 11: '𝙺', 12: '𝕂'},
|
||
'L': { 0: '𝐋', 1: '𝐿', 2: '𝑳', 3: '𝖫', 4: '𝗟', 5: '𝘓', 6: '𝙇', 7: 'ℒ', 8: '𝓛', 9: '𝔏', 10: '𝕷', 11: '𝙻', 12: '𝕃'},
|
||
'M': { 0: '𝐌', 1: '𝑀', 2: '𝑴', 3: '𝖬', 4: '𝗠', 5: '𝘔', 6: '𝙈', 7: 'ℳ', 8: '𝓜', 9: '𝔐', 10: '𝕸', 11: '𝙼', 12: '𝕄'},
|
||
'N': { 0: '𝐍', 1: '𝑁', 2: '𝑵', 3: '𝖭', 4: '𝗡', 5: '𝘕', 6: '𝙉', 7: '𝒩', 8: '𝓝', 9: '𝔑', 10: '𝕹', 11: '𝙽', 12: 'ℕ'},
|
||
'O': { 0: '𝐎', 1: '𝑂', 2: '𝑶', 3: '𝖮', 4: '𝗢', 5: '𝘖', 6: '𝙊', 7: '𝒪', 8: '𝓞', 9: '𝔒', 10: '𝕺', 11: '𝙾', 12: '𝕆'},
|
||
'P': { 0: '𝐏', 1: '𝑃', 2: '𝑷', 3: '𝖯', 4: '𝗣', 5: '𝘗', 6: '𝙋', 7: '𝒫', 8: '𝓟', 9: '𝔓', 10: '𝕻', 11: '𝙿', 12: 'ℙ'},
|
||
'Q': { 0: '𝐐', 1: '𝑄', 2: '𝑸', 3: '𝖰', 4: '𝗤', 5: '𝘘', 6: '𝙌', 7: '𝒬', 8: '𝓠', 9: '𝔔', 10: '𝕼', 11: '𝚀', 12: 'ℚ'},
|
||
'R': { 0: '𝐑', 1: '𝑅', 2: '𝑹', 3: '𝖱', 4: '𝗥', 5: '𝘙', 6: '𝙍', 7: 'ℛ', 8: '𝓡', 9: 'ℜ', 10: '𝕽', 11: '𝚁', 12: 'ℝ'},
|
||
'S': { 0: '𝐒', 1: '𝑆', 2: '𝑺', 3: '𝖲', 4: '𝗦', 5: '𝘚', 6: '𝙎', 7: '𝒮', 8: '𝓢', 9: '𝔖', 10: '𝕾', 11: '𝚂', 12: '𝕊'},
|
||
'T': { 0: '𝐓', 1: '𝑇', 2: '𝑻', 3: '𝖳', 4: '𝗧', 5: '𝘛', 6: '𝙏', 7: '𝒯', 8: '𝓣', 9: '𝔗', 10: '𝕿', 11: '𝚃', 12: '𝕋'},
|
||
'U': { 0: '𝐔', 1: '𝑈', 2: '𝑼', 3: '𝖴', 4: '𝗨', 5: '𝘜', 6: '𝙐', 7: '𝒰', 8: '𝓤', 9: '𝔘', 10: '𝖀', 11: '𝚄', 12: '𝕌'},
|
||
'V': { 0: '𝐕', 1: '𝑉', 2: '𝑽', 3: '𝖵', 4: '𝗩', 5: '𝘝', 6: '𝙑', 7: '𝒱', 8: '𝓥', 9: '𝔙', 10: '𝖁', 11: '𝚅', 12: '𝕍'},
|
||
'W': { 0: '𝐖', 1: '𝑊', 2: '𝑾', 3: '𝖶', 4: '𝗪', 5: '𝘞', 6: '𝙒', 7: '𝒲', 8: '𝓦', 9: '𝔚', 10: '𝖂', 11: '𝚆', 12: '𝕎'},
|
||
'X': { 0: '𝐗', 1: '𝑋', 2: '𝑿', 3: '𝖷', 4: '𝗫', 5: '𝘟', 6: '𝙓', 7: '𝒳', 8: '𝓧', 9: '𝔛', 10: '𝖃', 11: '𝚇', 12: '𝕏'},
|
||
'Y': { 0: '𝐘', 1: '𝑌', 2: '𝒀', 3: '𝖸', 4: '𝗬', 5: '𝘠', 6: '𝙔', 7: '𝒴', 8: '𝓨', 9: '𝔜', 10: '𝖄', 11: '𝚈', 12: '𝕐'},
|
||
'Z': { 0: '𝐙', 1: '𝑍', 2: '𝒁', 3: '𝖹', 4: '𝗭', 5: '𝘡', 6: '𝙕', 7: '𝒵', 8: '𝓩', 9: 'ℨ', 10: '𝖅', 11: '𝚉', 12: 'ℤ'},
|
||
'a': { 0: '𝐚', 1: '𝑎', 2: '𝒂', 3: '𝖺', 4: '𝗮', 5: '𝘢', 6: '𝙖', 7: '𝒶', 8: '𝓪', 9: '𝔞', 10: '𝖆', 11: '𝚊', 12: '𝕒'},
|
||
'b': { 0: '𝐛', 1: '𝑏', 2: '𝒃', 3: '𝖻', 4: '𝗯', 5: '𝘣', 6: '𝙗', 7: '𝒷', 8: '𝓫', 9: '𝔟', 10: '𝖇', 11: '𝚋', 12: '𝕓'},
|
||
'c': { 0: '𝐜', 1: '𝑐', 2: '𝒄', 3: '𝖼', 4: '𝗰', 5: '𝘤', 6: '𝙘', 7: '𝒸', 8: '𝓬', 9: '𝔠', 10: '𝖈', 11: '𝚌', 12: '𝕔'},
|
||
'd': { 0: '𝐝', 1: '𝑑', 2: '𝒅', 3: '𝖽', 4: '𝗱', 5: '𝘥', 6: '𝙙', 7: '𝒹', 8: '𝓭', 9: '𝔡', 10: '𝖉', 11: '𝚍', 12: '𝕕'},
|
||
'e': { 0: '𝐞', 1: '𝑒', 2: '𝒆', 3: '𝖾', 4: '𝗲', 5: '𝘦', 6: '𝙚', 7: 'ℯ', 8: '𝓮', 9: '𝔢', 10: '𝖊', 11: '𝚎', 12: '𝕖'},
|
||
'f': { 0: '𝐟', 1: '𝑓', 2: '𝒇', 3: '𝖿', 4: '𝗳', 5: '𝘧', 6: '𝙛', 7: '𝒻', 8: '𝓯', 9: '𝔣', 10: '𝖋', 11: '𝚏', 12: '𝕗'},
|
||
'g': { 0: '𝐠', 1: '𝑔', 2: '𝒈', 3: '𝗀', 4: '𝗴', 5: '𝘨', 6: '𝙜', 7: 'ℊ', 8: '𝓰', 9: '𝔤', 10: '𝖌', 11: '𝚐', 12: '𝕘'},
|
||
'h': { 0: '𝐡', 1: 'ℎ', 2: '𝒉', 3: '𝗁', 4: '𝗵', 5: '𝘩', 6: '𝙝', 7: '𝒽', 8: '𝓱', 9: '𝔥', 10: '𝖍', 11: '𝚑', 12: '𝕙'},
|
||
'i': { 0: '𝐢', 1: '𝑖', 2: '𝒊', 3: '𝗂', 4: '𝗶', 5: '𝘪', 6: '𝙞', 7: '𝒾', 8: '𝓲', 9: '𝔦', 10: '𝖎', 11: '𝚒', 12: '𝕚'},
|
||
'j': { 0: '𝐣', 1: '𝑗', 2: '𝒋', 3: '𝗃', 4: '𝗷', 5: '𝘫', 6: '𝙟', 7: '𝒿', 8: '𝓳', 9: '𝔧', 10: '𝖏', 11: '𝚓', 12: '𝕛'},
|
||
'k': { 0: '𝐤', 1: '𝑘', 2: '𝒌', 3: '𝗄', 4: '𝗸', 5: '𝘬', 6: '𝙠', 7: '𝓀', 8: '𝓴', 9: '𝔨', 10: '𝖐', 11: '𝚔', 12: '𝕜'},
|
||
'l': { 0: '𝐥', 1: '𝑙', 2: '𝒍', 3: '𝗅', 4: '𝗹', 5: '𝘭', 6: '𝙡', 7: '𝓁', 8: '𝓵', 9: '𝔩', 10: '𝖑', 11: '𝚕', 12: '𝕝'},
|
||
'm': { 0: '𝐦', 1: '𝑚', 2: '𝒎', 3: '𝗆', 4: '𝗺', 5: '𝘮', 6: '𝙢', 7: '𝓂', 8: '𝓶', 9: '𝔪', 10: '𝖒', 11: '𝚖', 12: '𝕞'},
|
||
'n': { 0: '𝐧', 1: '𝑛', 2: '𝒏', 3: '𝗇', 4: '𝗻', 5: '𝘯', 6: '𝙣', 7: '𝓃', 8: '𝓷', 9: '𝔫', 10: '𝖓', 11: '𝚗', 12: '𝕟'},
|
||
'o': { 0: '𝐨', 1: '𝑜', 2: '𝒐', 3: '𝗈', 4: '𝗼', 5: '𝘰', 6: '𝙤', 7: 'ℴ', 8: '𝓸', 9: '𝔬', 10: '𝖔', 11: '𝚘', 12: '𝕠'},
|
||
'p': {0: '𝐩',1: '𝑝',2: '𝒑',3: '𝗉',4: '𝗽',5: '𝘱',6: '𝙥',7: '𝓅',8: '𝓹',9: '𝔭',10: '𝖕',11: '𝚙',12: '𝕡'},
|
||
'q': { 0: '𝐪', 1: '𝑞', 2: '𝒒', 3: '𝗊', 4: '𝗾', 5: '𝘲', 6: '𝙦', 7: '𝓆', 8: '𝓺', 9: '𝔮', 10: '𝖖', 11: '𝚚', 12: '𝕢'},
|
||
'r': { 0: '𝐫', 1: '𝑟', 2: '𝒓', 3: '𝗋', 4: '𝗿', 5: '𝘳', 6: '𝙧', 7: '𝓇', 8: '𝓻', 9: '𝔯', 10: '𝖗', 11: '𝚛', 12: '𝕣'},
|
||
's': { 0: '𝐬', 1: '𝑠', 2: '𝒔', 3: '𝗌', 4: '𝘀', 5: '𝘴', 6: '𝙨', 7: '𝓈', 8: '𝓼', 9: '𝔰', 10: '𝖘', 11: '𝚜', 12: '𝕤'},
|
||
't': { 0: '𝐭', 1: '𝑡', 2: '𝒕', 3: '𝗍', 4: '𝘁', 5: '𝘵', 6: '𝙩', 7: '𝓉', 8: '𝓽', 9: '𝔱', 10: '𝖙', 11: '𝚝', 12: '𝕥'},
|
||
'u': { 0: '𝐮', 1: '𝑢', 2: '𝒖', 3: '𝗎', 4: '𝘂', 5: '𝘶', 6: '𝙪', 7: '𝓊', 8: '𝓾', 9: '𝔲', 10: '𝖚', 11: '𝚞', 12: '𝕦'},
|
||
'v': { 0: '𝐯', 1: '𝑣', 2: '𝒗', 3: '𝗏', 4: '𝘃', 5: '𝘷', 6: '𝙫', 7: '𝓋', 8: '𝓿', 9: '𝔳', 10: '𝖛', 11: '𝚟', 12: '𝕧'},
|
||
'w': { 0: '𝐰', 1: '𝑤', 2: '𝒘', 3: '𝗐', 4: '𝘄', 5: '𝘸', 6: '𝙬', 7: '𝓌', 8: '𝔀', 9: '𝔴', 10: '𝖜', 11: '𝚠', 12: '𝕨'},
|
||
'x': { 0: '𝐱', 1: '𝑥', 2: '𝒙', 3: '𝗑', 4: '𝘅', 5: '𝘹', 6: '𝙭', 7: '𝓍', 8: '𝔁', 9: '𝔵', 10: '𝖝', 11: '𝚡', 12: '𝕩'},
|
||
'y': { 0: '𝐲', 1: '𝑦', 2: '𝒚', 3: '𝗒', 4: '𝘆', 5: '𝘺', 6: '𝙮', 7: '𝓎', 8: '𝔂', 9: '𝔶', 10: '𝖞', 11: '𝚢', 12: '𝕪'},
|
||
'z': { 0: '𝐳', 1: '𝑧', 2: '𝒛', 3: '𝗓', 4: '𝘇', 5: '𝘻', 6: '𝙯', 7: '𝓏', 8: '𝔃', 9: '𝔷', 10: '𝖟', 11: '𝚣', 12: '𝕫'},
|
||
// 'ı': {mathit: '𝚤'},
|
||
// 'ȷ': {mathit: '𝚥'},
|
||
'Α': {0: '𝚨', 1: '𝛢', 2: '𝜜', 4: '𝝖', 6: '𝞐'},
|
||
'Β': {0: '𝚩', 1: '𝛣', 2: '𝜝', 4: '𝝗', 6: '𝞑'},
|
||
'Γ': {0: '𝚪', 1: '𝛤', 2: '𝜞', 4: '𝝘', 6: '𝞒'},
|
||
'Δ': {0: '𝚫', 1: '𝛥', 2: '𝜟', 4: '𝝙', 6: '𝞓'},
|
||
'Ε': {0: '𝚬', 1: '𝛦', 2: '𝜠', 4: '𝝚', 6: '𝞔'},
|
||
'Ζ': {0: '𝚭', 1: '𝛧', 2: '𝜡', 4: '𝝛', 6: '𝞕'},
|
||
'Η': {0: '𝚮', 1: '𝛨', 2: '𝜢', 4: '𝝜', 6: '𝞖'},
|
||
'Θ': {0: '𝚯', 1: '𝛩', 2: '𝜣', 4: '𝝝', 6: '𝞗'},
|
||
'Ι': {0: '𝚰', 1: '𝛪', 2: '𝜤', 4: '𝝞', 6: '𝞘'},
|
||
'Κ': {0: '𝚱', 1: '𝛫', 2: '𝜥', 4: '𝝟', 6: '𝞙'},
|
||
'Λ': {0: '𝚲', 1: '𝛬', 2: '𝜦', 4: '𝝠', 6: '𝞚'},
|
||
'Μ': {0: '𝚳', 1: '𝛭', 2: '𝜧', 4: '𝝡', 6: '𝞛'},
|
||
'Ν': {0: '𝚴', 1: '𝛮', 2: '𝜨', 4: '𝝢', 6: '𝞜'},
|
||
'Ξ': {0: '𝚵', 1: '𝛯', 2: '𝜩', 4: '𝝣', 6: '𝞝'},
|
||
'Ο': {0: '𝚶', 1: '𝛰', 2: '𝜪', 4: '𝝤', 6: '𝞞'},
|
||
'Π': {0: '𝚷', 1: '𝛱', 2: '𝜫', 4: '𝝥', 6: '𝞟'},
|
||
'Ρ': {0: '𝚸', 1: '𝛲', 2: '𝜬', 4: '𝝦', 6: '𝞠'},
|
||
'ϴ': {0: '𝚹', 1: '𝛳', 2: '𝜭', 4: '𝝧', 6: '𝞡'},
|
||
'Σ': {0: '𝚺', 1: '𝛴', 2: '𝜮', 4: '𝝨', 6: '𝞢'},
|
||
'Τ': {0: '𝚻', 1: '𝛵', 2: '𝜯', 4: '𝝩', 6: '𝞣'},
|
||
'Υ': {0: '𝚼', 1: '𝛶', 2: '𝜰', 4: '𝝪', 6: '𝞤'},
|
||
'Φ': {0: '𝚽', 1: '𝛷', 2: '𝜱', 4: '𝝫', 6: '𝞥'},
|
||
'Χ': {0: '𝚾', 1: '𝛸', 2: '𝜲', 4: '𝝬', 6: '𝞦'},
|
||
'Ψ': {0: '𝚿', 1: '𝛹', 2: '𝜳', 4: '𝝭', 6: '𝞧'},
|
||
'Ω': {0: '𝛀', 1: '𝛺', 2: '𝜴', 4: '𝝮', 6: '𝞨'},
|
||
'∇': {0: '𝛁', 1: '𝛻', 2: '𝜵', 4: '𝝯', 6: '𝞩'},
|
||
'α': {0: '𝛂', 1: '𝛼', 2: '𝜶', 4: '𝝰', 6: '𝞪'},
|
||
'β': {0: '𝛃', 1: '𝛽', 2: '𝜷', 4: '𝝱', 6: '𝞫'},
|
||
'γ': {0: '𝛄', 1: '𝛾', 2: '𝜸', 4: '𝝲', 6: '𝞬'},
|
||
'δ': {0: '𝛅', 1: '𝛿', 2: '𝜹', 4: '𝝳', 6: '𝞭'},
|
||
'ε': {0: '𝛆', 1: '𝜀', 2: '𝜺', 4: '𝝴', 6: '𝞮'},
|
||
'ζ': {0: '𝛇', 1: '𝜁', 2: '𝜻', 4: '𝝵', 6: '𝞯'},
|
||
'η': {0: '𝛈', 1: '𝜂', 2: '𝜼', 4: '𝝶', 6: '𝞰'},
|
||
'θ': {0: '𝛉', 1: '𝜃', 2: '𝜽', 4: '𝝷', 6: '𝞱'},
|
||
'ι': {0: '𝛊', 1: '𝜄', 2: '𝜾', 4: '𝝸', 6: '𝞲'},
|
||
'κ': {0: '𝛋', 1: '𝜅', 2: '𝜿', 4: '𝝹', 6: '𝞳'},
|
||
'λ': {0: '𝛌', 1: '𝜆', 2: '𝝀', 4: '𝝺', 6: '𝞴'},
|
||
'μ': {0: '𝛍', 1: '𝜇', 2: '𝝁', 4: '𝝻', 6: '𝞵'},
|
||
'ν': {0: '𝛎', 1: '𝜈', 2: '𝝂', 4: '𝝼', 6: '𝞶'},
|
||
'ξ': {0: '𝛏', 1: '𝜉', 2: '𝝃', 4: '𝝽', 6: '𝞷'},
|
||
'ο': {0: '𝛐', 1: '𝜊', 2: '𝝄', 4: '𝝾', 6: '𝞸'},
|
||
'π': {0: '𝛑', 1: '𝜋', 2: '𝝅', 4: '𝝿', 6: '𝞹'},
|
||
'ρ': {0: '𝛒', 1: '𝜌', 2: '𝝆', 4: '𝞀', 6: '𝞺'},
|
||
'ς': {0: '𝛓', 1: '𝜍', 2: '𝝇', 4: '𝞁', 6: '𝞻'},
|
||
'σ': {0: '𝛔', 1: '𝜎', 2: '𝝈', 4: '𝞂', 6: '𝞼'},
|
||
'τ': {0: '𝛕', 1: '𝜏', 2: '𝝉', 4: '𝞃', 6: '𝞽'},
|
||
'υ': {0: '𝛖', 1: '𝜐', 2: '𝝊', 4: '𝞄', 6: '𝞾'},
|
||
'φ': {0: '𝛗', 1: '𝜑', 2: '𝝋', 4: '𝞅', 6: '𝞿'},
|
||
'χ': {0: '𝛘', 1: '𝜒', 2: '𝝌', 4: '𝞆', 6: '𝟀'},
|
||
'ψ': {0: '𝛙', 1: '𝜓', 2: '𝝍', 4: '𝞇', 6: '𝟁'},
|
||
'ω': {0: '𝛚', 1: '𝜔', 2: '𝝎', 4: '𝞈', 6: '𝟂'},
|
||
'∂': {0: '𝛛', 1: '𝜕', 2: '𝝏', 4: '𝞉', 6: '𝟃'},
|
||
'ϵ': {0: '𝛜', 1: '𝜖', 2: '𝝐', 4: '𝞊', 6: '𝟄'},
|
||
'ϑ': {0: '𝛝', 1: '𝜗', 2: '𝝑', 4: '𝞋', 6: '𝟅'},
|
||
'ϰ': {0: '𝛞', 1: '𝜘', 2: '𝝒', 4: '𝞌', 6: '𝟆'},
|
||
'ϕ': {0: '𝛟', 1: '𝜙', 2: '𝝓', 4: '𝞍', 6: '𝟇'},
|
||
'ϱ': {0: '𝛠', 1: '𝜚', 2: '𝝔', 4: '𝞎', 6: '𝟈'},
|
||
'ϖ': {0: '𝛡', 1: '𝜛', 2: '𝝕', 4: '𝞏', 6: '𝟉'},
|
||
'Ϝ': {0: '𝟊'},
|
||
'ϝ': {0: '𝟋'},
|
||
'0': {0: '𝟎', 12: '𝟘', 3: '𝟢', 4: '𝟬', 11: '𝟶'},
|
||
'1': {0: '𝟏', 12: '𝟙', 3: '𝟣', 4: '𝟭', 11: '𝟷'},
|
||
'2': {0: '𝟐', 12: '𝟚', 3: '𝟤', 4: '𝟮', 11: '𝟸'},
|
||
'3': {0: '𝟑', 12: '𝟛', 3: '𝟥', 4: '𝟯', 11: '𝟹'},
|
||
'4': {0: '𝟒', 12: '𝟜', 3: '𝟦', 4: '𝟰', 11: '𝟺'},
|
||
'5': {0: '𝟓', 12: '𝟝', 3: '𝟧', 4: '𝟱', 11: '𝟻'},
|
||
'6': {0: '𝟔', 12: '𝟞', 3: '𝟨', 4: '𝟲', 11: '𝟼'},
|
||
'7': {0: '𝟕', 12: '𝟟', 3: '𝟩', 4: '𝟳', 11: '𝟽'},
|
||
'8': {0: '𝟖', 12: '𝟠', 3: '𝟪', 4: '𝟴', 11: '𝟾'},
|
||
'9': {0: '𝟗', 12: '𝟡', 3: '𝟫', 4: '𝟵', 11: '𝟿'},
|
||
};
|
||
function GetNamesTypeFontLaTeX(nType)
|
||
{
|
||
let arrNamesGetTypeFont = Object.entries(GetTypeFont);
|
||
return arrNamesGetTypeFont.find(function (element){return element[1] === Number(nType)})
|
||
}
|
||
let GetLaTeXFont = {};
|
||
let nameOfLaTeX = Object.keys(GetMathFontChar)
|
||
for (let i = 0; i < nameOfLaTeX.length; i++)
|
||
{
|
||
let part_font = GetMathFontChar[nameOfLaTeX[i]];
|
||
let part_keys = Object.keys(part_font);
|
||
|
||
for (let j = 0; j < part_keys.length; j++)
|
||
{
|
||
GetLaTeXFont[part_font[part_keys[j]]] = [part_keys[j], nameOfLaTeX[i]];
|
||
}
|
||
}
|
||
|
||
const UnicodeWordList = {}
|
||
|
||
function LexerLiterals()
|
||
{
|
||
this.Unicode = {};
|
||
this.LaTeX = {};
|
||
this.LaTeXSpecial = undefined;
|
||
this.isUseLaTeXBrackets = false;
|
||
this.UnicodeWords = false;
|
||
|
||
this.Init();
|
||
}
|
||
LexerLiterals.prototype.Init = function (isUseUnicodeInLaTeX)
|
||
{
|
||
let names = Object.keys(this.LaTeX);
|
||
|
||
if (names.length < 1)
|
||
return false;
|
||
|
||
for (let i = 0; i < names.length; i++)
|
||
{
|
||
let name = names[i];
|
||
let data = this.LaTeX[name];
|
||
|
||
if (typeof(data) === "string")
|
||
{
|
||
this.SetUnicodeFromLaTeX(data, name);
|
||
|
||
if (this.Unicode !== UnicodeWordList)
|
||
UnicodeWordList[name] = 1;
|
||
|
||
if (isUseUnicodeInLaTeX)
|
||
this.private_AddToLaTeX(data, data);
|
||
}
|
||
}
|
||
|
||
return true;
|
||
};
|
||
LexerLiterals.prototype.IsLaTeXInclude = function (name)
|
||
{
|
||
if (!this.LaTeX)
|
||
return false;
|
||
|
||
return this.LaTeX[name] !== undefined;
|
||
};
|
||
LexerLiterals.prototype.IsUnicodeInclude = function (name)
|
||
{
|
||
if (!this.Unicode)
|
||
return false;
|
||
return this.Unicode[name] !== undefined;
|
||
};
|
||
LexerLiterals.prototype.AddToLaTeX = function (name, data)
|
||
{
|
||
if (!this.IsLaTeXInclude(name))
|
||
this.private_AddToLaTeX(name, data);
|
||
};
|
||
LexerLiterals.prototype.AddToUnicode = function (name, data)
|
||
{
|
||
if (!this.IsUnicodeInclude(name))
|
||
this.private_AddToUnicode(name, data);
|
||
};
|
||
LexerLiterals.prototype.private_AddToLaTeX = function (name, data)
|
||
{
|
||
this.LaTeX[name] = data;
|
||
this.SetUnicodeFromLaTeX(data, name);
|
||
};
|
||
LexerLiterals.prototype.private_AddToUnicode = function (name, data)
|
||
{
|
||
this.Unicode[name] = data;
|
||
this.SetLaTeXFromUnicode(data, name);
|
||
};
|
||
LexerLiterals.prototype.private_GetLaTeXWord = function (arrStr)
|
||
{
|
||
if (!arrStr || !arrStr[0])
|
||
return;
|
||
|
||
let strFunc = ""
|
||
|
||
// remove regexp
|
||
if (this.isUseLaTeXBrackets)
|
||
{
|
||
let isStartBracket = false;
|
||
let isEndBracket = false;
|
||
let isSlashes = false;
|
||
for (let index = 0; arrStr[index] && /[a-zA-Z\\{}]/.test(arrStr[index]); index++)
|
||
{
|
||
if (arrStr[index] === "{")
|
||
{
|
||
if (!isStartBracket)
|
||
isStartBracket = true;
|
||
else
|
||
return strFunc;
|
||
}
|
||
else if (arrStr[index] === "}")
|
||
{
|
||
if (!isEndBracket && isStartBracket)
|
||
isEndBracket = true;
|
||
else
|
||
return strFunc;
|
||
}
|
||
else if (arrStr[index] === "\\")
|
||
{
|
||
if (!isSlashes)
|
||
isSlashes = true;
|
||
else
|
||
return strFunc;
|
||
}
|
||
|
||
strFunc += arrStr[index];
|
||
|
||
if (this.LaTeX && this.LaTeX[strFunc])
|
||
return strFunc;
|
||
}
|
||
}
|
||
else if (this.Unicode && this.Unicode[arrStr[0]])
|
||
{
|
||
return arrStr[0];
|
||
}
|
||
else
|
||
{
|
||
let strTemp;
|
||
let isSlashes = false;
|
||
for (let index = 0; arrStr[index] && /[a-zA-Z\\ ]/.test(arrStr[index]); index++)
|
||
{
|
||
strFunc += arrStr[index]
|
||
|
||
if (this.LaTeX && this.LaTeX[strFunc])
|
||
strTemp = strFunc;
|
||
else if (this instanceof TokenFunctionLiteral && this.IsLaTeXInclude(strFunc))
|
||
strTemp = strFunc;
|
||
}
|
||
|
||
if (!strTemp)
|
||
return strFunc
|
||
|
||
return strTemp;
|
||
}
|
||
|
||
return strFunc;
|
||
};
|
||
LexerLiterals.prototype.private_GetUnicodeWord = function (arrStr)
|
||
{
|
||
if (!arrStr || !arrStr[0])
|
||
return;
|
||
|
||
let strFunc = "";
|
||
for (let index = 0; arrStr[index] && /[a-zA-Z\\ ]/.test(arrStr[index]); index++)
|
||
{
|
||
strFunc += arrStr[index]
|
||
|
||
if (this.UnicodeWords
|
||
&& ( this.UnicodeWords[strFunc]
|
||
|| (this.UnicodeWords === UnicodeWordList && strFunc[0] === '\\' && (MathAutoCorrectionFuncNames.includes(strFunc.slice(1)) || limitFunctions.includes(strFunc.slice(1))))))
|
||
return strFunc;
|
||
}
|
||
};
|
||
LexerLiterals.prototype.private_GetSpecialLaTeXWord = function (arrStr)
|
||
{
|
||
let isSlashes = false;
|
||
let strWord = "";
|
||
for (let i = 0; i < arrStr.length; i++)
|
||
{
|
||
strWord = strWord + arrStr[i];
|
||
if (this.LaTeXSpecial && this.LaTeXSpecial[strWord])
|
||
return strWord;
|
||
}
|
||
};
|
||
LexerLiterals.prototype.SetUnicodeFromLaTeX= function (name, data)
|
||
{
|
||
if (!this.Unicode[name])
|
||
this.Unicode[name] = data;
|
||
};
|
||
LexerLiterals.prototype.SetLaTeXFromUnicode = function (name, data)
|
||
{
|
||
this.LaTeX[name] = data;
|
||
};
|
||
LexerLiterals.prototype.GetToken = function (type, str)
|
||
{
|
||
if (this.UnicodeWords && !type)
|
||
{
|
||
let outputData = this.private_GetUnicodeWord(str);
|
||
|
||
if (outputData)
|
||
return outputData;
|
||
}
|
||
|
||
if (this.GetByOneRule)
|
||
return this.GetByOneRule(str);
|
||
|
||
if (!type)
|
||
return this.GetUnicodeToken(str);
|
||
else
|
||
{
|
||
if (this.LaTeXSpecial)
|
||
{
|
||
let word = this.private_GetSpecialLaTeXWord(str);
|
||
|
||
if (typeof word === "string" && word)
|
||
return word;
|
||
}
|
||
return this.GetLaTeXToken(str);
|
||
}
|
||
};
|
||
LexerLiterals.prototype.GetUnicodeToken = function (str)
|
||
{
|
||
if (this.IsUnicodeInclude(str[0]))
|
||
return str[0];
|
||
};
|
||
LexerLiterals.prototype.GetLaTeXToken = function (str)
|
||
{
|
||
let word = this.private_GetLaTeXWord(str);
|
||
|
||
if (typeof word === "string" && this.IsLaTeXInclude(word))
|
||
return word;
|
||
|
||
else if (this.IsLaTeXInclude(str[0]))
|
||
return str[0];
|
||
};
|
||
LexerLiterals.prototype.GetLaTeXWordFromSymbol = function (str)
|
||
{
|
||
let arr = Object.entries(this.LaTeX);
|
||
|
||
for (let i = 0; i < arr.length; i++)
|
||
{
|
||
let curArr = arr[i];
|
||
|
||
if (curArr[1] === str)
|
||
return curArr[0];
|
||
}
|
||
}
|
||
// Search in Unicode group of tokens
|
||
LexerLiterals.prototype.SearchU = function (str)
|
||
{
|
||
return this.IsUnicodeInclude(str);
|
||
};
|
||
// Search in LaTeX group of tokens
|
||
LexerLiterals.prototype.SearchL = function (str)
|
||
{
|
||
return this.IsLaTeXInclude(str);
|
||
};
|
||
|
||
function TokenChars()
|
||
{
|
||
this.id = 0;
|
||
this.UnicodeWords = UnicodeWordList;
|
||
}
|
||
TokenChars.prototype = Object.create(LexerLiterals.prototype);
|
||
TokenChars.prototype.constructor = TokenChars;
|
||
TokenChars.prototype.GetByOneRule = function(arrStr)
|
||
{
|
||
if (arrStr[0])
|
||
return arrStr[0];
|
||
};
|
||
TokenChars.prototype.SearchU = function (str)
|
||
{
|
||
if (str[0])
|
||
return true;
|
||
}
|
||
|
||
function TokenNumbers()
|
||
{
|
||
this.id = 1;
|
||
}
|
||
TokenNumbers.prototype = Object.create(LexerLiterals.prototype);
|
||
TokenNumbers.prototype.constructor = TokenNumbers;
|
||
TokenNumbers.prototype.GetByOneRule = function (arrStr)
|
||
{
|
||
if (['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'].includes(arrStr[0]))
|
||
return arrStr[0];
|
||
};
|
||
|
||
function TokenOperators()
|
||
{
|
||
this.id = 2;
|
||
this.LaTeX = {
|
||
"\\angle" : "∠",
|
||
"\\approx" : "≈",
|
||
"\\ast" : "∗",
|
||
"\\asymp" : "≍",
|
||
"\\because" : "∵",
|
||
"\\bot" : "⊥",
|
||
"\\bowtie" : "⋈",
|
||
"\\bullet" : "∙",
|
||
"\\cap" : "∩",
|
||
"\\cdot" : "⋅",
|
||
"\\cdots" : "⋯",
|
||
"\\circ" : "∘",
|
||
"\\clubsuit" : "♣",
|
||
"\\cong" : "≅",
|
||
"\\cup" : "∪",
|
||
"\\ddots" : "⋱",
|
||
"\\diamond" : "⋄",
|
||
"\\diamondsuit" : "♢",
|
||
"\\div" : "÷",
|
||
"\\doteq" : "≐",
|
||
"\\dots" : "…",
|
||
"\\Downarrow" : "⇓",
|
||
"\\downarrow" : "↓",
|
||
"\\equiv" : "≡",
|
||
"\\exists" : "∃",
|
||
"\\forall" : "∀",
|
||
"\\ge" : "≥",
|
||
"\\geq" : "≥",
|
||
"\\gg" : "≫",
|
||
"\\heartsuit" : "♡",
|
||
"\\in" : "∈",
|
||
"\\infty" : "∞",
|
||
"\\ldots" : "…",
|
||
"\\le" : "≤",
|
||
"\\leq" : "≤",
|
||
"\\ll" : "≪",
|
||
"\\Longleftarrow" : "⟸",
|
||
"\\longleftarrow" : "⟵",
|
||
"\\Longleftrightarrow" : "⟺",
|
||
"\\longleftrightarrow" : "⟷",
|
||
"\\Longrightarrow" : "⟹",
|
||
"\\longrightarrow" : "⟶",
|
||
"\\ne" : "≠",
|
||
"\\nearrow" : "↗",
|
||
"\\neg" : "¬",
|
||
"\\neq" : "≠",
|
||
"\\ni" : "∋",
|
||
"\\nwarrow" : "↖",
|
||
"\\odot" : "⊙",
|
||
"\\ominus" : "⊖",
|
||
"\\oplus" : "⊕",
|
||
//"\\oslash" : "⊘", // todo
|
||
"\\otimes" : "⊗",
|
||
"\\parallel" : "∥",
|
||
"\\pm": "±",
|
||
"\\prcue" : "≼",
|
||
"\\prec" : "≺",
|
||
"\\preceq" : "⪯",
|
||
"\\preccurlyeq" : "≼",
|
||
"\\propto" : "∝",
|
||
"\\ratio" : "∶",
|
||
"\\rddots" : "⋰",
|
||
"\\searrow" : "↙",
|
||
"\\setminus" : "∖",
|
||
"\\sim" : "∼",
|
||
"\\simeq" : "≃",
|
||
"\\sqcap" : "⊓",
|
||
"\\sqcup" : "⊔",
|
||
"\\sqsubseteq" : "⊑",
|
||
"\\sqsuperseteq" : "⊒",
|
||
"\\star" : "⋆",
|
||
"\\subset" : "⊂",
|
||
"\\subseteq" : "⊆",
|
||
"\\succ" : "≻",
|
||
"\\succeq" : "≽",
|
||
"\\superset" : "⊃",
|
||
"\\superseteq" : "⊇",
|
||
"\\swarrow" : "↘",
|
||
"\\therefore" : "∴",
|
||
"\\times" : "×",
|
||
"\\top" : "⊤",
|
||
"\\Uparrow" : "⇑",
|
||
"\\uparrow" : "↑",
|
||
"\\Updownarrow" : "⇕",
|
||
"\\updownarrow" : "↕",
|
||
"\\uplus" : "⊎",
|
||
"\\vdots" : "⋮",
|
||
"\\vee" : "∨",
|
||
"\\wedge" : "∧",
|
||
"\\wr" : "≀",
|
||
"\\boxdot" : "⊡",
|
||
"\\boxminus" : "⊟",
|
||
"\\boxplus" : "⊞",
|
||
"\\defeq" : "≝",
|
||
"\\degc" : "℃",
|
||
"\\degf" : "℉",
|
||
"\\Deltaeq": "≜",
|
||
"\\frown": "⌑",
|
||
"\\mp" : "∓",
|
||
"\\notcontain" : "∌",
|
||
"\\notelement" : "∉",
|
||
"\\notin" : "∉",
|
||
"\\itimes" : "",
|
||
|
||
"" : "",
|
||
"" : "",
|
||
"⨯" : "⨯",
|
||
"⨝" : "⨝",
|
||
"⟕" : "⟕",
|
||
"⟖" : "⟖",
|
||
"⟗" : "⟗",
|
||
"⋉" : "⋉",
|
||
"⋊" : "⋊",
|
||
"▷" : "▷",
|
||
"+" : "+",
|
||
"-" : "-",
|
||
"*" : "*",
|
||
"=" : "=",
|
||
"≶" : "≶",
|
||
"≷" : "≷",
|
||
};
|
||
this.Unicode = {
|
||
"" : 1,
|
||
"" : 1,
|
||
"⨯" : 1,
|
||
"⨝" : 1,
|
||
"⟕" : 1,
|
||
"⟖" : 1,
|
||
"⟗" : 1,
|
||
"⋉" : 1,
|
||
"⋊" : 1,
|
||
"▷" : 1,
|
||
"+" : 1,
|
||
"-" : 1,
|
||
"−" : 1,
|
||
"*" : 1,
|
||
"=" : 1,
|
||
"≶" : 1,
|
||
"≷" : 1,
|
||
};
|
||
this.Init(true);
|
||
}
|
||
TokenOperators.prototype = Object.create(LexerLiterals.prototype);
|
||
TokenOperators.prototype.constructor = TokenOperators;
|
||
TokenOperators.prototype.IsNeedReturnCorrected_Unicode = true;
|
||
|
||
function TokenOperand()
|
||
{
|
||
this.id = 3;
|
||
this.LaTeX = {
|
||
"\\aleph" : "ℵ",
|
||
"\\alpha" : "α",
|
||
"\\Alpha" : "Α",
|
||
"\\beta" : "β",
|
||
"\\beth" : "ℶ",
|
||
"\\bet" : "ℶ",
|
||
"\\chi" : "χ",
|
||
"\\daleth" : "ℸ",
|
||
"\\Dd" : "ⅅ",
|
||
"\\dd" : "ⅆ",
|
||
"\\degree" : "°",
|
||
"\\Delta" : "Δ",
|
||
"\\delta" : "δ",
|
||
"\\ee" : "ⅇ",
|
||
"\\ell" : "ℓ",
|
||
"\\emptyset" : "∅",
|
||
"\\epsilon" : "ϵ",
|
||
"\\eta" : "η",
|
||
"\\Gamma" : "Γ",
|
||
"\\G" : "Γ",
|
||
"\\gamma" : "γ",
|
||
"\\gimel" : "ℷ",
|
||
"\\hbar" : "ℏ",
|
||
"\\ii" : "ⅈ",
|
||
"\\Im" : "ℑ",
|
||
"\\imath" : "ı",
|
||
"\\inc" : "∆",
|
||
"\\iota" : "ι",
|
||
"\\jj" : "ⅉ",
|
||
"\\jmath" : "ȷ",
|
||
"\\kappa" : "κ",
|
||
"\\Lambda" : "Λ",
|
||
"\\lambda" : "λ",
|
||
"\\mu" : "μ",
|
||
"\\nabla" : "∇",
|
||
"\\nu" : "ν",
|
||
"\\Omega" : "Ω",
|
||
"\\omega" : "ω",
|
||
"\\partial" : "∂",
|
||
"\\Phi" : "Φ",
|
||
"\\phi" : "π",
|
||
"\\Psi" : "Ψ",
|
||
"\\psi" : "ψ",
|
||
"\\Re" : "ℜ",
|
||
"\\rho" : "ρ",
|
||
"\\Sigma" : "Σ",
|
||
"\\sigma" : "σ",
|
||
"\\tau" : "τ",
|
||
"\\Theta" : "Θ",
|
||
"\\theta" : "θ",
|
||
"\\Upsilon" : "Υ",
|
||
"\\upsilon" : "υ",
|
||
"\\varepsilon" : "ε",
|
||
"\\varphi" : "φ",
|
||
"\\varpi" : "ϖ",
|
||
"\\varrho" : "ϱ",
|
||
"\\varsigma" : "ς",
|
||
"\\vartheta" : "ϑ",
|
||
"\\wp" : "℘",
|
||
"\\Xi" : "Ξ",
|
||
"\\xi" : "ξ",
|
||
"\\zeta" : "ζ",
|
||
"\\Beta" : "Β",
|
||
"\\Epsilon" : "Ε",
|
||
"\\Zeta" : "Ζ",
|
||
"\\Eta" : "Η",
|
||
"\\Iota" : "Ι",
|
||
"\\Kappa" : "Κ",
|
||
"\\Mu" : "Μ",
|
||
"\\Nu" : "Ν",
|
||
"\\O" : "Ο",
|
||
"\\o" : "ο",
|
||
"\\pi" : "π",
|
||
"\\Pi" : "Π",
|
||
"\\Rho" : "Ρ",
|
||
"\\Tau" : "Τ",
|
||
"\\Chi" : "Χ",
|
||
|
||
"\\to" : "→",
|
||
};
|
||
this.Unicode = {};
|
||
this.Init();
|
||
}
|
||
TokenOperand.prototype = Object.create(LexerLiterals.prototype);
|
||
TokenOperand.prototype.constructor = TokenOperand;
|
||
TokenOperand.prototype.IsNeedReturnCorrected_Unicode = true;
|
||
|
||
function TokenOpenBrackets()
|
||
{
|
||
this.id = 4;
|
||
this.Unicode = {
|
||
"(" : 1,
|
||
};
|
||
this.LaTeXSpecial = {
|
||
"\\{" : "\\{",
|
||
};
|
||
this.LaTeX = {
|
||
"\\begin" : "〖",
|
||
"\\langle" : "⟨",
|
||
"\\lbrace" : "{",
|
||
"\\lbrack" : "[",
|
||
"\\lceil" : "⌈",
|
||
"\\lfloor" : "⌊",
|
||
"\\lbbrack" : "⟦",
|
||
"\\lmoust" : "⎰",
|
||
"\\bra" : "⟨",
|
||
"\\{" : "\\{",
|
||
"{" : "{",
|
||
"(" : "(",
|
||
"⟨" : "⟨",
|
||
"[" : "[",
|
||
"⌈" : "⌈",
|
||
"⌊" : "⌊",
|
||
"⟦" : "⟦",
|
||
"⎰" : "⎰",
|
||
"\\left" : 1,
|
||
};
|
||
this.Init();
|
||
}
|
||
TokenOpenBrackets.prototype = Object.create(LexerLiterals.prototype);
|
||
TokenOpenBrackets.prototype.constructor = TokenOpenBrackets;
|
||
TokenOpenBrackets.prototype.IsSimple = function (str)
|
||
{
|
||
return str === "(" ||
|
||
str === "[" ||
|
||
str === "{" ||
|
||
str === "|"
|
||
}
|
||
|
||
function TokenSpecialBrackets()
|
||
{
|
||
this.id = 544;
|
||
this.Unicode = {};
|
||
this.UnicodeWords = {
|
||
"\\open" : "├",
|
||
"\\close" : "┤",
|
||
"\\left" : "├",
|
||
"\\right" : "┤",
|
||
}
|
||
this.LaTeX = {
|
||
"\\open" : "├",
|
||
"\\close" : "┤",
|
||
"\\left" : "├",
|
||
"\\right" : "┤",
|
||
};
|
||
|
||
this.Init();
|
||
}
|
||
TokenSpecialBrackets.prototype = Object.create(LexerLiterals.prototype);
|
||
TokenSpecialBrackets.prototype.constructor = TokenSpecialBrackets;
|
||
|
||
function TokenCloseBrackets()
|
||
{
|
||
this.id = 5;
|
||
this.Unicode = {
|
||
")" : 1,
|
||
"⟫" : 1,
|
||
"⟧" : 1,
|
||
};
|
||
this.LaTeXSpecial = {
|
||
"\\}" : "\\}",
|
||
};
|
||
this.LaTeX = {
|
||
"\\end" : "〗",
|
||
"\\rangle" : "⟩",
|
||
"\\ket" : "⟩",
|
||
"\\rbrace" : "}",
|
||
"\\rbrack" : "]",
|
||
"\\rceil" : "⌉",
|
||
"\\rfloor" : "⌋",
|
||
"\\Rbrack" : "⟧",
|
||
"\\right" : 1,
|
||
"}" : "}",
|
||
")" : ")",
|
||
"⟩" : "⟩",
|
||
"]" : "]",
|
||
"⌉" : "⌉",
|
||
"⌋" : "⌋",
|
||
"⟧" : "⟧",
|
||
};
|
||
this.Init();
|
||
}
|
||
TokenCloseBrackets.prototype = Object.create(LexerLiterals.prototype);
|
||
TokenCloseBrackets.prototype.constructor = TokenCloseBrackets;
|
||
TokenCloseBrackets.prototype.IsSimple = function (str)
|
||
{
|
||
return str === ")" ||
|
||
str === "]" ||
|
||
str === "}" ||
|
||
str === "|"
|
||
}
|
||
|
||
function TokenOpenCloseBrackets()
|
||
{
|
||
this.id = 6;
|
||
this.Unicode = {};
|
||
this.LaTeXSpecial = {
|
||
"\\|" : "|",
|
||
};
|
||
this.LaTeX = {
|
||
"\\norm" : "‖",
|
||
"\\Vert" : "‖",
|
||
"\\vert" : "|",
|
||
|
||
"‖" : "‖",
|
||
"|" : "|",
|
||
};
|
||
this.Init();
|
||
}
|
||
TokenOpenCloseBrackets.prototype = Object.create(LexerLiterals.prototype);
|
||
TokenOpenCloseBrackets.prototype.constructor = TokenOpenCloseBrackets;
|
||
|
||
function TokenPhantom()
|
||
{
|
||
this.id = 7;
|
||
this.LaTeX = {
|
||
"\\asmash" : "⬆",
|
||
"\\dsmash" : "⬇",
|
||
"\\hphantom" : "⬄",
|
||
"\\hsmash" : "⬌",
|
||
"\\phantom" : "⟡",
|
||
"\\smash" : "⬍",
|
||
"\\vphantom" : "⇳",
|
||
};
|
||
this.Unicode = {};
|
||
this.Init();
|
||
}
|
||
TokenPhantom.prototype = Object.create(LexerLiterals.prototype);
|
||
TokenPhantom.prototype.constructor = TokenPhantom;
|
||
|
||
function TokenHorizontalStretch()
|
||
{
|
||
this.id = 8;
|
||
this.LaTeX = {
|
||
"\\dashv" : "⊣",
|
||
"\\gets" : "←",
|
||
"\\hookleftarrow" : "↩",
|
||
"\\hookrightarrow" : "↪",
|
||
"\\Leftarrow" : "⇐",
|
||
"\\leftarrow" : "←",
|
||
"\\leftharpoondown" : "↽",
|
||
"\\leftharpoonup" : "↼",
|
||
"\\Leftrightarrow" : "⇔",
|
||
"\\leftrightarrow" : "↔",
|
||
"\\mapsto" : "↦",
|
||
"\\models" : "⊨",
|
||
"\\Rightarrow" : "⇒",
|
||
"\\rightarrow" : "→",
|
||
"\\rightharpoondown" : "⇁",
|
||
"\\rightharpoonup" : "⇀",
|
||
//"\\to" : "→",
|
||
"\\vdash" : "⊢",
|
||
};
|
||
this.UnicodeWords = {
|
||
"\\leftarrow" : "←",
|
||
"\\leftharpoondown" : "↽",
|
||
"\\leftharpoonup" : "↼",
|
||
"\\leftrightarrow" : "↔",
|
||
}
|
||
this.Unicode = {
|
||
"←" : "\\gets",
|
||
};
|
||
this.Init();
|
||
}
|
||
TokenHorizontalStretch.prototype = Object.create(LexerLiterals.prototype);
|
||
TokenHorizontalStretch.prototype.constructor = TokenHorizontalStretch;
|
||
|
||
function TokenDivide()
|
||
{
|
||
this.id = 11;
|
||
this.LaTeXSpecial = {
|
||
"\\binom": "\\binom",
|
||
"\\sfrac": "\\sfrac",
|
||
"\\frac": "\\frac",
|
||
"\\cfrac": "\\cfrac",
|
||
"\\over" : "\\over",
|
||
};
|
||
this.LaTeX = {
|
||
"\\atop" : "¦",
|
||
"\\ndiv" : "⊘",
|
||
"\\over" : "/",
|
||
"\\sdiv" : "⁄",
|
||
"\\ldiv" : "∕",
|
||
"\\ldivide" : "∕",
|
||
};
|
||
this.Unicode = {};
|
||
this.Init();
|
||
}
|
||
TokenDivide.prototype = Object.create(LexerLiterals.prototype);
|
||
TokenDivide.prototype.constructor = TokenDivide;
|
||
|
||
function TokenEqArray()
|
||
{
|
||
this.id = 12;
|
||
this.LaTeX = {
|
||
"\\substack" : "\\substack",
|
||
};
|
||
this.Unicode = {};
|
||
this.Init();
|
||
}
|
||
TokenEqArray.prototype = Object.create(LexerLiterals.prototype);
|
||
TokenEqArray.prototype.constructor = TokenEqArray;
|
||
|
||
function TokenMarker()
|
||
{
|
||
this.id = 13;
|
||
this.LaTeX = {
|
||
"\\eqno" : "#",
|
||
};
|
||
this.Unicode = {};
|
||
this.Init();
|
||
}
|
||
TokenMarker.prototype = Object.create(LexerLiterals.prototype);
|
||
TokenMarker.prototype.constructor = TokenMarker;
|
||
|
||
function TokenSubSup()
|
||
{
|
||
this.id = 14;
|
||
this.LaTeX = {
|
||
"\\above" : "┴",
|
||
"\\below" : "┬",
|
||
"\\pppprime" : "⁗",
|
||
"\\ppprime" : "‴",
|
||
"\\pprime" : "″",
|
||
"\\prime" : "′",
|
||
"_" : "_",
|
||
"^" : "^",
|
||
};
|
||
this.Unicode = {
|
||
"_" : 1,
|
||
"^" : 1,
|
||
};
|
||
this.UnicodeWords = {
|
||
"\\above" : 1,
|
||
"\\below" : 1,
|
||
}
|
||
this.Init();
|
||
}
|
||
TokenSubSup.prototype = Object.create(LexerLiterals.prototype);
|
||
TokenSubSup.prototype.constructor = TokenSubSup;
|
||
|
||
function TokenNary()
|
||
{
|
||
this.id = 15;
|
||
this.Unicode = {
|
||
};
|
||
this.LaTeX = {
|
||
"\\amalg" : "∐",
|
||
"\\aoint": "∳",
|
||
"\\bigcap" : "⋂",
|
||
"\\bigcup" : "⋃",
|
||
"\\bigodot" : "⨀",
|
||
"\\bigoplus" : "⨁",
|
||
"\\bigotimes" : "⨂",
|
||
"\\bigsqcup" : "⨆",
|
||
"\\biguplus" : "⨄",
|
||
"\\bigvee" : "⋁",
|
||
"\\bigwedge" : "⋀",
|
||
"\\coint" : "∲",
|
||
"\\iiiint" : "⨌",
|
||
"\\iiint" : "∭",
|
||
"\\iint" : "∬",
|
||
"\\int" : "∫",
|
||
"\\oiiint" : "∰",
|
||
"\\oiint" : "∯",
|
||
"\\oint" : "∮",
|
||
"\\prod" : "∏",
|
||
"\\sum" : "∑",
|
||
};
|
||
this.Init();
|
||
}
|
||
TokenNary.prototype = Object.create(LexerLiterals.prototype);
|
||
TokenNary.prototype.constructor = TokenNary;
|
||
|
||
function TokenRadical()
|
||
{
|
||
this.id = 16;
|
||
this.Unicode = {};
|
||
this.LaTeX = {
|
||
"\\cbrt" : "∛",
|
||
"\\qdrt" : "∜",
|
||
"\\sqrt" : "√",
|
||
|
||
"\\root" : "⒭",
|
||
};
|
||
this.Init();
|
||
}
|
||
TokenRadical.prototype = Object.create(LexerLiterals.prototype);
|
||
TokenRadical.prototype.constructor = TokenRadical;
|
||
|
||
function TokenRrect()
|
||
{
|
||
this.id = 17;
|
||
this.Unicode = {};
|
||
this.LaTeX = {
|
||
"\\rrect" : "▢",
|
||
};
|
||
this.Init();
|
||
}
|
||
TokenRrect.prototype = Object.create(LexerLiterals.prototype);
|
||
TokenRrect.prototype.constructor = TokenRrect;
|
||
|
||
function TokenDelimiter()
|
||
{
|
||
this.id = 18;
|
||
this.Unicode = {};
|
||
this.LaTeX = {
|
||
"\\mid" : "∣",
|
||
"\\vbar" : "│",
|
||
|
||
};
|
||
this.Init();
|
||
}
|
||
TokenDelimiter.prototype = Object.create(LexerLiterals.prototype);
|
||
TokenDelimiter.prototype.constructor = TokenDelimiter;
|
||
|
||
function TokenAccent()
|
||
{
|
||
this.id = 19;
|
||
this.LaTeX = {
|
||
"\\hat": "̂",
|
||
"\\widehat": "̂",
|
||
"\\check": "̌",
|
||
"\\tilde": "̃",
|
||
"\\widetilde": "̃",
|
||
"\\acute": "́",
|
||
"\\grave": "̀",
|
||
"\\dot": "̇",
|
||
"\\ddddot" : "⃜",
|
||
"\\ddot": '̈',
|
||
"\\dddot": "⃛",
|
||
"\\breve": "̆",
|
||
"\\bar": "̅",
|
||
"\\Bar": "̿",
|
||
"\\vec": "⃗",
|
||
"\\lhvec" : "⃐",
|
||
"\\hvec" : "⃑",
|
||
"\\tvec" : "⃡",
|
||
"\\lvec" : "⃖",
|
||
"\\ubar": "̲",
|
||
"\\Ubar": "̳",
|
||
};
|
||
this.Unicode = {};
|
||
|
||
this.Init();
|
||
}
|
||
TokenAccent.prototype = Object.create(LexerLiterals.prototype);
|
||
TokenAccent.prototype.IsUnicodeToken = function (str)
|
||
{
|
||
if (!str || !str[0])
|
||
return;
|
||
|
||
let strFirstSymbol = str[0];
|
||
|
||
let code = strFirstSymbol.charCodeAt(0);
|
||
const isFirstBlocks = function (code) {
|
||
return code >= 768 && code <= 879
|
||
}
|
||
const isSecondBlocks = function (code) {
|
||
return code >= 8400 && code <= 8447
|
||
}
|
||
|
||
if (isFirstBlocks(code) || isSecondBlocks(code))
|
||
return strFirstSymbol;
|
||
};
|
||
|
||
function TokenBox()
|
||
{
|
||
this.id = 20;
|
||
this.Unicode = {};
|
||
this.LaTeX = {
|
||
"\\box" : "□"
|
||
};
|
||
this.Init();
|
||
}
|
||
TokenBox.prototype = Object.create(LexerLiterals.prototype);
|
||
TokenBox.prototype.constructor = TokenBox;
|
||
|
||
function TokenMatrix()
|
||
{
|
||
this.id = 21;
|
||
this.data = ["⒩", "■"];
|
||
this.Unicode = {};
|
||
this.LaTeX = {
|
||
"\\matrix" : "■",
|
||
"\\eqarray" : "█",
|
||
|
||
"\\begin{cases}" : 1,
|
||
"\\begin{pmatrix}" : 1,
|
||
"\\begin{matrix}" : 1,
|
||
"\\begin{bmatrix}" : 1,
|
||
"\\begin{Bmatrix}" : 1,
|
||
"\\begin{vmatrix}" : 1,
|
||
"\\begin{Vmatrix}" : 1,
|
||
"\\begin{equation}" : 1,
|
||
|
||
"\\end{cases}" : 2,
|
||
"\\end{pmatrix}" : 2,
|
||
"\\end{matrix}" : 2,
|
||
"\\end{bmatrix}" : 2,
|
||
"\\end{Bmatrix}" : 2,
|
||
"\\end{vmatrix}" : 2,
|
||
"\\end{Vmatrix}" : 2,
|
||
"\\end{equation}" : 2,
|
||
};
|
||
this.Init();
|
||
}
|
||
TokenMatrix.prototype = Object.create(LexerLiterals.prototype);
|
||
TokenMatrix.prototype.constructor = TokenMatrix;
|
||
TokenMatrix.prototype.isUseLaTeXBrackets = true;
|
||
|
||
function TokenArray()
|
||
{
|
||
this.id = 89;
|
||
this.data = [];
|
||
this.Unicode = {};
|
||
this.LaTeX = {
|
||
"\\begin{array}" : 1,
|
||
"\\end{array}" : 2,
|
||
"\\array{" : 1,
|
||
"\\begin{aligned}": 1,
|
||
"\\end{aligned}": 2,
|
||
"\\begin{gathered}": 1,
|
||
"\\end{gathered}": 2,
|
||
};
|
||
this.Init();
|
||
}
|
||
TokenArray.prototype = Object.create(LexerLiterals.prototype);
|
||
TokenArray.prototype.constructor = TokenArray;
|
||
TokenArray.prototype.isUseLaTeXBrackets = true;
|
||
|
||
function TokenRect()
|
||
{
|
||
this.id = 22;
|
||
this.Unicode = {};
|
||
this.LaTeX = {
|
||
"\\rect" : "▭",
|
||
};
|
||
this.Init();
|
||
}
|
||
TokenRect.prototype = Object.create(LexerLiterals.prototype);
|
||
TokenRect.prototype.constructor = TokenRect;
|
||
|
||
function TokenSpace()
|
||
{
|
||
this.id = 23;
|
||
this.Unicode = {
|
||
" " : 1, // 2/18em space very thin math space
|
||
" " : 1, // 7/18em space very very thick math space
|
||
" " : 1,
|
||
"\t" : 1,
|
||
"\n" : 1,
|
||
" " : 1,
|
||
"" : 1,
|
||
};
|
||
this.LaTeX = {
|
||
"\\nbsp" : " ", // space width && no-break space
|
||
"\\numsp" : " ", // digit width
|
||
"\\emsp" : " ", // 18/18 em
|
||
"\\ensp" : " ", // 9/18 em
|
||
"\\vthicksp": " ", // 6/18 em verythickmathspace
|
||
"\\thicksp" : " ", // 5/18 em thickmathspace
|
||
"\\medsp" : " ", // 4/18 em mediummathspace
|
||
"\\thinsp" : " ", // 3/18 em thinmathspace
|
||
"\\hairsp" : " ", // 3/18 em veryverythinmathspace
|
||
"\\zwsp" : "",
|
||
"\\zwnj" : "",
|
||
" " : " ",
|
||
|
||
"\\ " : " ",
|
||
"\\quad" : " "
|
||
// "\\qquad" : " ",
|
||
// "\:" : " ",
|
||
// "\;" : " ",
|
||
//"\!" : "",
|
||
|
||
};
|
||
this.Init();
|
||
}
|
||
TokenSpace.prototype = Object.create(LexerLiterals.prototype);
|
||
TokenSpace.prototype.constructor = TokenSpace;
|
||
|
||
function TokenLaTeXWords()
|
||
{
|
||
this.LaTeX = {
|
||
"\\nolimits": "\\nolimits",
|
||
"\\underset": "\\underset",
|
||
"\\overset": "\\overset",
|
||
"\\operatorname": "\\operatorname"
|
||
};
|
||
this.id = 24;
|
||
this.isClassEqalData = true;
|
||
}
|
||
TokenLaTeXWords.prototype = Object.create(LexerLiterals.prototype);
|
||
TokenLaTeXWords.prototype.constructor = TokenLaTeXWords;
|
||
TokenLaTeXWords.prototype.SearchForLaTeXToken = function (arrStr)
|
||
{
|
||
return this.private_GetLaTeXWord(arrStr);
|
||
};
|
||
|
||
function TokenFunctionLiteral()
|
||
{
|
||
this.id = 25;
|
||
}
|
||
TokenFunctionLiteral.prototype = Object.create(LexerLiterals.prototype);
|
||
TokenFunctionLiteral.prototype.constructor = TokenFunctionLiteral;
|
||
TokenFunctionLiteral.prototype.IsLaTeXInclude = function (str)
|
||
{
|
||
if (MathAutoCorrectionFuncNames.includes(str.slice(1)) || limitFunctions.includes(str.slice(1)))
|
||
return str;
|
||
};
|
||
TokenFunctionLiteral.prototype.IsLaTeXIncludeNormal = function (str)
|
||
{
|
||
if (MathAutoCorrectionFuncNames.includes(str.slice(1)))
|
||
return str;
|
||
}
|
||
TokenFunctionLiteral.prototype.IsLaTeXIncludeLimit = function (str)
|
||
{
|
||
if (limitFunctionsLaTeX.includes(str.slice(1)))
|
||
return str;
|
||
}
|
||
TokenFunctionLiteral.prototype.IsUnicodeInclude = function(arrStr)
|
||
{
|
||
if (!arrStr)
|
||
return;
|
||
|
||
if (!Array.isArray(arrStr))
|
||
arrStr = [arrStr];
|
||
|
||
let strLast = "";
|
||
|
||
function IsFunc(arrStr)
|
||
{
|
||
let str = arrStr.join("");
|
||
if (oMathAutoCorrection.arrFunctionsNames[str] === null)
|
||
strLast = str;
|
||
}
|
||
|
||
for (let i = 1; i <= arrStr.length; i++)
|
||
{
|
||
IsFunc(arrStr.slice(0, i), i);
|
||
}
|
||
|
||
if (strLast)
|
||
return strLast;
|
||
};
|
||
TokenFunctionLiteral.prototype.GetUnicodeToken = function (arrStr)
|
||
{
|
||
return this.IsUnicodeInclude(arrStr);
|
||
};
|
||
|
||
function TokenSpecialLiteral()
|
||
{
|
||
this.id = 26;
|
||
this.Unicode = {
|
||
// "┬" : 1,
|
||
// "┴" : 1,
|
||
"&" : 1,
|
||
"@" : 1,
|
||
};
|
||
this.LaTeX = {
|
||
// "\\cases" : "Ⓒ",
|
||
// "\\j" : "Jay",
|
||
}
|
||
|
||
}
|
||
TokenSpecialLiteral.prototype = Object.create(LexerLiterals.prototype);
|
||
TokenSpecialLiteral.prototype.constructor = TokenSpecialLiteral;
|
||
|
||
function TokenOther()
|
||
{
|
||
this.id = 27;
|
||
this.Unicode = {};
|
||
this.LaTeX = {};
|
||
this.Init();
|
||
}
|
||
TokenOther.prototype = Object.create(LexerLiterals.prototype);
|
||
TokenOther.prototype.constructor = TokenOther;
|
||
TokenOther.prototype.GetUnicodeToken = function(arrStr)
|
||
{
|
||
let intCode = GetFixedCharCodeAt(arrStr[0]);
|
||
if (intCode >= 0x1D400 && intCode <= 0x1D7FF)
|
||
return arrStr[0];
|
||
};
|
||
|
||
function TokenHorizontalBrackets()
|
||
{
|
||
this.id = 28;
|
||
this.LaTeX = {
|
||
"\\overparen": "⏜",
|
||
"\\underparen": "⏝",
|
||
"\\overbrace": "⏞",
|
||
"\\overline": "¯",
|
||
"\\underbar" : "▁",
|
||
"\\overbar" : "¯",
|
||
"\\underbrace": "⏟",
|
||
"\\overshell": "⏠",
|
||
"\\undershell": "⏡",
|
||
"\\overbracket": "⎴",
|
||
"\\underbracket": "⎵",
|
||
"\\underline" : "▁",
|
||
};
|
||
this.Unicode = {};
|
||
this.Init();
|
||
}
|
||
TokenHorizontalBrackets.prototype = Object.create(LexerLiterals.prototype);
|
||
TokenHorizontalBrackets.prototype.constructor = TokenHorizontalBrackets;
|
||
TokenHorizontalBrackets.prototype.GetPos = function (str)
|
||
{
|
||
switch (str) {
|
||
case "⏜": return VJUST_TOP;
|
||
case "⏝": return VJUST_BOT;
|
||
case "⏞": return VJUST_TOP;
|
||
case "⏟": return VJUST_BOT;
|
||
case "⏠": return VJUST_TOP;
|
||
case "⏡": return VJUST_BOT;
|
||
case "⎴": return VJUST_BOT;
|
||
case "⎵": return VJUST_TOP;
|
||
case "▁": return VJUST_BOT;
|
||
case "¯": return VJUST_TOP;
|
||
|
||
case "\\overparen": return VJUST_TOP;
|
||
case "\\underparen": return VJUST_BOT;
|
||
case "\\overbrace": return VJUST_TOP;
|
||
case "\\overline": return VJUST_TOP;
|
||
case "\\underbar" : return VJUST_BOT;
|
||
case "\\overbar" : return VJUST_TOP;
|
||
case "\\underbrace": return VJUST_BOT;
|
||
case "\\overshell": return VJUST_TOP;
|
||
case "\\undershell": return VJUST_BOT;
|
||
case "\\overbracket": return VJUST_TOP;
|
||
case "\\underbracket": return VJUST_BOT;
|
||
case "\\underline" : return VJUST_BOT;
|
||
}
|
||
}
|
||
|
||
function TokenInvisibleOperators()
|
||
{
|
||
this.id = 29;
|
||
this.Unicode = {};
|
||
this.LaTeX = {
|
||
"\\funcapply" : "", // Invisible function application
|
||
};
|
||
this.Init();
|
||
}
|
||
TokenInvisibleOperators.prototype = Object.create(LexerLiterals.prototype);
|
||
TokenInvisibleOperators.prototype.constructor = TokenInvisibleOperators;
|
||
|
||
function TokenAlphanumeric()
|
||
{
|
||
this.id = 30;
|
||
this.Unicode = {};
|
||
this.LaTeX = {};
|
||
this.Init();
|
||
}
|
||
TokenAlphanumeric.prototype = Object.create(LexerLiterals.prototype);
|
||
TokenAlphanumeric.prototype.constructor = TokenAlphanumeric;
|
||
TokenAlphanumeric.prototype.GetUnicodeToken = function(arrStr)
|
||
{
|
||
let intCode = GetFixedCharCodeAt(arrStr[0]);
|
||
if (intCode >= 0x1D400 && intCode <= 0x1D7FF || intCode >= 0x2102 && intCode <= 0x2134)
|
||
return arrStr[0];
|
||
};
|
||
|
||
function TokenFont()
|
||
{
|
||
this.id = 31;
|
||
this.Unicode = {};
|
||
this.LaTeX = {
|
||
// Standart Word functions with higher proirity for linear format
|
||
"\\mathcal": "\\mathcal",
|
||
"\\mathsf": "\\mathsf",
|
||
"\\mathrm": "\\mathrm",
|
||
"\\mathit": "\\mathit",
|
||
"\\mathfrak": "\\mathfrak",
|
||
"\\mathbfcal": "\\mathbfcal",
|
||
"\\mathbf": "\\mathbf",
|
||
"\\mathbb": "\\mathbb",
|
||
|
||
// other LaTeX functions
|
||
"\\sf": "\\sf",
|
||
"\\script":"\\script",
|
||
"\\scr":"\\scr",
|
||
"\\rm": "\\rm",
|
||
"\\oldstyle":"\\oldstyle",
|
||
"\\mathtt": "\\mathtt",
|
||
"\\mathsfit":"\\mathsfit",
|
||
"\\mathsfbfit":"\\mathsfbfit",
|
||
"\\mathsfbf":"\\mathsfbf",
|
||
"\\mathbfit":"\\mathbfit",
|
||
"\\mathbffrak": "\\mathbffrak",
|
||
"\\it":"\\it",
|
||
"\\fraktur":"\\fraktur",
|
||
"\\frak":"\\frak",
|
||
"\\double": "\\double",
|
||
};
|
||
this.Init();
|
||
}
|
||
TokenFont.prototype = Object.create(LexerLiterals.prototype);
|
||
TokenFont.prototype.constructor = TokenFont;
|
||
TokenFont.prototype.GetType = function (strToken)
|
||
{
|
||
return GetTypeFont[strToken];
|
||
};
|
||
TokenFont.prototype.GetTypes = function ()
|
||
{
|
||
return GetTypeFont;
|
||
}
|
||
|
||
function TokenOf()
|
||
{
|
||
this.id = 32;
|
||
this.Unicode = {};
|
||
this.LaTeX = {
|
||
"\\of" : "▒",
|
||
"\\naryand" : "▒",
|
||
};
|
||
this.Init();
|
||
}
|
||
TokenOf.prototype = Object.create(LexerLiterals.prototype)
|
||
TokenOf.prototype.constructor = TokenOf;
|
||
|
||
function TokenArrayMatrix()
|
||
{
|
||
this.id = 33;
|
||
this.Unicode = {};
|
||
this.LaTeX = {
|
||
"\\\\" : "\\\\",
|
||
};
|
||
this.Init();
|
||
}
|
||
TokenArrayMatrix.prototype = Object.create(LexerLiterals.prototype)
|
||
TokenArrayMatrix.prototype.constructor = TokenArrayMatrix;
|
||
TokenArrayMatrix.prototype.GetLaTeXToken = function (str)
|
||
{
|
||
if (str[0] === "\\" && str[1] === "\\")
|
||
return "\\\\"
|
||
}
|
||
|
||
function TokenPunctuation()
|
||
{
|
||
this.id = 34;
|
||
this.Unicode = {};
|
||
this.LaTeX = {};
|
||
//for now, later add Unicode
|
||
this.LaTeXSpecial = {
|
||
",": ",",
|
||
".": ".",
|
||
};
|
||
this.Init();
|
||
}
|
||
TokenPunctuation.prototype = Object.create(LexerLiterals.prototype)
|
||
TokenPunctuation.prototype.constructor = TokenPunctuation;
|
||
|
||
function TokenText()
|
||
{
|
||
this.id = 35;
|
||
this.Unicode = {};
|
||
this.LaTeX = {};
|
||
//for now, later add Unicode
|
||
this.LaTeXSpecial = {
|
||
"\\text": "\\text"
|
||
};
|
||
this.Init();
|
||
}
|
||
TokenText.prototype = Object.create(LexerLiterals.prototype)
|
||
TokenText.prototype.constructor = TokenText;
|
||
|
||
//---------------------------------------Initialize data for Tokenizer----------------------------------------------
|
||
|
||
// List of tokens types for parsers processing
|
||
const MathLiterals = {
|
||
subSup: new TokenSubSup(),
|
||
func: new TokenFunctionLiteral(),
|
||
LaTeX: new TokenLaTeXWords(),
|
||
alphanumeric: new TokenAlphanumeric(),
|
||
other: new TokenOther(),
|
||
radical: new TokenRadical(),
|
||
nary: new TokenNary(),
|
||
invisible: new TokenInvisibleOperators(),
|
||
divide: new TokenDivide(),
|
||
hbrack: new TokenHorizontalBrackets(),
|
||
specialBrac: new TokenSpecialBrackets(),
|
||
lrBrackets: new TokenOpenCloseBrackets(),
|
||
rBrackets: new TokenCloseBrackets(),
|
||
lBrackets: new TokenOpenBrackets(),
|
||
operand: new TokenOperand(),
|
||
operator: new TokenOperators(),
|
||
space: new TokenSpace(),
|
||
accent: new TokenAccent(),
|
||
number: new TokenNumbers(),
|
||
special: new TokenSpecialLiteral(),
|
||
box: new TokenBox(),
|
||
rect: new TokenRect(),
|
||
matrix: new TokenMatrix(),
|
||
array: new TokenArray(),
|
||
font: new TokenFont(),
|
||
of: new TokenOf(),
|
||
delimiter: new TokenDelimiter(),
|
||
char: new TokenChars(),
|
||
horizontal: new TokenHorizontalStretch(),
|
||
arrayMatrix: new TokenArrayMatrix(),
|
||
eqArray: new TokenEqArray(),
|
||
punct: new TokenPunctuation(),
|
||
text: new TokenText()
|
||
};
|
||
|
||
// The array defines the sequence in which the tokens are checked by the lexer
|
||
// the higher an element is, the lower its priority
|
||
const arrTokensCheckerList = [
|
||
MathLiterals.char,
|
||
MathLiterals.func,
|
||
MathLiterals.specialBrac,
|
||
MathLiterals.LaTeX,
|
||
MathLiterals.font,
|
||
MathLiterals.delimiter,
|
||
MathLiterals.special,
|
||
MathLiterals.of,
|
||
MathLiterals.number,
|
||
MathLiterals.operand,
|
||
MathLiterals.accent,
|
||
MathLiterals.operator,
|
||
MathLiterals.divide,
|
||
MathLiterals.rect,
|
||
MathLiterals.lBrackets,
|
||
MathLiterals.rBrackets,
|
||
MathLiterals.lrBrackets,
|
||
MathLiterals.hbrack,
|
||
MathLiterals.invisible,
|
||
MathLiterals.horizontal,
|
||
MathLiterals.matrix,
|
||
MathLiterals.array,
|
||
MathLiterals.nary,
|
||
MathLiterals.radical,
|
||
MathLiterals.other,
|
||
MathLiterals.alphanumeric,
|
||
MathLiterals.subSup,
|
||
MathLiterals.arrayMatrix,
|
||
MathLiterals.eqArray,
|
||
MathLiterals.punct,
|
||
MathLiterals.space,
|
||
MathLiterals.text
|
||
];
|
||
|
||
//-------------------------------------Generating AutoCorrection Rules----------------------------------------------
|
||
|
||
// Special autocorrection elements (doesn't start with //)
|
||
const SpecialAutoCorrection = {
|
||
"!!" : "‼",
|
||
"...": "…",
|
||
"::" : "∷",
|
||
":=" : "≔",
|
||
|
||
"~=" : "≅",
|
||
"+-" : "±",
|
||
"-+" : "∓",
|
||
"<<" : "≪",
|
||
"<=" : "≤",
|
||
"->" : "→",
|
||
">=" : "≥",
|
||
">>" : "≫",
|
||
"/<" : "≮",
|
||
"/=" : "≠",
|
||
};
|
||
const MathAutoCorrectionLong = {
|
||
"\\binomial" : "(a+b)^n=∑_(k=0)^n ▒(n¦k)a^k b^(n-k)",
|
||
"\\integral": "1/2π ∫_0^2π ▒ⅆθ/(a+b sin θ)=1/√(a^2-b^2)",
|
||
"\\identitymatrix": "(■(1&0&0@0&1&0@0&0&1))",
|
||
"\\break": "⤶",
|
||
"\\limit" : "lim_(n→∞)〖(1+1/n)^n〗=e",
|
||
}
|
||
|
||
// Generate autocorrection rules
|
||
function MathAutoCorrectionList() // oMathAutoCorrection
|
||
{
|
||
this.arrRuleList = [];
|
||
this.oGeneralRules = {};
|
||
this.oSpecialList = {};
|
||
this.arrFunctionsNames = {
|
||
'arcsin' : null,
|
||
'asin' : null,
|
||
'sin' : null,
|
||
'arcsinh' : null,
|
||
'asinh' : null,
|
||
'sinh' : null,
|
||
'arcsec' : null,
|
||
'sec' : null,
|
||
'asec' : null,
|
||
'arcsech' : null,
|
||
'asech' : null,
|
||
'sech' : null,
|
||
'arccos' : null,
|
||
'acos' : null,
|
||
'cos' : null,
|
||
'arccosh' : null,
|
||
'acosh' : null,
|
||
'cosh' : null,
|
||
'arccsc' : null,
|
||
'acsc' : null,
|
||
'csc' : null,
|
||
'arccsch' : null,
|
||
'acsch' : null,
|
||
'csch' : null,
|
||
'arctan' : null,
|
||
'atan' : null,
|
||
'tan' : null,
|
||
'arctanh' : null,
|
||
'atanh' : null,
|
||
'tanh' : null,
|
||
'arccot' : null,
|
||
'acot' : null,
|
||
'cot' : null,
|
||
'arccoth' : null,
|
||
'acoth' : null,
|
||
'coth' : null,
|
||
'arg' : null,
|
||
'det' : null,
|
||
'exp' : null,
|
||
'inf' : null,
|
||
'lim' : null,
|
||
'min' : null,
|
||
'def' : null,
|
||
'dim' : null,
|
||
'gcd' : null,
|
||
'log' : null,
|
||
'Pr' : null,
|
||
'deg' : null,
|
||
'erf' : null,
|
||
'lg' : null,
|
||
'ln' : null,
|
||
'max' : null,
|
||
'sup' : null,
|
||
"ker" : null,
|
||
'hom' : null,
|
||
'sgn' : null,
|
||
};
|
||
this.GenerateTokens();
|
||
|
||
return this;
|
||
}
|
||
MathAutoCorrectionList.prototype.AddObjectToGeneral = function (oObj)
|
||
{
|
||
this.oGeneralRules = Object.assign(this.oGeneralRules, oObj);
|
||
};
|
||
MathAutoCorrectionList.prototype.AddData = function (name, data)
|
||
{
|
||
this.oGeneralRules[name] = data;
|
||
};
|
||
MathAutoCorrectionList.prototype.GenerateTokens = function ()
|
||
{
|
||
this.GenerateAutoCorrectionList();
|
||
this.GenerateTokensByFont();
|
||
this.GenerateSpecialRules();
|
||
this.GenerateCustomRules();
|
||
|
||
const CheckSort = function (a,b)
|
||
{
|
||
if (a[0] < b[0])
|
||
{
|
||
return -1;
|
||
}
|
||
else if (a[0] > b[0])
|
||
{
|
||
return 1;
|
||
}
|
||
|
||
return 0;
|
||
};
|
||
const IsSpecialRule = function(rule)
|
||
{
|
||
return rule[0][0] !== "\\";
|
||
}
|
||
|
||
for (let i = 0; i < this.arrRuleList.length; i++)
|
||
{
|
||
let arrCurrentRule = this.arrRuleList[i];
|
||
if (IsSpecialRule(arrCurrentRule))
|
||
{
|
||
let strName = arrCurrentRule[0];
|
||
let oData = arrCurrentRule[1];
|
||
this.oSpecialList[strName] = oData;
|
||
}
|
||
}
|
||
|
||
this.arrRuleList.sort(CheckSort);
|
||
};
|
||
MathAutoCorrectionList.prototype.GenerateTokensByFont = function ()
|
||
{
|
||
let arr_Literals = [
|
||
'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
|
||
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
|
||
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'
|
||
];
|
||
|
||
let oFontTypes = MathLiterals.font.GetTypes();
|
||
let name = Object.keys(oFontTypes);
|
||
|
||
for (let j = 0; j < name.length; j++)
|
||
{
|
||
let indexOfFont = oFontTypes[name[j]];
|
||
for (let i = 0; i < arr_Literals.length; i++)
|
||
{
|
||
let Current = GetMathFontChar[arr_Literals[i]];
|
||
if (Current[indexOfFont])
|
||
{
|
||
let strName = name[j] + arr_Literals[i];
|
||
let intData = Current[indexOfFont].codePointsArray([]);
|
||
let arrCorrectionRule = [strName, intData];
|
||
this.AddData(strName, intData);
|
||
this.arrRuleList.push(arrCorrectionRule);
|
||
}
|
||
}
|
||
}
|
||
};
|
||
MathAutoCorrectionList.prototype.GenerateSpecialRules = function ()
|
||
{
|
||
let name = Object.keys(MathAutoCorrectionLong);
|
||
|
||
for (let j = 0; j < name.length; j++)
|
||
{
|
||
let strName = name[j];
|
||
let strData = AscCommon.convertUTF16toUnicode(MathAutoCorrectionLong[strName]);
|
||
let arrAutoCorrectionRule = [strName, strData];
|
||
|
||
this.arrRuleList.push(arrAutoCorrectionRule);
|
||
}
|
||
};
|
||
MathAutoCorrectionList.prototype.GenerateAutoCorrectionList = function ()
|
||
{
|
||
let names = Object.keys(MathLiterals);
|
||
|
||
for (let i = 0; i < names.length; i++)
|
||
{
|
||
let name = names[i];
|
||
let oData = MathLiterals[name].LaTeX;
|
||
|
||
if (oData)
|
||
{
|
||
let innerNames = Object.keys(oData);
|
||
for (let i = 0; i < innerNames.length; i++)
|
||
{
|
||
let strName = innerNames[i];
|
||
let strData = AscCommon.convertUTF16toUnicode(oData[strName]);
|
||
|
||
if (strData)
|
||
{
|
||
let arrRule = [strName, strData]
|
||
this.AddData(strName, strData);
|
||
this.arrRuleList.push(arrRule);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
MathAutoCorrectionList.prototype.GenerateCustomRules = function ()
|
||
{
|
||
let name = Object.keys(SpecialAutoCorrection);
|
||
|
||
for (let j = 0; j < name.length; j++)
|
||
{
|
||
let strName = name[j];
|
||
let strData = AscCommon.convertUTF16toUnicode(SpecialAutoCorrection[strName]);
|
||
let arrAutoCorrectionRule = [strName, strData];
|
||
|
||
this.AddData(strName, strData);
|
||
this.arrRuleList.push(arrAutoCorrectionRule);
|
||
}
|
||
};
|
||
|
||
// Array defining which words cannot be corrected during LaTeX processing
|
||
const arrDoNotConvertWordsForLaTeX = [
|
||
"\\left", "\\right",
|
||
"\\array",
|
||
"\\begin", "\\end",
|
||
"\\matrix",
|
||
"\\below", "\\above",
|
||
"\\box", "\\fbox", "\\rect",
|
||
|
||
"\\sum", "\\prod", "\\amalg", "\\coprod", "\\bigwedge",
|
||
"\\bigvee", "\\bigcup", "\\bigcap", "\\bigsqcup", "\\biguplus",
|
||
"\\bigodot", "\\bigoplus", "\\bigotimes",
|
||
"\\int", "\\iint", "\\iiint", "\\iiiint", "\\oint", "\\oiint",
|
||
"\\oiiint", "\\coint", "\\aouint",
|
||
];
|
||
let oMathAutoCorrection = new MathAutoCorrectionList();
|
||
// Default list of autocorrection elements
|
||
let AutoCorrectionList = oMathAutoCorrection.arrRuleList;
|
||
// Array with function names for autocorrection
|
||
const MathAutoCorrectionFuncNames = [
|
||
'arcsin', 'asin', 'sin', 'arcsinh', 'asinh', 'sinh',
|
||
'arcsec', 'sec', 'asec', 'arcsech', 'asech','sech',
|
||
'arccos', 'acos', 'cos', 'arccosh','acosh', 'cosh',
|
||
'arccsc', 'acsc', 'csc', 'arccsch', 'acsch', 'csch',
|
||
'arctan', 'atan', 'tan', 'arctanh', 'atanh', 'tanh',
|
||
'arccot', 'acot', 'cot', 'arccoth', 'acoth', 'coth',
|
||
'arg', 'det', 'exp', 'inf', 'lim', 'min',
|
||
'def', 'dim', 'gcd', 'ker', 'log', 'Pr',
|
||
'deg', 'erf', 'hom', 'lg', 'ln', 'max', 'sup', "ker",
|
||
'hom', 'sgn',
|
||
];
|
||
// List of structures types that generate parsers
|
||
const MathStructures = {
|
||
char: 0,
|
||
space: 1,
|
||
number: 2,
|
||
other: 3,
|
||
frac: 5,
|
||
bracket_block: 6,
|
||
minus: 7,
|
||
plain: 8,
|
||
bar: 9,
|
||
nary: 10,
|
||
box: 11,
|
||
rect: 12,
|
||
radical:13,
|
||
func: 14,
|
||
pre_script: 15,
|
||
sub_sub: 16,
|
||
func_lim: 18,
|
||
limit: 19,
|
||
diacritic_base: 20,
|
||
matrix: 21,
|
||
accent: 22,
|
||
group_character: 23,
|
||
horizontal: 24,
|
||
array: 25,
|
||
};
|
||
|
||
const oNamesOfLiterals = {
|
||
fractionLiteral: [0, "FractionLiteral"],
|
||
spaceLiteral: [1, "SpaceLiteral", MathLiterals.space],
|
||
charLiteral: [2, "CharLiteral"],
|
||
operatorLiteral: [5, "OperatorLiteral"],
|
||
binomLiteral: [6, "BinomLiteral"],
|
||
bracketBlockLiteral: [7, "BracketBlock"],
|
||
functionLiteral: [8, "FunctionLiteral"],
|
||
subSupLiteral: [9, "SubSupLiteral"],
|
||
sqrtLiteral: [10, "SqrtLiteral"],
|
||
numberLiteral: [11, "NumberLiteral"],
|
||
mathOperatorLiteral: [12, "MathOperatorLiteral"],
|
||
rectLiteral: [13, "RectLiteral"],
|
||
boxLiteral: [14, "BoxLiteral"],
|
||
borderBoxLiteral: [58, "BorderBoxLiteral"],
|
||
preScriptLiteral: [15, "PreScriptLiteral"],
|
||
mathFontLiteral: [16, "MathFontLiteral"],
|
||
overLiteral: [17, "OverLiteral"],
|
||
diacriticLiteral: [18, "DiacriticLiteral"],
|
||
diacriticBaseLiteral: [19, "DiacriticBaseLiteral"],
|
||
otherLiteral: [20, "OtherLiteral"],
|
||
anMathLiteral: [21, "AnMathLiteral"],
|
||
opBuildupLiteral: [22, "opBuildUpLiteral"],
|
||
opOpenBracket: [23, "opOpenLiteral"],
|
||
opCloseBracket: [24, "opCLoseLiteral"],
|
||
opOpenCloseBracket: [25, "opCloseLiteral"],
|
||
hBracketLiteral: [28, "hBracketLiteral"],
|
||
opNaryLiteral: [29, "opNaryLiteral"],
|
||
asciiLiteral: [30, "asciiLiteral"],
|
||
opArrayLiteral: [31, "opArrayLiteral"],
|
||
opDecimal: [32, "opDecimal"],
|
||
|
||
specialScriptNumberLiteral: [33, "specialScriptLiteral"],
|
||
specialScriptCharLiteral: [34, "specialScriptLiteral"],
|
||
specialScriptBracketLiteral: [35, "specialScriptBracketLiteral"],
|
||
specialScriptOperatorLiteral: [36, "specialScriptBracketLiteral"],
|
||
|
||
specialIndexNumberLiteral: [37, "specialScriptLiteral"],
|
||
specialIndexCharLiteral: [38, "specialScriptLiteral"],
|
||
specialIndexBracketLiteral: [39, "specialScriptBracketLiteral"],
|
||
specialIndexOperatorLiteral: [40, "specialScriptBracketLiteral"],
|
||
|
||
textPlainLiteral: [41, "textPlainLiteral"],
|
||
nthrtLiteral: [42, "nthrtLiteral"],
|
||
fourthrtLiteral: [43, "fourthrtLiteral"],
|
||
cubertLiteral: [44, "cubertLiteral"],
|
||
overBarLiteral: [45, "overBarLiteral"],
|
||
|
||
factorialLiteral: [46, "factorialLiteral"],
|
||
rowLiteral: [47, "rowLiteral"],
|
||
rowsLiteral: [48, "rowsLiteral"],
|
||
|
||
minusLiteral: [49, "minusLiteral"],
|
||
LaTeXLiteral: [50, "LaTeXLiteral"],
|
||
|
||
functionWithLimitLiteral: [51, "functionWithLimitLiteral"],
|
||
functionNameLiteral: [52, "functionNameLiteral"],
|
||
matrixLiteral: [53, "matrixLiteral"],
|
||
arrayLiteral: [53, "arrayLiteral"],
|
||
|
||
skewedFractionLiteral: [54, "skewedFractionLiteral"],
|
||
EqArrayliteral: [55, "EqArrayliteral"],
|
||
|
||
groupLiteral: [56, "GroupLiteral"],
|
||
belowAboveLiteral: [57, "BelowAboveLiteral"],
|
||
|
||
};
|
||
|
||
function AddFunctionAutoCorrection(str)
|
||
{
|
||
if (undefined === str || null === str)
|
||
return;
|
||
|
||
MathAutoCorrectionFuncNames.push(str);
|
||
}
|
||
function SearchFunctionName(str)
|
||
{
|
||
if (undefined === str || null === str)
|
||
return false;
|
||
|
||
return MathAutoCorrectionFuncNames.includes(str);
|
||
}
|
||
|
||
//---------------------------------------------Tokenizer section----------------------------------------------------
|
||
function Tokenizer(isLaTeX)
|
||
{
|
||
this._string = [];
|
||
this._styles = {};
|
||
this._cursor = 0;
|
||
|
||
this.state = [];
|
||
this.isLaTeX = isLaTeX;
|
||
}
|
||
Tokenizer.prototype.Init = function (string)
|
||
{
|
||
if (string instanceof MathTextAndStyles)
|
||
{
|
||
let arrContent = [];
|
||
let oAdditionalData = {};
|
||
let nLength = 0;
|
||
|
||
function Proceed (oMathTextAndStyles, context)
|
||
{
|
||
let arr = oMathTextAndStyles.arr;
|
||
|
||
for (let i = 0; i < arr.length; i++)
|
||
{
|
||
let oCurrentElement = arr[i];
|
||
if (oCurrentElement instanceof MathTextAndStyles)
|
||
{
|
||
Proceed(oCurrentElement, context);
|
||
}
|
||
else if (oCurrentElement instanceof MathText)
|
||
{
|
||
let oLocalAdditionalData = oCurrentElement.GetAdditionalData();
|
||
let strCurrent = oCurrentElement.GetText();
|
||
if (undefined === strCurrent)
|
||
continue;
|
||
let tempLength = context.GetStringLength(strCurrent);
|
||
let arrCurrent = context.GetSymbols(strCurrent);
|
||
arrContent = arrContent.concat(arrCurrent);
|
||
|
||
for (let j = nLength; j < tempLength + nLength; j++)
|
||
{
|
||
oAdditionalData[j] = oLocalAdditionalData;
|
||
}
|
||
nLength += tempLength;
|
||
}
|
||
else
|
||
{
|
||
let arrCurrent = context.GetSymbols(oCurrentElement);
|
||
nLength += arrCurrent.length;
|
||
arrContent = arrContent.concat(arrCurrent);
|
||
oAdditionalData[nLength] = undefined;
|
||
}
|
||
}
|
||
}
|
||
|
||
Proceed(string, this)
|
||
|
||
this._string = arrContent;
|
||
this._styles = oAdditionalData;
|
||
}
|
||
else
|
||
{
|
||
let arrContent = this.GetSymbols(string);
|
||
this._string = arrContent;
|
||
}
|
||
};
|
||
Tokenizer.prototype.GetSymbols = function (str)
|
||
{
|
||
let output = [];
|
||
for (let oIter = str.getUnicodeIterator(); oIter.check(); oIter.next())
|
||
{
|
||
output.push(String.fromCodePoint(oIter.value()));
|
||
}
|
||
return output;
|
||
};
|
||
Tokenizer.prototype.GetStringLength = function (str)
|
||
{
|
||
let intLen = 0;
|
||
for (let oIter = str.getUnicodeIterator(); oIter.check(); oIter.next())
|
||
{
|
||
intLen++;
|
||
}
|
||
return intLen;
|
||
};
|
||
Tokenizer.prototype.IsHasMoreTokens = function ()
|
||
{
|
||
return this._cursor < this._string.length;
|
||
};
|
||
Tokenizer.prototype.GetNextToken = function (isNextLookahead)
|
||
{
|
||
if (!this.IsHasMoreTokens())
|
||
return {
|
||
class: undefined,
|
||
data: undefined,
|
||
};
|
||
|
||
let autoCorrectRule = {class:null},
|
||
tokenValue,
|
||
tokenClass,
|
||
string = this._string.slice(this._cursor);
|
||
|
||
for (let i = arrTokensCheckerList.length - 1; i >= 0; i--)
|
||
{
|
||
autoCorrectRule.class = arrTokensCheckerList[i];
|
||
tokenValue = this.MatchToken(autoCorrectRule, string, isNextLookahead, i);
|
||
|
||
if (string[0] === "\\" && string[1] === "/")
|
||
{
|
||
autoCorrectRule.class = MathLiterals.divide;
|
||
tokenValue = "/"
|
||
this._cursor += this.GetStringLength("\\/");
|
||
|
||
let oStyle = this.GetStyle(this._cursor);
|
||
let oMetaData = oStyle.GetMathMetaData();
|
||
oMetaData.setIsEscapedSlash(true);
|
||
}
|
||
|
||
if (tokenValue === null)
|
||
continue;
|
||
else if (!Array.isArray(autoCorrectRule.class))
|
||
{
|
||
tokenClass = (autoCorrectRule.class.isClassEqalData)
|
||
? tokenValue
|
||
: autoCorrectRule.class.id;
|
||
}
|
||
else if (autoCorrectRule.class.length === 1)
|
||
{
|
||
tokenClass = MathLiterals.char.id;
|
||
}
|
||
else if (autoCorrectRule.class.length === 2)
|
||
{
|
||
tokenClass = (autoCorrectRule.class[1] === true)
|
||
? autoCorrectRule.class[0]
|
||
: autoCorrectRule.class[1];
|
||
}
|
||
|
||
let oStyle = this.GetStyle(this._cursor);
|
||
this.LaTeXVariant = null;
|
||
|
||
return {
|
||
class: tokenClass,
|
||
data: tokenValue,
|
||
style: oStyle,
|
||
}
|
||
}
|
||
};
|
||
Tokenizer.prototype.GetStyle = function (nCursorPos)
|
||
{
|
||
let style = this._styles[nCursorPos - 1];
|
||
|
||
if (!style)
|
||
style = new MathTextAdditionalData();
|
||
|
||
return style;
|
||
};
|
||
Tokenizer.prototype.ProcessString = function (str, char)
|
||
{
|
||
let intLenOfRule = 0;
|
||
|
||
while (intLenOfRule <= char.length - 1)
|
||
{
|
||
if (char[intLenOfRule] === str[intLenOfRule])
|
||
intLenOfRule++;
|
||
else
|
||
return;
|
||
}
|
||
return char;
|
||
};
|
||
Tokenizer.prototype.MatchToken = function (fMathCheck, arrStr, isNextLookahead, i)
|
||
{
|
||
if (undefined === fMathCheck.class)
|
||
return null;
|
||
|
||
let oMatched = fMathCheck.class.GetToken(this.isLaTeX, arrStr);
|
||
|
||
if (oMatched === null || oMatched === undefined)
|
||
return null;
|
||
|
||
if (this.isLaTeX && oMatched)
|
||
{
|
||
if (!this.LaTeXVariant || oMatched > this.LaTeXVariant.tokenValue)
|
||
{
|
||
this.LaTeXVariant = {
|
||
tokenValue: oMatched,
|
||
autoCorrectRule: fMathCheck.class
|
||
}
|
||
}
|
||
}
|
||
|
||
if (this.isLaTeX)
|
||
{
|
||
if (i === 0)
|
||
{
|
||
fMathCheck.class = this.LaTeXVariant.autoCorrectRule;
|
||
oMatched = this.LaTeXVariant.tokenValue;
|
||
|
||
if (!isNextLookahead)
|
||
this._cursor += this.GetStringLength(oMatched);
|
||
|
||
if (fMathCheck.class.IsNeedReturnCorrected_Unicode === true && this.isLaTeX)
|
||
oMatched = fMathCheck.class.LaTeX[oMatched];
|
||
|
||
return oMatched
|
||
}
|
||
else
|
||
{
|
||
return null;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (!isNextLookahead)
|
||
this._cursor += this.GetStringLength(oMatched);
|
||
|
||
return oMatched;
|
||
}
|
||
};
|
||
Tokenizer.prototype.SaveState = function (oLookahead)
|
||
{
|
||
let strClass = oLookahead.class;
|
||
let data = oLookahead.data;
|
||
let style = oLookahead.style;
|
||
|
||
this.state.push({
|
||
_string: this._string,
|
||
_cursor: this._cursor,
|
||
oLookahead: { class: strClass, data: data, style: style},
|
||
})
|
||
};
|
||
Tokenizer.prototype.RestoreState = function ()
|
||
{
|
||
if (this.state.length > 0) {
|
||
let oState = this.state.shift();
|
||
this._cursor = oState._cursor;
|
||
this._string = oState._string;
|
||
return oState.oLookahead;
|
||
}
|
||
};
|
||
Tokenizer.prototype.IsTextContent = function(intClass, intTokenClass)
|
||
{
|
||
return (intClass !== intTokenClass) ||
|
||
(
|
||
intTokenClass !== 0
|
||
&& intTokenClass !== 1
|
||
&& intTokenClass !== 3
|
||
)
|
||
};
|
||
Tokenizer.prototype.IsContentOfOneType = function()
|
||
{
|
||
let intTokenClass = null;
|
||
while (this.IsHasMoreTokens())
|
||
{
|
||
let intClass = this.GetNextToken().class;
|
||
|
||
if (intTokenClass === null)
|
||
intTokenClass = intClass;
|
||
else if (intClass === undefined)
|
||
return true;
|
||
else if (this.IsTextContent(intClass, intTokenClass))
|
||
return false;
|
||
}
|
||
return true;
|
||
};
|
||
|
||
//-----------------------Functions for convert tokens array in inner math format------------------------------------
|
||
function GetPrForFunction(oIndex)
|
||
{
|
||
let isHide = true;
|
||
if (oIndex)
|
||
isHide = false;
|
||
|
||
return {
|
||
degHide: isHide,
|
||
}
|
||
}
|
||
// Convert tokens to math objects
|
||
function ConvertTokens(oTokens, oContext)
|
||
{
|
||
Paragraph = oContext.Paragraph;
|
||
|
||
let arrContentAfterConvert = [];
|
||
if (oContext.Content[oContext.CurPos] instanceof ParaRun)
|
||
{
|
||
arrContentAfterConvert = oContext.SplitContentByPos(oContext.CurPos, true)
|
||
oContext.CurPos = oContext.Content.length - 1;
|
||
}
|
||
|
||
if (typeof oTokens === "object")
|
||
{
|
||
if (oTokens.type === "LaTeXEquation" || oTokens.type === "UnicodeEquation")
|
||
{
|
||
type = oTokens.type === "LaTeXEquation" ? 1 : 0;
|
||
oTokens = oTokens.body;
|
||
}
|
||
|
||
if (Array.isArray(oTokens))
|
||
{
|
||
for (let i = 0; i < oTokens.length; i++)
|
||
{
|
||
if (Array.isArray(oTokens[i]))
|
||
{
|
||
let oToken = oTokens[i];
|
||
|
||
for (let j = 0; j < oTokens[i].length; j++)
|
||
{
|
||
SelectObject(oToken[j], oContext);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
SelectObject(oTokens[i], oContext);
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
SelectObject(oTokens, oContext)
|
||
}
|
||
}
|
||
else
|
||
{
|
||
oContext.Add_Text(oTokens);
|
||
}
|
||
|
||
if (arrContentAfterConvert.length)
|
||
{
|
||
oContext.MoveCursorToEndPos();
|
||
oContext.ConcatToContent(oContext.Content.length, arrContentAfterConvert);
|
||
}
|
||
}
|
||
// Find token in all types for convert
|
||
function SelectObject (oTokens, oContext)
|
||
{
|
||
if (oTokens)
|
||
{
|
||
if (oTokens instanceof MathText)
|
||
{
|
||
oContext.Add_Text(oTokens.text, undefined, undefined, oTokens);
|
||
return;
|
||
}
|
||
switch (oTokens.type)
|
||
{
|
||
case undefined:
|
||
for (let i = 0; i < oTokens.length; i++) {
|
||
ConvertTokens(
|
||
oTokens[i],
|
||
oContext
|
||
);
|
||
}
|
||
break;
|
||
case MathStructures.other:
|
||
for (const oUnicodeIterator = oTokens.value.getUnicodeIterator(); oUnicodeIterator.check(); oUnicodeIterator.next())
|
||
{
|
||
oContext.Add_Text(AscCommon.encodeSurrogateChar(oUnicodeIterator.value()), undefined, undefined, oTokens.style[oUnicodeIterator.position()]);
|
||
}
|
||
break;
|
||
case MathStructures.char:
|
||
case MathStructures.space:
|
||
case MathStructures.number:
|
||
if (oTokens.decimal)
|
||
{
|
||
ConvertTokens(
|
||
oTokens.left,
|
||
oContext
|
||
);
|
||
oContext.Add_Text(oTokens.decimal)
|
||
ConvertTokens(
|
||
oTokens.right,
|
||
oContext
|
||
);
|
||
}
|
||
else
|
||
{
|
||
if (Array.isArray(oTokens.style))
|
||
{
|
||
if (oTokens.value.length > 1 && typeof oTokens.value === 'string')
|
||
{
|
||
oContext.Add_Text(oTokens.value, undefined, undefined, oTokens.style[0]);
|
||
}
|
||
else
|
||
{
|
||
for (let nTokenStyle = 0; nTokenStyle < oTokens.style.length; nTokenStyle++) {
|
||
oContext.Add_Text(oTokens.value[nTokenStyle], undefined, undefined, oTokens.style[nTokenStyle]);
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
oContext.Add_Text(oTokens.value, undefined, undefined, oTokens.style);
|
||
}
|
||
}
|
||
break;
|
||
case MathStructures.plain:
|
||
oContext.Add_Text(oTokens.value, Paragraph, STY_PLAIN);
|
||
break
|
||
case MathStructures.nary:
|
||
let lPr = {
|
||
ctrPrp: oTokens.style.style,
|
||
chr: oTokens.value.charCodeAt(0),
|
||
subHide: true,
|
||
supHide: true,
|
||
}
|
||
|
||
let oNary = oContext.Add_NAry(lPr, null, null, null);
|
||
|
||
if (oTokens.third) {
|
||
ConvertTokens(
|
||
oTokens.third,
|
||
oNary.getBase()
|
||
);
|
||
|
||
let oBase = oNary.getBase();
|
||
oBase.setCtrPrp(oTokens.thirdStyle.style);
|
||
}
|
||
|
||
break;
|
||
case MathStructures.pre_script:
|
||
let oPreSubSup = oContext.Add_Script(
|
||
oTokens.up && oTokens.down,
|
||
{ctrPrp: new CTextPr(), type: DEGREE_PreSubSup},
|
||
null,
|
||
null,
|
||
null
|
||
);
|
||
ConvertTokens(
|
||
oTokens.value,
|
||
oPreSubSup.getBase()
|
||
);
|
||
UnicodeArgument(
|
||
oTokens.up,
|
||
MathStructures.bracket_block,
|
||
oPreSubSup.getUpperIterator()
|
||
)
|
||
UnicodeArgument(
|
||
oTokens.down,
|
||
MathStructures.bracket_block,
|
||
oPreSubSup.getLowerIterator()
|
||
)
|
||
break;
|
||
case MathStructures.accent:
|
||
let oAccent = oContext.Add_Accent(
|
||
oTokens.value.style.style,
|
||
GetFixedCharCodeAt(oTokens.value.value),
|
||
null
|
||
);
|
||
UnicodeArgument(
|
||
oTokens.base,
|
||
MathStructures.bracket_block,
|
||
oAccent.getBase()
|
||
)
|
||
break;
|
||
case MathStructures.frac:
|
||
if (oTokens.fracType === LITTLE_FRACTION)
|
||
{
|
||
let oBox = new CBox({ctrPrp: new CTextPr()});
|
||
oContext.Add_Element(oBox);
|
||
let BoxMathContent = oBox.getBase();
|
||
BoxMathContent.SetArgSize(-1);
|
||
let oFraction = BoxMathContent.Add_Fraction({ctrPrp: oTokens.style.style, type: BAR_FRACTION}, null, null);
|
||
UnicodeArgument(
|
||
oTokens.up,
|
||
MathStructures.bracket_block,
|
||
oFraction.getNumeratorMathContent()
|
||
);
|
||
UnicodeArgument(
|
||
oTokens.down,
|
||
MathStructures.bracket_block,
|
||
oFraction.getDenominatorMathContent()
|
||
);
|
||
}
|
||
else
|
||
{
|
||
let oFraction = oContext.Add_Fraction(
|
||
{ctrPrp: oTokens.style.style, type: oTokens.fracType},
|
||
null,
|
||
null
|
||
);
|
||
|
||
if (oTokens.style.reviewData.reviewType && oTokens.style.reviewData.reviewInfo)
|
||
oFraction.SetReviewTypeWithInfo(oTokens.style.reviewData.reviewType, oTokens.style.reviewData.reviewInfo);
|
||
|
||
if (oTokens.style.reviewData.reviewInfo && oFraction.ReviewInfo)
|
||
oFraction.ReviewInfo.Update();
|
||
|
||
UnicodeArgument(
|
||
oTokens.up,
|
||
MathStructures.bracket_block,
|
||
oFraction.getNumeratorMathContent()
|
||
);
|
||
UnicodeArgument(
|
||
oTokens.down,
|
||
MathStructures.bracket_block,
|
||
oFraction.getDenominatorMathContent()
|
||
);
|
||
}
|
||
break;
|
||
case MathStructures.sub_sub:
|
||
if (oTokens.value && oTokens.value.type === MathStructures.func)
|
||
{
|
||
let oStyle = oTokens.value.style.style
|
||
let oFunc = oContext.Add_Function({ctrPrp: oStyle}, null, null);
|
||
let oFuncName = oFunc.getFName();
|
||
|
||
let Pr = (oTokens.up && oTokens.down)
|
||
? {}
|
||
: (oTokens.up)
|
||
? {type: DEGREE_SUPERSCRIPT, ctrPrp : oStyle}
|
||
: {type: DEGREE_SUBSCRIPT, ctrPrp : oStyle}
|
||
|
||
let SubSup = oFuncName.Add_Script(
|
||
oTokens.up && oTokens.down,
|
||
Pr,
|
||
null,
|
||
null,
|
||
null
|
||
);
|
||
|
||
oTokens.value.type = MathStructures.char;
|
||
UnicodeArgument(
|
||
oTokens.value.value,
|
||
MathStructures.bracket_block,
|
||
SubSup.getBase()
|
||
);
|
||
|
||
if (oTokens.up) {
|
||
UnicodeArgument(
|
||
oTokens.up,
|
||
MathStructures.bracket_block,
|
||
SubSup.getUpperIterator()
|
||
)
|
||
}
|
||
if (oTokens.down) {
|
||
UnicodeArgument(
|
||
oTokens.down,
|
||
MathStructures.bracket_block,
|
||
SubSup.getLowerIterator()
|
||
)
|
||
}
|
||
if (oTokens.third) {
|
||
let oFuncArgument = oFunc.getArgument();
|
||
UnicodeArgument(
|
||
oTokens.third,
|
||
MathStructures.bracket_block,
|
||
oFuncArgument
|
||
)
|
||
}
|
||
|
||
// Set styles
|
||
let oUpper = SubSup.getUpperIterator();
|
||
if (oUpper && oTokens.style.supStyle)
|
||
oUpper.CtrPrp.Merge(oTokens.style.supStyle.style);
|
||
|
||
let oLower = SubSup.getLowerIterator();
|
||
if (oLower && oTokens.style.subStyle)
|
||
oLower.CtrPrp.Merge(oTokens.style.subStyle.style);
|
||
}
|
||
else if (oTokens.value && oTokens.value.type === MathStructures.func_lim)
|
||
{
|
||
let oFuncWithLimit = oContext.Add_FunctionWithTypeLimit(
|
||
{},
|
||
null,
|
||
null,
|
||
null,
|
||
oTokens.up ? LIMIT_UP : LIMIT_LOW
|
||
);
|
||
|
||
ConvertTokens(
|
||
oTokens.value.value,
|
||
oFuncWithLimit.getFName().Content[0].getFName());
|
||
|
||
let oLimitIterator = oFuncWithLimit
|
||
.getFName()
|
||
.Content[0]
|
||
.getIterator();
|
||
|
||
if (oTokens.up || oTokens.down)
|
||
{
|
||
UnicodeArgument(
|
||
oTokens.up === undefined ? oTokens.down : oTokens.up,
|
||
MathStructures.bracket_block,
|
||
oLimitIterator
|
||
)
|
||
}
|
||
|
||
UnicodeArgument(
|
||
oTokens.third,
|
||
MathStructures.bracket_block,
|
||
oFuncWithLimit.getArgument()
|
||
)
|
||
}
|
||
else if (oTokens.value && oTokens.value.type === MathStructures.nary)
|
||
{
|
||
let Pr = {
|
||
ctrPrp: oTokens.value.style.style,
|
||
chr: oTokens.value.value.charCodeAt(0),
|
||
subHide: oTokens.down === undefined,
|
||
supHide: oTokens.up === undefined,
|
||
limLoc: oTokens.value.style.metaData.getIsLimitNary() === true ? NARY_UndOvr : NARY_SubSup
|
||
}
|
||
|
||
let oNary = oContext.Add_NAry(Pr, null, null, null);
|
||
|
||
ConvertTokens(
|
||
oTokens.third,
|
||
oNary.getBase()
|
||
);
|
||
|
||
let oBase = oNary.getBase();
|
||
|
||
if (oTokens.style.ofStyle)
|
||
oBase.setCtrPrp(oTokens.style.ofStyle.style);
|
||
|
||
UnicodeArgument(
|
||
oTokens.up,
|
||
MathStructures.bracket_block,
|
||
oNary.getSupMathContent()
|
||
);
|
||
|
||
let oUp = oNary.getSupMathContent();
|
||
|
||
if (oTokens.style.supStyle)
|
||
oUp.setCtrPrp(oTokens.style.supStyle.style);
|
||
|
||
UnicodeArgument(
|
||
oTokens.down,
|
||
MathStructures.bracket_block,
|
||
oNary.getSubMathContent()
|
||
)
|
||
|
||
let oDown = oNary.getSubMathContent();
|
||
if (oTokens.style.subStyle)
|
||
oDown.setCtrPrp(oTokens.style.subStyle.style);
|
||
|
||
}
|
||
else
|
||
{
|
||
let isSubSup = ((Array.isArray(oTokens.up) && oTokens.up.length > 0) || (!Array.isArray(oTokens.up) && oTokens.up !== undefined)) &&
|
||
((Array.isArray(oTokens.down) && oTokens.down.length > 0) || (!Array.isArray(oTokens.down) && oTokens.down !== undefined))
|
||
|
||
let oCurrentStyle = oTokens.style.subStyle ? oTokens.style.subStyle : oTokens.style.supStyle;
|
||
let Pr = {};
|
||
Pr.ctrPrp = oCurrentStyle.style;
|
||
|
||
if (!isSubSup)
|
||
{
|
||
if (oTokens.up)
|
||
Pr.type = DEGREE_SUPERSCRIPT;
|
||
else if (oTokens.down)
|
||
Pr.type = DEGREE_SUBSCRIPT;
|
||
}
|
||
|
||
let SubSup = oContext.Add_Script(
|
||
isSubSup,
|
||
Pr,
|
||
null,
|
||
null,
|
||
null
|
||
);
|
||
|
||
if (oCurrentStyle.reviewData.reviewType && oCurrentStyle.reviewData.reviewInfo)
|
||
SubSup.SetReviewTypeWithInfo(oCurrentStyle.reviewData.reviewType, oCurrentStyle.reviewData.reviewInfo);
|
||
|
||
ConvertTokens(
|
||
oTokens.value,
|
||
SubSup.getBase()
|
||
);
|
||
|
||
UnicodeArgument(
|
||
oTokens.up,
|
||
MathStructures.bracket_block,
|
||
SubSup.getUpperIterator()
|
||
);
|
||
|
||
UnicodeArgument(
|
||
oTokens.down,
|
||
MathStructures.bracket_block,
|
||
SubSup.getLowerIterator()
|
||
);
|
||
|
||
// Set styles
|
||
let oUpper = SubSup.getUpperIterator();
|
||
if (oUpper && oTokens.style.subStyle)
|
||
{
|
||
oUpper.CtrPrp.Merge(oTokens.style.subStyle.style);
|
||
if (oTokens.style.subStyle.reviewData.reviewType && oTokens.style.subStyle.reviewData.reviewInfo)
|
||
oUpper.SetReviewTypeWithInfo(oTokens.style.subStyle.reviewData.reviewType, oTokens.style.subStyle.reviewData.reviewInfo);
|
||
}
|
||
|
||
let oLower = SubSup.getLowerIterator();
|
||
if (oLower && oTokens.style.supStyle)
|
||
{
|
||
oLower.CtrPrp.Merge(oTokens.style.supStyle.style);
|
||
if (oTokens.style.supStyle.reviewData.reviewType && oTokens.style.supStyle.reviewData.reviewInfo)
|
||
oLower.SetReviewTypeWithInfo(oTokens.style.supStyle.reviewData.reviewType, oTokens.style.supStyle.reviewData.reviewInfo);
|
||
}
|
||
}
|
||
break;
|
||
case MathStructures.func_lim:
|
||
let MathFunc = new CMathFunc({});
|
||
oContext.Add_Element(MathFunc);
|
||
|
||
let FuncName = MathFunc.getFName();
|
||
|
||
let Limit = new CLimit({ctrPrp : oTokens.style.style, type : oTokens.down !== undefined ? LIMIT_LOW : LIMIT_UP});
|
||
FuncName.Add_Element(Limit);
|
||
|
||
let LimitName = Limit.getFName();
|
||
|
||
UnicodeArgument(
|
||
oTokens.value,
|
||
undefined,
|
||
LimitName
|
||
);
|
||
|
||
if (oTokens.up || oTokens.down) {
|
||
UnicodeArgument(
|
||
oTokens.up === undefined ? oTokens.down : oTokens.up,
|
||
MathStructures.bracket_block,
|
||
Limit.getIterator()
|
||
)
|
||
}
|
||
|
||
if (oTokens.third)
|
||
{
|
||
ConvertTokens(
|
||
oTokens.third,
|
||
MathFunc.getArgument()
|
||
)
|
||
}
|
||
|
||
break;
|
||
case MathStructures.horizontal:
|
||
if (type === 1)
|
||
{
|
||
let hBrack = oTokens.hBrack,
|
||
nCodeOfHorizontal = hBrack.value.charCodeAt(0),
|
||
BoxPr = {ctrPrp : hBrack.style.style, opEmu : 1},
|
||
Box = oContext.Add_Box(BoxPr, null),
|
||
MathContent = Box.getBase(),
|
||
oGroup = null;
|
||
|
||
let oPrGroup = (oTokens.VJUSTType === VJUST_TOP)
|
||
? {ctrPrp : BoxPr.ctrPrp, pos : oTokens.VJUSTType, chr : nCodeOfHorizontal}
|
||
: {ctrPrp : BoxPr.ctrPrp, vertJc : oTokens.VJUSTType, chr : nCodeOfHorizontal};
|
||
|
||
let Group = new CGroupCharacter(oPrGroup);
|
||
MathContent.Add_Element(Group);
|
||
|
||
UnicodeArgument(
|
||
oTokens.value,
|
||
MathStructures.bracket_block,
|
||
Group.getBase()
|
||
);
|
||
}
|
||
else
|
||
{
|
||
let hBrack = oTokens.hBrack,
|
||
nCodeOfHorizontal = hBrack.value.charCodeAt(0),
|
||
BoxPr = {ctrPrp : hBrack.style.style, opEmu : 1},
|
||
oGroup = null;
|
||
|
||
let oPrGroup = (oTokens.VJUSTType === VJUST_TOP)
|
||
? {ctrPrp : BoxPr.ctrPrp, pos : oTokens.VJUSTType, chr : nCodeOfHorizontal}
|
||
: {ctrPrp : BoxPr.ctrPrp, vertJc : oTokens.VJUSTType, chr : nCodeOfHorizontal};
|
||
|
||
let Group = new CGroupCharacter(oPrGroup);
|
||
oContext.Add_Element(Group);
|
||
|
||
UnicodeArgument(
|
||
oTokens.value,
|
||
MathStructures.bracket_block,
|
||
Group.getBase()
|
||
);
|
||
}
|
||
break;
|
||
case MathStructures.bar:
|
||
let oBar = (oTokens.bar.data === "¯")
|
||
? oContext.Add_Bar({ctrPrp : oTokens.style.style, pos : LOCATION_TOP}, null)
|
||
: oContext.Add_Bar({ctrPrp : oTokens.style.style, pos : LOCATION_BOT}, null);
|
||
|
||
UnicodeArgument(
|
||
oTokens.value,
|
||
MathStructures.bracket_block,
|
||
oBar.getBase()
|
||
);
|
||
break;
|
||
case MathStructures.group_character:
|
||
|
||
if (oTokens.up || oTokens.down)
|
||
{
|
||
let Limit = oContext.Add_Limit({ctrPrp : oTokens.hBrack.style.style, type : oTokens.up ? LIMIT_UP : LIMIT_LOW}, null, null);
|
||
|
||
let MathContent = Limit.getFName();
|
||
let oAccent = MathContent.Add_GroupCharacter({ctrPrp : oTokens.hBrack.style.style, chr : oTokens.hBrack.data.charCodeAt(0), pos : oTokens.up ? VJUST_TOP : VJUST_BOT, vertJc : VJUST_BOT}, null );
|
||
|
||
UnicodeArgument(
|
||
oTokens.value,
|
||
MathStructures.bracket_block,
|
||
oAccent.getBase()
|
||
);
|
||
|
||
UnicodeArgument(
|
||
oTokens.up ? oTokens.up : oTokens.down,
|
||
MathStructures.bracket_block,
|
||
Limit.getIterator()
|
||
);
|
||
}
|
||
else
|
||
{
|
||
let oGroup;
|
||
if (oTokens.isBelow === VJUST_TOP)
|
||
{
|
||
oGroup = oContext.Add_GroupCharacter({
|
||
ctrPrp: oTokens.hBrack.style.style,
|
||
chr: oTokens.hBrack.data.charCodeAt(0),
|
||
pos: VJUST_TOP,
|
||
vertJc: VJUST_BOT
|
||
}, null);
|
||
}
|
||
else
|
||
{
|
||
oGroup = oContext.Add_GroupCharacter({ctrPrp : oTokens.hBrack.style.style, chr: oTokens.hBrack.data.charCodeAt(0)});
|
||
}
|
||
|
||
UnicodeArgument(
|
||
oTokens.value,
|
||
MathStructures.bracket_block,
|
||
oGroup.getBase()
|
||
);
|
||
}
|
||
break;
|
||
case MathStructures.bracket_block:
|
||
let arr = [null]
|
||
let oPr = {
|
||
ctrPrp : oTokens.style.startStyle.style,
|
||
column : oTokens.value.length > 0 ? oTokens.value.length : 1,
|
||
begChr : GetBracketCode(oTokens.left, oTokens.counter),
|
||
endChr : GetBracketCode(oTokens.right, oTokens.counter),
|
||
};
|
||
|
||
let oBracket = oContext.Add_Delimiter(
|
||
oPr,
|
||
oTokens.value.length > 0 ? oTokens.value.length : 1,
|
||
arr
|
||
);
|
||
|
||
if (oTokens.value.length >= 0)
|
||
{
|
||
for (let intCount = 0; intCount < oTokens.value.length; intCount++)
|
||
{
|
||
ConvertTokens(
|
||
oTokens.value[intCount],
|
||
oBracket.getElementMathContent(intCount)
|
||
);
|
||
|
||
//Last content
|
||
if (intCount === oTokens.value.length - 1 && oTokens.style.endStyle)
|
||
{
|
||
let oCon = oBracket.getElementMathContent(intCount);
|
||
oCon.setCtrPrp(oTokens.style.endStyle.style);
|
||
}
|
||
|
||
if (oTokens.style.middle && oTokens.style.middle[intCount - 1])
|
||
{
|
||
let oContent = oBracket.getElementMathContent(intCount - 1);
|
||
oContent.setCtrPrp(oTokens.style.middle[intCount - 1].style);
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
ConvertTokens(
|
||
oTokens.value,
|
||
oBracket.getElementMathContent(0)
|
||
);
|
||
}
|
||
|
||
break;
|
||
case MathStructures.radical:
|
||
let Pr = GetPrForFunction(oTokens.index);
|
||
Pr.ctrPrp = oTokens.style.style;
|
||
let oRadical = oContext.Add_Radical(
|
||
Pr,
|
||
null,
|
||
null
|
||
);
|
||
|
||
if (oTokens.style.reviewData.reviewType && oTokens.style.reviewData.reviewInfo)
|
||
oRadical.SetReviewTypeWithInfo(oTokens.style.reviewData.reviewType, oTokens.style.reviewData.reviewInfo);
|
||
|
||
UnicodeArgument(
|
||
oTokens.value,
|
||
MathStructures.bracket_block,
|
||
oRadical.getBase()
|
||
)
|
||
ConvertTokens(
|
||
oTokens.index,
|
||
oRadical.getDegree()
|
||
);
|
||
break;
|
||
case MathStructures.func:
|
||
let oFunc = oContext.Add_Function({ctrPrp: oTokens.style.style}, null, null);
|
||
|
||
ConvertTokens(
|
||
oTokens.value,
|
||
oFunc.getFName()
|
||
);
|
||
|
||
let oName = oFunc.getFName();
|
||
oName.CtrPrp.SetItalic(false);
|
||
|
||
ConvertTokens(
|
||
oTokens.third,
|
||
oFunc.getArgument()
|
||
)
|
||
break;
|
||
case MathStructures.matrix:
|
||
let strStartBracket, strEndBracket;
|
||
|
||
if (oTokens.strMatrixType)
|
||
{
|
||
if (oTokens.strMatrixType.length === 2)
|
||
{
|
||
strStartBracket = oTokens.strMatrixType[0].charCodeAt(0)
|
||
strEndBracket = oTokens.strMatrixType[1].charCodeAt(0)
|
||
}
|
||
else
|
||
{
|
||
strStartBracket = oTokens.strMatrixType[0].charCodeAt(0);
|
||
strEndBracket = -1;
|
||
}
|
||
}
|
||
|
||
let rows = oTokens.value.length;
|
||
let cols;
|
||
|
||
if (oTokens.value[0] && oTokens.value[0].length)
|
||
{
|
||
cols = oTokens.value[0].length;
|
||
}
|
||
|
||
if (strEndBracket || strStartBracket)
|
||
{
|
||
let Delimiter = oContext.Add_DelimiterEx(
|
||
new CTextPr(),
|
||
1,
|
||
[null],
|
||
strStartBracket,
|
||
strEndBracket
|
||
);
|
||
oContext = Delimiter.getElementMathContent(0);
|
||
}
|
||
|
||
let oMatrix = oContext.Add_Matrix(
|
||
oTokens.style.head.style,
|
||
rows,
|
||
cols,
|
||
false,
|
||
[]
|
||
);
|
||
|
||
for (let intRow = 0; intRow < rows; intRow++)
|
||
{
|
||
for (let intCol = 0; intCol < cols; intCol++)
|
||
{
|
||
let oContent = oMatrix.getContentElement(intRow, intCol);
|
||
ConvertTokens(
|
||
oTokens.value[intRow][intCol],
|
||
oContent
|
||
);
|
||
|
||
let oPr = oTokens.style.cols[intRow]
|
||
if (oPr && intCol === cols - 1)
|
||
{
|
||
oContent.setCtrPrp(oPr.style);
|
||
continue;
|
||
}
|
||
|
||
let rPr = oTokens.style.rows[intRow];
|
||
if (rPr)
|
||
{
|
||
let cPr = rPr[intCol];
|
||
if (cPr)
|
||
oContent.setCtrPrp(cPr.style);
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
case MathStructures.array:
|
||
let intCountOfRows = oTokens.value.length;
|
||
|
||
let arrayPr = {
|
||
ctrPrp: oTokens.style.style,
|
||
row: intCountOfRows
|
||
};
|
||
|
||
let oEqArray = oContext.Add_EqArray(arrayPr, null, null);
|
||
|
||
for (let i = 0; i < oTokens.value.length; i++)
|
||
{
|
||
let oMathContent = oEqArray.getElementMathContent(i);
|
||
ConvertTokens(
|
||
oTokens.value[i],
|
||
oMathContent
|
||
);
|
||
}
|
||
break;
|
||
case MathStructures.box:
|
||
let oBox = oContext.Add_Box({ctrPrp: oTokens.style.style, opEmu : 1}, null);
|
||
if (oTokens.argSize)
|
||
{
|
||
let BoxMathContent = oBox.getBase();
|
||
BoxMathContent.SetArgSize(oTokens.argSize);
|
||
}
|
||
UnicodeArgument(
|
||
oTokens.value,
|
||
MathStructures.bracket_block,
|
||
oBox.getBase()
|
||
)
|
||
break;
|
||
case MathStructures.rect:
|
||
let oBorderBox = oContext.Add_BorderBox({ctrPrp: oTokens.style.style}, null);
|
||
UnicodeArgument(
|
||
oTokens.value,
|
||
MathStructures.bracket_block,
|
||
oBorderBox.getBase()
|
||
)
|
||
break;
|
||
case MathStructures.limit:
|
||
let oLimit = oContext.Add_Limit({ctrPrp: oTokens.style.style, type: oTokens.isBelow});
|
||
UnicodeArgument(
|
||
oTokens.base,
|
||
MathStructures.bracket_block,
|
||
oLimit.getFName()
|
||
);
|
||
UnicodeArgument(
|
||
oTokens.value,
|
||
MathStructures.bracket_block,
|
||
oLimit.getIterator()
|
||
);
|
||
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
// Trow content and may skip bracket block
|
||
function UnicodeArgument (oInput, oComparison, oContext)
|
||
{
|
||
if (oInput && type === 0 && oInput.type === oComparison && oInput.left === "(" && oInput.right === ")" && oInput.counter === 1)
|
||
{
|
||
ConvertTokens(
|
||
oInput.value,
|
||
oContext
|
||
)
|
||
}
|
||
else if (oInput)
|
||
{
|
||
ConvertTokens(
|
||
oInput,
|
||
oContext
|
||
)
|
||
}
|
||
}
|
||
//--------------------------------------Helper functions for lexer and converter------------------------------------
|
||
function GetBracketCode(code, nCounter)
|
||
{
|
||
const oBrackets = {
|
||
".": -1,
|
||
"\\{": "{".charCodeAt(0),
|
||
"\\}": "}".charCodeAt(0),
|
||
"\\|": "|".charCodeAt(0),
|
||
"|": 124,
|
||
"〖": -1,
|
||
"〗": -1,
|
||
"⟨" : 10216,
|
||
"⟩": 10217,
|
||
"├": -1,
|
||
"┤": -1,
|
||
|
||
}
|
||
if (code)
|
||
{
|
||
if (nCounter > 1 && code === "〖")
|
||
return "〖".charCodeAt();
|
||
if (nCounter > 1 && code === "〗")
|
||
return "〗".charCodeAt();
|
||
|
||
let strBracket = oBrackets[code];
|
||
if (strBracket) {
|
||
return strBracket
|
||
}
|
||
|
||
if (typeof MathLiterals.rBrackets.LaTeX[code] === 'string')
|
||
{
|
||
return MathLiterals.rBrackets.LaTeX[code].charCodeAt(0);
|
||
}
|
||
else if (typeof MathLiterals.lrBrackets.LaTeX[code] === 'string')
|
||
{
|
||
return MathLiterals.lrBrackets.LaTeX[code].charCodeAt(0);
|
||
}
|
||
else if (typeof MathLiterals.lBrackets.LaTeX[code] === 'string')
|
||
{
|
||
return MathLiterals.lBrackets.LaTeX[code].charCodeAt(0);
|
||
}
|
||
|
||
return code.charCodeAt(0)
|
||
}
|
||
}
|
||
function GetFixedCharCodeAt(str)
|
||
{
|
||
let code = str.charCodeAt(0);
|
||
let hi, low;
|
||
|
||
if (0xd800 <= code && code <= 0xdbff) {
|
||
hi = code;
|
||
low = str.charCodeAt(1);
|
||
if (isNaN(low)) {
|
||
return null;
|
||
}
|
||
return (hi - 0xd800) * 0x400 + (low - 0xdc00) + 0x10000;
|
||
}
|
||
if (0xdc00 <= code && code <= 0xdfff) {
|
||
return false;
|
||
}
|
||
return code;
|
||
}
|
||
|
||
function GetLaTeXFromValue(value)
|
||
{
|
||
if (!isGetLaTeX || value === "{" || value === "}")
|
||
return undefined;
|
||
|
||
let arrValue = Object.keys(AutoCorrection).filter(function(key) {
|
||
return AutoCorrection[key] === value;
|
||
});
|
||
|
||
for (let i = 0; i < arrValue.length; i++)
|
||
{
|
||
let currentValue = arrValue[i];
|
||
if (currentValue[0] === "\\")
|
||
{
|
||
return currentValue;
|
||
}
|
||
}
|
||
return undefined;
|
||
}
|
||
|
||
let AutoCorrection = {
|
||
|
||
'/<' : '≮',
|
||
'/=' : '≠',
|
||
'/>' : '≯',
|
||
|
||
'/\\approx' : "≉",
|
||
'/\\asymp' : '≭',
|
||
'/\\cong' : '≇',
|
||
'/\\equiv' : '≢',
|
||
'/\\exists' : '∄',
|
||
'/\\ge' : '≱',
|
||
'/\\gtrless': '≹',
|
||
'/\\in' : '∉',
|
||
'/\\le' : '≰',
|
||
'/\\lessgtr': '≸',
|
||
'/\\ni' : '∌',
|
||
'/\\prec' : '⊀',
|
||
'/\\preceq' : '⋠',
|
||
'/\\sim' : '≁',
|
||
'/\\simeq' : '≄',
|
||
'/\\sqsubseteq' : '⋢',
|
||
'/\\sqsuperseteq': '⋣',
|
||
'/\\sqsupseteq' : '⋣',
|
||
'/\\subset': '⊄',
|
||
'/\\subseteq': '⊈',
|
||
'/\\succ': '⊁',
|
||
'/\\succeq': '⋡',
|
||
'/\\supset': '⊅',
|
||
'/\\superset': '⊅',
|
||
'/\\superseteq': '⊉',
|
||
'/\\supseteq': '⊉',
|
||
|
||
"\\above": "┴",
|
||
"\\acute": "́",
|
||
"\\aleph": "ℵ",
|
||
"\\alpha": "α",
|
||
"\\Alpha": "Α",
|
||
"\\amalg": "∐", //?
|
||
"\\angle": "∠",
|
||
"\\aoint": "∳",
|
||
"\\approx": "≈",
|
||
"\\asmash": "⬆",
|
||
"\\ast": "∗",
|
||
"\\asymp": "≍",
|
||
"\\atop": "¦",
|
||
"\\array": "■",
|
||
|
||
"\\Bar": "̿",
|
||
"\\bar": "̅",
|
||
"\\backslash": "\\",
|
||
"\\backprime": "‵",
|
||
"\\because": "∵",
|
||
"\\begin": "〖",
|
||
"\\below": "┬",
|
||
"\\bet": "ℶ",
|
||
"\\beta": "β",
|
||
"\\Beta": "Β",
|
||
"\\beth": "ℶ",
|
||
"\\bigcap": "⋂",
|
||
"\\bigcup": "⋃",
|
||
"\\bigodot": "⨀",
|
||
"\\bigoplus": "⨁",
|
||
"\\bigotimes": "⨂",
|
||
"\\bigsqcup": "⨆",
|
||
"\\biguplus": "⨄",
|
||
"\\bigvee": "⋁",
|
||
"\\bigwedge": "⋀",
|
||
"\\binomial": "(a+b)^n=∑_(k=0)^n ▒(n¦k)a^k b^(n-k)",
|
||
"\\bot": "⊥",
|
||
"\\bowtie": "⋈",
|
||
"\\box": "□",
|
||
"\\boxdot": "⊡",
|
||
"\\boxminus": "⊟",
|
||
"\\boxplus": "⊞",
|
||
"\\bra": "⟨",
|
||
"\\break": "⤶",
|
||
"\\breve": "̆",
|
||
"\\bullet": "∙",
|
||
|
||
"\\cap": "∩",
|
||
"\\cases": "Ⓒ", //["\\cases", "█", true], TODO CHECK
|
||
"\\cbrt": "∛",
|
||
"\\cdot": "⋅",
|
||
"\\cdots": "⋯",
|
||
"\\check": "̌",
|
||
"\\chi": "χ",
|
||
"\\Chi": "Χ",
|
||
"\\circ": "∘",
|
||
"\\close": "┤",
|
||
"\\clubsuit": "♣",
|
||
"\\coint": "∲",
|
||
"\\cong": "≅",
|
||
"\\contain": "∋",
|
||
"\\coprod": "∐",
|
||
"\\cup": "∪",
|
||
|
||
"\\dalet": "ℸ",
|
||
"\\daleth": "ℸ",
|
||
"\\dashv": "⊣",
|
||
"\\dd": "ⅆ",
|
||
"\\Dd": "ⅅ",
|
||
"\\ddddot": "⃜",
|
||
"\\dddot": "⃛",
|
||
"\\ddot": "̈",
|
||
"\\ddots": "⋱",
|
||
"\\defeq": "≝",
|
||
"\\degc": "℃",
|
||
"\\degf": "℉",
|
||
"\\degree": "°",
|
||
"\\delta": "δ",
|
||
"\\Delta": "Δ",
|
||
"\\Deltaeq": "≜",
|
||
"\\diamond": "⋄",
|
||
"\\diamondsuit": "♢",
|
||
"\\div": "÷",
|
||
"\\dot": "̇",
|
||
"\\doteq": "≐",
|
||
"\\dots": "…",
|
||
"\\doublea": "𝕒",
|
||
"\\doubleA": "𝔸",
|
||
"\\doubleb": "𝕓",
|
||
"\\doubleB": "𝔹",
|
||
"\\doublec": "𝕔",
|
||
"\\doubleC": "ℂ",
|
||
"\\doubled": "𝕕",
|
||
"\\doubleD": "𝔻",
|
||
"\\doublee": "𝕖",
|
||
"\\doubleE": "𝔼",
|
||
"\\doublef": "𝕗",
|
||
"\\doubleF": "𝔽",
|
||
"\\doubleg": "𝕘",
|
||
"\\doubleG": "𝔾",
|
||
"\\doubleh": "𝕙",
|
||
"\\doubleH": "ℍ",
|
||
"\\doublei": "𝕚",
|
||
"\\doubleI": "𝕀",
|
||
"\\doublej": "𝕛",
|
||
"\\doubleJ": "𝕁",
|
||
"\\doublek": "𝕜",
|
||
"\\doubleK": "𝕂",
|
||
"\\doublel": "𝕝",
|
||
"\\doubleL": "𝕃",
|
||
"\\doublem": "𝕞",
|
||
"\\doubleM": "𝕄",
|
||
"\\doublen": "𝕟",
|
||
"\\doubleN": "ℕ",
|
||
"\\doubleo": "𝕠",
|
||
"\\doubleO": "𝕆",
|
||
"\\doublep": "𝕡",
|
||
"\\doubleP": "ℙ",
|
||
"\\doubleq": "𝕢",
|
||
"\\doubleQ": "ℚ",
|
||
"\\doubler": "𝕣",
|
||
"\\doubleR": "ℝ",
|
||
"\\doubles": "𝕤",
|
||
"\\doubleS": "𝕊",
|
||
"\\doublet": "𝕥",
|
||
"\\doubleT": "𝕋",
|
||
"\\doubleu": "𝕦",
|
||
"\\doubleU": "𝕌",
|
||
"\\doublev": "𝕧",
|
||
"\\doubleV": "𝕍",
|
||
"\\doublew": "𝕨",
|
||
"\\doubleW": "𝕎",
|
||
"\\doublex": "𝕩",
|
||
"\\doubleX": "𝕏",
|
||
"\\doubley": "𝕪",
|
||
"\\doubleY": "𝕐",
|
||
"\\doublez": "𝕫",
|
||
"\\doubleZ": "ℤ",
|
||
"\\downarrow": "↓",
|
||
"\\Downarrow": "⇓",
|
||
"\\dsmash": "⬇",
|
||
|
||
"\\ee": "ⅇ",
|
||
"\\ell": "ℓ",
|
||
"\\emptyset": "∅",
|
||
"\\emsp": " ",
|
||
"\\end": "〗",
|
||
"\\ensp": " ",
|
||
"\\epsilon": "ϵ",
|
||
"\\Epsilon": "Ε",
|
||
"\\eqarray": "█",
|
||
"\\equiv": "≡",
|
||
"\\eta": "η",
|
||
"\\Eta": "Η",
|
||
"\\exists": "∃",
|
||
|
||
"\\forall": "∀",
|
||
"\\fraktura": "𝔞",
|
||
"\\frakturA": "𝔄",
|
||
"\\frakturb": "𝔟",
|
||
"\\frakturB": "𝔅",
|
||
"\\frakturc": "𝔠",
|
||
"\\frakturC": "ℭ",
|
||
"\\frakturd": "𝔡",
|
||
"\\frakturD": "𝔇",
|
||
"\\frakture": "𝔢",
|
||
"\\frakturE": "𝔈",
|
||
"\\frakturf": "𝔣",
|
||
"\\frakturF": "𝔉",
|
||
"\\frakturg": "𝔤",
|
||
"\\frakturG": "𝔊",
|
||
"\\frakturh": "𝔥",
|
||
"\\frakturH": "ℌ",
|
||
"\\frakturi": "𝔦",
|
||
"\\frakturI": "ℑ",
|
||
"\\frakturj": "𝔧",
|
||
"\\frakturJ": "𝔍",
|
||
"\\frakturk": "𝔨",
|
||
"\\frakturK": "𝔎",
|
||
"\\frakturl": "𝔩",
|
||
"\\frakturL": "𝔏",
|
||
"\\frakturm": "𝔪",
|
||
"\\frakturM": "𝔐",
|
||
"\\frakturn": "𝔫",
|
||
"\\frakturN": "𝔑",
|
||
"\\frakturo": "𝔬",
|
||
"\\frakturO": "𝔒",
|
||
"\\frakturp": "𝔭",
|
||
"\\frakturP": "𝔓",
|
||
"\\frakturq": "𝔮",
|
||
"\\frakturQ": "𝔔",
|
||
"\\frakturr": "𝔯",
|
||
"\\frakturR": "ℜ",
|
||
"\\frakturs": "𝔰",
|
||
"\\frakturS": "𝔖",
|
||
"\\frakturt": "𝔱",
|
||
"\\frakturT": "𝔗",
|
||
"\\frakturu": "𝔲",
|
||
"\\frakturU": "𝔘",
|
||
"\\frakturv": "𝔳",
|
||
"\\frakturV": "𝔙",
|
||
"\\frakturw": "𝔴",
|
||
"\\frakturW": "𝔚",
|
||
"\\frakturx": "𝔵",
|
||
"\\frakturX": "𝔛",
|
||
"\\fraktury": "𝔶",
|
||
"\\frakturY": "𝔜",
|
||
"\\frakturz": "𝔷",
|
||
"\\frakturZ": "ℨ",
|
||
"\\frown": "⌑",
|
||
"\\funcapply": "",
|
||
|
||
"\\G": "Γ",
|
||
"\\gamma": "γ",
|
||
"\\Gamma": "Γ",
|
||
"\\ge": "≥",
|
||
"\\geq": "≥",
|
||
"\\gets": "←",
|
||
"\\gg": "≫",
|
||
"\\gimel": "ℷ",
|
||
"\\grave": "̀",
|
||
|
||
"\\hairsp": " ",
|
||
"\\hat": "̂",
|
||
"\\hbar": "ℏ",
|
||
"\\heartsuit": "♡",
|
||
"\\hookleftarrow": "↩",
|
||
"\\hookrightarrow": "↪",
|
||
"\\hphantom": "⬄",
|
||
"\\hsmash": "⬌",
|
||
"\\hvec": "⃑",
|
||
|
||
"\\identitymatrix": "(■(1&0&0@0&1&0@0&0&1))",
|
||
"\\ii": "ⅈ",
|
||
"\\iiiint": "⨌",
|
||
"\\iiint": "∭",
|
||
"\\iint": "∬",
|
||
"\\Im": "ℑ",
|
||
"\\imath": "ı",
|
||
"\\inc": "∆",
|
||
"\\int": "∫",
|
||
"\\infty": "∞",
|
||
"\\in": "∈",
|
||
"\\integral": "1/2π ∫_0^2π ▒ⅆθ/(a+b sin θ)=1/√(a^2-b^2)",
|
||
"\\iota": "ι",
|
||
"\\Iota": "Ι",
|
||
"\\itimes": "",
|
||
|
||
"\\j": "Jay",
|
||
"\\jj": "ⅉ",
|
||
"\\jmath": "ȷ",
|
||
"\\kappa": "κ",
|
||
"\\Kappa": "Κ",
|
||
"\\ket": "⟩",
|
||
"\\lambda": "λ",
|
||
"\\Lambda": "Λ",
|
||
"\\langle": "〈",
|
||
"\\lbbrack": "⟦",
|
||
"\\lbrace": "\{",
|
||
"\\lbrack": "[",
|
||
"\\lceil": "⌈",
|
||
"\\ldiv": "∕",
|
||
"\\ldivide": "∕",
|
||
"\\ldots": "…",
|
||
"\\le": "≤",
|
||
"\\left": "├",
|
||
"\\leftarrow": "←",
|
||
"\\Leftarrow": "⇐",
|
||
"\\leftharpoondown": "↽",
|
||
"\\leftharpoonup": "↼",
|
||
"\\Leftrightarrow": "⇔",
|
||
"\\leftrightarrow": "↔",
|
||
|
||
"\\leq": "≤",
|
||
"\\lfloor": "⌊",
|
||
"\\lhvec": "⃐",
|
||
"\\limit": "lim_(n→∞)〖(1+1/n)^n〗=e",
|
||
"\\ll": "≪",
|
||
"\\lmoust": "⎰",
|
||
"\\Longleftarrow": "⟸",
|
||
"\\Longleftrightarrow": "⟺",
|
||
"\\Longrightarrow": "⟹",
|
||
"\\lrhar": "⇋",
|
||
"\\lvec": "⃖",
|
||
|
||
"\\mapsto": "↦",
|
||
"\\matrix": "■",
|
||
"\\medsp": " ",
|
||
"\\mid": "∣",
|
||
"\\middle": "ⓜ",
|
||
"\\models": "⊨",
|
||
"\\mp": "∓",
|
||
"\\mu": "μ",
|
||
"\\Mu": "Μ",
|
||
|
||
"\\nabla": "∇",
|
||
"\\naryand": "▒",
|
||
"\\nbsp": " ",
|
||
"\\ndiv": "⊘",
|
||
"\\neg": "¬",
|
||
"\\norm": "‖",
|
||
"\\notcontain": "∌",
|
||
"\\notelement": "∉",
|
||
"\\nu": "ν",
|
||
"\\Nu": "Ν",
|
||
"\\nwarrow": "↖",
|
||
|
||
"\\nLeftarrow" : "⇍",
|
||
"\\nLeftrightarrow" : "⇎",
|
||
"\\nRightarrow" : "⇏",
|
||
"\\nVDash" : "⊯",
|
||
"\\nVdash" : "⊮",
|
||
"\\nVleftarrow" : "⇺",
|
||
"\\nVleftarrowtail" : "⬺",
|
||
"\\nVleftrightarrow" : "⇼",
|
||
"\\nVrightarrow" : "⇻",
|
||
"\\nVrightarrowtail" : "⤕",
|
||
"\\nVtwoheadleftarrow" : "⬵",
|
||
"\\nVtwoheadleftarrowtail" : "⬽",
|
||
"\\nVtwoheadrightarrow" : "⤁",
|
||
"\\nVtwoheadrightarrowtail" : "⤘",
|
||
"\\napprox" : "≉",
|
||
"\\nasymp" : "≭",
|
||
"\\ncong" : "≇",
|
||
"\\ne" : "≠",
|
||
"\\nearrow" : "↗",
|
||
"\\neq" : "≠",
|
||
"\\nequiv" : "≢",
|
||
"\\neswarrow" : "⤢",
|
||
"\\ngeq" : "≱",
|
||
"\\ngtr" : "≯",
|
||
"\\ngtrless" : "≹",
|
||
"\\ngtrsim" : "≵",
|
||
"\\nhpar" : "⫲",
|
||
"\\ni" : "∋",
|
||
"\\niobar" : "⋾",
|
||
"\\nis" : "⋼",
|
||
"\\nisd" : "⋺",
|
||
"\\nleftarrow" : "↚",
|
||
"\\nleftrightarrow" : "↮",
|
||
"\\nleq" : "≰",
|
||
"\\nless" : "≮",
|
||
"\\nlessgtr" : "≸",
|
||
"\\nlesssim" : "≴",
|
||
"\\nmid" : "∤",
|
||
"\\nni" : "∌",
|
||
"\\notasymp" : "≭",
|
||
"\\notin" : "∉",
|
||
"\\notslash" : "⌿",
|
||
"\\nparallel" : "∦",
|
||
"\\nprec" : "⊀",
|
||
"\\npreccurlyeq" : "⋠",
|
||
"\\npreceq" : "⋠",
|
||
"\\nrightarrow" : "↛",
|
||
"\\nsim" : "≁",
|
||
"\\nsime" : "≄",
|
||
"\\nsimeq" : "≄",
|
||
"\\nsqsubseteq" : "⋢",
|
||
"\\nsqsupseteq" : "⋣",
|
||
"\\nsubset" : "⊄",
|
||
"\\nsubseteq" : "⊈",
|
||
"\\nsucc" : "⊁",
|
||
"\\nsucccurlyeq" : "⋡",
|
||
"\\nsucceq" : "⋡",
|
||
"\\nsupset" : "⊅",
|
||
"\\nsupseteq" : "⊉",
|
||
"\\ntriangleleft" : "⋪",
|
||
"\\ntrianglelefteq" : "⋬",
|
||
"\\ntriangleright" : "⋫",
|
||
"\\ntrianglerighteq" : "⋭",
|
||
"\\nvDash" : "⊭",
|
||
"\\nvLeftarrow" : "⤂",
|
||
"\\nvLeftrightarrow" : "⤄",
|
||
"\\nvRightarrow" : "⤃",
|
||
"\\nvdash" : "⊬",
|
||
"\\nvleftarrow" : "⇷",
|
||
"\\nvleftarrowtail" : "⬹",
|
||
"\\nvleftrightarrow" : "⇹",
|
||
"\\nvrightarrow" : "⇸",
|
||
"\\nvrightarrowtail" : "⤔",
|
||
"\\nvtwoheadleftarrow" : "⬴",
|
||
"\\nvtwoheadleftarrowtail" : "⬼",
|
||
"\\nvtwoheadrightarrow" : "⤀",
|
||
"\\nvtwoheadrightarrowtail" : "⤗",
|
||
|
||
"\\o": "ο",
|
||
"\\O": "Ο",
|
||
"\\odot": "⊙",
|
||
"\\of": "▒",
|
||
"\\oiiint": "∰",
|
||
"\\oiint": "∯",
|
||
"\\oint": "∮",
|
||
"\\omega": "ω",
|
||
"\\Omega": "Ω",
|
||
"\\ominus": "⊖",
|
||
"\\open": "├",
|
||
"\\oplus": "⊕",
|
||
"\\otimes": "⊗",
|
||
"\\overbar": "¯",
|
||
"\\overbrace": "⏞",
|
||
"\\overbracket": "⎴",
|
||
"\\overline": "¯",
|
||
"\\overparen": "⏜",
|
||
"\\overshell": "⏠",
|
||
|
||
"\\parallel": "∥",
|
||
"\\partial": "∂",
|
||
"\\perp": "⊥",
|
||
"\\phantom": "⟡",
|
||
"\\phi": "ϕ",
|
||
"\\Phi": "Φ",
|
||
"\\pi": "π",
|
||
"\\Pi": "Π",
|
||
"\\pm": "±",
|
||
"\\pmatrix": "⒨",
|
||
"\\pppprime": "⁗",
|
||
"\\ppprime": "‴",
|
||
"\\pprime": "″",
|
||
"\\prec": "≺",
|
||
"\\preceq": "≼",
|
||
"\\prime": "′",
|
||
"\\prod": "∏",
|
||
"\\propto": "∝",
|
||
"\\psi": "ψ",
|
||
"\\Psi": "Ψ",
|
||
|
||
"\\qdrt": "∜",
|
||
"\\quad": " ",
|
||
"\\quadratic": "x=(-b±√(b^2-4ac))/2a",
|
||
|
||
"\\rangle": "〉",
|
||
"\\Rangle": "⟫",
|
||
"\\ratio": "∶",
|
||
"\\rbrace": "}",
|
||
"\\rbrack": "]",
|
||
"\\Rbrack": "⟧",
|
||
"\\rceil": "⌉",
|
||
"\\rddots": "⋰",
|
||
"\\Re": "ℜ",
|
||
"\\rect": "▭",
|
||
"\\rfloor": "⌋",
|
||
"\\rho": "ρ",
|
||
"\\Rho": "Ρ",
|
||
"\\rhvec": "⃑",
|
||
"\\right": "┤",
|
||
"\\rightarrow": "→",
|
||
"\\Rightarrow": "⇒",
|
||
"\\rightharpoondown": "⇁",
|
||
"\\rightharpoonup": "⇀",
|
||
"\\rmoust": "⎱",
|
||
"\\root": "⒭",
|
||
|
||
"\\scripta": "𝒶",
|
||
"\\scriptA": "𝒜",
|
||
"\\scriptb": "𝒷",
|
||
"\\scriptB": "ℬ",
|
||
"\\scriptc": "𝒸",
|
||
"\\scriptC": "𝒞",
|
||
"\\scriptd": "𝒹",
|
||
"\\scriptD": "𝒟",
|
||
"\\scripte": "ℯ",
|
||
"\\scriptE": "ℰ",
|
||
"\\scriptf": "𝒻",
|
||
"\\scriptF": "ℱ",
|
||
"\\scriptg": "ℊ",
|
||
"\\scriptG": "𝒢",
|
||
"\\scripth": "𝒽",
|
||
"\\scriptH": "ℋ",
|
||
"\\scripti": "𝒾",
|
||
"\\scriptI": "ℐ",
|
||
"\\scriptj": "𝒥",
|
||
"\\scriptk": "𝓀",
|
||
"\\scriptK": "𝒦",
|
||
"\\scriptl": "ℓ",
|
||
"\\scriptL": "ℒ",
|
||
"\\scriptm": "𝓂",
|
||
"\\scriptM": "ℳ",
|
||
"\\scriptn": "𝓃",
|
||
"\\scriptN": "𝒩",
|
||
"\\scripto": "ℴ",
|
||
"\\scriptO": "𝒪",
|
||
"\\scriptp": "𝓅",
|
||
"\\scriptP": "𝒫",
|
||
"\\scriptq": "𝓆",
|
||
"\\scriptQ": "𝒬",
|
||
"\\scriptr": "𝓇",
|
||
"\\scriptR": "ℛ",
|
||
"\\scripts": "𝓈",
|
||
"\\scriptS": "𝒮",
|
||
"\\scriptt": "𝓉",
|
||
"\\scriptT": "𝒯",
|
||
"\\scriptu": "𝓊",
|
||
"\\scriptU": "𝒰",
|
||
"\\scriptv": "𝓋",
|
||
"\\scriptV": "𝒱",
|
||
"\\scriptw": "𝓌",
|
||
"\\scriptW": "𝒲",
|
||
"\\scriptx": "𝓍",
|
||
"\\scriptX": "𝒳",
|
||
"\\scripty": "𝓎",
|
||
"\\scriptY": "𝒴",
|
||
"\\scriptz": "𝓏",
|
||
"\\scriptZ": "𝒵",
|
||
"\\sdiv": "⁄",
|
||
"\\sdivide": "⁄",
|
||
"\\searrow": "↘",
|
||
"\\setminus": "∖",
|
||
"\\sigma": "σ",
|
||
"\\Sigma": "Σ",
|
||
"\\sim": "∼",
|
||
"\\simeq": "≃",
|
||
"\\smash": "⬍",
|
||
"\\smile": "⌣",
|
||
"\\spadesuit": "♠",
|
||
"\\sqcap": "⊓",
|
||
"\\sqcup": "⊔",
|
||
"\\sqrt": "√",
|
||
"\\sqsubseteq": "⊑",
|
||
"\\sqsuperseteq": "⊒",
|
||
"\\star": "⋆",
|
||
"\\subset": "⊂",
|
||
"\\subseteq": "⊆",
|
||
"\\succ": "≻",
|
||
"\\succeq": "≽",
|
||
"\\sum": "∑",
|
||
"\\superset": "⊃",
|
||
"\\superseteq": "⊇",
|
||
"\\swarrow": "↙",
|
||
|
||
"\\tau": "τ",
|
||
"\\Tau": "Τ",
|
||
"\\therefore": "∴",
|
||
"\\theta": "θ",
|
||
"\\Theta": "Θ",
|
||
"\\thicksp": " ",
|
||
"\\thinsp": " ",
|
||
"\\tilde": "̃",
|
||
"\\times": "×",
|
||
"\\to": "→",
|
||
"\\top": "⊤",
|
||
"\\tvec": "⃡",
|
||
|
||
"\\ubar": "̲",
|
||
"\\Ubar": "̳",
|
||
"\\underbar": "▁",
|
||
"\\underbrace": "⏟",
|
||
"\\underbracket": "⎵",
|
||
"\\underline": "▁",
|
||
"\\underparen": "⏝",
|
||
"\\uparrow": "↑",
|
||
"\\Uparrow": "⇑",
|
||
"\\updownarrow": "↕",
|
||
"\\Updownarrow": "⇕",
|
||
"\\uplus": "⊎",
|
||
"\\upsilon": "υ",
|
||
"\\Upsilon": "Υ",
|
||
|
||
"\\varepsilon": "ε",
|
||
"\\varphi": "φ",
|
||
"\\varpi": "ϖ",
|
||
"\\varrho": "ϱ",
|
||
"\\varsigma": "ς",
|
||
"\\vartheta": "ϑ",
|
||
"\\vbar": "│",
|
||
"\\vdots": "⋮",
|
||
"\\vec": "⃗",
|
||
"\\vee": "∨",
|
||
"\\vert": "|",
|
||
"\\Vert": "‖",
|
||
"\\Vmatrix": "⒩",
|
||
"\\vphantom": "⇳",
|
||
"\\vthicksp": " ",
|
||
|
||
"\\wedge": "∧",
|
||
"\\wp": "℘",
|
||
"\\wr": "≀",
|
||
|
||
"\\xi": "ξ",
|
||
"\\Xi": "Ξ",
|
||
|
||
"\\zeta": "ζ",
|
||
"\\Zeta": "Ζ",
|
||
"\\zwnj": "",
|
||
"\\zwsp": "",
|
||
};
|
||
|
||
function UpdateAutoCorrection()
|
||
{
|
||
let arrG_AutoCorrectionList = window['AscCommonWord'].g_AutoCorrectMathsList.AutoCorrectMathSymbols;
|
||
AutoCorrection = {};
|
||
for (let i = 0; i < arrG_AutoCorrectionList.length; i++)
|
||
{
|
||
let arrCurrentElement = arrG_AutoCorrectionList[i];
|
||
let data = AscCommon.convertUnicodeToUTF16(Array.isArray(arrCurrentElement[1]) ? arrCurrentElement[1] : [arrCurrentElement[1]]);
|
||
let name = arrCurrentElement[0];
|
||
AutoCorrection[name] = data;
|
||
}
|
||
}
|
||
|
||
function UpdateFuncCorrection()
|
||
{
|
||
functionNames = window['AscCommonWord'].g_AutoCorrectMathsList.AutoCorrectMathFuncs;
|
||
}
|
||
|
||
const SymbolsToLaTeX = {
|
||
"∞" : "\\infty",
|
||
"→" : "\\to",
|
||
"…" : "\\ldots",
|
||
|
||
"ϵ" : "\\epsilon",
|
||
"∃" : "\\exists",
|
||
"∀" : "\\forall",
|
||
"≠" : "\\neq",
|
||
"≤" : "\\le",
|
||
"≥" : "\\geq",
|
||
"≮" : "\\nless",
|
||
"≰" : "\\nleq",
|
||
"≯" : "\\ngt",
|
||
"≱" : "\\ngeq",
|
||
"≡" : "\\equiv",
|
||
"∼" : "\\sim",
|
||
"≃" : "\\simeq",
|
||
"≈" : "\\approx",
|
||
"≅" : "\\cong",
|
||
"≢" : "\\nequiv",
|
||
//"≄" : "\\nsimeq",
|
||
"≉" : "\\napprox",
|
||
"≇" : "\\ncong",
|
||
"≪" : "\\ll",
|
||
"≫" : "\\gg",
|
||
"∈" : "\\in",
|
||
"∋" : "\\ni",
|
||
"∉" : "\\notin",
|
||
"⊂" : "\\subset",
|
||
"⊃" : "\\supset",
|
||
"⊆" : "\\subseteq",
|
||
"⊇" : "\\supseteq",
|
||
"≺" : "\\prcue",
|
||
"≻" : "\\succ",
|
||
"≼" : "\\preccurlyeq",
|
||
"≽" : "\\succcurlyeq",
|
||
"⊏" : "\\sqsubset",
|
||
"⊐" : "\\sqsupset",
|
||
"⊑" : "\\sqsubseteq",
|
||
"⊒" : "\\sqsupseteq",
|
||
"∥" : "\\parallel",
|
||
"⊥" : "\\bot",
|
||
"⊢" : "\\vdash",
|
||
"⊣" : "\\dashv",
|
||
"⋈" : "\\bowtie",
|
||
"≍" : "\\asymp",
|
||
"∔" : "\\dotplus",
|
||
"∸" : "\\dotminus",
|
||
"∖" : "\\setminus",
|
||
"⋒" : "\\Cap",
|
||
"⋓" : "\\Cup",
|
||
"⊟" : "\\boxminus",
|
||
"⊠" : "\\boxtimes",
|
||
"⊡" : "\\boxdot",
|
||
"⊞" : "\\boxplus",
|
||
"⋇" : "\\divideontimes",
|
||
"⋉" : "\\ltimes",
|
||
"⋊" : "\\rtimes",
|
||
"⋋" : "\\leftthreetimes",
|
||
"⋌" : "\\rightthreetimes",
|
||
"⋏" : "\\curlywedge",
|
||
"⋎" : "\\curlyvee",
|
||
"⊝" : "\\odash",
|
||
"⊺" : "\\intercal",
|
||
"⊕" : "\\oplus",
|
||
"⊖" : "\\ominus",
|
||
"⊗" : "\\otimes",
|
||
"⊘" : "\\oslash",
|
||
"⊙" : "\\odot",
|
||
"⊛" : "\\oast",
|
||
"⊚" : "\\ocirc",
|
||
"†" : "\\dag",
|
||
"‡" : "\\ddag",
|
||
"⋆" : "\\star",
|
||
"⋄" : "\\diamond",
|
||
"≀" : "\\wr",
|
||
"△" : "\\triangle",
|
||
"⋀" : "\\bigwedge",
|
||
"⋁" : "\\bigvee",
|
||
"⨀" : "\\bigodot",
|
||
"⨂" : "\\bigotimes",
|
||
"⨁" : "\\bigoplus",
|
||
"⨅" : "\\bigsqcap",
|
||
"⨆" : "\\bigsqcup",
|
||
"⨄" : "\\biguplus",
|
||
"⨃" : "\\bigudot",
|
||
"∴" : "\\therefore",
|
||
"∵" : "\\because",
|
||
"⋘" : "\\lll",
|
||
"⋙" : "\\ggg",
|
||
"≦" : "\\leqq",
|
||
"≧" : "\\geqq",
|
||
"≲" : "\\lesssim",
|
||
"≳" : "\\gtrsim",
|
||
"⋖" : "\\lessdot",
|
||
"⋗" : "\\gtrdot",
|
||
"≶" : "\\lessgtr",
|
||
"⋚" : "\\lesseqgtr",
|
||
"≷" : "\\gtrless",
|
||
"⋛" : "\\gtreqless",
|
||
"≑" : "\\Doteq",
|
||
"≒" : "\\fallingdotseq",
|
||
"≓" : "\\risingdotseq",
|
||
"∽" : "\\backsim",
|
||
"≊" : "\\approxeq",
|
||
"⋍" : "\\backsimeq",
|
||
"⋞" : "\\curlyeqprec",
|
||
"⋟" : "\\curlyeqsucc",
|
||
"≾" : "\\precsim",
|
||
"≿" : "\\succsim",
|
||
"⋜" : "\\eqless",
|
||
"⋝" : "\\eqgtr",
|
||
"⊲" : "\\vartriangleleft",
|
||
"⊳" : "\\vartriangleright",
|
||
"⊴" : "\\trianglelefteq",
|
||
"⊵" : "\\trianglerighteq",
|
||
"⊨" : "\\models",
|
||
"⋐" : "\\Subset",
|
||
"⋑" : "\\Supset",
|
||
"⊩" : "\\Vdash",
|
||
"⊪" : "\\Vvdash",
|
||
"≖" : "\\eqcirc",
|
||
"≗" : "\\circeq",
|
||
"≜" : "\\Deltaeq",
|
||
"≏" : "\\bumpeq",
|
||
"≎" : "\\Bumpeq",
|
||
"∝" : "\\propto",
|
||
"≬" : "\\between",
|
||
"⋔" : "\\pitchfork",
|
||
"≐" : "\\doteq",
|
||
|
||
"⇍" : "\\nLeftarrow",
|
||
"⇎" : "\\nLeftrightarrow",
|
||
"⇏" : "\\nRightarrow",
|
||
"⊯" : "\\nVDash",
|
||
"⊮" : "\\nVdash",
|
||
"⇺" : "\\nVleftarrow",
|
||
"⬺" : "\\nVleftarrowtail",
|
||
"⇼" : "\\nVleftrightarrow",
|
||
"⇻" : "\\nVrightarrow",
|
||
"⤕" : "\\nVrightarrowtail",
|
||
"⬵" : "\\nVtwoheadleftarrow",
|
||
"⬽" : "\\nVtwoheadleftarrowtail",
|
||
"⤁" : "\\nVtwoheadrightarrow",
|
||
"⤘" : "\\nVtwoheadrightarrowtail",
|
||
//"≉" : "\\napprox",
|
||
"≭" : "\\nasymp",
|
||
// "≇" : "\\ncong",
|
||
// "≠" : "\\ne",
|
||
"↗" : "\\nearrow",
|
||
// "≠" : "\\neq",
|
||
// "≢" : "\\nequiv",
|
||
"⤢" : "\\neswarrow",
|
||
// "≱" : "\\ngeq",
|
||
// "≯" : "\\ngtr",
|
||
"≹" : "\\ngtrless",
|
||
"≵" : "\\ngtrsim",
|
||
"⫲" : "\\nhpar",
|
||
// "∋" : "\\ni",
|
||
"⋾" : "\\niobar",
|
||
"⋼" : "\\nis",
|
||
"⋺" : "\\nisd",
|
||
"↚" : "\\nleftarrow",
|
||
"↮" : "\\nleftrightarrow",
|
||
// "≰" : "\\nleq",
|
||
// "≮" : "\\nless",
|
||
"≸" : "\\nlessgtr",
|
||
"≴" : "\\nlesssim",
|
||
"∤" : "\\nmid",
|
||
"∌" : "\\nni",
|
||
// "≭" : "\\notasymp",
|
||
// "∉" : "\\notin",
|
||
"⌿" : "\\notslash",
|
||
"∦" : "\\nparallel",
|
||
"⊀" : "\\nprec",
|
||
// "⋠" : "\\npreccurlyeq",
|
||
// "⋠" : "\\npreceq",
|
||
"↛" : "\\nrightarrow",
|
||
"≁" : "\\nsim",
|
||
// "≄" : "\\nsime",
|
||
// "≄" : "\\nsimeq",
|
||
"⋢" : "\\nsqsubseteq",
|
||
"⋣" : "\\nsqsupseteq",
|
||
"⊄" : "\\nsubset",
|
||
"⊈" : "\\nsubseteq",
|
||
"⊁" : "\\nsucc",
|
||
// "⋡" : "\\nsucccurlyeq",
|
||
// "⋡" : "\\nsucceq",
|
||
"⊅" : "\\nsupset",
|
||
"⊉" : "\\nsupseteq",
|
||
"⋪" : "\\ntriangleleft",
|
||
"⋬" : "\\ntrianglelefteq",
|
||
"⋫": "\\ntriangleright",
|
||
"⋭" : "\\ntrianglerighteq",
|
||
"⊭" : "\\nvDash",
|
||
"⤂" : "\\nvLeftarrow",
|
||
"⤄" : "\\nvLeftrightarrow",
|
||
"⤃" : "\\nvRightarrow",
|
||
"⊬" : "\\nvdash",
|
||
"⇷" : "\\nvleftarrow",
|
||
"⬹" : "\\nvleftarrowtail",
|
||
"⇹" : "\\nvleftrightarrow",
|
||
"⇸" : "\\nvrightarrow",
|
||
"⤔" : "\\nvrightarrowtail",
|
||
"⬴" : "\\nvtwoheadleftarrow",
|
||
"⬼" : "\\nvtwoheadleftarrowtail",
|
||
"⤀" : "\\nvtwoheadrightarrow",
|
||
"⤗" : "\\nvtwoheadrightarrowtail",
|
||
|
||
"ⅆ" :"\\dd" ,
|
||
"ⅅ" :"\\Dd" ,
|
||
"ⅇ" :"\\ee" ,
|
||
"ℓ" :"\\ell" ,
|
||
"ℏ" :"\\hbar" ,
|
||
"ⅈ" :"\\ii" ,
|
||
"ℑ" :"\\Im" ,
|
||
"ı" :"\\imath" ,
|
||
"Jay" :"\\j" ,
|
||
"ⅉ" :"\\jj" ,
|
||
"ȷ" :"\\jmath" ,
|
||
"∂" :"\\partial" ,
|
||
"ℜ" :"\\Re" ,
|
||
"℘" :"\\wp" ,
|
||
"ℵ" :"\\aleph" ,
|
||
"ℶ" :"\\bet" ,
|
||
"ℷ" :"\\gimel" ,
|
||
"ℸ" :"\\dalet" ,
|
||
|
||
"Α" :"\\Alpha" ,
|
||
"α" :"\\alpha" ,
|
||
"Β" :"\\Beta" ,
|
||
"β" :"\\beta" ,
|
||
"γ" :"\\gamma" ,
|
||
"Γ" :"\\Gamma" ,
|
||
"Δ" :"\\Delta" ,
|
||
"δ" :"\\delta" ,
|
||
"Ε" :"\\Epsilon" ,
|
||
"ε" :"\\varepsilon" ,
|
||
"ζ" :"\\zeta" ,
|
||
"Ζ" :"\\Zeta" ,
|
||
"η" :"\\eta" ,
|
||
"Η" :"\\Eta" ,
|
||
"θ" :"\\theta" ,
|
||
"Θ" :"\\Theta" ,
|
||
"ϑ" :"\\vartheta" ,
|
||
"ι" :"\\iota" ,
|
||
"Ι" :"\\Iota" ,
|
||
"κ" :"\\kappa" ,
|
||
"Κ" :"\\Kappa" ,
|
||
"λ" :"\\lambda" ,
|
||
"Λ" :"\\Lambda" ,
|
||
"μ" :"\\mu" ,
|
||
"Μ" :"\\Mu" ,
|
||
"ν" :"\\nu" ,
|
||
"Ν" :"\\Nu" ,
|
||
"ξ" :"\\xi" ,
|
||
"Ξ" :"\\Xi" ,
|
||
"Ο" :"\\O" ,
|
||
"ο" :"\\o" ,
|
||
"π" :"\\pi" ,
|
||
"Π" :"\\Pi" ,
|
||
"ϖ" :"\\varpi" ,
|
||
"ρ" :"\\rho" ,
|
||
"Ρ" :"\\Rho" ,
|
||
"ϱ" :"\\varrho" ,
|
||
"σ" :"\\sigma" ,
|
||
"Σ" :"\\Sigma" ,
|
||
"ς" :"\\varsigma" ,
|
||
"τ" :"\\tau" ,
|
||
"Τ" :"\\Tau" ,
|
||
"υ" :"\\upsilon" ,
|
||
"Υ" :"\\Upsilon" ,
|
||
"ϕ" :"\\phi" ,
|
||
"Φ" :"\\Phi" ,
|
||
"φ" :"\\varphi" ,
|
||
"χ" :"\\chi" ,
|
||
"Χ" :"\\Chi" ,
|
||
"ψ" :"\\psi" ,
|
||
"Ψ" :"\\Psi" ,
|
||
"ω" :"\\omega" ,
|
||
"Ω" :"\\Omega" ,
|
||
|
||
"┴" : "\\above",
|
||
"́" : "\\acute",
|
||
"∐" : "\\amalg",
|
||
"∠" : "\\angle",
|
||
"∳" : "\\aoint",
|
||
"⬆" : "\\asmash",
|
||
"∗" : "\\ast",
|
||
"¦" : "\\atop",
|
||
"■" : "\\array",
|
||
|
||
"̿" : "\\Bar",
|
||
"̅" : "\\bar",
|
||
"‵" : "\\backprime",
|
||
"〖" : "\\begin",
|
||
"┬" : "\\below",
|
||
"⋂" : "\\bigcap",
|
||
"⋃" : "\\bigcup",
|
||
"□" : "\\box",
|
||
"⟨" : "\\bra",
|
||
"⤶" : "\\break",
|
||
"̆" : "\\breve",
|
||
"∙" : "\\bullet",
|
||
|
||
"∩" : "\\cap",
|
||
"Ⓒ" : "\\cases",
|
||
"∛" : "\\cbrt",
|
||
"⋅" : "\\cdot",
|
||
"⋯" : "\\cdots",
|
||
"̌" : "\\check",
|
||
"∘" : "\\circ",
|
||
"┤" : "\\close",
|
||
"♣" : "\\clubsuit",
|
||
"∲" : "\\coint",
|
||
"∪" : "\\cup",
|
||
|
||
"⃜" : "\\ddddot",
|
||
"⃛" : "\\dddot",
|
||
"̈" : "\\ddot",
|
||
"⋱" : "\\ddots",
|
||
"≝" : "\\defeq",
|
||
"℃" : "\\degc",
|
||
"℉" : "\\degf",
|
||
"°" : "\\degree",
|
||
"♢" : "\\diamondsuit",
|
||
"÷" : "\\div",
|
||
"̇" : "\\dot",
|
||
"𝕒" : "\\doublea",
|
||
"𝔸" : "\\doubleA",
|
||
"𝕓" : "\\doubleb",
|
||
"𝔹" : "\\doubleB",
|
||
"𝕔" : "\\doublec",
|
||
"ℂ" : "\\doubleC",
|
||
"𝕕" : "\\doubled",
|
||
"𝔻" : "\\doubleD",
|
||
"𝕖" : "\\doublee",
|
||
"𝔼" : "\\doubleE",
|
||
"𝕗" : "\\doublef",
|
||
"𝔽" : "\\doubleF",
|
||
"𝕘" : "\\doubleg",
|
||
"𝔾" : "\\doubleG",
|
||
"𝕙" : "\\doubleh",
|
||
"ℍ" : "\\doubleH",
|
||
"𝕚" : "\\doublei",
|
||
"𝕀" : "\\doubleI",
|
||
"𝕛" : "\\doublej",
|
||
"𝕁" : "\\doubleJ",
|
||
"𝕜" : "\\doublek",
|
||
"𝕂" : "\\doubleK",
|
||
"𝕝" : "\\doublel",
|
||
"𝕃" : "\\doubleL",
|
||
"𝕞" : "\\doublem",
|
||
"𝕄" : "\\doubleM",
|
||
"𝕟" : "\\doublen",
|
||
"ℕ" : "\\doubleN",
|
||
"𝕠" : "\\doubleo",
|
||
"𝕆" : "\\doubleO",
|
||
"𝕡" : "\\doublep",
|
||
"ℙ" : "\\doubleP",
|
||
"𝕢" : "\\doubleq",
|
||
"ℚ" : "\\doubleQ",
|
||
"𝕣" : "\\doubler",
|
||
"ℝ" : "\\doubleR",
|
||
"𝕤" : "\\doubles",
|
||
"𝕊" : "\\doubleS",
|
||
"𝕥" : "\\doublet",
|
||
"𝕋" : "\\doubleT",
|
||
"𝕦" : "\\doubleu",
|
||
"𝕌" : "\\doubleU",
|
||
"𝕧" : "\\doublev",
|
||
"𝕍" : "\\doubleV",
|
||
"𝕨" : "\\doublew",
|
||
"𝕎" : "\\doubleW",
|
||
"𝕩" : "\\doublex",
|
||
"𝕏" : "\\doubleX",
|
||
"𝕪" : "\\doubley",
|
||
"𝕐" : "\\doubleY",
|
||
"𝕫" : "\\doublez",
|
||
"ℤ" : "\\doubleZ",
|
||
"↓" : "\\downarrow",
|
||
"⇓" : "\\Downarrow",
|
||
"⬇" : "\\dsmash",
|
||
|
||
"∅" : "\\emptyset",
|
||
" " : "\\emsp",
|
||
"〗" : "\\end",
|
||
" " : "\\ensp",
|
||
"█" : "\\eqarray",
|
||
|
||
"𝔞" : "\\fraktura",
|
||
"𝔄" : "\\frakturA",
|
||
"𝔟" : "\\frakturb",
|
||
"𝔅" : "\\frakturB",
|
||
"𝔠" : "\\frakturc",
|
||
"ℭ" : "\\frakturC",
|
||
"𝔡" : "\\frakturd",
|
||
"𝔇" : "\\frakturD",
|
||
"𝔢" : "\\frakture",
|
||
"𝔈" : "\\frakturE",
|
||
"𝔣" : "\\frakturf",
|
||
"𝔉" : "\\frakturF",
|
||
"𝔤" : "\\frakturg",
|
||
"𝔊" : "\\frakturG",
|
||
"𝔥" : "\\frakturh",
|
||
"ℌ" : "\\frakturH",
|
||
"𝔦" : "\\frakturi",
|
||
"𝔧" : "\\frakturj",
|
||
"𝔍" : "\\frakturJ",
|
||
"𝔨" : "\\frakturk",
|
||
"𝔎" : "\\frakturK",
|
||
"𝔩" : "\\frakturl",
|
||
"𝔏" : "\\frakturL",
|
||
"𝔪" : "\\frakturm",
|
||
"𝔐" : "\\frakturM",
|
||
"𝔫" : "\\frakturn",
|
||
"𝔑" : "\\frakturN",
|
||
"𝔬" : "\\frakturo",
|
||
"𝔒" : "\\frakturO",
|
||
"𝔭" : "\\frakturp",
|
||
"𝔓" : "\\frakturP",
|
||
"𝔮" : "\\frakturq",
|
||
"𝔔" : "\\frakturQ",
|
||
"𝔯" : "\\frakturr",
|
||
"𝔰" : "\\frakturs",
|
||
"𝔖" : "\\frakturS",
|
||
"𝔱" : "\\frakturt",
|
||
"𝔗" : "\\frakturT",
|
||
"𝔲" : "\\frakturu",
|
||
"𝔘" : "\\frakturU",
|
||
"𝔳" : "\\frakturv",
|
||
"𝔙" : "\\frakturV",
|
||
"𝔴" : "\\frakturw",
|
||
"𝔚" : "\\frakturW",
|
||
"𝔵" : "\\frakturx",
|
||
"𝔛" : "\\frakturX",
|
||
"𝔶" : "\\fraktury",
|
||
"𝔜" : "\\frakturY",
|
||
"𝔷" : "\\frakturz",
|
||
"ℨ" : "\\frakturZ",
|
||
"⌑" : "\\frown",
|
||
"" : "\\funcapply",
|
||
|
||
"←" : "\\gets",
|
||
"̀" : "\\grave",
|
||
|
||
" " : "\\hairsp",
|
||
"̂" : "\\hat",
|
||
"♡" : "\\heartsuit",
|
||
"↩" : "\\hookleftarrow",
|
||
"↪" : "\\hookrightarrow",
|
||
"⬄" : "\\hphantom",
|
||
"⬌" : "\\hsmash",
|
||
"⃑" : "\\hvec",
|
||
|
||
"⨌" : "\\iiiint",
|
||
"∭" : "\\iiint",
|
||
"∬" : "\\iint",
|
||
|
||
"∆" : "\\inc",
|
||
"∫" : "\\int",
|
||
"" : "\\itimes",
|
||
|
||
|
||
"⟩" : "\\ket",
|
||
"〈" : "\\langle",
|
||
"⟦" : "\\lbbrack",
|
||
//"[" : "\\lbrack",
|
||
"⌈" : "\\lceil",
|
||
"├" : "\\left",
|
||
"⇐" : "\\Leftarrow",
|
||
"↽" : "\\leftharpoondown",
|
||
"↼" : "\\leftharpoonup",
|
||
"⇔" : "\\Leftrightarrow",
|
||
"↔" : "\\leftrightarrow",
|
||
|
||
"⌊" : "\\lfloor",
|
||
"⃐" : "\\lhvec",
|
||
"⎰" : "\\lmoust",
|
||
"⟸" : "\\Longleftarrow",
|
||
"⟺" : "\\Longleftrightarrow",
|
||
"⟹" : "\\Longrightarrow",
|
||
"⇋" : "\\lrhar",
|
||
"⃖" : "\\lvec",
|
||
|
||
"↦" : "\\mapsto",
|
||
" " : "\\medsp",
|
||
"∣" : "\\mid",
|
||
"ⓜ" : "\\middle",
|
||
"∓" : "\\mp",
|
||
"∇" : "\\nabla",
|
||
"▒" : "\\naryand",
|
||
" " : "\\nbsp",
|
||
"¬" : "\\neg",
|
||
"‖" : "\\norm",
|
||
"↖" : "\\nwarrow",
|
||
|
||
"∰" : "\\oiiint",
|
||
"∯" : "\\oiint",
|
||
"∮" : "\\oint",
|
||
"⏞" : "\\overbrace",
|
||
"⎴" : "\\overbracket",
|
||
"¯" : "\\overline",
|
||
"⏜" : "\\overparen",
|
||
"⏠" : "\\overshell",
|
||
|
||
"⟡" : "\\phantom",
|
||
"±" : "\\pm",
|
||
"⒨" : "\\pmatrix",
|
||
"⁗" : "\\pppprime",
|
||
"‴" : "\\ppprime",
|
||
"″" : "\\pprime",
|
||
"′" : "\\prime",
|
||
"∏" : "\\prod",
|
||
|
||
"\\qdrt": "∜",
|
||
"\\quad": " ",
|
||
|
||
"〉" : "\\rangle",
|
||
"⟫" : "\\Rangle",
|
||
"∶" : "\\ratio",
|
||
//"]" : "\\rbrack",
|
||
"⟧" : "\\Rbrack",
|
||
"⌉" : "\\rceil",
|
||
"⋰" : "\\rddots",
|
||
"▭" : "\\rect",
|
||
"⌋" : "\\rfloor",
|
||
"⇒" : "\\Rightarrow",
|
||
"⇁" : "\\rightharpoondown",
|
||
"⇀" : "\\rightharpoonup",
|
||
"⎱" : "\\rmoust",
|
||
"⒭" : "\\root",
|
||
|
||
"𝒶" : "\\scripta",
|
||
"𝒜" : "\\scriptA",
|
||
"𝒷" : "\\scriptb",
|
||
"ℬ" : "\\scriptB",
|
||
"𝒸" : "\\scriptc",
|
||
"𝒞" : "\\scriptC",
|
||
"𝒹" : "\\scriptd",
|
||
"𝒟" : "\\scriptD",
|
||
"ℯ" : "\\scripte",
|
||
"ℰ" : "\\scriptE",
|
||
"𝒻" : "\\scriptf",
|
||
"ℱ" : "\\scriptF",
|
||
"ℊ" : "\\scriptg",
|
||
"𝒢" : "\\scriptG",
|
||
"𝒽" : "\\scripth",
|
||
"ℋ" : "\\scriptH",
|
||
"𝒾" : "\\scripti",
|
||
"ℐ" : "\\scriptI",
|
||
"𝒥" : "\\scriptj",
|
||
"𝓀" : "\\scriptk",
|
||
"𝒦" : "\\scriptK",
|
||
"ℒ" : "\\scriptL",
|
||
"𝓂" : "\\scriptm",
|
||
"ℳ" : "\\scriptM",
|
||
"𝓃" : "\\scriptn",
|
||
"𝒩" : "\\scriptN",
|
||
"ℴ" : "\\scripto",
|
||
"𝒪" : "\\scriptO",
|
||
"𝓅" : "\\scriptp",
|
||
"𝒫" : "\\scriptP",
|
||
"𝓆" : "\\scriptq",
|
||
"𝒬" : "\\scriptQ",
|
||
"𝓇" : "\\scriptr",
|
||
"ℛ" : "\\scriptR",
|
||
"𝓈" : "\\scripts",
|
||
"𝒮" : "\\scriptS",
|
||
"𝓉" : "\\scriptt",
|
||
"𝒯" : "\\scriptT",
|
||
"𝓊" : "\\scriptu",
|
||
"𝒰" : "\\scriptU",
|
||
"𝓋" : "\\scriptv",
|
||
"𝒱" : "\\scriptV",
|
||
"𝓌" : "\\scriptw",
|
||
"𝒲" : "\\scriptW",
|
||
"𝓍" : "\\scriptx",
|
||
"𝒳" : "\\scriptX",
|
||
"𝓎" : "\\scripty",
|
||
"𝒴" : "\\scriptY",
|
||
"𝓏" : "\\scriptz",
|
||
"𝒵" : "\\scriptZ",
|
||
|
||
"↘" : "\\searrow",
|
||
"⬍" : "\\smash",
|
||
"⌣" : "\\smile",
|
||
"♠" : "\\spadesuit",
|
||
"⊓" : "\\sqcap",
|
||
"⊔" : "\\sqcup",
|
||
"√" : "\\sqrt",
|
||
"∑" : "\\sum",
|
||
"↙" : "\\swarrow",
|
||
|
||
" " : "\\thicksp",
|
||
" " : "\\thinsp",
|
||
"̃" : "\\tilde",
|
||
"×" : "\\times",
|
||
"⊤" : "\\top",
|
||
"⃡" : "\\tvec",
|
||
|
||
"̲" : "\\ubar",
|
||
"̳" : "\\Ubar",
|
||
"⏟" : "\\underbrace",
|
||
"⎵" : "\\underbracket",
|
||
"▁" : "\\underline",
|
||
"⏝" : "\\underparen",
|
||
"↑" : "\\uparrow",
|
||
"⇑" : "\\Uparrow",
|
||
"↕" : "\\updownarrow",
|
||
"⇕" : "\\Updownarrow",
|
||
"⊎" : "\\uplus",
|
||
|
||
"│" : "\\vbar",
|
||
"⋮" : "\\vdots",
|
||
"⃗" : "\\vec",
|
||
"∨" : "\\vee",
|
||
//"|" : "\\vert",
|
||
"⒩" : "\\Vmatrix",
|
||
"⇳" : "\\vphantom",
|
||
" " : "\\vthicksp",
|
||
|
||
"∧" : "\\wedge",
|
||
|
||
"" : "\\zwnj",
|
||
"" : "\\zwsp",
|
||
};
|
||
|
||
function CMathContentIterator(oCMathContent)
|
||
{
|
||
if (oCMathContent instanceof CMathContent)
|
||
{
|
||
this._content = oCMathContent.Content;
|
||
this._paraRun = null;
|
||
this._nParaRun = 0;
|
||
this._index = oCMathContent.Content.length - 1; // индекс текущего элемента
|
||
this.counter = 0; // количество отданных элементов
|
||
this.currentEl = null;
|
||
}
|
||
}
|
||
CMathContentIterator.prototype.Count = function ()
|
||
{
|
||
this.counter++;
|
||
};
|
||
CMathContentIterator.prototype.Next = function(isStr)
|
||
{
|
||
if (!this.IsHasContent())
|
||
return false;
|
||
|
||
if (this._nParaRun >= 0 && this._paraRun)
|
||
{
|
||
return this.GetValue(isStr);
|
||
}
|
||
else
|
||
{
|
||
let oCurrentContent = this._content[this._index];
|
||
|
||
if (!oCurrentContent instanceof ParaRun)
|
||
{
|
||
// прерываем обработку здесь точно не слово для автокоррекции
|
||
return false;
|
||
}
|
||
else
|
||
{
|
||
this._index--;
|
||
this._paraRun = oCurrentContent;
|
||
this._nParaRun = oCurrentContent.GetElementsCount() - 1;
|
||
return this.GetValue(isStr);
|
||
}
|
||
}
|
||
};
|
||
CMathContentIterator.prototype.IsHasContent = function ()
|
||
{
|
||
return this._index >= 0 || this._nParaRun >= 0;
|
||
};
|
||
CMathContentIterator.prototype.GetValue = function(isStr)
|
||
{
|
||
if (this._nParaRun >= 0)
|
||
{
|
||
this.Count();
|
||
this._nParaRun--;
|
||
let oMathText = this._paraRun.GetElement(this._nParaRun + 1);
|
||
|
||
// если не текст просто прерываем обработку, здесь точно не слово для автокоррекции
|
||
if (!(oMathText instanceof CMathText))
|
||
return false;
|
||
|
||
this.currentEl = oMathText;
|
||
if (isStr)
|
||
return String.fromCodePoint(oMathText.value);
|
||
return oMathText.GetCodePoint();
|
||
}
|
||
return false;
|
||
}
|
||
CMathContentIterator.prototype.GetCurrentEl = function ()
|
||
{
|
||
return this.currentEl;
|
||
}
|
||
CMathContentIterator.prototype.NextCopy = function()
|
||
{
|
||
let nParaCopy = this._nParaRun;
|
||
let nIndex = this._index;
|
||
let counter = this.counter;
|
||
|
||
if (!this.IsHasContent())
|
||
return false;
|
||
|
||
if (this._paraRun)
|
||
{
|
||
return this.Reset(this.Next(), nParaCopy, nIndex, counter);
|
||
}
|
||
};
|
||
CMathContentIterator.prototype.Reset = function (El, RunPos, nIndex, Counter)
|
||
{
|
||
this._nParaRun = RunPos;
|
||
this._index = nIndex;
|
||
this.counter = Counter;
|
||
|
||
return El;
|
||
};
|
||
function CorrectWordOnCursor(oCMathContent, IsLaTeX, isSkipFirstLetter)
|
||
{
|
||
let isConvert = false;
|
||
let isSkipFirst = isSkipFirstLetter === true;
|
||
let strLast = oCMathContent.GetLastTextElement();
|
||
let isLastOperator = oCMathContent.IsLastElement(AscMath.MathLiterals.operator) || strLast === "(" || strLast === ")";
|
||
let oContent = new CMathContentIterator(oCMathContent);
|
||
let oLastOperator;
|
||
|
||
if (strLast === " ")
|
||
isSkipFirst = true;
|
||
|
||
let str = "";
|
||
|
||
while (oContent.IsHasContent())
|
||
{
|
||
let nElement = oContent.Next();
|
||
|
||
if (nElement === false)
|
||
break;
|
||
|
||
let strElement = String.fromCharCode(nElement);
|
||
|
||
if (oContent.counter === 1 && isSkipFirst)
|
||
{
|
||
if (isLastOperator)
|
||
{
|
||
oLastOperator = strElement;
|
||
}
|
||
continue;
|
||
}
|
||
|
||
let isContinue =
|
||
(nElement >= 97 && nElement <= 122)
|
||
|| (nElement >= 65 && nElement <= 90)
|
||
|| (nElement >= 48 && nElement <= 57)
|
||
|| nElement === 92
|
||
|| nElement === 47; // a-zA-z && 0-9
|
||
|
||
if (!isContinue)
|
||
return false;
|
||
|
||
str = strElement + str;
|
||
|
||
if (nElement === 92 || nElement === 47)
|
||
break;
|
||
}
|
||
|
||
let oCurrentEl = oContent.GetCurrentEl();
|
||
let nSlash = oContent.Next();
|
||
if (nSlash === 47)
|
||
{
|
||
str = "/" + str;
|
||
oCurrentEl = oContent.GetCurrentEl();
|
||
}
|
||
|
||
let strCorrection = ConvertWord(str, IsLaTeX);
|
||
if (strCorrection)
|
||
{
|
||
RemoveCountFormMathContent(oCMathContent, str.length + 1);
|
||
|
||
if (MathLiterals.accent.SearchU(strCorrection))
|
||
strCorrection = String.fromCharCode(160) + strCorrection; //add nbsp before accent, like word
|
||
|
||
for (let oIter = strCorrection.getUnicodeIterator(); oIter.check(); oIter.next())
|
||
{
|
||
let oAddMath = new MathTextAdditionalData(oCurrentEl.Parent);
|
||
oCMathContent.Add_Text(String.fromCodePoint(oIter.value()), undefined, undefined, oAddMath);
|
||
}
|
||
|
||
if (oLastOperator)
|
||
{
|
||
let oAddMath = new MathTextAdditionalData(oCurrentEl.Parent);
|
||
oCMathContent.Add_Text(oLastOperator, undefined, undefined, oAddMath);
|
||
}
|
||
|
||
isConvert = true;
|
||
}
|
||
|
||
oCMathContent.MoveCursorToEndPos();
|
||
return isConvert;
|
||
}
|
||
function RemoveCountFormMathContent (oContent, nCount, isSkipFirst)
|
||
{
|
||
let oCurrentContent;
|
||
for (let i = oContent.Content.length - 1; i >= 0; i--)
|
||
{
|
||
let isSkippedFirst = false;
|
||
oCurrentContent = oContent.Content[i];
|
||
for (let j = oCurrentContent.Content.length - 1; j >= 0; j--)
|
||
{
|
||
if (isSkipFirst === true)
|
||
{
|
||
isSkipFirst = false;
|
||
isSkippedFirst = true;
|
||
continue;
|
||
}
|
||
oCurrentContent.RemoveFromContent(j, 1, true);
|
||
nCount--;
|
||
|
||
if (nCount === 0)
|
||
return oCurrentContent;
|
||
}
|
||
}
|
||
return oCurrentContent;
|
||
}
|
||
|
||
function CorrectSpecialWordOnCursor(oCMathContent, IsLaTeX)
|
||
{
|
||
let oContent= new CMathContentIterator(oCMathContent);
|
||
|
||
if (oContent.IsHasContent())
|
||
{
|
||
let strSecond = oContent.Next(true);
|
||
let strFirst = oContent.Next(true);
|
||
|
||
if (strSecond
|
||
&& strFirst
|
||
&& strFirst !== "\\"
|
||
&& strSecond !== "\\"
|
||
&& CorrectSpecial(oCMathContent, strFirst, strSecond))
|
||
{
|
||
oContent._paraRun.MoveCursorToEndPos();
|
||
return true;
|
||
}
|
||
}
|
||
}
|
||
function ConvertWord(str, IsLaTeX)
|
||
{
|
||
if (!IsNotConvertedLaTeXWords(str) || !IsLaTeX)
|
||
{
|
||
return AutoCorrection[str];
|
||
}
|
||
}
|
||
|
||
function IsNotConvertedLaTeXWords(str)
|
||
{
|
||
return arrDoNotConvertWordsForLaTeX.includes(str);
|
||
}
|
||
|
||
function CorrectAllWords (oCMathContent, isLaTeX)
|
||
{
|
||
let isConvert = false;
|
||
|
||
if (oCMathContent.Type === 49)
|
||
{
|
||
for (let nCount = 0; nCount < oCMathContent.Content.length; nCount++)
|
||
{
|
||
if (oCMathContent.Content[nCount].value === 92)
|
||
{
|
||
let str = oCMathContent.Content[nCount].GetTextOfElement();
|
||
let intStart = nCount;
|
||
let intEnd = 0;
|
||
|
||
for (let i = nCount + 1; i < oCMathContent.Content.length; i++) {
|
||
|
||
let oContent = oCMathContent.Content[i];
|
||
let intCode = oContent.value;
|
||
|
||
if (intCode >= 97 && intCode <= 122 || intCode >= 65 && intCode <= 90) {
|
||
intEnd = i;
|
||
str += oContent.GetTextOfElement();
|
||
}
|
||
else
|
||
{
|
||
break;
|
||
}
|
||
|
||
nCount++;
|
||
}
|
||
|
||
if (intEnd > intStart) {
|
||
|
||
let strCorrection = ConvertWord(str, isLaTeX);
|
||
if (strCorrection) {
|
||
nCount -= (intEnd - intStart);
|
||
oCMathContent.RemoveFromContent(intStart, intEnd - intStart + 1, true);
|
||
oCMathContent.AddText(strCorrection, intStart);
|
||
isConvert = true;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
for (let nCount = 0; nCount < oCMathContent.Content.length; nCount++) {
|
||
isConvert = CorrectAllWords(oCMathContent.Content[nCount], isLaTeX) || isConvert;
|
||
}
|
||
}
|
||
|
||
return isConvert;
|
||
}
|
||
function CorrectAllSpecialWords(oCMathContent, isLaTeX)
|
||
{
|
||
let isConvert = false;
|
||
|
||
if (oCMathContent.Type === 49)
|
||
{
|
||
for (let nCount = oCMathContent.Content.length - 1; nCount >= 1; nCount--)
|
||
{
|
||
let str = oCMathContent.Content[nCount].GetTextOfElement();
|
||
let strPrev = oCMathContent.Content[nCount - 1].GetTextOfElement();
|
||
if (CorrectSpecial(oCMathContent, strPrev, str))
|
||
nCount--;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
for (let nCount = 0; nCount < oCMathContent.Content.length; nCount++) {
|
||
isConvert = CorrectAllSpecialWords(oCMathContent.Content[nCount], isLaTeX) || isConvert;
|
||
}
|
||
}
|
||
|
||
return isConvert;
|
||
}
|
||
function CorrectSpecial(oCMathContent, strPrev, strNext)
|
||
{
|
||
for (let i = 0; i < g_DefaultAutoCorrectMathSymbolsList.length; i++)
|
||
{
|
||
let current = g_DefaultAutoCorrectMathSymbolsList[i];
|
||
let strToken = strPrev + strNext;
|
||
if (current[0] === strToken)
|
||
{
|
||
let data = current[1],
|
||
str = "";
|
||
|
||
if (Array.isArray(data))
|
||
{
|
||
for (let count = 0; i < data.length; i++)
|
||
{
|
||
data[count] = String.fromCharCode(data[count]);
|
||
}
|
||
str = data.join("");
|
||
}
|
||
else {
|
||
str = String.fromCharCode(data);
|
||
}
|
||
|
||
if (str)
|
||
{
|
||
let nCounter = 0;
|
||
|
||
let oCurrentElement = oCMathContent.Content[oCMathContent.Content.length - 1];
|
||
if (!oCurrentElement || !oCurrentElement.Content)
|
||
return false;
|
||
|
||
let oCurrentElementCounter = oCurrentElement.Content.length;
|
||
|
||
if (oCurrentElementCounter > strToken.length)
|
||
{
|
||
oCurrentElement.RemoveFromContent(oCurrentElementCounter - strToken.length, strToken.length);
|
||
}
|
||
else
|
||
{
|
||
nCounter += oCurrentElementCounter;
|
||
oCMathContent.RemoveFromContent(oCMathContent.Content.length - 1, 1);
|
||
}
|
||
oCMathContent.Add_TextOnPos(oCMathContent.Content.length, str);
|
||
return true;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
function GetConvertContent(nInputType, strConversionData, oContext)
|
||
{
|
||
nInputType === Asc.c_oAscMathInputType.Unicode
|
||
? AscMath.CUnicodeConverter(strConversionData, oContext)
|
||
: AscMath.ConvertLaTeXToTokensList(strConversionData, oContext);
|
||
}
|
||
|
||
let isGetLaTeX = true;
|
||
|
||
function SetIsLaTeXGetParaRun(isConvert)
|
||
{
|
||
isGetLaTeX = isConvert;
|
||
}
|
||
|
||
function GetIsLaTeXGetParaRun()
|
||
{
|
||
return isGetLaTeX;
|
||
}
|
||
|
||
function GetFractionType(strToken)
|
||
{
|
||
switch (strToken)
|
||
{
|
||
case "/" : return BAR_FRACTION
|
||
case "⁄" : return SKEWED_FRACTION
|
||
case "⊘" : return BAR_FRACTION
|
||
case "∕" : return LINEAR_FRACTION
|
||
case "¦" : return NO_BAR_FRACTION
|
||
case "⒞" : return NO_BAR_FRACTION
|
||
|
||
case "\\binom" : return NO_BAR_FRACTION
|
||
case "\\sfrac" : return SKEWED_FRACTION
|
||
case "\\frac" : return BAR_FRACTION
|
||
case "\\cfrac" : return BAR_FRACTION
|
||
}
|
||
}
|
||
|
||
function ContentWithStylesIterator(arr)
|
||
{
|
||
let oArr = [];
|
||
for (let i = 0; i < arr.length; i++)
|
||
{
|
||
let CurrentElement = arr[i];
|
||
|
||
if (Array.isArray(CurrentElement))
|
||
{
|
||
let strTemp = ContentWithStylesIterator(CurrentElement);
|
||
oArr = oArr.concat(strTemp);
|
||
}
|
||
else if (CurrentElement instanceof MathText)
|
||
{
|
||
oArr.push(CurrentElement)
|
||
}
|
||
else
|
||
{
|
||
oArr.push(CurrentElement)
|
||
}
|
||
}
|
||
return oArr;
|
||
}
|
||
function ContentWithStylesToText(arr)
|
||
{
|
||
let arrInput = ContentWithStylesIterator(arr);
|
||
let str = "";
|
||
|
||
for (let i = 0; i < arrInput.length; i++)
|
||
{
|
||
let oCurrentElement = arrInput[i];
|
||
str += oCurrentElement.GetText();
|
||
}
|
||
|
||
return str;
|
||
}
|
||
function ConvertMathTextToText(arr)
|
||
{
|
||
if (arr.length === 0)
|
||
return "";
|
||
|
||
if (arr instanceof MathText)
|
||
{
|
||
return arr.GetText();
|
||
}
|
||
else if (arr.Type)
|
||
{
|
||
return arr.GetTextOfElement(false, true)
|
||
}
|
||
|
||
let strContent = "";
|
||
|
||
for (let nCount = 0; nCount < arr.length; nCount++)
|
||
{
|
||
let CurrentElement = arr[nCount];
|
||
|
||
if (undefined === CurrentElement)
|
||
continue;
|
||
|
||
if (Array.isArray(CurrentElement))
|
||
{
|
||
let strTemp = ConvertMathTextToText(CurrentElement);
|
||
if (strTemp)
|
||
{
|
||
strContent += strTemp;
|
||
}
|
||
}
|
||
else if (CurrentElement instanceof MathText)
|
||
{
|
||
strContent += CurrentElement.GetText();
|
||
}
|
||
else
|
||
{
|
||
strContent += CurrentElement;
|
||
}
|
||
}
|
||
|
||
return strContent;
|
||
}
|
||
function GetOnlyText(oContent, nInputType)
|
||
{
|
||
let one = oContent.GetTextOfElement(nInputType);
|
||
return ConvertMathTextToText(one);
|
||
}
|
||
|
||
function PosInMathText(nPos, nLength)
|
||
{
|
||
this.pos = nPos; // EndPos
|
||
this.length = nLength; // Length of content
|
||
|
||
this.Copy = function ()
|
||
{
|
||
return new PosInMathText(this.pos, this.length);
|
||
}
|
||
|
||
}
|
||
|
||
/**
|
||
* @param {boolean|undefined|MathTextAndStyles} [isLaTeX]
|
||
* @constructor
|
||
*/
|
||
function MathTextAndStyles (isLaTeX, isDefaultText)
|
||
{
|
||
if (isLaTeX instanceof MathTextAndStyles)
|
||
return isLaTeX;
|
||
|
||
if (isLaTeX === undefined)
|
||
isLaTeX = false;
|
||
|
||
this.LaTeX = isLaTeX;
|
||
this.Positions = [];
|
||
this.arr = [];
|
||
this.oContent = undefined;
|
||
|
||
this.nPos = 0;
|
||
this.IsBracket = false;
|
||
|
||
this.globalStyle = undefined;
|
||
this.IsGetStyleFromFirst = true;
|
||
|
||
this.IsNotWrap = false;
|
||
this.IsDefaultText = isDefaultText;
|
||
}
|
||
MathTextAndStyles.prototype.IsEmpty = function ()
|
||
{
|
||
return this.arr.length === 0;
|
||
};
|
||
MathTextAndStyles.prototype.SetGlobalStyle = function (oContent, isCtrPr)
|
||
{
|
||
this.globalStyle = new MathTextAdditionalData(oContent, isCtrPr)
|
||
};
|
||
MathTextAndStyles.prototype.GetGlobalStyle = function ()
|
||
{
|
||
let oStyle = this.globalStyle;
|
||
this.globalStyle = undefined;
|
||
return oStyle;
|
||
};
|
||
MathTextAndStyles.prototype.ResetGlobalStyle = function ()
|
||
{
|
||
this.globalStyle = undefined;
|
||
};
|
||
MathTextAndStyles.prototype.GetFirstStyle = function ()
|
||
{
|
||
if (this.arr.length > 0)
|
||
{
|
||
let oLastItem = this.arr[0];
|
||
|
||
if (oLastItem instanceof MathTextAndStyles)
|
||
return oLastItem.GetFirstStyle();
|
||
else
|
||
{
|
||
return oLastItem.GetAdditionalData().Copy();
|
||
}
|
||
}
|
||
};
|
||
MathTextAndStyles.prototype.GetStyleFromFirst = function (oContent)
|
||
{
|
||
if (!this.IsGetStyleFromFirst)
|
||
{
|
||
this.IsGetStyleFromFirst = true;
|
||
return oContent;
|
||
}
|
||
|
||
for (let i = 0; i < this.arr.length; i++)
|
||
{
|
||
if (this.arr[i] instanceof MathTextAndStyles && !this.arr[i].IsEmpty())
|
||
return this.arr[i].GetStyleFromFirst();
|
||
else if (this.arr[i] instanceof MathTextAndStyles)
|
||
continue;
|
||
else
|
||
return this.arr[i].additionalMathData;
|
||
}
|
||
};
|
||
MathTextAndStyles.prototype.SetNotGetStyleFromFirst = function ()
|
||
{
|
||
this.IsGetStyleFromFirst = false;
|
||
};
|
||
MathTextAndStyles.prototype.CreateInnerCopy = function()
|
||
{
|
||
return new MathTextAndStyles(this.LaTeX, this.IsDefaultText);
|
||
};
|
||
MathTextAndStyles.prototype.AddContainer = function()
|
||
{
|
||
let oMathTextAndStyles = this.CreateInnerCopy();
|
||
this.arr.push(oMathTextAndStyles);
|
||
return oMathTextAndStyles;
|
||
};
|
||
MathTextAndStyles.prototype.DelEmptyContainer = function()
|
||
{
|
||
if (this.arr.length > 0)
|
||
{
|
||
let lastContainer = this.arr[this.arr.length - 1];
|
||
if (lastContainer instanceof MathTextAndStyles && lastContainer.IsEmpty())
|
||
{
|
||
this.arr.splice(this.arr.length - 1, 1);
|
||
}
|
||
}
|
||
};
|
||
MathTextAndStyles.prototype.IsLaTeX = function()
|
||
{
|
||
return this.LaTeX;
|
||
};
|
||
MathTextAndStyles.prototype.GetLengthOfContentByPos = function(oPos)
|
||
{
|
||
let oContentElement = this.GetExact(oPos);
|
||
if (oContentElement instanceof MathTextAndStyles)
|
||
{
|
||
return oContentElement.arr.length > 1;
|
||
}
|
||
};
|
||
MathTextAndStyles.prototype.GetLastPos = function ()
|
||
{
|
||
if (this.Positions.length > 0)
|
||
return this.Positions[this.Positions.length - 1];
|
||
else
|
||
return false;
|
||
};
|
||
MathTextAndStyles.prototype.GetFirstPos = function ()
|
||
{
|
||
if (this.Positions.length > 0)
|
||
return this.Positions[0];
|
||
else
|
||
return false;
|
||
};
|
||
MathTextAndStyles.prototype.SetContent = function (oContent)
|
||
{
|
||
this.oContent = oContent;
|
||
}
|
||
/**
|
||
*
|
||
* @param oContent
|
||
* @param isNew {boolean} - Нужно ли отделять текущий контент в отдельный MathTextAndStyles
|
||
* @param [Wrap] {number|Array} Unicode: 0 - not wrap; 1 - special wrap; LaTeX: 1 - wrap
|
||
* @param isSelectedText
|
||
* @return {PosInMathText|false}
|
||
* @constructor
|
||
*/
|
||
MathTextAndStyles.prototype.Add = function(oContent, isNew, Wrap, isSelectedText)
|
||
{
|
||
if (!(oContent instanceof MathTextAndStyles) && oContent.Content.length === 0)
|
||
return this.GetLastPos();
|
||
|
||
let nPosCopy = this.nPos;
|
||
|
||
if (oContent instanceof MathTextAndStyles)
|
||
{
|
||
this.arr.push(oContent);
|
||
this.Increase();
|
||
return this.AddPosition(this.nPos - nPosCopy);
|
||
}
|
||
|
||
if (isNew)
|
||
{
|
||
let oMath = this.AddContainer();
|
||
this.SetContent(oContent);
|
||
|
||
oContent.GetTextOfElement(oMath, isSelectedText);
|
||
|
||
this.DelEmptyContainer();
|
||
if (oMath.IsEmpty())
|
||
{
|
||
// in LaTeX mode, despite the fact that there is no content, add brackets to wrap the content
|
||
if (this.IsLaTeX() && Wrap === 2)
|
||
this.AddText(new MathText('{}', oContent));
|
||
|
||
return this.GetLastPos();
|
||
}
|
||
|
||
this.Increase();
|
||
let oPos = this.AddPosition(this.nPos - nPosCopy);
|
||
let str = oMath.GetText();
|
||
|
||
if (this.IsLaTeX())
|
||
{
|
||
let oCurrentStyle = this.globalStyle
|
||
? this.globalStyle
|
||
: this.GetStyleFromFirst(oContent);
|
||
|
||
if (Array.isArray(Wrap))
|
||
this.WrapExactElement(oPos, Wrap[0], Wrap[1], this.GetFirstStyle());
|
||
else if (Wrap === 0 || oContent instanceof ParaRun)
|
||
return oPos;
|
||
else if (Wrap === 1 && ((oContent.haveMixedContent && oContent.haveMixedContent(this.IsLaTeX())) || (this.IsLaTeX() && str.length > 1 && this.IsNotWrap === false)))
|
||
this.WrapExactElement(oPos, "{", "}", oCurrentStyle);
|
||
else if (Wrap === 2)
|
||
this.WrapExactElement(oPos, "{", "}", oCurrentStyle);
|
||
|
||
this.IsNotWrap = false;
|
||
}
|
||
else
|
||
{
|
||
if (Array.isArray(Wrap))
|
||
this.WrapExactElement(oPos, Wrap[0], Wrap[1], oContent);
|
||
else if (Wrap === 0 || oContent instanceof ParaRun)
|
||
return oPos;
|
||
else if (Wrap === 1 && oContent.haveMixedContent(false, true) && !oMath.IsBracket)
|
||
this.WrapExactElement(oPos, "〖", "〗", oContent);
|
||
else if (Wrap === 2 && !(oContent.Content.length === 1 && oContent.Content[0] instanceof ParaRun))
|
||
this.WrapExactElement(oPos, "(", ")", oContent);
|
||
else if (!(oContent.Parent instanceof CDelimiter) && oContent.haveMixedContent && oContent.haveMixedContent() && !oMath.IsBracket)
|
||
this.WrapExactElement(oPos, "(", ")", oContent);
|
||
}
|
||
|
||
return oPos;
|
||
}
|
||
else
|
||
{
|
||
this.SetContent(oContent);
|
||
oContent.GetTextOfElement(this, isSelectedText);
|
||
|
||
if (this.nPos === nPosCopy)
|
||
return this.Get_Position();
|
||
|
||
return this.AddPosition(this.nPos - nPosCopy);
|
||
}
|
||
};
|
||
MathTextAndStyles.prototype.SetNotWrap = function()
|
||
{
|
||
this.IsNotWrap = true;
|
||
}
|
||
MathTextAndStyles.prototype.GetLastContentInLayer = function ()
|
||
{
|
||
if (this.arr.length > 0)
|
||
return this.arr[this.arr.length - 1];
|
||
}
|
||
MathTextAndStyles.prototype.AddText = function(oContent, isNew)
|
||
{
|
||
let nPosCopy = this.nPos;
|
||
|
||
if (!isNew)
|
||
{
|
||
let oLast = this.GetLastContentInLayer();
|
||
|
||
if (oLast && oLast instanceof MathText
|
||
&& oLast.additionalMathData.GetMathMetaData().getIsEscapedSlash() !== true
|
||
&& oContent instanceof MathText
|
||
&& oLast.IsAdditionalDataEqual(oContent.additionalMathData))
|
||
{
|
||
oLast.text += oContent.text;
|
||
return this.AddPosition(this.nPos - nPosCopy);
|
||
}
|
||
}
|
||
|
||
this.arr.push(oContent);
|
||
this.Increase();
|
||
|
||
return this.AddPosition(this.nPos - nPosCopy);
|
||
};
|
||
MathTextAndStyles.prototype.Get_Position = function()
|
||
{
|
||
for (let nCounter = 0; nCounter < this.Positions.length; nCounter++)
|
||
{
|
||
let oCurrentPos = this.Positions[nCounter];
|
||
if (oCurrentPos.pos === this.nPos)
|
||
{
|
||
return oCurrentPos;
|
||
}
|
||
}
|
||
};
|
||
MathTextAndStyles.prototype.AddPosition = function(nLength, nPos)
|
||
{
|
||
let oPos;
|
||
|
||
if (nPos !== undefined)
|
||
{
|
||
oPos = new PosInMathText(nPos, nLength);
|
||
for (let i = 0; i < this.Positions.length; i++)
|
||
{
|
||
let oCurrentPos = this.Positions[i];
|
||
if (oCurrentPos.pos > nPos)
|
||
{
|
||
this.Positions.splice(i, 0, oPos);
|
||
return oPos;
|
||
}
|
||
}
|
||
}
|
||
|
||
oPos = this.Get_Position();
|
||
|
||
if (!oPos)
|
||
{
|
||
oPos = new PosInMathText(this.nPos, nLength);
|
||
this.Positions.push(oPos);
|
||
}
|
||
|
||
return oPos;
|
||
};
|
||
MathTextAndStyles.prototype.GetExact = function(oPos, isText)
|
||
{
|
||
let oCurrent = this.arr[oPos.pos - 1];
|
||
|
||
if (isText && oCurrent instanceof MathText)
|
||
return oCurrent.GetText();
|
||
else
|
||
return oCurrent;
|
||
};
|
||
MathTextAndStyles.prototype.SetExact = function (oPos, oContent)
|
||
{
|
||
this.arr[oPos.pos - 1] = oContent;
|
||
}
|
||
MathTextAndStyles.prototype.ConvertTextToMathTextAndStyles = function (oPos)
|
||
{
|
||
let oText = this.GetExact(oPos);
|
||
let oContent = new MathTextAndStyles(this.LaTeX, this.IsDefaultText);
|
||
|
||
oContent.AddText(oText, false);
|
||
this.SetExact(oPos, oContent);
|
||
|
||
return oContent;
|
||
}
|
||
MathTextAndStyles.prototype.GetArrPos = function(oPos, isBefore)
|
||
{
|
||
let arrAfterPos = [];
|
||
|
||
for (let nCounter = 0; nCounter < this.Positions.length; nCounter++)
|
||
{
|
||
let oCurrentPos = this.Positions[nCounter];
|
||
let nCurrentPos = oCurrentPos.pos;
|
||
|
||
if (isBefore)
|
||
{
|
||
if (nCurrentPos > oPos.pos - 1)
|
||
arrAfterPos.push(oCurrentPos);
|
||
}
|
||
else
|
||
{
|
||
if (nCurrentPos > oPos.pos )
|
||
arrAfterPos.push(oCurrentPos);
|
||
}
|
||
}
|
||
return arrAfterPos;
|
||
};
|
||
MathTextAndStyles.prototype.ChangePositions = function(arrPositions, oFunc)
|
||
{
|
||
for (let nCounter = 0; nCounter < arrPositions.length; nCounter++)
|
||
{
|
||
let arrCurrentPos = arrPositions[nCounter];
|
||
oFunc(arrCurrentPos);
|
||
}
|
||
};
|
||
MathTextAndStyles.prototype.AddAfter = function(oPos, oContent, isNotCopyStyle)
|
||
{
|
||
let arrPositions = this.GetArrPos(oPos);
|
||
let oCurrentContainer = this.GetExact(oPos);
|
||
let oCurrent = !isNotCopyStyle && oCurrentContainer instanceof MathText ? oCurrentContainer.GetAdditionalData() : undefined;
|
||
let oNew = oContent instanceof MathTextAndStyles || oContent instanceof MathText ? oContent :new MathText(oContent, oCurrent);
|
||
|
||
this.arr.splice(oPos.pos, 0, oNew);
|
||
|
||
this.nPos++;
|
||
this.ChangePositions(arrPositions, function(oPos) {oPos.pos++});
|
||
return this.AddPosition(oContent.length, oPos.pos + 1);
|
||
};
|
||
MathTextAndStyles.prototype.AddBefore = function(oPos, oContent, isNotCopyStyle)
|
||
{
|
||
if (!oContent)
|
||
return;
|
||
|
||
let arrPositions = this.GetArrPos(oPos, true);
|
||
let oCurrentContainer = this.GetExact(oPos);
|
||
let oCurrent = !isNotCopyStyle && oCurrentContainer instanceof MathText ? oCurrentContainer.GetAdditionalData() : undefined;
|
||
let oNew = oContent instanceof MathTextAndStyles || oContent instanceof MathText ? oContent : new MathText(oContent, oCurrent);
|
||
let nPos = oPos.pos - oPos.length;
|
||
|
||
this.arr.splice(nPos, 0, oNew);
|
||
|
||
this.nPos++;
|
||
this.ChangePositions(arrPositions, function(oPos) {oPos.pos++});
|
||
return this.AddPosition(oContent.length, nPos);
|
||
};
|
||
MathTextAndStyles.prototype.RemoveByPos = function (oPos)
|
||
{
|
||
let arrPositions = this.GetArrPos(oPos, true);
|
||
let oCurrentContainer = this.GetExact(oPos);
|
||
|
||
this.arr.splice(oPos.pos - 1, 1);
|
||
this.Positions.splice(oPos.pos - 1, 1);
|
||
|
||
this.nPos--;
|
||
this.ChangePositions(arrPositions, function(oPos) {oPos.pos--});
|
||
}
|
||
MathTextAndStyles.prototype.Wrap = function(strStart, strEnd)
|
||
{
|
||
this.AddBefore(this.Positions[0], strStart);
|
||
this.AddAfter(this.Positions[this.Positions.length - 1], strEnd);
|
||
};
|
||
MathTextAndStyles.prototype.IsNeedWrap = function()
|
||
{
|
||
return this.arr.length > 1;
|
||
};
|
||
MathTextAndStyles.prototype.GetLength = function ()
|
||
{
|
||
return this.arr.length;
|
||
};
|
||
MathTextAndStyles.prototype.WrapExactElement = function(oPos, strOne, strTwo, oContent)
|
||
{
|
||
let oToken;
|
||
|
||
if (oPos instanceof MathTextAndStyles)
|
||
oToken = oPos;
|
||
else
|
||
oToken = this.GetExact(oPos);
|
||
|
||
// при получении линейного математического текста можно получить не MathTextAndStyles, а MathText
|
||
// что бы иметь возможность обрамления создаем MathTextAndStyles с MathText внутри
|
||
if (oToken instanceof MathText)
|
||
oToken = this.ConvertTextToMathTextAndStyles(oPos);
|
||
|
||
if (strOne && strTwo)
|
||
{
|
||
if (this.IsLaTeX())
|
||
{
|
||
if (strOne instanceof MathText && strTwo instanceof MathText)
|
||
oToken.Wrap(strOne, strTwo);
|
||
else
|
||
oToken.Wrap(new MathText(strOne, oContent), new MathText(strTwo, oContent));
|
||
}
|
||
else
|
||
{
|
||
oToken.Wrap(
|
||
new MathText(strOne, this.globalStyle ? this.globalStyle : oContent),
|
||
new MathText(strTwo, this.globalStyle ? this.globalStyle : oContent)
|
||
);
|
||
}
|
||
|
||
return;
|
||
}
|
||
|
||
if (!this.IsLaTeX())
|
||
{
|
||
oToken.Wrap(new MathText("(", this.globalStyle ? this.globalStyle : oContent), new MathText(")", this.globalStyle ? this.globalStyle : oContent));
|
||
}
|
||
else
|
||
{
|
||
oToken.Wrap(new MathText("{", this.globalStyle ? this.globalStyle : oContent), new MathText("}", this.globalStyle ? this.globalStyle : oContent));
|
||
}
|
||
};
|
||
MathTextAndStyles.prototype.Increase = function()
|
||
{
|
||
this.nPos++;
|
||
};
|
||
MathTextAndStyles.prototype.GetText = function()
|
||
{
|
||
let strOutput = "";
|
||
|
||
for (let nCounter = 0; nCounter < this.arr.length; nCounter++)
|
||
{
|
||
let oCurrentElement = this.arr[nCounter];
|
||
if (oCurrentElement instanceof MathText)
|
||
{
|
||
strOutput += oCurrentElement.GetText();
|
||
}
|
||
else if (oCurrentElement instanceof MathTextAndStyles)
|
||
{
|
||
strOutput += oCurrentElement.GetText();
|
||
}
|
||
else
|
||
{
|
||
strOutput += oCurrentElement;
|
||
}
|
||
}
|
||
|
||
return strOutput;
|
||
};
|
||
MathTextAndStyles.prototype.IsHasText = function ()
|
||
{
|
||
return this.GetText().trim().length > 0;
|
||
};
|
||
MathTextAndStyles.prototype.ChangeContent = function (str)
|
||
{
|
||
this.Positions = [];
|
||
this.arr = [];
|
||
this.nPos = 0;
|
||
if (str instanceof AscMath.MathText)
|
||
{
|
||
return this.AddText(str);
|
||
}
|
||
else
|
||
{
|
||
return this.AddText(new AscMath.MathText(str));
|
||
}
|
||
};
|
||
MathTextAndStyles.prototype.Flat = function ()
|
||
{
|
||
let arrData = [];
|
||
let Flat = function (arr)
|
||
{
|
||
for (let i = 0; i < arr.length; i++)
|
||
{
|
||
let oCurrentElement = arr[i];
|
||
if (oCurrentElement instanceof MathTextAndStyles)
|
||
{
|
||
Flat(oCurrentElement.arr);
|
||
}
|
||
else if (oCurrentElement instanceof MathText)
|
||
{
|
||
arrData.push(oCurrentElement);
|
||
}
|
||
else
|
||
{
|
||
arrData.push(new MathText(oCurrentElement));
|
||
}
|
||
}
|
||
}
|
||
Flat(this.arr);
|
||
|
||
for (let i = 0; i < arrData.length; i++)
|
||
{
|
||
let oCurrentText = arrData[i];
|
||
for (let nNext = i + 1; nNext < arrData.length; nNext++)
|
||
{
|
||
let oNextText = arrData[nNext];
|
||
if (oCurrentText.IsAdditionalDataEqual(oNextText.GetAdditionalData())){
|
||
oCurrentText.text += oNextText.text;
|
||
|
||
arrData.splice(nNext, 1);
|
||
nNext--;
|
||
}
|
||
else
|
||
break;
|
||
}
|
||
}
|
||
|
||
return arrData;
|
||
};
|
||
MathTextAndStyles.prototype.GetLastContent = function ()
|
||
{
|
||
if (this.arr.length > 0)
|
||
{
|
||
let oLast = this.arr[this.arr.length - 1];
|
||
if (oLast instanceof MathTextAndStyles)
|
||
return oLast.GetLastContent();
|
||
else
|
||
return oLast;
|
||
}
|
||
}
|
||
MathTextAndStyles.prototype.GetFirstContent = function ()
|
||
{
|
||
if (this.arr.length > 0)
|
||
{
|
||
let oLast = this.arr[0];
|
||
if (oLast instanceof MathTextAndStyles)
|
||
return oLast.GetFirstContent();
|
||
else
|
||
return oLast;
|
||
}
|
||
}
|
||
MathTextAndStyles.prototype.DelFirstSpace = function ()
|
||
{
|
||
let oLastContent = this.GetFirstContent();
|
||
|
||
if (oLastContent && oLastContent.text[0] === " ")
|
||
oLastContent.text = oLastContent.text.slice(1, -1);
|
||
|
||
return this
|
||
};
|
||
MathTextAndStyles.prototype.DelLastSpace = function ()
|
||
{
|
||
let oLastContent = this.GetLastContent();
|
||
|
||
if (oLastContent && oLastContent.text[oLastContent.text.length - 1] === " ")
|
||
oLastContent.text = oLastContent.text.slice(0, -1);
|
||
|
||
return this
|
||
};
|
||
|
||
// for store data without symbols and transfer data between autocorrection/correction sessions
|
||
function MathMetaData()
|
||
{
|
||
this.isMathRm = false;
|
||
this.isLinearFraction = false;
|
||
this.isEscapedSlash = false;
|
||
this.isLimitNary = false;
|
||
this.isText = false;
|
||
|
||
this.setIsLinearFraction = function (isLinearFraction)
|
||
{
|
||
this.isLinearFraction = isLinearFraction;
|
||
}
|
||
this.getIsLinearFraction = function ()
|
||
{
|
||
return this.isLinearFraction;
|
||
}
|
||
|
||
this.setIsMathRm = function(isMathRm)
|
||
{
|
||
this.isMathRm = isMathRm;
|
||
}
|
||
this.getIsMathRm = function()
|
||
{
|
||
return this.isMathRm;
|
||
}
|
||
|
||
this.setIsEscapedSlash = function (isEscapedSlash)
|
||
{
|
||
this.isEscapedSlash = isEscapedSlash;
|
||
}
|
||
this.getIsEscapedSlash = function ()
|
||
{
|
||
return this.isEscapedSlash;
|
||
}
|
||
|
||
this.setIsLimitNary = function(isLimitNary)
|
||
{
|
||
this.isLimitNary = isLimitNary;
|
||
}
|
||
this.getIsLimitNary = function()
|
||
{
|
||
return this.isLimitNary;
|
||
}
|
||
|
||
this.setIsText = function(isText)
|
||
{
|
||
this.isText = isText;
|
||
}
|
||
this.getIsText = function()
|
||
{
|
||
return this.isText;
|
||
}
|
||
|
||
this.Copy = function ()
|
||
{
|
||
let oCopy = new MathMetaData();
|
||
|
||
oCopy.setIsMathRm(this.isMathRm);
|
||
oCopy.setIsLinearFraction(this.isLinearFraction);
|
||
oCopy.setIsEscapedSlash(this.isEscapedSlash);
|
||
oCopy.setIsLimitNary(this.isLimitNary);
|
||
oCopy.setIsText(this.isText);
|
||
|
||
return oCopy;
|
||
}
|
||
|
||
this.Write_ToBinary = function(oWriter)
|
||
{
|
||
oWriter.WriteBool(this.isMathRm);
|
||
oWriter.WriteBool(this.isLinearFraction);
|
||
oWriter.WriteBool(this.isEscapedSlash);
|
||
oWriter.WriteBool(this.isLimitNary);
|
||
oWriter.WriteBool(this.isText);
|
||
}
|
||
|
||
this.Read_FromBinary = function(oReader)
|
||
{
|
||
this.isMathRm = oReader.GetBool();
|
||
this.isLinearFraction = oReader.GetBool();
|
||
this.isEscapedSlash = oReader.GetBool();
|
||
this.isLimitNary = oReader.GetBool();
|
||
this.isText = oReader.GetBool();
|
||
}
|
||
|
||
this.Set = function(oMetaData)
|
||
{
|
||
if (this.isMathRm !== oMetaData.isMathRm)
|
||
this.setIsMathRm(oMetaData.isMathRm);
|
||
|
||
if (this.isLinearFraction !== oMetaData.isLinearFraction)
|
||
this.setIsLinearFraction(oMetaData.isLinearFraction);
|
||
|
||
if (this.isEscapedSlash !== oMetaData.isEscapedSlash)
|
||
this.setIsEscapedSlash(oMetaData.isEscapedSlash);
|
||
|
||
if (this.isLimitNary !== oMetaData.isLimitNary)
|
||
this.setIsLimitNary(oMetaData.isLimitNary);
|
||
|
||
if (this.isText !== oMetaData.isText)
|
||
this.setIsText(oMetaData.isTex);
|
||
}
|
||
}
|
||
|
||
function MathTextAdditionalData (oContent, isCtrPr)
|
||
{
|
||
this.style = undefined;
|
||
this.reviewData = {
|
||
reviewType : reviewtype_Common,
|
||
reviewInfo : new AscWord.ReviewInfo()
|
||
}
|
||
this.mathPrp = new CMPrp();
|
||
this.metaData = new MathMetaData();
|
||
|
||
if (oContent)
|
||
this.SetAdditionalDataFromContent(oContent, isCtrPr);
|
||
|
||
if (!oContent)
|
||
this.style = new CTextPr();
|
||
}
|
||
|
||
MathTextAdditionalData.prototype.Copy = function()
|
||
{
|
||
let newAdditionalData = new MathTextAdditionalData();
|
||
|
||
if (this.style)
|
||
newAdditionalData.style = this.style.Copy();
|
||
|
||
newAdditionalData.reviewData = {
|
||
reviewType : this.reviewData.reviewType,
|
||
reviewInfo : this.reviewData.reviewInfo
|
||
}
|
||
|
||
newAdditionalData.mathPrp = this.mathPrp.Copy();
|
||
newAdditionalData.metaData = this.metaData.Copy();
|
||
|
||
return newAdditionalData;
|
||
}
|
||
/**
|
||
*
|
||
* @return {MathMetaData}
|
||
* @constructor
|
||
*/
|
||
MathTextAdditionalData.prototype.GetMathMetaData = function ()
|
||
{
|
||
return this.metaData;
|
||
}
|
||
MathTextAdditionalData.prototype.SetMathMetaData = function (oMathMetaData)
|
||
{
|
||
if (oMathMetaData)
|
||
this.metaData = oMathMetaData.Copy();
|
||
}
|
||
MathTextAdditionalData.prototype.Copy = function()
|
||
{
|
||
let oNewMath = new MathTextAdditionalData();
|
||
|
||
oNewMath.SetAdditionalStyleData(this.style);
|
||
oNewMath.SetAdditionalReviewData(this.reviewData);
|
||
oNewMath.SetMathPrp(this.mathPrp);
|
||
oNewMath.SetMathMetaData(this.metaData);
|
||
|
||
return oNewMath;
|
||
};
|
||
MathTextAdditionalData.prototype.GetAdditionalStyleData = function()
|
||
{
|
||
return this.style;
|
||
};
|
||
MathTextAdditionalData.prototype.SetAdditionalStyleData = function (oStyle)
|
||
{
|
||
this.style = oStyle;
|
||
};
|
||
MathTextAdditionalData.prototype.SetMathPrp = function (oMathPrp)
|
||
{
|
||
if (oMathPrp)
|
||
this.mathPrp = oMathPrp.Copy();
|
||
};
|
||
MathTextAdditionalData.prototype.IsAdditionalStyleData = function()
|
||
{
|
||
return this.style !== undefined;
|
||
};
|
||
MathTextAdditionalData.prototype.GetAdditionalReviewData = function()
|
||
{
|
||
return this.reviewData;
|
||
};
|
||
MathTextAdditionalData.prototype.SetAdditionalReviewData = function (oReviewData)
|
||
{
|
||
this.reviewData = oReviewData;
|
||
};
|
||
MathTextAdditionalData.prototype.GetAdditionalReviewType = function()
|
||
{
|
||
return this.reviewData.reviewType;
|
||
};
|
||
MathTextAdditionalData.prototype.SetAdditionalReviewType = function (nReviewType)
|
||
{
|
||
this.reviewData.reviewType = nReviewType;
|
||
};
|
||
MathTextAdditionalData.prototype.IsAdditionalReviewType = function ()
|
||
{
|
||
return this.reviewData.reviewType !== undefined;
|
||
};
|
||
MathTextAdditionalData.prototype.GetAdditionalReviewInfo = function()
|
||
{
|
||
return this.reviewData.reviewInfo;
|
||
};
|
||
MathTextAdditionalData.prototype.SetAdditionalReviewInfo = function (oReviewInfo)
|
||
{
|
||
this.reviewData.reviewInfo = oReviewInfo;
|
||
};
|
||
MathTextAdditionalData.prototype.IsMPrpEqual = function (oMPrp)
|
||
{
|
||
return oMPrp === undefined
|
||
|| this.mathPrp === undefined
|
||
|| (oMPrp !== undefined && this.mathPrp !== undefined && this.mathPrp.IsEqual(oMPrp))
|
||
};
|
||
MathTextAdditionalData.prototype.IsStyleEqual = function (oStyleParent)
|
||
{
|
||
if (oStyleParent instanceof MathTextAdditionalData)
|
||
{
|
||
if (this.style === undefined || oStyleParent.style === undefined)
|
||
return true;
|
||
|
||
return this.style.IsEqual(oStyleParent.GetAdditionalStyleData())
|
||
&& this.IsReviewDataEqual(oStyleParent)
|
||
&& this.IsMPrpEqual(oStyleParent.mathPrp)
|
||
&& this.IsMetaDataEqual(oStyleParent.metaData)
|
||
}
|
||
|
||
if (oStyleParent)
|
||
{
|
||
let oStyle = oStyleParent instanceof ParaRun
|
||
? oStyleParent.Pr
|
||
: oStyleParent.CtrPrp;
|
||
|
||
return this.IsPrStyleEqual(oStyle)
|
||
&& this.IsReviewDataEqual(oStyleParent)
|
||
&& this.IsMPrpEqual(oStyleParent.MathPrp)
|
||
&& this.IsMetaDataEqual(oStyleParent.math_autocorrection)
|
||
}
|
||
|
||
return false;
|
||
};
|
||
MathTextAdditionalData.prototype.IsMetaDataEqual = function (oMetaData)
|
||
{
|
||
let oCurrentMetaData = this.metaData;
|
||
|
||
if (!oMetaData
|
||
&& oCurrentMetaData.getIsEscapedSlash() === false
|
||
&& oCurrentMetaData.getIsMathRm() === false
|
||
&& oCurrentMetaData.getIsText() === false)
|
||
return true;
|
||
|
||
if (!oMetaData)
|
||
return false;
|
||
|
||
return oMetaData.getIsEscapedSlash() === oCurrentMetaData.getIsEscapedSlash()
|
||
&& oMetaData.getIsMathRm() === oCurrentMetaData.getIsMathRm()
|
||
&& oMetaData.getIsText() === oCurrentMetaData.getIsText();
|
||
};
|
||
MathTextAdditionalData.prototype.IsPrStyleEqual = function(oStyle)
|
||
{
|
||
if (this.style && this.style.IsEqual(oStyle))
|
||
return true;
|
||
|
||
return false;
|
||
};
|
||
MathTextAdditionalData.prototype.IsReviewDataEqual = function (oContent)
|
||
{
|
||
let reviewType = undefined;
|
||
let reviewInfo = undefined;
|
||
|
||
if (oContent instanceof MathTextAdditionalData)
|
||
{
|
||
reviewType = oContent.reviewData.reviewType;
|
||
reviewInfo = oContent.reviewData.reviewInfo;
|
||
}
|
||
else if (oContent.GetReviewType)
|
||
{
|
||
reviewType = oContent.GetReviewType();
|
||
reviewInfo = oContent.GetReviewInfo();
|
||
}
|
||
|
||
if (this.reviewData.reviewType !== reviewType)
|
||
return false;
|
||
|
||
if (!this.reviewData.reviewInfo && !reviewInfo)
|
||
return true;
|
||
|
||
if (!this.reviewData.reviewInfo || !reviewInfo)
|
||
return false;
|
||
|
||
return this.reviewData.reviewInfo.IsEqual(reviewInfo, false)
|
||
|
||
}
|
||
MathTextAdditionalData.prototype.SetAdditionalDataFromContent = function (oContent, isCtrPrp)
|
||
{
|
||
let oPr;
|
||
|
||
if (oContent instanceof ParaRun)
|
||
{
|
||
oPr = oContent.Pr.Copy();
|
||
}
|
||
else if (oContent instanceof CMathContent && !oContent.CtrPrp.IsEmpty())
|
||
{
|
||
oPr = oContent.GetCtrPrp();
|
||
}
|
||
else if (oContent instanceof CMathContent && oContent.CtrPrp.IsEmpty() && oContent.Content.length > 0)
|
||
{
|
||
let oItem = oContent.Content[0];
|
||
if (oItem instanceof ParaRun)
|
||
oPr = oItem.Pr.Copy();
|
||
}
|
||
else if (oContent instanceof CMathMatrix)
|
||
{
|
||
oPr = oContent.TextPrControlLetter.Copy();
|
||
}
|
||
else
|
||
{
|
||
oPr = oContent.CtrPrp;
|
||
}
|
||
|
||
this.SetAdditionalStyleData(oPr);
|
||
|
||
if (oContent.GetReviewType)
|
||
{
|
||
this.SetAdditionalReviewType(oContent.GetReviewType());
|
||
this.SetAdditionalReviewInfo(oContent.GetReviewInfo());
|
||
}
|
||
else
|
||
{
|
||
this.SetAdditionalReviewType(undefined);
|
||
this.SetAdditionalReviewInfo(undefined);
|
||
}
|
||
|
||
if (oContent instanceof ParaRun)
|
||
this.SetMathPrp(oContent.MathPrp);
|
||
};
|
||
|
||
/**
|
||
* @param {string|undefined} str text of math literal
|
||
* @param [oContent] {MathTextAdditionalData|}
|
||
* @param [isCtrPr] {boolean}
|
||
*
|
||
*/
|
||
function MathText(str, oContent, isCtrPr)
|
||
{
|
||
this.text = str;
|
||
this.additionalMathData = new MathTextAdditionalData;
|
||
|
||
if (oContent instanceof MathTextAdditionalData)
|
||
this.additionalMathData = oContent;
|
||
else if (oContent)
|
||
this.SetAdditionalDataFromContent(oContent, isCtrPr);
|
||
}
|
||
MathText.prototype.GetAdditionalData = function ()
|
||
{
|
||
return this.additionalMathData;
|
||
};
|
||
MathText.prototype.GetText = function ()
|
||
{
|
||
return this.text;
|
||
};
|
||
MathText.prototype.SetText = function (str)
|
||
{
|
||
this.text = str;
|
||
};
|
||
MathText.prototype.Check = function (func)
|
||
{
|
||
return func(this.text);
|
||
};
|
||
MathText.prototype.IsAdditionalDataEqual = function (oStyle)
|
||
{
|
||
return this.additionalMathData.IsStyleEqual(oStyle);
|
||
};
|
||
MathText.prototype.SetAdditionalDataFromContent = function (oContent, isCtrPrp)
|
||
{
|
||
this.additionalMathData.SetAdditionalDataFromContent(oContent, isCtrPrp);
|
||
};
|
||
|
||
const TokenSearch_All = [
|
||
MathLiterals.specialBrac,
|
||
MathLiterals.lrBrackets,
|
||
MathLiterals.lBrackets,
|
||
MathLiterals.rBrackets,
|
||
|
||
MathLiterals.hbrack,
|
||
MathLiterals.invisible,
|
||
MathLiterals.operator,
|
||
MathLiterals.space,
|
||
MathLiterals.nary,
|
||
MathLiterals.accent,
|
||
MathLiterals.accent,
|
||
MathLiterals.box,
|
||
MathLiterals.divide,
|
||
MathLiterals.func,
|
||
MathLiterals.matrix,
|
||
MathLiterals.radical,
|
||
MathLiterals.rect,
|
||
MathLiterals.special,
|
||
MathLiterals.subSup,
|
||
MathLiterals.of,
|
||
];
|
||
const TokenSearch_NotBrackets = [
|
||
MathLiterals.operator,
|
||
MathLiterals.hbrack,
|
||
MathLiterals.space,
|
||
MathLiterals.nary,
|
||
MathLiterals.accent,
|
||
MathLiterals.accent,
|
||
MathLiterals.box,
|
||
MathLiterals.divide,
|
||
MathLiterals.func,
|
||
MathLiterals.matrix,
|
||
MathLiterals.radical,
|
||
MathLiterals.rect,
|
||
MathLiterals.special,
|
||
MathLiterals.subSup,
|
||
];
|
||
const TokenSearch_Brackets = [
|
||
MathLiterals.lrBrackets,
|
||
MathLiterals.lBrackets,
|
||
MathLiterals.rBrackets,
|
||
MathLiterals.operator,
|
||
];
|
||
const TokenSearch_Everything = [];
|
||
|
||
let names = Object.keys(MathLiterals);
|
||
for (let j = 0; j < names.length; j++)
|
||
{
|
||
TokenSearch_Everything.push(MathLiterals[names[j]]);
|
||
}
|
||
|
||
function IsConvertWord (nType)
|
||
{
|
||
return nType === MathLiterals.space.id
|
||
|| nType === MathLiterals.operator.id
|
||
|| nType === MathLiterals.lBrackets.id
|
||
|| nType === MathLiterals.rBrackets.id
|
||
}
|
||
|
||
function ProcessingBrackets ()
|
||
{
|
||
this.BracketsPair = [];
|
||
this.BracketNoPair = [];
|
||
this.obj = {};
|
||
this.intCounter = 0;
|
||
|
||
/**
|
||
* Add bracket pair to BracketsPair array
|
||
* @param {PositionIsCMathContent} oStart
|
||
* @param {PositionIsCMathContent} oEnd
|
||
*/
|
||
this.AddBracket = function (oStart, oEnd)
|
||
{
|
||
this.BracketsPair.push([oStart, oEnd]);
|
||
};
|
||
/**
|
||
* Add bracket without pair in specific BracketNoPair array
|
||
* @param oPos
|
||
* @constructor
|
||
*/
|
||
this.AddNoPair = function (oPos)
|
||
{
|
||
this.BracketNoPair.push(oPos);
|
||
};
|
||
/**
|
||
* Delete on specific level Position
|
||
*/
|
||
this.Shift = function ()
|
||
{
|
||
this.obj[this.intCounter] = undefined;
|
||
};
|
||
/**
|
||
* Add on specific level given Position
|
||
* @param {PositionIsCMathContent} oPosition
|
||
*/
|
||
this.Add = function (oPosition)
|
||
{
|
||
if (this.obj[this.intCounter] === undefined)
|
||
{
|
||
this.obj[this.intCounter] = oPosition;
|
||
}
|
||
};
|
||
/**
|
||
* Get last bracket content
|
||
* @return {PositionIsCMathContent}
|
||
*/
|
||
this.Get = function ()
|
||
{
|
||
let intCounter = this.intCounter - 1;
|
||
|
||
while (intCounter >= 0)
|
||
{
|
||
if (this.obj[intCounter] === undefined)
|
||
{
|
||
intCounter--;
|
||
}
|
||
else
|
||
{
|
||
let oNewPos = this.obj[intCounter];
|
||
|
||
if (!oNewPos instanceof PositionIsCMathContent)
|
||
{
|
||
break;
|
||
}
|
||
return oNewPos;
|
||
}
|
||
}
|
||
//TODO Check safety:
|
||
return new PositionIsCMathContent(undefined, undefined, undefined, undefined);
|
||
};
|
||
/**
|
||
* Check given bracket and proceed it
|
||
* @param {PositionIsCMathContent} oPos
|
||
* @param {object} oIsOpenOrClose
|
||
* @param {boolean} oIsOpenOrClose.isOpen
|
||
* @param {boolean} oIsOpenOrClose.isClose
|
||
*/
|
||
this.Check = function (oPos, oIsOpenOrClose)
|
||
{
|
||
let oPrevContent = this.Get();
|
||
|
||
let intPrevType = oPrevContent.GetType();
|
||
let intCurrentType = oPos.GetType();
|
||
|
||
// если открывающая скобка: ) ] } ...
|
||
if (intCurrentType === MathLiterals.rBrackets.id || oIsOpenOrClose.isClose === true)
|
||
{
|
||
this.Add(oPos);
|
||
this.intCounter++;
|
||
}
|
||
// если закрывающая скобка ( [ { ...
|
||
else if (intCurrentType === MathLiterals.lBrackets.id || oIsOpenOrClose.isOpen === true)
|
||
{
|
||
if (intPrevType === MathLiterals.rBrackets.id || intPrevType === MathLiterals.lrBrackets.id || intPrevType === MathLiterals.specialBrac.id)
|
||
{
|
||
// нашли скобку
|
||
this.AddBracket(oPrevContent, oPos);
|
||
this.intCounter--;
|
||
this.Shift();
|
||
}
|
||
else
|
||
{
|
||
this.AddNoPair(oPos);
|
||
}
|
||
}
|
||
// TODO
|
||
else if (intCurrentType === MathLiterals.lrBrackets.id)
|
||
{
|
||
if (this.intCounter > 0)
|
||
{
|
||
if (intPrevType === MathLiterals.rBrackets.id || intPrevType === MathLiterals.lrBrackets.id || intPrevType === MathLiterals.specialBrac.id)
|
||
{
|
||
this.AddBracket(oPrevContent, oPos);
|
||
this.intCounter--;
|
||
this.Shift();
|
||
}
|
||
}
|
||
else
|
||
{
|
||
this.Add(oPos);
|
||
this.intCounter++;
|
||
}
|
||
}
|
||
};
|
||
/**
|
||
* Get brackets information
|
||
* @return {{NoPair: [], Pairs: []}}
|
||
* @constructor
|
||
*/
|
||
this.GetContent = function ()
|
||
{
|
||
return {
|
||
Pairs: this.BracketsPair,
|
||
NoPair: this.BracketNoPair,
|
||
};
|
||
};
|
||
this.GetLastPiarStartPos = function ()
|
||
{
|
||
if (this.BracketNoPair.length > 0)
|
||
{
|
||
return this.BracketNoPair[0];
|
||
}
|
||
}
|
||
this.IsLastBracketPairSpecial = function ()
|
||
{
|
||
if (this.BracketsPair.length > 0)
|
||
{
|
||
let oLastPair = this.BracketsPair[0];
|
||
let oLastPos = oLastPair[0];
|
||
|
||
if (oLastPos.type === MathLiterals.specialBrac.id)
|
||
return true
|
||
}
|
||
|
||
return false;
|
||
}
|
||
};
|
||
|
||
const oAutoCorrection = new ProceedTokens();
|
||
|
||
function StartAutoCorrectionMath(oCMathContent, isNotCorrect)
|
||
{
|
||
if (!oCMathContent)
|
||
return;
|
||
|
||
oAutoCorrection.Start(oCMathContent, isNotCorrect);
|
||
}
|
||
|
||
function ProceedTokens()
|
||
{
|
||
this.oCMathContent = null;
|
||
}
|
||
ProceedTokens.prototype.Start = function (oCMathContent, isNotCorrect)
|
||
{
|
||
this.oCMathContent = oCMathContent;
|
||
|
||
this.Init();
|
||
|
||
if (this.CorrectWord())
|
||
return;
|
||
|
||
if (!isNotCorrect)
|
||
this.StartAutoCorrection();
|
||
};
|
||
ProceedTokens.prototype.Reset = function ()
|
||
{
|
||
this.oAbsoluteLastId = undefined;
|
||
this.Tokens = {
|
||
all: [],
|
||
};
|
||
this.Brackets = new ProcessingBrackets();
|
||
};
|
||
ProceedTokens.prototype.CorrectWord = function ()
|
||
{
|
||
if (this.Tokens.brackets.NoPair.length > 1)
|
||
return true;
|
||
|
||
let oAbsoluteLastId = this.GetAbsoluteLast();
|
||
let nInputType = 0;
|
||
|
||
if (CorrectSpecialWordOnCursor(this.oCMathContent, false))
|
||
{
|
||
return true
|
||
}
|
||
else if (IsConvertWord(oAbsoluteLastId))
|
||
{
|
||
if (oAbsoluteLastId === MathLiterals.space.id)
|
||
{
|
||
if (CorrectWordOnCursor(this.oCMathContent, nInputType === 1))
|
||
{
|
||
return true;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (CorrectWordOnCursor(this.oCMathContent, nInputType === 1, true))
|
||
{
|
||
return true;
|
||
}
|
||
}
|
||
}
|
||
};
|
||
/**
|
||
* Generate this.Tokens and this.Brackets list
|
||
*/
|
||
ProceedTokens.prototype.Init = function ()
|
||
{
|
||
this.Reset();
|
||
const arrData = GetInfo(this.oCMathContent, TokenSearch_All);
|
||
if (arrData.length > 0)
|
||
{
|
||
for (let nPosInBlock = arrData.length - 1; nPosInBlock >= 0; nPosInBlock--)
|
||
{
|
||
let oCurrent = arrData[nPosInBlock];
|
||
let oPrevContent = nPosInBlock > 0 ? arrData[nPosInBlock - 1] : false;
|
||
|
||
let nCurrentType = oCurrent.GetType();
|
||
let nPrevType = oPrevContent ? oPrevContent.GetType() : undefined;
|
||
|
||
let oIsOpenOrClose = {}
|
||
|
||
if (nPrevType === MathLiterals.specialBrac.id)
|
||
{
|
||
nPosInBlock--;
|
||
let strText = oPrevContent.GetText();
|
||
|
||
oIsOpenOrClose = {
|
||
isOpen: strText === "├" ? true : false,
|
||
isClose: strText === "┤" ? true : false,
|
||
}
|
||
}
|
||
|
||
if (this.IsOtherId(nCurrentType))
|
||
{
|
||
this.AddContent(nCurrentType, oCurrent);
|
||
}
|
||
else if (this.IsBracketsId(nCurrentType))
|
||
{
|
||
this.Brackets.Check(arrData[nPosInBlock], oIsOpenOrClose);
|
||
this.AddContent(nCurrentType, oCurrent);
|
||
}
|
||
}
|
||
}
|
||
this.Tokens.brackets = this.Brackets.GetContent();
|
||
};
|
||
ProceedTokens.prototype.GetFirstPosition = function ()
|
||
{
|
||
if (this.oCMathContent.Content.length > 0)
|
||
{
|
||
let oFirstContent = this.oCMathContent.Content[0];
|
||
return new PositionIsCMathContent(0, 0, 0, oFirstContent);
|
||
}
|
||
}
|
||
/**
|
||
* Check given id is "other" (all tokens without brackets)
|
||
* @param nId
|
||
* @return {boolean}
|
||
*/
|
||
ProceedTokens.prototype.IsOtherId = function(nId)
|
||
{
|
||
return MathLiterals.operator.id === nId
|
||
|| MathLiterals.space.id === nId
|
||
|| MathLiterals.nary.id === nId
|
||
|| MathLiterals.accent.id === nId
|
||
|| MathLiterals.box.id === nId
|
||
|| MathLiterals.divide.id === nId
|
||
|| MathLiterals.func.id === nId
|
||
|| MathLiterals.matrix.id === nId
|
||
|| MathLiterals.radical.id === nId
|
||
|| MathLiterals.rect.id === nId
|
||
|| MathLiterals.special.id === nId
|
||
|| MathLiterals.subSup.id === nId
|
||
|| MathLiterals.of.id === nId
|
||
|| MathLiterals.specialBrac.id === nId
|
||
|| MathLiterals.hbrack.id === nId
|
||
|| MathLiterals.invisible.id === nId;
|
||
};
|
||
/**
|
||
* Check is given id is brackets id
|
||
* @param nId
|
||
* @return {boolean}
|
||
*/
|
||
ProceedTokens.prototype.IsBracketsId = function(nId)
|
||
{
|
||
return MathLiterals.rBrackets.id === nId
|
||
|| MathLiterals.lBrackets.id === nId
|
||
|| MathLiterals.lrBrackets.id === nId
|
||
};
|
||
/**
|
||
* Add tokens to lists in this.Tokens
|
||
* @param {number} nId - ID of token
|
||
* @param {PositionIsCMathContent} oToken
|
||
*/
|
||
ProceedTokens.prototype.AddContent = function (nId, oToken)
|
||
{
|
||
this.AddById(nId, oToken);
|
||
this.AddToAll(oToken);
|
||
};
|
||
/**
|
||
* Add tokens to this.Tokens by grouping them on id
|
||
* @param {number} nId
|
||
* @param {PositionIsCMathContent} oInToken
|
||
* @constructor
|
||
*/
|
||
ProceedTokens.prototype.AddById = function (nId, oInToken)
|
||
{
|
||
let oToken = {
|
||
data: oInToken,
|
||
link: nId,
|
||
pos: this.Tokens[nId] ? this.Tokens[nId].length : 0,
|
||
};
|
||
|
||
if (!this.Tokens[nId])
|
||
this.Tokens[nId] = [];
|
||
|
||
this.Tokens[nId].push(oToken);
|
||
};
|
||
/**
|
||
* Add tokens to this.Tokens.all array
|
||
* @param {PositionIsCMathContent} oToken
|
||
*/
|
||
ProceedTokens.prototype.AddToAll = function (oToken)
|
||
{
|
||
this.Tokens.all.push(oToken);
|
||
};
|
||
/**
|
||
* Return MathLiteral class of last content block except:
|
||
* brackets,
|
||
* spaces
|
||
* and tokens inside bracket blocks
|
||
*
|
||
* @returns {PositionIsCMathContent|false}
|
||
*/
|
||
ProceedTokens.prototype.GetLast = function()
|
||
{
|
||
let arrAllTokens = this.Tokens.all;
|
||
let oSubSup = null; // Last subSub token
|
||
|
||
if (!arrAllTokens || arrAllTokens.length === 0)
|
||
return false;
|
||
|
||
for (let nCounter = 0; nCounter < arrAllTokens.length; nCounter++)
|
||
{
|
||
let oToken = arrAllTokens[nCounter];
|
||
let nType = oToken.GetType();
|
||
let oPos = this.IsStepInBracket(oToken);
|
||
|
||
if (oPos)
|
||
{
|
||
while (oToken && nCounter < arrAllTokens.length && !oPos.IsEqualPosition(oToken))
|
||
{
|
||
nCounter++;
|
||
oToken = arrAllTokens[nCounter];
|
||
}
|
||
continue;
|
||
}
|
||
|
||
if (MathLiterals.lrBrackets.id === nType
|
||
|| MathLiterals.lBrackets.id === nType
|
||
|| MathLiterals.rBrackets.id === nType
|
||
|| MathLiterals.space.id === nType
|
||
|| MathLiterals.operator.id === nType
|
||
|| MathLiterals.subSup.id === nType
|
||
|| this.IsInSomeBracket(oToken)
|
||
)
|
||
{
|
||
if (MathLiterals.subSup.id === nType && !oSubSup)
|
||
oSubSup = oToken;
|
||
continue;
|
||
}
|
||
|
||
if (oToken)
|
||
return oToken;
|
||
}
|
||
|
||
if (oSubSup)
|
||
return oSubSup;
|
||
};
|
||
/**
|
||
* Get MathLiteral class of last token
|
||
* @returns {number|false}
|
||
*/
|
||
ProceedTokens.prototype.GetAbsoluteLast = function ()
|
||
{
|
||
let arrContent = this.oCMathContent.Content;
|
||
if (arrContent.length === 0)
|
||
return false;
|
||
|
||
let nCounter = arrContent.length - 1;
|
||
|
||
while (arrContent[nCounter])
|
||
{
|
||
let oLastElem = arrContent[nCounter];
|
||
|
||
if (oLastElem.Type === 49)
|
||
{
|
||
if (oLastElem.Content.length < 1)
|
||
{
|
||
nCounter--;
|
||
continue;
|
||
}
|
||
|
||
let nMinPosContent = Math.max(0, oLastElem.State.ContentPos - 1);
|
||
let oLastElement = oLastElem.Content[nMinPosContent];
|
||
let strValue = String.fromCharCode(oLastElement.value);
|
||
return GetTokenType(strValue, TokenSearch_Everything);
|
||
}
|
||
else
|
||
return false;
|
||
}
|
||
|
||
return false;
|
||
};
|
||
ProceedTokens.prototype.GetAbsolutLastObject = function ()
|
||
{
|
||
let arrContent = this.oCMathContent.Content;
|
||
if (arrContent.length === 0)
|
||
return false;
|
||
|
||
let oLastElem = arrContent[arrContent.length - 1];
|
||
|
||
if (oLastElem.Type === 49)
|
||
{
|
||
if (oLastElem.Content.length < 1)
|
||
return false;
|
||
let oLastElement = oLastElem.Content[oLastElem.Content.length - 1];
|
||
let strValue = String.fromCharCode(oLastElement.value);
|
||
|
||
return new AscMath.MathText(strValue, oLastElem);
|
||
}
|
||
};
|
||
/**
|
||
* Get MathLiteral class of pre last token
|
||
* @returns {number|false}
|
||
*/
|
||
ProceedTokens.prototype.GetAbsolutePreLast = function ()
|
||
{
|
||
let arrContent = this.oCMathContent.Content;
|
||
if (!arrContent || arrContent.length === 0)
|
||
return false;
|
||
|
||
let oLastElem = arrContent[arrContent.length - 1];
|
||
|
||
if (oLastElem.Type === 49)
|
||
{
|
||
let nMinPosContent = Math.min(oLastElem.Content.length - 2, oLastElem.State.ContentPos - 2);
|
||
if (nMinPosContent >= 0)
|
||
{
|
||
let oLastElement = oLastElem.Content[nMinPosContent];
|
||
let strValue = String.fromCharCode(oLastElement.value);
|
||
return GetTokenType(strValue, TokenSearch_Everything);
|
||
}
|
||
}
|
||
|
||
return false;
|
||
};
|
||
/**
|
||
* Check is given position in any brackets pair. Return returns the opposite position of the parenthesis
|
||
* @param {PositionIsCMathContent} oPos
|
||
* @returns {PositionIsCMathContent | false}
|
||
*/
|
||
ProceedTokens.prototype.IsStepInBracket = function(oPos, isOnlyGetStart)
|
||
{
|
||
let arrBracketsPairs = this.Tokens.brackets.Pairs;
|
||
|
||
if (!arrBracketsPairs || arrBracketsPairs.length === 0)
|
||
return false;
|
||
|
||
for (let nCount = 0; nCount < arrBracketsPairs.length; nCount++)
|
||
{
|
||
let arrCurrentBracketPair = arrBracketsPairs[nCount];
|
||
|
||
let oStartPos = arrCurrentBracketPair[1];
|
||
let oEndPos = arrCurrentBracketPair[0];
|
||
|
||
if (oStartPos.IsEqualPosition(oPos) && !isOnlyGetStart)
|
||
return oEndPos;
|
||
else if (oEndPos.IsEqualPosition(oPos))
|
||
return oStartPos;
|
||
}
|
||
|
||
return false;
|
||
};
|
||
/**
|
||
* Check is given position is start or end of any bracket block.
|
||
* @param {PositionIsCMathContent} oPos
|
||
* @returns {boolean}
|
||
*/
|
||
ProceedTokens.prototype.IsInSomeBracket = function(oPos)
|
||
{
|
||
let arrBracketsPairs = this.Tokens.brackets.Pairs;
|
||
|
||
if (!arrBracketsPairs || arrBracketsPairs.length === 0)
|
||
return false;
|
||
|
||
for (let nCount = 0; nCount < arrBracketsPairs.length; nCount++)
|
||
{
|
||
let arrCurrentBracketPair = arrBracketsPairs[nCount];
|
||
let oStartPos = arrCurrentBracketPair[1];
|
||
let oEndPos = arrCurrentBracketPair[0];
|
||
|
||
if (oPos.IsBetween(oStartPos, oEndPos))
|
||
return true;
|
||
}
|
||
|
||
return false;
|
||
};
|
||
/**
|
||
* Check token on given pos is operator
|
||
* @param {PositionIsCMathContent} oPos
|
||
* @return {boolean}
|
||
*/
|
||
ProceedTokens.prototype.IsOperator = function (oPos)
|
||
{
|
||
let arrOperators = this.Tokens[MathLiterals.operator.id];
|
||
|
||
if (!arrOperators || arrOperators.length === 0)
|
||
return false;
|
||
|
||
for (let i = 0; i < arrOperators.length; i++)
|
||
{
|
||
let oCurrentOperator = arrOperators[i];
|
||
if (oPos.IsEqualPosition(oCurrentOperator.data))
|
||
return true;
|
||
}
|
||
|
||
return false;
|
||
};
|
||
ProceedTokens.prototype.IsTrigger = function (nId)
|
||
{
|
||
return MathLiterals.space.id === nId
|
||
|| MathLiterals.rBrackets.id === nId
|
||
|| this.IsRecursiveTrigger(nId);
|
||
};
|
||
ProceedTokens.prototype.IsRecursiveTrigger = function (nId)
|
||
{
|
||
return MathLiterals.operator.id === nId;
|
||
};
|
||
/**
|
||
* Proceed AutoCorrection
|
||
* @returns {boolean}
|
||
*/
|
||
ProceedTokens.prototype.StartAutoCorrection = function ()
|
||
{
|
||
if (!isAllowAutoCorrect)
|
||
return false;
|
||
|
||
let oRuleLast = this.GetLast();
|
||
this.oAbsoluteLastId = this.GetAbsoluteLast();
|
||
let oAbsolutePLastId = this.GetAbsolutePreLast();
|
||
let oFuncNamePos = CheckFunctionOnCursor(this.oCMathContent);
|
||
|
||
if (this.oAbsoluteLastId === oAbsolutePLastId && this.oAbsoluteLastId === MathLiterals.space.id) // подряд два пробела, не начинам коррекцию
|
||
return false;
|
||
|
||
// если нажали пробел после названия функции (cos, sin, lim, log, ...), то
|
||
// нужно добавить символ \funcapply после и инициировать конвертацию
|
||
if (!oRuleLast && oFuncNamePos && this.oAbsoluteLastId === MathLiterals.space.id)
|
||
{
|
||
// последний элемент для получения стиля
|
||
let oLastMath = this.GetAbsolutLastObject();
|
||
// получаем контент и удаляем пробел
|
||
|
||
let oParamsCutContent = {
|
||
oDelMark : oFuncNamePos,
|
||
oEndDelMark : GetEndCurPos(oFuncNamePos),
|
||
isDelLastSpace : true
|
||
};
|
||
|
||
let oMathContent = CutContentFromEnd(this.oCMathContent, oParamsCutContent);
|
||
|
||
let oFuncName = oMathContent.GetFirstContent();
|
||
let oAddDataFuncName = oFuncName.GetAdditionalData();
|
||
let mPrp = oAddDataFuncName.mathPrp;
|
||
mPrp.SetStyle(false, false);
|
||
|
||
//добавляем символ funcapply
|
||
let oFuncApply = new MathText(String.fromCodePoint(8289), oLastMath.additionalMathData);
|
||
oMathContent.AddText(oFuncApply);
|
||
|
||
//конвертируем в профф. формат
|
||
GetConvertContent(0, oMathContent, this.oCMathContent);
|
||
this.SetCursorByConvertedData(this.oCMathContent);
|
||
return true
|
||
}
|
||
else if (oRuleLast && oFuncNamePos && this.oAbsoluteLastId === MathLiterals.subSup.id)
|
||
{
|
||
let oParamsCutContentSubSup = {
|
||
oDelMark : oRuleLast,
|
||
oEndDelMark : GetEndCurPos(oRuleLast)
|
||
};
|
||
let oMathContentSubSup = CutContentFromEnd(this.oCMathContent, oParamsCutContentSubSup);
|
||
|
||
// последний элемент для получения стиля
|
||
let oLastMath = this.GetAbsolutLastObject();
|
||
|
||
let oEndPos = GetEndCurPos(oRuleLast);
|
||
|
||
let oParamsCutContent = {
|
||
oDelMark : oFuncNamePos,
|
||
oEndDelMark : oEndPos
|
||
};
|
||
let oMathContent = CutContentFromEnd(this.oCMathContent, oParamsCutContent);
|
||
|
||
let oFuncName = oMathContent.GetFirstContent();
|
||
let oAddDataFuncName = oFuncName.GetAdditionalData();
|
||
let mPrp = oAddDataFuncName.mathPrp;
|
||
mPrp.SetStyle(false, false);
|
||
|
||
//добавляем символ funcapply
|
||
let oFuncApply = new MathText(String.fromCodePoint(8289), oLastMath.additionalMathData);
|
||
oMathContent.AddText(oFuncApply);
|
||
let oSubSup = new MathText(oMathContentSubSup.GetText(), oLastMath.additionalMathData);
|
||
oMathContent.AddText(oSubSup);
|
||
|
||
this.oCMathContent.AddDataFromFlatMathTextAndStyles(oMathContent.Flat());
|
||
|
||
//конвертируем в профф. формат
|
||
this.SetCursorByConvertedData(this.oCMathContent);
|
||
return true
|
||
}
|
||
|
||
// конвертация контента ВНУТРИ скобки, при закрытии скобки
|
||
if (this.IsBracketContentConvert())
|
||
{
|
||
let isResult = this.ConvertBracketContent();
|
||
if (typeof isResult === "boolean")
|
||
return isResult;
|
||
}
|
||
|
||
//конвертация контента перед символом деления "1_2/" -> СDegree block "1_2" + "/"
|
||
if (MathLiterals.divide.id === this.oAbsoluteLastId && true === this.ProceedBeforeDivide(oRuleLast))
|
||
{
|
||
return true;
|
||
}
|
||
|
||
//при написании оператора нужно конвертировать всю формулу до оператора (или до первой открывающей скобки)
|
||
if (this.IsRecursiveTrigger(this.oAbsoluteLastId))
|
||
{
|
||
if (true === this.ConvertByOperator())
|
||
return true;
|
||
}
|
||
else if (this.IsTrigger(this.oAbsoluteLastId) && oRuleLast && oRuleLast.type === MathLiterals.of.id) // сначала пытаемся преобразовать все что находится после "▒"
|
||
{
|
||
let oMathContentTemp = AscFormat.ExecuteNoHistory(
|
||
function (oRuleLast)
|
||
{
|
||
let oMathCopy = this.oCMathContent.Copy();
|
||
let oParamsCutContent = {
|
||
oDelMark : oRuleLast,
|
||
oEndDelMark : GetEndCurPos(oRuleLast),
|
||
isDelLastSpace : true
|
||
};
|
||
let oMathContent = CutContentFromEnd(oMathCopy, oParamsCutContent);
|
||
|
||
GetConvertContent(0, oMathContent, oMathCopy);
|
||
oMathCopy.Correct_Content(true);
|
||
|
||
return oMathCopy;
|
||
},
|
||
this,
|
||
[oRuleLast]
|
||
);
|
||
|
||
if (!this.CompareMathContent(oMathContentTemp)) // если контент изменился, то преобразуем все после ▒
|
||
{
|
||
let oParamsCutContent = {
|
||
oDelMark : oRuleLast,
|
||
oEndDelMark : GetEndCurPos(oRuleLast),
|
||
isDelLastSpace : true
|
||
};
|
||
let oMathContent = CutContentFromEnd(this.oCMathContent, oParamsCutContent);
|
||
|
||
GetConvertContent(0, oMathContent, this.oCMathContent);
|
||
this.SetCursorByConvertedData(this.oCMathContent);
|
||
return true;
|
||
}
|
||
// если остался прежним и есть большой оператор -> преобразуем весь контент до оператора включительно
|
||
else if (this.Tokens[MathLiterals.nary.id] && this.Tokens[MathLiterals.nary.id].length > 0)
|
||
{
|
||
let oStartPos = this.Tokens[MathLiterals.nary.id][0].data;
|
||
|
||
if (oStartPos)
|
||
{
|
||
let oParamsCutContent = {
|
||
oDelMark : oStartPos,
|
||
oEndDelMark : GetEndCurPos(oStartPos),
|
||
isDelLastSpace : true
|
||
};
|
||
let oMathContent = CutContentFromEnd(this.oCMathContent, oParamsCutContent);
|
||
|
||
GetConvertContent(0, oMathContent, this.oCMathContent);
|
||
|
||
this.SetCursorByConvertedData(this.oCMathContent);
|
||
return true;
|
||
}
|
||
}
|
||
}
|
||
else if (this.IsBIFunctionProcessing(oRuleLast) && this.IsTrigger(this.oAbsoluteLastId))
|
||
{
|
||
this.BIFunctionProcessing(oRuleLast);
|
||
return true;
|
||
}
|
||
else if (this.IsPCFunctionWithContentAfter(oRuleLast) && this.IsTrigger(this.oAbsoluteLastId))
|
||
{
|
||
this.PCFunctionProcessingWithContent(oRuleLast);
|
||
return true;
|
||
}
|
||
else if (this.IsPCFunction(oRuleLast) && this.IsTrigger(this.oAbsoluteLastId))
|
||
{
|
||
this.PCFunctionProcessing(oRuleLast);
|
||
return true;
|
||
}
|
||
else if (this.IsPRFunction(oRuleLast) && this.IsTrigger(this.oAbsoluteLastId))
|
||
{
|
||
this.PRFunctionProcessing(oRuleLast);
|
||
return true;
|
||
}
|
||
|
||
// prescript inside brackets "(_2^y) "
|
||
if (!oRuleLast && this.IsPreScript(oAbsolutePLastId))
|
||
{
|
||
this.ConvertPreScript();
|
||
this.SetCursorByConvertedData(this.oCMathContent);
|
||
return true;
|
||
}
|
||
|
||
//конвертация самих скобок
|
||
if (this.IsBracketConvert(oAbsolutePLastId) && !this.IsPreScript())
|
||
{
|
||
ConvertBracket(this.Tokens.brackets, this.oCMathContent);
|
||
this.SetCursorByConvertedData(this.oCMathContent);
|
||
return true;
|
||
}
|
||
};
|
||
ProceedTokens.prototype.ConvertByOperator = function ()
|
||
{
|
||
let oPos = this.Brackets.GetLastPiarStartPos();
|
||
|
||
if (oPos)
|
||
oPos.IncreasePosition();
|
||
|
||
if (!oPos)
|
||
oPos = this.GetFirstPosition();
|
||
|
||
let oParamsCutContent = {oDelMark : oPos, oEndDelMark: GetEndCurPos(oPos)};
|
||
|
||
let oMathContentCopy = AscFormat.ExecuteNoHistory(
|
||
function () {
|
||
let oMathContentCopy = this.oCMathContent.Copy();
|
||
let oMathContent = CutContentFromEnd(oMathContentCopy, oParamsCutContent);
|
||
|
||
GetConvertContent(0, oMathContent, oMathContentCopy);
|
||
oMathContentCopy.Correct_Content(true);
|
||
|
||
return oMathContentCopy;
|
||
},
|
||
this
|
||
);
|
||
|
||
if (!this.CompareMathContent(oMathContentCopy))
|
||
{
|
||
let oNewMathContent = CutContentFromEnd(this.oCMathContent, oParamsCutContent);
|
||
GetConvertContent(0, oNewMathContent, this.oCMathContent);
|
||
return true
|
||
}
|
||
|
||
return false;
|
||
}
|
||
ProceedTokens.prototype.private_ProceedBeforeDivide = function (oRuleLast, isCopy)
|
||
{
|
||
let oTempMathContent = isCopy ? this.oCMathContent.Copy() : this.oCMathContent;
|
||
|
||
function SetCurPos (oOriginalContent, oCopy)
|
||
{
|
||
let nCurPos = oOriginalContent.CurPos;
|
||
|
||
oCopy.CurPos = (oCopy.Content.length < nCurPos)
|
||
? oCopy.Content.length
|
||
: nCurPos;
|
||
|
||
let oLastElement = oOriginalContent.Content[oCopy.CurPos];
|
||
|
||
if (oLastElement && oLastElement instanceof ParaRun)
|
||
{
|
||
let nOriginalContentPos = oLastElement.State.ContentPos;
|
||
let oCopyParaRun = oCopy.Content[oCopy.CurPos];
|
||
|
||
if (oCopyParaRun && oCopyParaRun instanceof ParaRun)
|
||
{
|
||
oCopyParaRun.State.ContentPos = (oCopyParaRun.Content.length < nOriginalContentPos)
|
||
? oCopyParaRun.Content.length
|
||
: nOriginalContentPos;
|
||
}
|
||
}
|
||
}
|
||
|
||
SetCurPos(this.oCMathContent, oTempMathContent);
|
||
|
||
let oParamsCutContent = {
|
||
oDelMark : oRuleLast,
|
||
oEndDelMark : GetEndCurPos(oRuleLast)
|
||
};
|
||
|
||
let oPos = this.Brackets.GetLastPiarStartPos();
|
||
let oDivide = CutContentFromEnd(oTempMathContent, oParamsCutContent);
|
||
|
||
if (!oPos)
|
||
oPos = this.GetContentBlockBefore(oRuleLast).start;
|
||
|
||
oParamsCutContent = {
|
||
oDelMark : oPos,
|
||
oEndDelMark : GetEndCurPos(oPos)
|
||
};
|
||
|
||
let oMathContent = CutContentFromEnd(oTempMathContent, oParamsCutContent);
|
||
|
||
SetCurPos(this.oCMathContent, oTempMathContent);
|
||
GetConvertContent(0, oMathContent, oTempMathContent);
|
||
oTempMathContent.AddDataFromFlatMathTextAndStyles(oDivide.Flat());
|
||
|
||
return oTempMathContent;
|
||
}
|
||
ProceedTokens.prototype.ProceedBeforeDivide = function (oRuleLast)
|
||
{
|
||
if (!(oRuleLast instanceof PositionIsCMathContent))
|
||
return false;
|
||
|
||
let oMathContentTemp = AscFormat.ExecuteNoHistory(
|
||
this.private_ProceedBeforeDivide,
|
||
this,
|
||
[oRuleLast, true]
|
||
);
|
||
|
||
if (!this.CompareMathContent(oMathContentTemp, true))
|
||
{
|
||
this.private_ProceedBeforeDivide(oRuleLast, false);
|
||
return true;
|
||
}
|
||
else
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
ProceedTokens.prototype.CompareMathContent = function (oMathContentCopy, isCheckStr)
|
||
{
|
||
let isSame = true;
|
||
oMathContentCopy.Correct_Content(true);
|
||
|
||
for (let i = this.oCMathContent.Content.length; i >= 0;i--)
|
||
{
|
||
if (oMathContentCopy.Content[i])
|
||
{
|
||
if (this.oCMathContent.Content[i]
|
||
&& this.oCMathContent.Content[i].constructor.name !== oMathContentCopy.Content[i].constructor.name)
|
||
isSame = false;
|
||
|
||
if (oMathContentCopy.Content[i].Type !== para_Math_Run
|
||
&& !this.oCMathContent.Content[i])
|
||
isSame = false;
|
||
|
||
if (isCheckStr
|
||
&& oMathContentCopy.Content[i]
|
||
&& this.oCMathContent.Content[i]
|
||
&& oMathContentCopy.Content[i].GetTextOfElement().GetText() !== this.oCMathContent.Content[i].GetTextOfElement().GetText())
|
||
isSame = false;
|
||
}
|
||
}
|
||
|
||
return isSame;
|
||
};
|
||
ProceedTokens.prototype.IsBracketConvert = function (oAbsolutePLastId)
|
||
{
|
||
return (MathLiterals.rBrackets.id === oAbsolutePLastId || MathLiterals.lrBrackets.id === oAbsolutePLastId)
|
||
&& this.Tokens.brackets.Pairs.length > 0
|
||
&& this.IsTrigger(this.oAbsoluteLastId)
|
||
};
|
||
ProceedTokens.prototype.IsBracketContentConvert = function ()
|
||
{
|
||
return MathLiterals.rBrackets.id === this.oAbsoluteLastId
|
||
|| this.Brackets.IsLastBracketPairSpecial()
|
||
&& this.IsTrigger(this.oAbsoluteLastId)
|
||
};
|
||
ProceedTokens.prototype.ConvertBracketContent = function ()
|
||
{
|
||
// проверяем что первый символ внутри скобки это не _ или ^ для обработки pre-script
|
||
let oLastBracketBlock = this.Tokens.brackets.Pairs[this.Tokens.brackets.Pairs.length - 1];
|
||
|
||
if (oLastBracketBlock)
|
||
{
|
||
let oPos = oLastBracketBlock[1].GetCopy();
|
||
|
||
if (oPos)
|
||
{
|
||
oPos.IncreasePosition();
|
||
|
||
if (oPos.GetText() !== "_" && oPos.GetText() !== "^")
|
||
{
|
||
ConvertBracketContent(this.Tokens.brackets, this.oCMathContent);
|
||
this.oCMathContent.MoveCursorToEndPos();
|
||
return true;
|
||
}
|
||
else
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
ProceedTokens.prototype.IsStartBracketAndClose = function ()
|
||
{
|
||
return this.Tokens[MathLiterals.specialBrac.id]
|
||
&& this.Tokens[MathLiterals.specialBrac.id].length >= 1
|
||
&& this.Tokens.brackets.NoPair.length > 0
|
||
&& this.Tokens.brackets.NoPair[0].type === MathLiterals.rBrackets.id;
|
||
};
|
||
ProceedTokens.prototype.StartBracketAndClose = function ()
|
||
{
|
||
let oStartPos = this.Tokens.brackets.NoPair[0];
|
||
|
||
let oParamsCutContent = {
|
||
oDelMark : oStartPos,
|
||
isDelLastSpace : true,
|
||
oEndDelMark : GetEndCurPos(oStartPos),
|
||
};
|
||
let oMathContent = CutContentFromEnd(this.oCMathContent, oParamsCutContent);
|
||
|
||
GetConvertContent(0, oMathContent, this.oCMathContent);
|
||
};
|
||
ProceedTokens.prototype.IsStartAndCloseBracket = function ()
|
||
{
|
||
return this.Tokens[MathLiterals.specialBrac.id] && this.Tokens[MathLiterals.specialBrac.id].length >= 2
|
||
};
|
||
ProceedTokens.prototype.StartCloseBracket = function ()
|
||
{
|
||
let arrStartAndClose = this.Tokens[MathLiterals.specialBrac.id];
|
||
let oClosePos = arrStartAndClose[0].data;
|
||
let oStartPos = arrStartAndClose[1].data;
|
||
let strClosePos = oClosePos.GetText();
|
||
let strOpenPos = oStartPos.GetText();
|
||
|
||
if (strClosePos === "┤" && strOpenPos === "├")
|
||
{
|
||
let oParamsCutContent = {
|
||
oDelMark : oStartPos,
|
||
oEndDelMark : GetEndCurPos(oStartPos),
|
||
isDelLastSpace : true
|
||
};
|
||
|
||
let oMathContent = CutContentFromEnd(this.oCMathContent, oParamsCutContent);
|
||
|
||
GetConvertContent(0, oMathContent, this.oCMathContent);
|
||
}
|
||
};
|
||
ProceedTokens.prototype.IsPreScript = function (oAbsolutePLastId)
|
||
{
|
||
if (this.Tokens.brackets.Pairs.length > 0
|
||
&& (MathLiterals.space.id === this.oAbsoluteLastId && oAbsolutePLastId === MathLiterals.rBrackets.id
|
||
|| MathLiterals.char.id === oAbsolutePLastId && MathLiterals.space.id === this.oAbsoluteLastId))
|
||
{
|
||
return AscFormat.ExecuteNoHistory(
|
||
function () {
|
||
|
||
if (this.Tokens.brackets.Pairs.length < 1)
|
||
return false;
|
||
|
||
let oFirstPair = this.Tokens.brackets.Pairs[this.Tokens.brackets.Pairs.length - 1][1];
|
||
|
||
let oParamsCutContent = {
|
||
oDelMark : oFirstPair,
|
||
oEndDelMark : GetEndCurPos(oFirstPair),
|
||
isCopy : true,
|
||
isDelLastSpace : true
|
||
};
|
||
|
||
let oMathContent = CutContentFromEnd(this.oCMathContent, oParamsCutContent);
|
||
let strMathContent = oMathContent.GetText();
|
||
|
||
if (strMathContent.split("_").length >= 2 && strMathContent.split("^").length >= 2)
|
||
return this.Tokens.brackets.Pairs.length > 0;
|
||
},
|
||
this
|
||
);
|
||
}
|
||
};
|
||
ProceedTokens.prototype.ConvertPreScript = function ()
|
||
{
|
||
if (this.Tokens.brackets.Pairs.length < 1)
|
||
return false;
|
||
let oFirstPair = this.Tokens.brackets.Pairs[this.Tokens.brackets.Pairs.length - 1][1];
|
||
let oParamsCutContent = {
|
||
oDelMark : oFirstPair,
|
||
oEndDelMark : GetEndCurPos(oFirstPair),
|
||
isWrapFirstContent : true,
|
||
isDelLastSpace : true
|
||
};
|
||
let oMathContent = CutContentFromEnd(this.oCMathContent, oParamsCutContent);
|
||
|
||
GetConvertContent(0, oMathContent, this.oCMathContent);
|
||
};
|
||
/**
|
||
* Get content after given position
|
||
* @param {PositionIsCMathContent} oPos
|
||
* @returns {{start : PositionIsCMathContent, end: PositionIsCMathContent} | undefined}
|
||
*/
|
||
ProceedTokens.prototype.GetContentBlockAfter = function (oPos, isSpace)
|
||
{
|
||
let oStartPos = oPos.GetCopy();
|
||
oStartPos.IncreasePosition();
|
||
|
||
let oBracketPos = this.IsStepInBracket(oStartPos);
|
||
if (oBracketPos)
|
||
{
|
||
return {
|
||
start: oStartPos,
|
||
end: oBracketPos,
|
||
}
|
||
}
|
||
|
||
let isParaPosUsed = false;
|
||
let nMathPos = oStartPos.GetMathPos();
|
||
let nParaPos = oStartPos.GetPosition();
|
||
let nEndMathPos = nMathPos;
|
||
let nEndParaPos = nParaPos;
|
||
let oEndPos;
|
||
|
||
if (nMathPos >= this.oCMathContent.Content.length || nMathPos < 0)
|
||
return;
|
||
|
||
for (let i = nMathPos, nContentLength = this.oCMathContent.Content.length; i < nContentLength; i++)
|
||
{
|
||
let oCurrentElement = this.oCMathContent.Content[i];
|
||
nEndMathPos = i;
|
||
nEndParaPos = (i === nMathPos)
|
||
? nEndParaPos
|
||
: 0;
|
||
|
||
if (oCurrentElement.Type === 49)
|
||
{
|
||
if (!isParaPosUsed && nParaPos >= oCurrentElement.Content.length)
|
||
return;
|
||
|
||
for (let j = !isParaPosUsed ? nParaPos : 0; j < oCurrentElement.Content.length; j++)
|
||
{
|
||
if (!isParaPosUsed)
|
||
{
|
||
isParaPosUsed = true;
|
||
}
|
||
|
||
oEndPos = new PositionIsCMathContent(nEndMathPos, nEndParaPos, undefined, oCurrentElement);
|
||
if (isSpace && oEndPos.GetType() === MathLiterals.space.id)
|
||
return {
|
||
start: oStartPos,
|
||
end: oEndPos
|
||
}
|
||
let oPos = this.IsStepInBracket(oEndPos);
|
||
if (oPos)
|
||
{
|
||
nEndMathPos = i = oPos.GetMathPos();
|
||
nEndParaPos = j = oPos.GetPosition();
|
||
|
||
return {
|
||
start: oStartPos,
|
||
end: new PositionIsCMathContent(nEndMathPos, nEndParaPos, undefined, oCurrentElement)
|
||
}
|
||
}
|
||
else
|
||
{
|
||
nEndParaPos = j;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
return {
|
||
start: oPos,
|
||
end: oEndPos
|
||
}
|
||
};
|
||
/**
|
||
* Get content (CFraction, CDegree, CMatrix e.g. or text until it gets space) before given position
|
||
* @param {PositionIsCMathContent} oStartPos
|
||
* @returns {{start : PositionIsCMathContent, end: PositionIsCMathContent} | undefined}
|
||
*/
|
||
ProceedTokens.prototype.GetContentBlockBefore = function (oInputPos)
|
||
{
|
||
let oTempStartPos = oInputPos.GetCopy();
|
||
|
||
let oStartPos = oInputPos.GetCopy();
|
||
let nStartType = oStartPos.GetType();
|
||
|
||
let isSubSup = nStartType === MathLiterals.subSup.id;
|
||
let isNary = nStartType === MathLiterals.of.id;
|
||
let isFrac = nStartType === MathLiterals.divide.id;
|
||
|
||
let strSubSupType = isSubSup
|
||
? oStartPos.GetText()
|
||
: undefined;
|
||
|
||
if (oStartPos.position[0] === 0 && oStartPos.position[1] === 0)
|
||
{
|
||
return {
|
||
start: oStartPos,
|
||
end: oStartPos.GetCopy()
|
||
}
|
||
}
|
||
|
||
let oBracketPos = this.IsStepInBracket(oStartPos, true);
|
||
if (oBracketPos)
|
||
{
|
||
return {
|
||
start: oBracketPos,
|
||
end: oStartPos
|
||
}
|
||
}
|
||
|
||
oStartPos.DecreasePosition();
|
||
|
||
let isParaPosUsed = false;
|
||
let nMathPos = oStartPos.GetMathPos();
|
||
let nParaPos = oStartPos.GetPosition();
|
||
|
||
let nTempParaPos = null;
|
||
|
||
for (let i = nMathPos; i >= 0; i--)
|
||
{
|
||
let oCurrentElement = this.oCMathContent.Content[i];
|
||
|
||
if (i !== nMathPos)
|
||
nParaPos = oCurrentElement.Content.length - 1;
|
||
|
||
if (!oCurrentElement)
|
||
continue;
|
||
|
||
if (oCurrentElement.Type === 49)
|
||
{
|
||
if (!isParaPosUsed && nParaPos >= oCurrentElement.Content.length)
|
||
continue;
|
||
|
||
for (let j = nTempParaPos !== null ? nTempParaPos : nParaPos; j >= 0; j--)
|
||
{
|
||
if (null !== nTempParaPos)
|
||
nTempParaPos = null;
|
||
if (!isParaPosUsed)
|
||
isParaPosUsed = true;
|
||
|
||
let oEndPos = new PositionIsCMathContent(i, j, undefined, oCurrentElement);
|
||
let oPos = this.IsStepInBracket(oEndPos, true);
|
||
|
||
if (oPos)
|
||
{
|
||
i = oPos.GetMathPos() + 1;
|
||
nTempParaPos = oPos.GetPosition();
|
||
|
||
if (i === 0 && j === 0)
|
||
{
|
||
return {
|
||
start: new PositionIsCMathContent(0,0, oEndPos.GetType(), oCurrentElement),
|
||
end: oStartPos
|
||
}
|
||
}
|
||
|
||
break;
|
||
}
|
||
else if (this.IsOperator(oEndPos) || oEndPos.GetText() === " ")
|
||
{
|
||
if (oEndPos.GetText() === " " && isFrac)
|
||
{
|
||
return {
|
||
start: oEndPos,
|
||
end: oTempStartPos,
|
||
}
|
||
}
|
||
|
||
oEndPos.IncreasePosition();
|
||
return {
|
||
start: oEndPos,
|
||
end: oTempStartPos,
|
||
}
|
||
}
|
||
else if (oEndPos.GetType() === MathLiterals.of.id)
|
||
{
|
||
oEndPos.IncreasePosition()
|
||
return {
|
||
start: oEndPos,
|
||
end: oTempStartPos
|
||
}
|
||
}
|
||
else if (oEndPos.GetType() === MathLiterals.subSup.id && !isNary) // если _ или ^, то прерываемся
|
||
{
|
||
if (isSubSup)
|
||
{
|
||
if (strSubSupType !== oEndPos.GetText())
|
||
{
|
||
if (oEndPos.GetMathPos() === 0 && oEndPos.GetPosition() === 0)
|
||
{
|
||
return {
|
||
start: oEndPos,
|
||
end: oTempStartPos,
|
||
}
|
||
}
|
||
continue;
|
||
}
|
||
|
||
oEndPos.IncreasePosition()
|
||
return {
|
||
start: oEndPos,
|
||
end: oTempStartPos
|
||
}
|
||
}
|
||
else
|
||
{
|
||
isSubSup = true;
|
||
continue;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
continue;
|
||
}
|
||
}
|
||
|
||
return {
|
||
start: new PositionIsCMathContent(0, 0, 0, this.oCMathContent.Content[0]),
|
||
end: oTempStartPos
|
||
}
|
||
};
|
||
/**
|
||
* Need to process current data as PCFunction with bracket after trigger.
|
||
* For example ■(1&2@3&4).
|
||
*
|
||
* @param {PositionIsCMathContent} oLast
|
||
* @return {boolean}
|
||
*/
|
||
ProceedTokens.prototype.IsPCFunctionWithContentAfter = function(oLast)
|
||
{
|
||
if (!oLast)
|
||
return false;
|
||
|
||
let intLastTokenType = oLast.GetType();
|
||
|
||
return MathLiterals.matrix.id === intLastTokenType;
|
||
};
|
||
/**
|
||
* Processing PCFunction with bracket after trigger.
|
||
* For example ■(1&2@3&4).
|
||
* @param {PositionIsCMathContent} oLast
|
||
*/
|
||
ProceedTokens.prototype.PCFunctionProcessingWithContent = function(oLast)
|
||
{
|
||
let oConvertPos = this.GetContentBlockAfter(oLast);
|
||
|
||
// если найдется другой тип триггерного элемента, то
|
||
// лучше выделить нахождение блока скобки до/после триггерного токена в отдельный метод
|
||
|
||
if (oConvertPos)
|
||
{
|
||
let arrLastPos = oLast.position;
|
||
let arrBracketsPair = this.Brackets.BracketsPair;
|
||
|
||
for (let i = 0; i < arrBracketsPair.length; i++)
|
||
{
|
||
let arrCurrentBracket = arrBracketsPair[i];
|
||
let oStartPos = arrCurrentBracket[1];
|
||
|
||
oStartPos.DecreasePosition();
|
||
|
||
let arrPos = oStartPos.position;
|
||
|
||
// если после матрицы есть скобка
|
||
if (arrPos[0] === arrLastPos[0] && arrPos[1] === arrLastPos[1])
|
||
{
|
||
let oParamsCutContent = {
|
||
oDelMark : oLast,
|
||
oEndDelMark : GetEndCurPos(oLast),
|
||
isDelLastSpace : true
|
||
};
|
||
let oMathContent = CutContentFromEnd(this.oCMathContent, oParamsCutContent);
|
||
|
||
GetConvertContent(0, oMathContent, this.oCMathContent);
|
||
this.SetCursorByConvertedData(this.oCMathContent);
|
||
}
|
||
}
|
||
}
|
||
};
|
||
/**
|
||
* Is need to process current data as PCFunction type of math content.
|
||
* For example cos(1/2) or √(2&1xg2).
|
||
*
|
||
* @param {PositionIsCMathContent} oLast
|
||
* @return {boolean}
|
||
*/
|
||
ProceedTokens.prototype.IsPCFunction = function(oLast)
|
||
{
|
||
if (!oLast)
|
||
return false;
|
||
|
||
let intLastTokenType = oLast.GetType();
|
||
|
||
return MathLiterals.box.id === intLastTokenType
|
||
|| MathLiterals.nary.id === intLastTokenType
|
||
|| MathLiterals.radical.id === intLastTokenType
|
||
|| MathLiterals.rect.id === intLastTokenType
|
||
|| MathLiterals.func.id === intLastTokenType
|
||
|| MathLiterals.hbrack.id === intLastTokenType
|
||
};
|
||
/**
|
||
* Processing PCFunction type of math content.
|
||
* For example cos(1/2) or √(2&1xg2).
|
||
* @param {PositionIsCMathContent} oLast
|
||
*/
|
||
ProceedTokens.prototype.PCFunctionProcessing = function(oLast)
|
||
{
|
||
let oParamsCutContent = {oDelMark : oLast, oEndDelMark: GetEndCurPos(oLast), isDelLastSpace: true};
|
||
let oMathContent = CutContentFromEnd(this.oCMathContent, oParamsCutContent);
|
||
|
||
GetConvertContent(0, oMathContent, this.oCMathContent);
|
||
|
||
this.SetCursorByConvertedData(this.oCMathContent);
|
||
};
|
||
/**
|
||
* Is need to process current data as PRFunction type of math content.
|
||
* For example: (1+2) ̂, 2 ̂x.
|
||
*
|
||
* @param {PositionIsCMathContent} oLast
|
||
* @return {boolean}
|
||
*/
|
||
ProceedTokens.prototype.IsPRFunction = function(oLast)
|
||
{
|
||
if (!oLast)
|
||
return false;
|
||
|
||
let intLastTokenType = oLast.GetType();
|
||
|
||
return MathLiterals.accent.id === intLastTokenType;
|
||
};
|
||
/**
|
||
* Processing PRFunction type of math content.
|
||
* For example: (1+2) ̂, 2 ̂x.
|
||
*
|
||
* @param {PositionIsCMathContent} oLast
|
||
*/
|
||
ProceedTokens.prototype.PRFunctionProcessing = function(oLast)
|
||
{
|
||
let oConvertPos = this.GetContentBlockBefore(oLast);
|
||
|
||
if (oConvertPos)
|
||
{
|
||
let oStartPos = oConvertPos.start;
|
||
let oParamsCutContent = {
|
||
oDelMark : oStartPos,
|
||
oEndDelMark : GetEndCurPos(oStartPos),
|
||
isWrapFirstContent : true,
|
||
isDelLastSpace : true
|
||
};
|
||
let oMathContent = CutContentFromEnd(this.oCMathContent, oParamsCutContent);
|
||
|
||
GetConvertContent(0, oMathContent, this.oCMathContent);
|
||
}
|
||
else
|
||
{
|
||
let oParamsCutContent = {
|
||
oDelMark : oLast,
|
||
oEndDelMark : GetEndCurPos(oLast),
|
||
isDelLastSpace : true
|
||
};
|
||
let oMathContent = CutContentFromEnd(this.oCMathContent, oParamsCutContent);
|
||
|
||
GetConvertContent(0, oMathContent, this.oCMathContent);
|
||
}
|
||
|
||
this.SetCursorByConvertedData(this.oCMathContent);
|
||
};
|
||
/**
|
||
* Is need to process current data as BIFunction type of math content.
|
||
* For example: 1/2, s_d.
|
||
*
|
||
* @param {PositionIsCMathContent} oLast
|
||
* @return {boolean}
|
||
*/
|
||
ProceedTokens.prototype.IsBIFunctionProcessing = function (oLast)
|
||
{
|
||
if (!oLast)
|
||
return false;
|
||
|
||
let intLastTokenType = oLast.GetType();
|
||
|
||
return MathLiterals.subSup.id === intLastTokenType
|
||
|| MathLiterals.divide.id === intLastTokenType
|
||
|| MathLiterals.of.id === intLastTokenType
|
||
|| MathLiterals.invisible.id === intLastTokenType
|
||
|| MathLiterals.hbrack.id === intLastTokenType;
|
||
};
|
||
ProceedTokens.prototype.SetCursorByConvertedData = function (oMathContent)
|
||
{
|
||
if (!oMathContent)
|
||
return;
|
||
|
||
if (oMathContent.Content.length >= 1)
|
||
{
|
||
let oConvertedElement = (oMathContent.Content.length > 1)
|
||
? oMathContent.Content[oMathContent.Content.length - 1]
|
||
: oMathContent.Content[0];
|
||
|
||
if (oConvertedElement instanceof CNary)
|
||
{
|
||
let oNaryBase = oConvertedElement.getBase();
|
||
if (oNaryBase.Is_Empty())
|
||
{
|
||
oMathContent.Correct_Content(true);
|
||
oNaryBase.SelectThisElement(1);
|
||
oNaryBase.SelectAll(1);
|
||
return;
|
||
}
|
||
}
|
||
else if (oConvertedElement instanceof CMathFunc)
|
||
{
|
||
let oFuncArg = oConvertedElement.getArgument();
|
||
if (oFuncArg.Is_Empty())
|
||
{
|
||
oMathContent.Correct_Content(true);
|
||
oFuncArg.SelectThisElement(1);
|
||
oFuncArg.SelectAll(1);
|
||
return;
|
||
}
|
||
}
|
||
else if (oConvertedElement instanceof CDegreeSubSup && oConvertedElement.Pr.type === DEGREE_PreSubSup)
|
||
{
|
||
let oPreScriptBase = oConvertedElement.getBase();
|
||
if (oPreScriptBase.Is_Empty())
|
||
{
|
||
oMathContent.Correct_Content(true);
|
||
oPreScriptBase.SelectThisElement(1);
|
||
oPreScriptBase.SelectAll(1);
|
||
return;
|
||
}
|
||
}
|
||
|
||
oMathContent.Correct_Content(true);
|
||
oMathContent.Correct_ContentPos(1);
|
||
}
|
||
|
||
oMathContent.Correct_Content(true);
|
||
oMathContent.Correct_ContentPos(1);
|
||
};
|
||
/**
|
||
* Processing BIFunction type of math content.
|
||
* For example: 1/2, s_d.
|
||
*
|
||
* @param {PositionIsCMathContent} oLast
|
||
*/
|
||
ProceedTokens.prototype.BIFunctionProcessing = function(oLast)
|
||
{
|
||
let arrPreContent = this.GetContentBlockBefore(oLast);
|
||
let oEndPos = arrPreContent.end;
|
||
let isFrac = oLast.GetType() === MathLiterals.divide.id;
|
||
oEndPos.IncreasePositionToCurPos();
|
||
|
||
if (arrPreContent)
|
||
{
|
||
let oStartPos = arrPreContent.start;
|
||
|
||
// processing for pre-script "_2^j x ", "_(2+1)^(x) x ", "_2^j (1+y) "
|
||
if (oStartPos.GetText() === "_" && oLast.GetText() === "^" || oStartPos.GetText() === "^" && oLast.GetText() === "_")
|
||
return this.ProceedPreScript(oLast, oStartPos);
|
||
|
||
let oParamsCutContent = {
|
||
oDelMark : oStartPos,
|
||
oEndDelMark : oEndPos,
|
||
isWrapFirstContent : true,
|
||
isDelLastSpace : true,
|
||
isDelStartSpace : isFrac,
|
||
};
|
||
let oMathContent = CutContentFromEnd(this.oCMathContent, oParamsCutContent);
|
||
|
||
GetConvertContent(0, oMathContent, this.oCMathContent);
|
||
}
|
||
else
|
||
{
|
||
let oParamsCutContent = {
|
||
oDelMark : oLast,
|
||
oEndDelMark : GetEndCurPos(oLast),
|
||
isDelLastSpace : true
|
||
};
|
||
let oMathContent = CutContentFromEnd(this.oCMathContent, oParamsCutContent);
|
||
|
||
GetConvertContent(0, oMathContent, this.oCMathContent);
|
||
}
|
||
|
||
this.SetCursorByConvertedData(this.oCMathContent);
|
||
};
|
||
ProceedTokens.prototype.ProceedPreScript = function (oLast, oStartPos)
|
||
{
|
||
let oLastTemp = oLast.GetCopy();
|
||
oLastTemp.IncreasePosition(); // get last content of pre script
|
||
|
||
let oBracketPos = this.IsStepInBracket(oLastTemp, false); // if bracket pos get opposite
|
||
if (oBracketPos)
|
||
oLastTemp = oBracketPos;
|
||
|
||
if (oLastTemp.GetText() === ' ')
|
||
return false;
|
||
|
||
oLastTemp.IncreasePosition(); // space before base content
|
||
if (oLastTemp.GetText() !== " ")
|
||
return false;
|
||
|
||
oLastTemp.IncreasePosition(); // get base content
|
||
if (oLastTemp.GetText() === " " || oLastTemp.GetText() === '') // not space
|
||
return false;
|
||
|
||
let oMathContentTemp = AscFormat.ExecuteNoHistory(
|
||
function (oRuleLast)
|
||
{
|
||
let oMathCopy = this.oCMathContent.Copy();
|
||
|
||
let oParamsCutContent = {
|
||
oDelMark : oRuleLast,
|
||
oEndDelMark : GetEndCurPos(oRuleLast),
|
||
isDelLastSpace : true
|
||
};
|
||
let oMathContent = CutContentFromEnd(oMathCopy, oParamsCutContent);
|
||
|
||
GetConvertContent(0, oMathContent, oMathCopy);
|
||
oMathCopy.Correct_Content(true);
|
||
|
||
return oMathCopy;
|
||
},
|
||
this,
|
||
[oStartPos]
|
||
);
|
||
|
||
if (!this.CompareMathContent(oMathContentTemp))
|
||
{
|
||
let oParamsCutContent = {
|
||
oDelMark : oStartPos,
|
||
oEndDelMark : GetEndCurPos(oStartPos),
|
||
isDelLastSpace : true
|
||
};
|
||
|
||
let oMathContent = CutContentFromEnd(this.oCMathContent, oParamsCutContent);
|
||
|
||
GetConvertContent(0, oMathContent, this.oCMathContent);
|
||
this.SetCursorByConvertedData(this.oCMathContent);
|
||
return true
|
||
}
|
||
|
||
return false
|
||
}
|
||
function GetEndCurPos(oPos)
|
||
{
|
||
let oNewPos = oPos.GetCopy();
|
||
oNewPos.IncreasePositionToCurPos();
|
||
return oNewPos;
|
||
}
|
||
|
||
/**
|
||
* Deletes letters at the given position
|
||
* @param {CMathContent} oContent - Content that will proceed.
|
||
* @param {oParamsCutContent} oParamsCutContent - Setting of CutContentFromEnd.
|
||
* @param {PositionIsCMathContent} oParamsCutContent.oDelMark Deleting start position.
|
||
* @param {PositionIsCMathContent} oParamsCutContent.oEndDelMark Deleting end position.
|
||
* @param {boolean} [oParamsCutContent.isCopy] If we don't want change original content, copy it.
|
||
* @param {boolean} [oParamsCutContent.isWrapFirstContent] Is need to wrap custom block (CFraction, CDelimiter, CDegree, CMatrix e.g.) with 〖〗 brackets.
|
||
* @param {int} [oParamsCutContent.nTypeOfTrigger] Type of trigger for autocorrection
|
||
* @param {boolean} [oParamsCutContent.isDelLastSpace] Is need delete last space
|
||
* @param {boolean} [oParamsCutContent.isDelStartSpace] Is need delete first space
|
||
*/
|
||
function CutContentFromEnd(oContent, oParamsCutContent)
|
||
{
|
||
let oDelMark = oParamsCutContent.oDelMark;
|
||
let oEndDelMark = oParamsCutContent.oEndDelMark;
|
||
let isCopy = oParamsCutContent.isCopy;
|
||
let isWrapFirstContent = oParamsCutContent.isWrapFirstContent;
|
||
let nTypeOfTrigger = oParamsCutContent.nTypeOfTrigger;
|
||
let isDelLastSpace = oParamsCutContent.isDelLastSpace;
|
||
let isDelStartSpace = oParamsCutContent.isDelStartSpace;
|
||
|
||
if (isCopy === true)
|
||
oContent = oContent.Copy();
|
||
|
||
let intMathContent = oDelMark.GetMathPos();
|
||
let intRunContent = oDelMark.GetPosition();
|
||
|
||
let nEndMathContent = oEndDelMark.GetMathPos();
|
||
let nEndRunContent = oEndDelMark.GetPosition();
|
||
|
||
let oMathTextAndStyles = new MathTextAndStyles(false);
|
||
|
||
for (let nPosCMathContent = intMathContent; nPosCMathContent < oContent.Content.length && nPosCMathContent <= nEndMathContent; nPosCMathContent++)
|
||
{
|
||
let oCurrentElement = oContent.Content[nPosCMathContent];
|
||
|
||
if (oCurrentElement.Type === 49)
|
||
{
|
||
if (oCurrentElement.Content.length > 0)
|
||
{
|
||
if (intMathContent === nPosCMathContent && nPosCMathContent === nEndMathContent)
|
||
{
|
||
let isContentAfter = (nEndRunContent - intRunContent) < oCurrentElement.Content.length
|
||
&& intRunContent === 0;
|
||
|
||
for (let nRunPos = intRunContent; nRunPos < nEndRunContent; nRunPos++)
|
||
{
|
||
let oEl = oCurrentElement.Content[nRunPos];
|
||
if (oEl)
|
||
oEl.GetTextOfElement(oMathTextAndStyles);
|
||
}
|
||
|
||
oCurrentElement.State.ContentPos -= nEndRunContent - intRunContent;
|
||
oCurrentElement.State.ContentPos = Math.max(0, oCurrentElement.State.ContentPos);
|
||
oCurrentElement.Remove_FromContent(intRunContent, nEndRunContent - intRunContent, false);
|
||
|
||
if (oCurrentElement.Content.length === 0)
|
||
{
|
||
oContent.Remove_FromContent(nPosCMathContent, 1);
|
||
nPosCMathContent--;
|
||
nEndMathContent--;
|
||
}
|
||
|
||
if (!isContentAfter && nEndRunContent - intRunContent > 1)
|
||
{
|
||
oCurrentElement.Split2(intRunContent, oContent, nPosCMathContent);
|
||
oContent.CurPos = nPosCMathContent + 1;
|
||
continue;
|
||
}
|
||
|
||
oContent.CurPos = nPosCMathContent;
|
||
}
|
||
else if (nPosCMathContent === nEndMathContent)
|
||
{
|
||
for (let nRunPos = 0; nRunPos < nEndRunContent; nRunPos++)
|
||
{
|
||
let oEl = oCurrentElement.Content[nRunPos];
|
||
if (oEl)
|
||
oEl.GetTextOfElement(oMathTextAndStyles);
|
||
}
|
||
|
||
oCurrentElement.State.ContentPos = oCurrentElement.Content - 1;
|
||
oCurrentElement.Remove_FromContent(0, nEndRunContent, false);
|
||
oContent.CurPos = oContent.Content.length;
|
||
}
|
||
else if (nPosCMathContent === intMathContent)
|
||
{
|
||
for (let nRunPos = intRunContent; nRunPos < oCurrentElement.Content.length; nRunPos++)
|
||
{
|
||
let oEl = oCurrentElement.Content[nRunPos];
|
||
if (oEl)
|
||
oEl.GetTextOfElement(oMathTextAndStyles);
|
||
}
|
||
oCurrentElement.Remove_FromContent(intRunContent, oCurrentElement.Content.length - intRunContent, false);
|
||
|
||
if (oCurrentElement.Content.length === 0)
|
||
{
|
||
oContent.Remove_FromContent(nPosCMathContent, 1);
|
||
nPosCMathContent--;
|
||
nEndMathContent--;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
oCurrentElement.GetTextOfElement(oMathTextAndStyles);
|
||
oContent.Remove_FromContent(nPosCMathContent, 1);
|
||
nPosCMathContent--;
|
||
nEndMathContent--;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
oContent.Remove_FromContent(nPosCMathContent, 1);
|
||
nPosCMathContent--;
|
||
nEndMathContent--;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
let oMath = oMathTextAndStyles.AddContainer();
|
||
oCurrentElement.GetTextOfElement(oMath);
|
||
|
||
// При автокоррекции контент лучше оборачивать в спец. скобки,
|
||
// что бы не было поведения по типу CFraction 1/2"_x" -> CFraction 1/(2_x),
|
||
// а должно быть 1/2"_x" -> СDegree (1/2)_x
|
||
if (!(oCurrentElement instanceof CDelimiter))
|
||
{
|
||
let oFirstPos = oMath.Positions[0];
|
||
let oLastPos = oMath.Positions[oMath.Positions.length - 1];
|
||
oMath.AddBefore(oFirstPos, new MathText("〖", oContent));
|
||
oMath.AddAfter(oLastPos, new MathText("〗", oContent));
|
||
}
|
||
|
||
oContent.Remove_FromContent(nPosCMathContent, 1);
|
||
nPosCMathContent--;
|
||
nEndMathContent--;
|
||
}
|
||
}
|
||
|
||
if (isDelStartSpace)
|
||
oMathTextAndStyles.DelFirstSpace();
|
||
if (isDelLastSpace)
|
||
oMathTextAndStyles.DelLastSpace();
|
||
|
||
return oMathTextAndStyles;
|
||
}
|
||
/**
|
||
* Paste text at the given position
|
||
* @param {CMathContent} oContent - Content that will proceed.
|
||
* @param {PositionIsCMathContent} oPastePos - Paste position.
|
||
* @param {string} strText - Text to insert.
|
||
*/
|
||
function AddTextByPos(oContent, oPastePos, strText)
|
||
{
|
||
let intMathContent = oPastePos.GetMathPos();
|
||
let intRunContent = oPastePos.GetPosition();
|
||
let CurrentContent = oContent.Content[intMathContent];
|
||
|
||
for (let nCharPos = 0, nTextLen = strText.length; nCharPos < nTextLen; nCharPos++)
|
||
{
|
||
let oText = new CMathText(false);
|
||
oText.addTxt(strText[nCharPos]);
|
||
|
||
CurrentContent.private_AddItemToRun(intRunContent, oText);
|
||
intRunContent++;
|
||
}
|
||
}
|
||
function CheckFunctionOnCursor(oContent)
|
||
{
|
||
let oContentIterator = new CMathContentIterator(oContent);
|
||
let strWord = "";
|
||
let oTempPos;
|
||
|
||
while (oContentIterator.IsHasContent())
|
||
{
|
||
let strCurrentContent = oContentIterator.Next(true);
|
||
|
||
if (strCurrentContent === "_" || strCurrentContent === "^")
|
||
continue;
|
||
else if (strCurrentContent === false)
|
||
break;
|
||
|
||
strWord = strCurrentContent + strWord;
|
||
|
||
if (oMathAutoCorrection.arrFunctionsNames[strWord.trim()] === null)
|
||
{
|
||
let nTempRunCounter = oContentIterator._nParaRun;
|
||
let nTempRootIndex = oContentIterator._index;
|
||
let oLast = oContentIterator.NextCopy();
|
||
|
||
if (!oLast || GetTokenType(oLast, TokenSearch_Everything) !== 0)
|
||
{
|
||
oTempPos = new PositionIsCMathContent(
|
||
nTempRootIndex + 1,
|
||
nTempRunCounter + 1,
|
||
undefined,
|
||
oContentIterator._paraRun
|
||
);
|
||
}
|
||
}
|
||
else if (strCurrentContent === " ")
|
||
{
|
||
strWord = "";
|
||
}
|
||
}
|
||
|
||
if (oTempPos)
|
||
return oTempPos;
|
||
}
|
||
|
||
function ConvertBracketContent(oTokens, oCMathContent)
|
||
{
|
||
return ConvertBracket(oTokens, oCMathContent, true);
|
||
}
|
||
function ConvertBracket(oTokens, oCMathContent, isOnlyContent)
|
||
{
|
||
let arrBrackets = oTokens.Pairs;
|
||
|
||
if (arrBrackets.length === 0 || oTokens.NoPair.length > 0)
|
||
return false;
|
||
|
||
let oLastBracketBlock = arrBrackets[0];
|
||
let oPos = oLastBracketBlock[1];
|
||
|
||
// we don't need to convert the parenthesis block itself, only the content inside
|
||
if (isOnlyContent && oPos.type !== MathLiterals.specialBrac.id)
|
||
oPos.IncreasePosition();
|
||
|
||
let strConvertContent = CutContentFromEnd(oCMathContent, {oDelMark : oPos, oEndDelMark: GetEndCurPos(oPos)});
|
||
strConvertContent.DelLastSpace();
|
||
|
||
GetConvertContent(0, strConvertContent, oCMathContent);
|
||
return true;
|
||
}
|
||
function IsInBracket(oBracketPositions, oTokenPositions)
|
||
{
|
||
if (!oBracketPositions || !oTokenPositions)
|
||
return;
|
||
|
||
oTokenPositions.IsBetween(oBracketPositions[1], oBracketPositions[0]);
|
||
}
|
||
|
||
/**
|
||
* Token position and it's type
|
||
* @param {number} MathPos - Position in CMathContent
|
||
* @param {number }RunPos - Position in ParaRun
|
||
* @param {number }[type] - ID of type (MathLiterals[].id)
|
||
* @param {ParaRun.Content} [ref] - ContentOfParaRun
|
||
* @constructor
|
||
*/
|
||
function PositionIsCMathContent(MathPos, RunPos, type, ref)
|
||
{
|
||
this.position = [ MathPos, RunPos ];
|
||
this.ref = ref;
|
||
|
||
if (this.ref
|
||
&& this.ref.Content !== undefined
|
||
&& this.ref.Content !== null
|
||
&& this.ref.Content.length - 1 < RunPos
|
||
&& this.ref.Content.length > 0)
|
||
{
|
||
this.position[1] = this.ref.Content.length - 1;
|
||
}
|
||
|
||
/**
|
||
* Get position of token in CMathContent
|
||
* @returns {number}
|
||
*/
|
||
this.GetMathPos = function ()
|
||
{
|
||
return this.position[0]
|
||
};
|
||
/**
|
||
* Get position of token in ParaRun
|
||
* @returns {number}
|
||
*/
|
||
this.GetPosition = function ()
|
||
{
|
||
return this.position[1]
|
||
};
|
||
/**
|
||
* Get MathLiterals type of token
|
||
* @returns {number}
|
||
*/
|
||
this.GetType = function ()
|
||
{
|
||
return this.type
|
||
};
|
||
/**
|
||
* Get position of token in CMathContent
|
||
* @returns {boolean}
|
||
*/
|
||
this.IsEqualPosition = function (oPos)
|
||
{
|
||
return oPos.GetMathPos() === this.GetMathPos()
|
||
&& oPos.GetPosition() === this.GetPosition();
|
||
};
|
||
/**
|
||
* Check is pos is between (not include oStartPos and oEndPos) two another positions
|
||
* @returns {boolean}
|
||
*/
|
||
this.IsBetween = function (oStartPos, oEndPos)
|
||
{
|
||
if (!oStartPos || !oEndPos)
|
||
return false;
|
||
|
||
let MathPos = this.GetMathPos();
|
||
let ParaPos = this.GetPosition();
|
||
|
||
let StartMathPos = oStartPos.GetMathPos();
|
||
let StartParaPos = oStartPos.GetPosition();
|
||
|
||
if (MathPos >= StartMathPos && ParaPos > StartParaPos)
|
||
{
|
||
let EndMathPos = oEndPos.GetMathPos();
|
||
let EndParaPos = oEndPos.GetPosition();
|
||
|
||
if (MathPos < EndMathPos || (MathPos === EndMathPos && ParaPos < EndParaPos))
|
||
return true
|
||
}
|
||
|
||
return false;
|
||
};
|
||
/**
|
||
* Get text of token. Needs for debug
|
||
* @returns {string}
|
||
*/
|
||
this.GetText = function()
|
||
{
|
||
if (!this.ref || !this.ref.Content || this.ref.Content.length === 0)
|
||
return "";
|
||
|
||
let oCMathText = this.ref.Content[this.GetPosition()];
|
||
|
||
if (!oCMathText)
|
||
return "";
|
||
if (!oCMathText.value)
|
||
return "";
|
||
|
||
let strValue = String.fromCharCode(oCMathText.value);
|
||
return strValue;
|
||
};
|
||
/**
|
||
* Return copy of given PositionIsCMathContent with position, type and ref
|
||
* @returns {PositionIsCMathContent}
|
||
* @constructor
|
||
*/
|
||
this.GetCopy = function ()
|
||
{
|
||
return new PositionIsCMathContent(
|
||
this.GetMathPos(),
|
||
this.GetPosition(),
|
||
this.GetType(),
|
||
this.ref
|
||
);
|
||
};
|
||
this.IncreaseMathPos = function ()
|
||
{
|
||
if (!this.ref)
|
||
return false;
|
||
|
||
let CMathContent = this.ref.Parent;
|
||
|
||
if (CMathContent.Content.length > this.position[0] + 1)
|
||
{
|
||
this.position[0]++;
|
||
this.position[1] = 0;
|
||
this.ref = CMathContent.Content[this.position[0]];
|
||
return true;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
/**
|
||
* Increase ParaRun position by one, of need change CMathContent position
|
||
* @return {boolean}
|
||
*/
|
||
this.IncreasePosition = function()
|
||
{
|
||
if (!this.ref)
|
||
return false;
|
||
|
||
let CMathContent = this.ref.Parent;
|
||
|
||
if (this.GetPosition() > this.ref.Content.length)
|
||
{
|
||
if (CMathContent.Content.length - 1 < this.position[0] + 1)
|
||
return false;
|
||
|
||
this.position[0]++;
|
||
this.position[1] = 0
|
||
|
||
this.ref = CMathContent.Content[this.position[0]];
|
||
}
|
||
else
|
||
{
|
||
this.position[1]++;
|
||
}
|
||
|
||
return true;
|
||
};
|
||
/**
|
||
* Decrease ParaRun position by one, of need change CMathContent position
|
||
* @return {boolean}
|
||
* @constructor
|
||
*/
|
||
this.DecreasePosition = function()
|
||
{
|
||
if (!this.ref)
|
||
return false;
|
||
|
||
if (this.position[0] === 0 && this.position[1] === 0)
|
||
return false;
|
||
|
||
if (!this.ref.Parent)
|
||
{
|
||
this.position[1]--;
|
||
this.type = GetTokenType(this.GetText(), TokenSearch_Everything)
|
||
return true;
|
||
}
|
||
|
||
let CMathContent = this.ref.Parent;
|
||
let arrContent = CMathContent.Content;
|
||
|
||
if (this.position[1] === 0)
|
||
{
|
||
if (this.position[0] - 1 >= 0)
|
||
this.position[0]--;
|
||
|
||
let nPrev = this.position[1]; // decrease pos in RunPos
|
||
|
||
if (arrContent[this.position[0]].Type === para_Math_Run)
|
||
{
|
||
this.position[1] = arrContent[this.position[0]].Content.length - 1;
|
||
this.ref = arrContent[this.position[0]].Content;
|
||
|
||
if (nPrev === this.position[1])
|
||
this.position[1] = arrContent[this.position[0] + 1].Content.length - 1;
|
||
|
||
this.type = GetTokenType(this.GetText(), TokenSearch_Everything);
|
||
return true;
|
||
}
|
||
else
|
||
return false
|
||
}
|
||
|
||
if (this.position[1] - 1 >= 0)
|
||
this.position[1]--;
|
||
|
||
this.type = GetTokenType(this.GetText(), TokenSearch_Everything)
|
||
return true;
|
||
};
|
||
this.IsRef = function ()
|
||
{
|
||
return this.ref && this.ref.Content.length > 0
|
||
}
|
||
this.IsSetPosition = function ()
|
||
{
|
||
return this.position[0] !== undefined && this.position[1] !== undefined
|
||
}
|
||
this.IncreasePositionToCurPos = function ()
|
||
{
|
||
if (this.ref)
|
||
{
|
||
if (this.ref.Parent && this.ref.Parent.CurPos !== this.GetMathPos())
|
||
{
|
||
let isNotBreak = true;
|
||
while (this.GetMathPos() < this.ref.Parent.CurPos && isNotBreak)
|
||
{
|
||
isNotBreak = this.IncreaseMathPos();
|
||
}
|
||
}
|
||
|
||
if (this.ref.State.ContentPos !== 0)
|
||
{
|
||
while (this.GetPosition() < this.ref.State.ContentPos)
|
||
{
|
||
this.IncreasePosition();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if (this.IsRef() && this.IsSetPosition() && type === undefined)
|
||
this.type = GetTokenType(this.GetText(), TokenSearch_Everything);
|
||
else
|
||
this.type = type;
|
||
}
|
||
|
||
function ParaRunIterator(ParaRun)
|
||
{
|
||
this.Content = ParaRun.Content;
|
||
this.Cursor = ParaRun.Content.length - 1;
|
||
}
|
||
ParaRunIterator.prototype.GetNext = function()
|
||
{
|
||
if (!this.IsHasContent())
|
||
return false;
|
||
|
||
const oContent = this.Content[this.Cursor];
|
||
this.Cursor--;
|
||
|
||
return String.fromCharCode(oContent.value);
|
||
};
|
||
ParaRunIterator.prototype.IsHasContent = function()
|
||
{
|
||
return this.Cursor >= 0;
|
||
};
|
||
|
||
/**
|
||
* Return token MathLiteral class
|
||
* @param {string} strToken - Token to proceed
|
||
* @param {array} arrTypes - Classes for search
|
||
* @returns {number|false} - ID of class in MathLiterals or false
|
||
*/
|
||
function GetTokenType(strToken, arrTypes)
|
||
{
|
||
if (strToken === "" || undefined === strToken)
|
||
return false;
|
||
|
||
for (let nCount = 0; nCount < arrTypes.length; nCount++)
|
||
{
|
||
let oCurrentType = arrTypes[nCount];
|
||
|
||
|
||
if (oCurrentType.SearchU(strToken))
|
||
return oCurrentType.id;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
function IsFunctionNameToken(arrContent, oCMathContent)
|
||
{
|
||
let oPos = [];
|
||
arrContent = arrContent.slice().reverse();
|
||
let oNames = oMathAutoCorrection.arrFunctionsNames;
|
||
let arrCurrent = [];
|
||
let str = "";
|
||
|
||
for (let nPos = 0; nPos < arrContent.length; nPos++)
|
||
{
|
||
let oCurrentEl = arrContent[nPos];
|
||
arrCurrent.push(oCurrentEl[0]);
|
||
|
||
str = arrCurrent.slice().reverse().join("");
|
||
if (oNames[str] === null)
|
||
{
|
||
oPos[0] = new PositionIsCMathContent(
|
||
oCurrentEl[1],
|
||
oCurrentEl[2],
|
||
MathLiterals.func.id,
|
||
oCMathContent
|
||
);
|
||
oPos[1] = str;
|
||
}
|
||
}
|
||
|
||
if (oPos.length !== 0)
|
||
{
|
||
return oPos;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
function IsLastFunc(oCMathContent)
|
||
{
|
||
let arr = [];
|
||
|
||
for (let nCount = oCMathContent.Content.length - 1; nCount >= 0; nCount--)
|
||
{
|
||
let oCMathElement = oCMathContent.Content[nCount];
|
||
|
||
if (oCMathElement.Type === 49 && oCMathElement.Content.length > 0)
|
||
{
|
||
for (let nParaCount = oCMathElement.Content.length - 1; nParaCount >= 0; nParaCount--)
|
||
{
|
||
let oCurrentTextElement = oCMathElement.Content[nParaCount].value;
|
||
let strContent = String.fromCharCode(oCurrentTextElement);
|
||
let intType = GetTokenType(strContent, [MathLiterals.char]);
|
||
arr.unshift([strContent, nCount, nParaCount]);
|
||
|
||
let oFunction = IsFunctionNameToken(arr, oCMathElement.Content);
|
||
let oFunc = oFunction[0];
|
||
let strFunc = oFunction[1];
|
||
|
||
if (oFunc)
|
||
{
|
||
if (strFunc.length === arr.length)
|
||
return arr[0];
|
||
}
|
||
else if (intType !== MathLiterals.char.id)
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
function GetInfo(oCMathContent, arrTypesForSearch)
|
||
{
|
||
let arrMathPositions = [];
|
||
|
||
for (let nCount = 0; nCount < oCMathContent.Content.length; nCount++)
|
||
{
|
||
if (nCount <= oCMathContent.CurPos)
|
||
{
|
||
let oCMathElement = oCMathContent.Content[nCount];
|
||
|
||
if (oCMathElement.Type === 49 && oCMathElement.Content.length > 0)
|
||
{
|
||
for (let nParaCount = 0; nParaCount < oCMathElement.Content.length; nParaCount++)
|
||
{
|
||
if (nCount !== oCMathContent.CurPos || nParaCount < oCMathElement.State.ContentPos)
|
||
{
|
||
let oCurrentTextElement = oCMathElement.Content[nParaCount].value;
|
||
let strContent = String.fromCharCode(oCurrentTextElement);
|
||
let intType = GetTokenType(strContent, arrTypesForSearch);
|
||
|
||
if (false !== intType)
|
||
{
|
||
let oNewCMathPos = new PositionIsCMathContent(
|
||
nCount,
|
||
nParaCount,
|
||
intType,
|
||
oCMathElement
|
||
);
|
||
|
||
arrMathPositions.push(oNewCMathPos);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return arrMathPositions
|
||
}
|
||
|
||
/**
|
||
* Get information about specific tokens types determined by arrTypesForSearch
|
||
* @param {CMathContent} oCMathContent - CMathContent to be searched
|
||
* @param {array} arrTypesForSearch - Array with objects from MathLiterals (MathLiterals.operator, MathLiterals.space, e.g.)
|
||
* @return {array}
|
||
*/
|
||
function GetInfoAboutCMathContent(oCMathContent, arrTypesForSearch)
|
||
{
|
||
const arrInfo = [];
|
||
const oContent = oCMathContent.Content;
|
||
|
||
for (let nCount = 0; nCount < oContent.length; nCount++)
|
||
{
|
||
if (oContent[nCount].Type === 49 && oContent[nCount].Content.length > 0)
|
||
{
|
||
arrInfo[nCount] = GetInfoFromParaRun(nCount, oContent[nCount], arrTypesForSearch);
|
||
}
|
||
}
|
||
|
||
return arrInfo;
|
||
}
|
||
/**
|
||
* Get information about specific tokens types determined by arrTypesForSearch
|
||
* @param {number} nPosInCMathContent - Position in CMathContent
|
||
* @param {ParaRun} oRun - ParaRun to be searched
|
||
* @param {array} arrTypesForSearch - Array with objects from MathLiterals (MathLiterals.operator, MathLiterals.space, e.g.)
|
||
* @return {array}
|
||
*/
|
||
function GetInfoFromParaRun(nPosInCMathContent, oRun, arrTypesForSearch)
|
||
{
|
||
const arrBracketsInfo = [];
|
||
const arrContent = [];
|
||
const oContent = oRun.Content;
|
||
|
||
for (let nCounter = 0; nCounter < oContent.length; nCounter++)
|
||
{
|
||
let CurrentElement = oContent[nCounter].value;
|
||
let strContent = String.fromCharCode(CurrentElement);
|
||
let intType = null;
|
||
|
||
intType = GetTokenType(strContent, arrTypesForSearch);
|
||
arrContent.push(strContent);
|
||
|
||
let oFunc = IsFunctionNameToken(arrContent, nPosInCMathContent, nCounter);
|
||
let nCopyCounter = nCounter;
|
||
|
||
if (oFunc)
|
||
{
|
||
intType = MathLiterals.func.id;
|
||
nCopyCounter = nCounter - (arrContent.length - 1);
|
||
}
|
||
|
||
if (false !== intType)
|
||
{
|
||
let oNewCMathPos = new PositionIsCMathContent(nPosInCMathContent, nCopyCounter, intType, oRun.Content);
|
||
arrBracketsInfo.push(oNewCMathPos);
|
||
}
|
||
};
|
||
|
||
return arrBracketsInfo;
|
||
}
|
||
|
||
let IsAllowAutoConvertion = true;
|
||
function SetAutoConvertation(isConvert)
|
||
{
|
||
IsAllowAutoConvertion = isConvert;
|
||
}
|
||
function GetAutoConvertation()
|
||
{
|
||
return IsAllowAutoConvertion;
|
||
}
|
||
//--------------------------------------------------------export----------------------------------------------------
|
||
window["AscMath"] = window["AscMath"] || {};
|
||
window["AscMath"].oNamesOfLiterals = oNamesOfLiterals;
|
||
window["AscMath"].ConvertTokens = ConvertTokens;
|
||
window["AscMath"].Tokenizer = Tokenizer;
|
||
window["AscMath"].UnicodeSpecialScript = UnicodeSpecialScript;
|
||
window["AscMath"].LimitFunctions = limitFunctions;
|
||
window["AscMath"].functionNames = functionNames;
|
||
window["AscMath"].GetMathFontChar = GetMathFontChar;
|
||
window["AscMath"].AutoCorrection = AutoCorrection;
|
||
window["AscMath"].CorrectWordOnCursor = CorrectWordOnCursor;
|
||
window["AscMath"].CorrectAllWords = CorrectAllWords;
|
||
window["AscMath"].CorrectAllSpecialWords = CorrectAllSpecialWords;
|
||
window["AscMath"].CorrectSpecialWordOnCursor = CorrectSpecialWordOnCursor;
|
||
window["AscMath"].GetConvertContent = GetConvertContent;
|
||
window["AscMath"].MathLiterals = MathLiterals;
|
||
window["AscMath"].SymbolsToLaTeX = SymbolsToLaTeX;
|
||
window["AscMath"].UpdateAutoCorrection = UpdateAutoCorrection;
|
||
window["AscMath"].GetLaTeXFromValue = GetLaTeXFromValue;
|
||
window["AscMath"].SetIsLaTeXGetParaRun = SetIsLaTeXGetParaRun;
|
||
window["AscMath"].GetIsLaTeXGetParaRun = GetIsLaTeXGetParaRun;
|
||
window["AscMath"].GetFractionType = GetFractionType;
|
||
window["AscMath"].UpdateFuncCorrection = UpdateFuncCorrection;
|
||
window["AscMath"].MathStructures = MathStructures;
|
||
window["AscMath"].MathText = MathText;
|
||
window["AscMath"].MathTextAdditionalData = MathTextAdditionalData;
|
||
window["AscMath"].ConvertMathTextToText = ConvertMathTextToText;
|
||
window["AscMath"].GetOnlyText = GetOnlyText;
|
||
window["AscMath"].ContentWithStylesIterator = ContentWithStylesIterator;
|
||
window["AscMath"].MathTextAndStyles = MathTextAndStyles;
|
||
window["AscMath"].GetAutoConvertation = GetAutoConvertation;
|
||
window["AscMath"].SetAutoConvertation = SetAutoConvertation;
|
||
window["AscMath"].StartAutoCorrectionMath = StartAutoCorrectionMath;
|
||
window["AscMath"].GetLaTeXFont = GetLaTeXFont;
|
||
window["AscMath"].GetNamesTypeFontLaTeX = GetNamesTypeFontLaTeX;
|
||
window["AscMath"].oStandardFont = oStandardFont;
|
||
window["AscMath"].GetTypeFont = GetTypeFont;
|
||
window["AscMath"].ConvertWord = ConvertWord;
|
||
window["AscMath"].SetIsAllowAutoCorrect = SetIsAllowAutoCorrect;
|
||
window["AscMath"].GetIsAllowAutoCorrect = GetIsAllowAutoCorrect;
|
||
window["AscMath"].MathMetaData = MathMetaData;
|
||
})(window);
|