add initial marp implementation with sample content and build configuration
This commit is contained in:
34
node_modules/mathjax-full/js/input/tex/AllPackages.d.ts
generated
vendored
Normal file
34
node_modules/mathjax-full/js/input/tex/AllPackages.d.ts
generated
vendored
Normal file
@@ -0,0 +1,34 @@
|
||||
import './base/BaseConfiguration.js';
|
||||
import './action/ActionConfiguration.js';
|
||||
import './ams/AmsConfiguration.js';
|
||||
import './amscd/AmsCdConfiguration.js';
|
||||
import './bbox/BboxConfiguration.js';
|
||||
import './boldsymbol/BoldsymbolConfiguration.js';
|
||||
import './braket/BraketConfiguration.js';
|
||||
import './bussproofs/BussproofsConfiguration.js';
|
||||
import './cancel/CancelConfiguration.js';
|
||||
import './cases/CasesConfiguration.js';
|
||||
import './centernot/CenternotConfiguration.js';
|
||||
import './color/ColorConfiguration.js';
|
||||
import './colorv2/ColorV2Configuration.js';
|
||||
import './colortbl/ColortblConfiguration.js';
|
||||
import './configmacros/ConfigMacrosConfiguration.js';
|
||||
import './empheq/EmpheqConfiguration.js';
|
||||
import './enclose/EncloseConfiguration.js';
|
||||
import './extpfeil/ExtpfeilConfiguration.js';
|
||||
import './gensymb/GensymbConfiguration.js';
|
||||
import './html/HtmlConfiguration.js';
|
||||
import './mathtools/MathtoolsConfiguration.js';
|
||||
import './mhchem/MhchemConfiguration.js';
|
||||
import './newcommand/NewcommandConfiguration.js';
|
||||
import './noerrors/NoErrorsConfiguration.js';
|
||||
import './noundefined/NoUndefinedConfiguration.js';
|
||||
import './physics/PhysicsConfiguration.js';
|
||||
import './setoptions/SetOptionsConfiguration.js';
|
||||
import './tagformat/TagFormatConfiguration.js';
|
||||
import './textcomp/TextcompConfiguration.js';
|
||||
import './textmacros/TextMacrosConfiguration.js';
|
||||
import './upgreek/UpgreekConfiguration.js';
|
||||
import './unicode/UnicodeConfiguration.js';
|
||||
import './verb/VerbConfiguration.js';
|
||||
export declare const AllPackages: string[];
|
||||
72
node_modules/mathjax-full/js/input/tex/AllPackages.js
generated
vendored
Normal file
72
node_modules/mathjax-full/js/input/tex/AllPackages.js
generated
vendored
Normal file
@@ -0,0 +1,72 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.AllPackages = void 0;
|
||||
require("./base/BaseConfiguration.js");
|
||||
require("./action/ActionConfiguration.js");
|
||||
require("./ams/AmsConfiguration.js");
|
||||
require("./amscd/AmsCdConfiguration.js");
|
||||
require("./bbox/BboxConfiguration.js");
|
||||
require("./boldsymbol/BoldsymbolConfiguration.js");
|
||||
require("./braket/BraketConfiguration.js");
|
||||
require("./bussproofs/BussproofsConfiguration.js");
|
||||
require("./cancel/CancelConfiguration.js");
|
||||
require("./cases/CasesConfiguration.js");
|
||||
require("./centernot/CenternotConfiguration.js");
|
||||
require("./color/ColorConfiguration.js");
|
||||
require("./colorv2/ColorV2Configuration.js");
|
||||
require("./colortbl/ColortblConfiguration.js");
|
||||
require("./configmacros/ConfigMacrosConfiguration.js");
|
||||
require("./empheq/EmpheqConfiguration.js");
|
||||
require("./enclose/EncloseConfiguration.js");
|
||||
require("./extpfeil/ExtpfeilConfiguration.js");
|
||||
require("./gensymb/GensymbConfiguration.js");
|
||||
require("./html/HtmlConfiguration.js");
|
||||
require("./mathtools/MathtoolsConfiguration.js");
|
||||
require("./mhchem/MhchemConfiguration.js");
|
||||
require("./newcommand/NewcommandConfiguration.js");
|
||||
require("./noerrors/NoErrorsConfiguration.js");
|
||||
require("./noundefined/NoUndefinedConfiguration.js");
|
||||
require("./physics/PhysicsConfiguration.js");
|
||||
require("./setoptions/SetOptionsConfiguration.js");
|
||||
require("./tagformat/TagFormatConfiguration.js");
|
||||
require("./textcomp/TextcompConfiguration.js");
|
||||
require("./textmacros/TextMacrosConfiguration.js");
|
||||
require("./upgreek/UpgreekConfiguration.js");
|
||||
require("./unicode/UnicodeConfiguration.js");
|
||||
require("./verb/VerbConfiguration.js");
|
||||
if (typeof MathJax !== 'undefined' && MathJax.loader) {
|
||||
MathJax.loader.preLoad('[tex]/action', '[tex]/ams', '[tex]/amscd', '[tex]/bbox', '[tex]/boldsymbol', '[tex]/braket', '[tex]/bussproofs', '[tex]/cancel', '[tex]/cases', '[tex]/centernot', '[tex]/color', '[tex]/colorv2', '[tex]/colortbl', '[tex]/empheq', '[tex]/enclose', '[tex]/extpfeil', '[tex]/gensymb', '[tex]/html', '[tex]/mathtools', '[tex]/mhchem', '[tex]/newcommand', '[tex]/noerrors', '[tex]/noundefined', '[tex]/physics', '[tex]/upgreek', '[tex]/unicode', '[tex]/verb', '[tex]/configmacros', '[tex]/tagformat', '[tex]/textcomp', '[tex]/textmacros', '[tex]/setoptions');
|
||||
}
|
||||
exports.AllPackages = [
|
||||
'base',
|
||||
'action',
|
||||
'ams',
|
||||
'amscd',
|
||||
'bbox',
|
||||
'boldsymbol',
|
||||
'braket',
|
||||
'bussproofs',
|
||||
'cancel',
|
||||
'cases',
|
||||
'centernot',
|
||||
'color',
|
||||
'colortbl',
|
||||
'empheq',
|
||||
'enclose',
|
||||
'extpfeil',
|
||||
'gensymb',
|
||||
'html',
|
||||
'mathtools',
|
||||
'mhchem',
|
||||
'newcommand',
|
||||
'noerrors',
|
||||
'noundefined',
|
||||
'upgreek',
|
||||
'unicode',
|
||||
'verb',
|
||||
'configmacros',
|
||||
'tagformat',
|
||||
'textcomp',
|
||||
'textmacros'
|
||||
];
|
||||
//# sourceMappingURL=AllPackages.js.map
|
||||
1
node_modules/mathjax-full/js/input/tex/AllPackages.js.map
generated
vendored
Normal file
1
node_modules/mathjax-full/js/input/tex/AllPackages.js.map
generated
vendored
Normal file
@@ -0,0 +1 @@
|
||||
{"version":3,"file":"AllPackages.js","sourceRoot":"","sources":["../../../ts/input/tex/AllPackages.ts"],"names":[],"mappings":";;;AAuBA,uCAAqC;AACrC,2CAAyC;AACzC,qCAAmC;AACnC,yCAAuC;AACvC,uCAAqC;AACrC,mDAAiD;AACjD,2CAAyC;AACzC,mDAAiD;AACjD,2CAAyC;AACzC,yCAAuC;AACvC,iDAA+C;AAC/C,yCAAuC;AACvC,6CAA2C;AAC3C,+CAA6C;AAC7C,uDAAqD;AACrD,2CAAyC;AACzC,6CAA2C;AAC3C,+CAA6C;AAC7C,6CAA2C;AAC3C,uCAAqC;AACrC,iDAA+C;AAC/C,2CAAyC;AACzC,mDAAiD;AACjD,+CAA6C;AAC7C,qDAAmD;AACnD,6CAA2C;AAC3C,mDAAiD;AACjD,iDAA+C;AAC/C,+CAA6C;AAC7C,mDAAiD;AACjD,6CAA2C;AAC3C,6CAA2C;AAC3C,uCAAqC;AAGrC,IAAI,OAAO,OAAO,KAAK,WAAW,IAAI,OAAO,CAAC,MAAM,EAAE;IACpD,OAAO,CAAC,MAAM,CAAC,OAAO,CACpB,cAAc,EACd,WAAW,EACX,aAAa,EACb,YAAY,EACZ,kBAAkB,EAClB,cAAc,EACd,kBAAkB,EAClB,cAAc,EACd,aAAa,EACb,iBAAiB,EACjB,aAAa,EACb,eAAe,EACf,gBAAgB,EAChB,cAAc,EACd,eAAe,EACf,gBAAgB,EAChB,eAAe,EACf,YAAY,EACZ,iBAAiB,EACjB,cAAc,EACd,kBAAkB,EAClB,gBAAgB,EAChB,mBAAmB,EACnB,eAAe,EACf,eAAe,EACf,eAAe,EACf,YAAY,EACZ,oBAAoB,EACpB,iBAAiB,EACjB,gBAAgB,EAChB,kBAAkB,EAClB,kBAAkB,CACnB,CAAC;CACH;AAEY,QAAA,WAAW,GAAa;IACnC,MAAM;IACN,QAAQ;IACR,KAAK;IACL,OAAO;IACP,MAAM;IACN,YAAY;IACZ,QAAQ;IACR,YAAY;IACZ,QAAQ;IACR,OAAO;IACP,WAAW;IACX,OAAO;IACP,UAAU;IACV,QAAQ;IACR,SAAS;IACT,UAAU;IACV,SAAS;IACT,MAAM;IACN,WAAW;IACX,QAAQ;IACR,YAAY;IACZ,UAAU;IACV,aAAa;IACb,SAAS;IACT,SAAS;IACT,MAAM;IACN,cAAc;IACd,WAAW;IACX,UAAU;IACV,YAAY;CACb,CAAC"}
|
||||
99
node_modules/mathjax-full/js/input/tex/Configuration.d.ts
generated
vendored
Normal file
99
node_modules/mathjax-full/js/input/tex/Configuration.d.ts
generated
vendored
Normal file
@@ -0,0 +1,99 @@
|
||||
import { HandlerConfig, FallbackConfig } from './MapHandler.js';
|
||||
import { StackItemClass } from './StackItem.js';
|
||||
import { TagsClass } from './Tags.js';
|
||||
import { OptionList } from '../../util/Options.js';
|
||||
import { SubHandlers } from './MapHandler.js';
|
||||
import { FunctionList } from '../../util/FunctionList.js';
|
||||
import { TeX } from '../tex.js';
|
||||
import { PrioritizedList } from '../../util/PrioritizedList.js';
|
||||
export declare type StackItemConfig = {
|
||||
[kind: string]: StackItemClass;
|
||||
};
|
||||
export declare type TagsConfig = {
|
||||
[kind: string]: TagsClass;
|
||||
};
|
||||
export declare type Processor<T> = [T, number];
|
||||
export declare type ProtoProcessor<T> = Processor<T> | T;
|
||||
export declare type ProcessorList = Processor<Function>[];
|
||||
export declare type ConfigMethod = (c: ParserConfiguration, j: TeX<any, any, any>) => void;
|
||||
export declare type InitMethod = (c: ParserConfiguration) => void;
|
||||
export declare class Configuration {
|
||||
readonly name: string;
|
||||
readonly handler: HandlerConfig;
|
||||
readonly fallback: FallbackConfig;
|
||||
readonly items: StackItemConfig;
|
||||
readonly tags: TagsConfig;
|
||||
readonly options: OptionList;
|
||||
readonly nodes: {
|
||||
[key: string]: any;
|
||||
};
|
||||
readonly preprocessors: ProcessorList;
|
||||
readonly postprocessors: ProcessorList;
|
||||
readonly initMethod: Processor<InitMethod>;
|
||||
readonly configMethod: Processor<ConfigMethod>;
|
||||
priority: number;
|
||||
readonly parser: string;
|
||||
private static makeProcessor;
|
||||
private static _create;
|
||||
static create(name: string, config?: {
|
||||
handler?: HandlerConfig;
|
||||
fallback?: FallbackConfig;
|
||||
items?: StackItemConfig;
|
||||
tags?: TagsConfig;
|
||||
options?: OptionList;
|
||||
nodes?: {
|
||||
[key: string]: any;
|
||||
};
|
||||
preprocessors?: ProtoProcessor<Function>[];
|
||||
postprocessors?: ProtoProcessor<Function>[];
|
||||
init?: ProtoProcessor<InitMethod>;
|
||||
config?: ProtoProcessor<ConfigMethod>;
|
||||
priority?: number;
|
||||
parser?: string;
|
||||
}): Configuration;
|
||||
static local(config?: {
|
||||
handler?: HandlerConfig;
|
||||
fallback?: FallbackConfig;
|
||||
items?: StackItemConfig;
|
||||
tags?: TagsConfig;
|
||||
options?: OptionList;
|
||||
nodes?: {
|
||||
[key: string]: any;
|
||||
};
|
||||
preprocessors?: ProtoProcessor<Function>[];
|
||||
postprocessors?: ProtoProcessor<Function>[];
|
||||
init?: ProtoProcessor<InitMethod>;
|
||||
config?: ProtoProcessor<ConfigMethod>;
|
||||
priority?: number;
|
||||
parser?: string;
|
||||
}): Configuration;
|
||||
private constructor();
|
||||
get init(): InitMethod;
|
||||
get config(): ConfigMethod;
|
||||
}
|
||||
export declare namespace ConfigurationHandler {
|
||||
let set: (name: string, map: Configuration) => void;
|
||||
let get: (name: string) => Configuration;
|
||||
let keys: () => IterableIterator<string>;
|
||||
}
|
||||
export declare class ParserConfiguration {
|
||||
protected initMethod: FunctionList;
|
||||
protected configMethod: FunctionList;
|
||||
protected configurations: PrioritizedList<Configuration>;
|
||||
protected parsers: string[];
|
||||
handlers: SubHandlers;
|
||||
items: StackItemConfig;
|
||||
tags: TagsConfig;
|
||||
options: OptionList;
|
||||
nodes: {
|
||||
[key: string]: any;
|
||||
};
|
||||
constructor(packages: (string | [string, number])[], parsers?: string[]);
|
||||
init(): void;
|
||||
config(jax: TeX<any, any, any>): void;
|
||||
addPackage(pkg: (string | [string, number])): void;
|
||||
add(name: string, jax: TeX<any, any, any>, options?: OptionList): void;
|
||||
protected getPackage(name: string): Configuration;
|
||||
append(config: Configuration, priority?: number): void;
|
||||
private addFilters;
|
||||
}
|
||||
266
node_modules/mathjax-full/js/input/tex/Configuration.js
generated
vendored
Normal file
266
node_modules/mathjax-full/js/input/tex/Configuration.js
generated
vendored
Normal file
@@ -0,0 +1,266 @@
|
||||
"use strict";
|
||||
var __values = (this && this.__values) || function(o) {
|
||||
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
|
||||
if (m) return m.call(o);
|
||||
if (o && typeof o.length === "number") return {
|
||||
next: function () {
|
||||
if (o && i >= o.length) o = void 0;
|
||||
return { value: o && o[i++], done: !o };
|
||||
}
|
||||
};
|
||||
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
|
||||
};
|
||||
var __read = (this && this.__read) || function (o, n) {
|
||||
var m = typeof Symbol === "function" && o[Symbol.iterator];
|
||||
if (!m) return o;
|
||||
var i = m.call(o), r, ar = [], e;
|
||||
try {
|
||||
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
|
||||
}
|
||||
catch (error) { e = { error: error }; }
|
||||
finally {
|
||||
try {
|
||||
if (r && !r.done && (m = i["return"])) m.call(i);
|
||||
}
|
||||
finally { if (e) throw e.error; }
|
||||
}
|
||||
return ar;
|
||||
};
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.ParserConfiguration = exports.ConfigurationHandler = exports.Configuration = void 0;
|
||||
var Options_js_1 = require("../../util/Options.js");
|
||||
var MapHandler_js_1 = require("./MapHandler.js");
|
||||
var FunctionList_js_1 = require("../../util/FunctionList.js");
|
||||
var PrioritizedList_js_1 = require("../../util/PrioritizedList.js");
|
||||
var Tags_js_1 = require("./Tags.js");
|
||||
var Configuration = (function () {
|
||||
function Configuration(name, handler, fallback, items, tags, options, nodes, preprocessors, postprocessors, initMethod, configMethod, priority, parser) {
|
||||
if (handler === void 0) { handler = {}; }
|
||||
if (fallback === void 0) { fallback = {}; }
|
||||
if (items === void 0) { items = {}; }
|
||||
if (tags === void 0) { tags = {}; }
|
||||
if (options === void 0) { options = {}; }
|
||||
if (nodes === void 0) { nodes = {}; }
|
||||
if (preprocessors === void 0) { preprocessors = []; }
|
||||
if (postprocessors === void 0) { postprocessors = []; }
|
||||
if (initMethod === void 0) { initMethod = null; }
|
||||
if (configMethod === void 0) { configMethod = null; }
|
||||
this.name = name;
|
||||
this.handler = handler;
|
||||
this.fallback = fallback;
|
||||
this.items = items;
|
||||
this.tags = tags;
|
||||
this.options = options;
|
||||
this.nodes = nodes;
|
||||
this.preprocessors = preprocessors;
|
||||
this.postprocessors = postprocessors;
|
||||
this.initMethod = initMethod;
|
||||
this.configMethod = configMethod;
|
||||
this.priority = priority;
|
||||
this.parser = parser;
|
||||
this.handler = Object.assign({ character: [], delimiter: [], macro: [], environment: [] }, handler);
|
||||
}
|
||||
Configuration.makeProcessor = function (func, priority) {
|
||||
return Array.isArray(func) ? func : [func, priority];
|
||||
};
|
||||
Configuration._create = function (name, config) {
|
||||
var _this = this;
|
||||
if (config === void 0) { config = {}; }
|
||||
var priority = config.priority || PrioritizedList_js_1.PrioritizedList.DEFAULTPRIORITY;
|
||||
var init = config.init ? this.makeProcessor(config.init, priority) : null;
|
||||
var conf = config.config ? this.makeProcessor(config.config, priority) : null;
|
||||
var preprocessors = (config.preprocessors || []).map(function (pre) { return _this.makeProcessor(pre, priority); });
|
||||
var postprocessors = (config.postprocessors || []).map(function (post) { return _this.makeProcessor(post, priority); });
|
||||
var parser = config.parser || 'tex';
|
||||
return new Configuration(name, config.handler || {}, config.fallback || {}, config.items || {}, config.tags || {}, config.options || {}, config.nodes || {}, preprocessors, postprocessors, init, conf, priority, parser);
|
||||
};
|
||||
Configuration.create = function (name, config) {
|
||||
if (config === void 0) { config = {}; }
|
||||
var configuration = Configuration._create(name, config);
|
||||
ConfigurationHandler.set(name, configuration);
|
||||
return configuration;
|
||||
};
|
||||
Configuration.local = function (config) {
|
||||
if (config === void 0) { config = {}; }
|
||||
return Configuration._create('', config);
|
||||
};
|
||||
Object.defineProperty(Configuration.prototype, "init", {
|
||||
get: function () {
|
||||
return this.initMethod ? this.initMethod[0] : null;
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
Object.defineProperty(Configuration.prototype, "config", {
|
||||
get: function () {
|
||||
return this.configMethod ? this.configMethod[0] : null;
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
return Configuration;
|
||||
}());
|
||||
exports.Configuration = Configuration;
|
||||
var ConfigurationHandler;
|
||||
(function (ConfigurationHandler) {
|
||||
var maps = new Map();
|
||||
ConfigurationHandler.set = function (name, map) {
|
||||
maps.set(name, map);
|
||||
};
|
||||
ConfigurationHandler.get = function (name) {
|
||||
return maps.get(name);
|
||||
};
|
||||
ConfigurationHandler.keys = function () {
|
||||
return maps.keys();
|
||||
};
|
||||
})(ConfigurationHandler = exports.ConfigurationHandler || (exports.ConfigurationHandler = {}));
|
||||
var ParserConfiguration = (function () {
|
||||
function ParserConfiguration(packages, parsers) {
|
||||
var e_1, _a, e_2, _b;
|
||||
if (parsers === void 0) { parsers = ['tex']; }
|
||||
this.initMethod = new FunctionList_js_1.FunctionList();
|
||||
this.configMethod = new FunctionList_js_1.FunctionList();
|
||||
this.configurations = new PrioritizedList_js_1.PrioritizedList();
|
||||
this.parsers = [];
|
||||
this.handlers = new MapHandler_js_1.SubHandlers();
|
||||
this.items = {};
|
||||
this.tags = {};
|
||||
this.options = {};
|
||||
this.nodes = {};
|
||||
this.parsers = parsers;
|
||||
try {
|
||||
for (var _c = __values(packages.slice().reverse()), _d = _c.next(); !_d.done; _d = _c.next()) {
|
||||
var pkg = _d.value;
|
||||
this.addPackage(pkg);
|
||||
}
|
||||
}
|
||||
catch (e_1_1) { e_1 = { error: e_1_1 }; }
|
||||
finally {
|
||||
try {
|
||||
if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
|
||||
}
|
||||
finally { if (e_1) throw e_1.error; }
|
||||
}
|
||||
try {
|
||||
for (var _e = __values(this.configurations), _f = _e.next(); !_f.done; _f = _e.next()) {
|
||||
var _g = _f.value, config = _g.item, priority = _g.priority;
|
||||
this.append(config, priority);
|
||||
}
|
||||
}
|
||||
catch (e_2_1) { e_2 = { error: e_2_1 }; }
|
||||
finally {
|
||||
try {
|
||||
if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
|
||||
}
|
||||
finally { if (e_2) throw e_2.error; }
|
||||
}
|
||||
}
|
||||
ParserConfiguration.prototype.init = function () {
|
||||
this.initMethod.execute(this);
|
||||
};
|
||||
ParserConfiguration.prototype.config = function (jax) {
|
||||
var e_3, _a;
|
||||
this.configMethod.execute(this, jax);
|
||||
try {
|
||||
for (var _b = __values(this.configurations), _c = _b.next(); !_c.done; _c = _b.next()) {
|
||||
var config = _c.value;
|
||||
this.addFilters(jax, config.item);
|
||||
}
|
||||
}
|
||||
catch (e_3_1) { e_3 = { error: e_3_1 }; }
|
||||
finally {
|
||||
try {
|
||||
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
|
||||
}
|
||||
finally { if (e_3) throw e_3.error; }
|
||||
}
|
||||
};
|
||||
ParserConfiguration.prototype.addPackage = function (pkg) {
|
||||
var name = typeof pkg === 'string' ? pkg : pkg[0];
|
||||
var conf = this.getPackage(name);
|
||||
conf && this.configurations.add(conf, typeof pkg === 'string' ? conf.priority : pkg[1]);
|
||||
};
|
||||
ParserConfiguration.prototype.add = function (name, jax, options) {
|
||||
var e_4, _a;
|
||||
if (options === void 0) { options = {}; }
|
||||
var config = this.getPackage(name);
|
||||
this.append(config);
|
||||
this.configurations.add(config, config.priority);
|
||||
this.init();
|
||||
var parser = jax.parseOptions;
|
||||
parser.nodeFactory.setCreators(config.nodes);
|
||||
try {
|
||||
for (var _b = __values(Object.keys(config.items)), _c = _b.next(); !_c.done; _c = _b.next()) {
|
||||
var kind = _c.value;
|
||||
parser.itemFactory.setNodeClass(kind, config.items[kind]);
|
||||
}
|
||||
}
|
||||
catch (e_4_1) { e_4 = { error: e_4_1 }; }
|
||||
finally {
|
||||
try {
|
||||
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
|
||||
}
|
||||
finally { if (e_4) throw e_4.error; }
|
||||
}
|
||||
Tags_js_1.TagsFactory.addTags(config.tags);
|
||||
(0, Options_js_1.defaultOptions)(parser.options, config.options);
|
||||
(0, Options_js_1.userOptions)(parser.options, options);
|
||||
this.addFilters(jax, config);
|
||||
if (config.config) {
|
||||
config.config(this, jax);
|
||||
}
|
||||
};
|
||||
ParserConfiguration.prototype.getPackage = function (name) {
|
||||
var config = ConfigurationHandler.get(name);
|
||||
if (config && this.parsers.indexOf(config.parser) < 0) {
|
||||
throw Error("Package ".concat(name, " doesn't target the proper parser"));
|
||||
}
|
||||
return config;
|
||||
};
|
||||
ParserConfiguration.prototype.append = function (config, priority) {
|
||||
priority = priority || config.priority;
|
||||
if (config.initMethod) {
|
||||
this.initMethod.add(config.initMethod[0], config.initMethod[1]);
|
||||
}
|
||||
if (config.configMethod) {
|
||||
this.configMethod.add(config.configMethod[0], config.configMethod[1]);
|
||||
}
|
||||
this.handlers.add(config.handler, config.fallback, priority);
|
||||
Object.assign(this.items, config.items);
|
||||
Object.assign(this.tags, config.tags);
|
||||
(0, Options_js_1.defaultOptions)(this.options, config.options);
|
||||
Object.assign(this.nodes, config.nodes);
|
||||
};
|
||||
ParserConfiguration.prototype.addFilters = function (jax, config) {
|
||||
var e_5, _a, e_6, _b;
|
||||
try {
|
||||
for (var _c = __values(config.preprocessors), _d = _c.next(); !_d.done; _d = _c.next()) {
|
||||
var _e = __read(_d.value, 2), pre = _e[0], priority = _e[1];
|
||||
jax.preFilters.add(pre, priority);
|
||||
}
|
||||
}
|
||||
catch (e_5_1) { e_5 = { error: e_5_1 }; }
|
||||
finally {
|
||||
try {
|
||||
if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
|
||||
}
|
||||
finally { if (e_5) throw e_5.error; }
|
||||
}
|
||||
try {
|
||||
for (var _f = __values(config.postprocessors), _g = _f.next(); !_g.done; _g = _f.next()) {
|
||||
var _h = __read(_g.value, 2), post = _h[0], priority = _h[1];
|
||||
jax.postFilters.add(post, priority);
|
||||
}
|
||||
}
|
||||
catch (e_6_1) { e_6 = { error: e_6_1 }; }
|
||||
finally {
|
||||
try {
|
||||
if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
|
||||
}
|
||||
finally { if (e_6) throw e_6.error; }
|
||||
}
|
||||
};
|
||||
return ParserConfiguration;
|
||||
}());
|
||||
exports.ParserConfiguration = ParserConfiguration;
|
||||
//# sourceMappingURL=Configuration.js.map
|
||||
1
node_modules/mathjax-full/js/input/tex/Configuration.js.map
generated
vendored
Normal file
1
node_modules/mathjax-full/js/input/tex/Configuration.js.map
generated
vendored
Normal file
File diff suppressed because one or more lines are too long
25
node_modules/mathjax-full/js/input/tex/FilterUtil.d.ts
generated
vendored
Normal file
25
node_modules/mathjax-full/js/input/tex/FilterUtil.d.ts
generated
vendored
Normal file
@@ -0,0 +1,25 @@
|
||||
import ParseOptions from './ParseOptions.js';
|
||||
declare namespace FilterUtil {
|
||||
let cleanStretchy: (arg: {
|
||||
math: any;
|
||||
data: ParseOptions;
|
||||
}) => void;
|
||||
let cleanAttributes: (arg: {
|
||||
data: ParseOptions;
|
||||
}) => void;
|
||||
let combineRelations: (arg: {
|
||||
data: ParseOptions;
|
||||
}) => void;
|
||||
let cleanSubSup: (arg: {
|
||||
math: any;
|
||||
data: ParseOptions;
|
||||
}) => void;
|
||||
let moveLimits: (arg: {
|
||||
data: ParseOptions;
|
||||
}) => void;
|
||||
let setInherited: (arg: {
|
||||
math: any;
|
||||
data: ParseOptions;
|
||||
}) => void;
|
||||
}
|
||||
export default FilterUtil;
|
||||
269
node_modules/mathjax-full/js/input/tex/FilterUtil.js
generated
vendored
Normal file
269
node_modules/mathjax-full/js/input/tex/FilterUtil.js
generated
vendored
Normal file
@@ -0,0 +1,269 @@
|
||||
"use strict";
|
||||
var __values = (this && this.__values) || function(o) {
|
||||
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
|
||||
if (m) return m.call(o);
|
||||
if (o && typeof o.length === "number") return {
|
||||
next: function () {
|
||||
if (o && i >= o.length) o = void 0;
|
||||
return { value: o && o[i++], done: !o };
|
||||
}
|
||||
};
|
||||
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
|
||||
};
|
||||
var __importDefault = (this && this.__importDefault) || function (mod) {
|
||||
return (mod && mod.__esModule) ? mod : { "default": mod };
|
||||
};
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
var MmlNode_js_1 = require("../../core/MmlTree/MmlNode.js");
|
||||
var NodeUtil_js_1 = __importDefault(require("./NodeUtil.js"));
|
||||
var FilterUtil;
|
||||
(function (FilterUtil) {
|
||||
FilterUtil.cleanStretchy = function (arg) {
|
||||
var e_1, _a;
|
||||
var options = arg.data;
|
||||
try {
|
||||
for (var _b = __values(options.getList('fixStretchy')), _c = _b.next(); !_c.done; _c = _b.next()) {
|
||||
var mo = _c.value;
|
||||
if (NodeUtil_js_1.default.getProperty(mo, 'fixStretchy')) {
|
||||
var symbol = NodeUtil_js_1.default.getForm(mo);
|
||||
if (symbol && symbol[3] && symbol[3]['stretchy']) {
|
||||
NodeUtil_js_1.default.setAttribute(mo, 'stretchy', false);
|
||||
}
|
||||
var parent_1 = mo.parent;
|
||||
if (!NodeUtil_js_1.default.getTexClass(mo) && (!symbol || !symbol[2])) {
|
||||
var texAtom = options.nodeFactory.create('node', 'TeXAtom', [mo]);
|
||||
parent_1.replaceChild(texAtom, mo);
|
||||
texAtom.inheritAttributesFrom(mo);
|
||||
}
|
||||
NodeUtil_js_1.default.removeProperties(mo, 'fixStretchy');
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (e_1_1) { e_1 = { error: e_1_1 }; }
|
||||
finally {
|
||||
try {
|
||||
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
|
||||
}
|
||||
finally { if (e_1) throw e_1.error; }
|
||||
}
|
||||
};
|
||||
FilterUtil.cleanAttributes = function (arg) {
|
||||
var node = arg.data.root;
|
||||
node.walkTree(function (mml, _d) {
|
||||
var e_2, _a;
|
||||
var attribs = mml.attributes;
|
||||
if (!attribs) {
|
||||
return;
|
||||
}
|
||||
var keep = new Set((attribs.get('mjx-keep-attrs') || '').split(/ /));
|
||||
delete (attribs.getAllAttributes())['mjx-keep-attrs'];
|
||||
try {
|
||||
for (var _b = __values(attribs.getExplicitNames()), _c = _b.next(); !_c.done; _c = _b.next()) {
|
||||
var key = _c.value;
|
||||
if (!keep.has(key) && attribs.attributes[key] === mml.attributes.getInherited(key)) {
|
||||
delete attribs.attributes[key];
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (e_2_1) { e_2 = { error: e_2_1 }; }
|
||||
finally {
|
||||
try {
|
||||
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
|
||||
}
|
||||
finally { if (e_2) throw e_2.error; }
|
||||
}
|
||||
}, {});
|
||||
};
|
||||
FilterUtil.combineRelations = function (arg) {
|
||||
var e_3, _a, e_4, _b;
|
||||
var remove = [];
|
||||
try {
|
||||
for (var _c = __values(arg.data.getList('mo')), _e = _c.next(); !_e.done; _e = _c.next()) {
|
||||
var mo = _e.value;
|
||||
if (mo.getProperty('relationsCombined') || !mo.parent ||
|
||||
(mo.parent && !NodeUtil_js_1.default.isType(mo.parent, 'mrow')) ||
|
||||
NodeUtil_js_1.default.getTexClass(mo) !== MmlNode_js_1.TEXCLASS.REL) {
|
||||
continue;
|
||||
}
|
||||
var mml = mo.parent;
|
||||
var m2 = void 0;
|
||||
var children = mml.childNodes;
|
||||
var next = children.indexOf(mo) + 1;
|
||||
var variantForm = NodeUtil_js_1.default.getProperty(mo, 'variantForm');
|
||||
while (next < children.length && (m2 = children[next]) &&
|
||||
NodeUtil_js_1.default.isType(m2, 'mo') &&
|
||||
NodeUtil_js_1.default.getTexClass(m2) === MmlNode_js_1.TEXCLASS.REL) {
|
||||
if (variantForm === NodeUtil_js_1.default.getProperty(m2, 'variantForm') &&
|
||||
_compareExplicit(mo, m2)) {
|
||||
NodeUtil_js_1.default.appendChildren(mo, NodeUtil_js_1.default.getChildren(m2));
|
||||
_copyExplicit(['stretchy', 'rspace'], mo, m2);
|
||||
try {
|
||||
for (var _f = (e_4 = void 0, __values(m2.getPropertyNames())), _g = _f.next(); !_g.done; _g = _f.next()) {
|
||||
var name_1 = _g.value;
|
||||
mo.setProperty(name_1, m2.getProperty(name_1));
|
||||
}
|
||||
}
|
||||
catch (e_4_1) { e_4 = { error: e_4_1 }; }
|
||||
finally {
|
||||
try {
|
||||
if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
|
||||
}
|
||||
finally { if (e_4) throw e_4.error; }
|
||||
}
|
||||
children.splice(next, 1);
|
||||
remove.push(m2);
|
||||
m2.parent = null;
|
||||
m2.setProperty('relationsCombined', true);
|
||||
}
|
||||
else {
|
||||
if (mo.attributes.getExplicit('rspace') == null) {
|
||||
NodeUtil_js_1.default.setAttribute(mo, 'rspace', '0pt');
|
||||
}
|
||||
if (m2.attributes.getExplicit('lspace') == null) {
|
||||
NodeUtil_js_1.default.setAttribute(m2, 'lspace', '0pt');
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
mo.attributes.setInherited('form', mo.getForms()[0]);
|
||||
}
|
||||
}
|
||||
catch (e_3_1) { e_3 = { error: e_3_1 }; }
|
||||
finally {
|
||||
try {
|
||||
if (_e && !_e.done && (_a = _c.return)) _a.call(_c);
|
||||
}
|
||||
finally { if (e_3) throw e_3.error; }
|
||||
}
|
||||
arg.data.removeFromList('mo', remove);
|
||||
};
|
||||
var _copyExplicit = function (attrs, node1, node2) {
|
||||
var attr1 = node1.attributes;
|
||||
var attr2 = node2.attributes;
|
||||
attrs.forEach(function (x) {
|
||||
var attr = attr2.getExplicit(x);
|
||||
if (attr != null) {
|
||||
attr1.set(x, attr);
|
||||
}
|
||||
});
|
||||
};
|
||||
var _compareExplicit = function (node1, node2) {
|
||||
var e_5, _a;
|
||||
var filter = function (attr, space) {
|
||||
var exp = attr.getExplicitNames();
|
||||
return exp.filter(function (x) {
|
||||
return x !== space &&
|
||||
(x !== 'stretchy' ||
|
||||
attr.getExplicit('stretchy'));
|
||||
});
|
||||
};
|
||||
var attr1 = node1.attributes;
|
||||
var attr2 = node2.attributes;
|
||||
var exp1 = filter(attr1, 'lspace');
|
||||
var exp2 = filter(attr2, 'rspace');
|
||||
if (exp1.length !== exp2.length) {
|
||||
return false;
|
||||
}
|
||||
try {
|
||||
for (var exp1_1 = __values(exp1), exp1_1_1 = exp1_1.next(); !exp1_1_1.done; exp1_1_1 = exp1_1.next()) {
|
||||
var name_2 = exp1_1_1.value;
|
||||
if (attr1.getExplicit(name_2) !== attr2.getExplicit(name_2)) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (e_5_1) { e_5 = { error: e_5_1 }; }
|
||||
finally {
|
||||
try {
|
||||
if (exp1_1_1 && !exp1_1_1.done && (_a = exp1_1.return)) _a.call(exp1_1);
|
||||
}
|
||||
finally { if (e_5) throw e_5.error; }
|
||||
}
|
||||
return true;
|
||||
};
|
||||
var _cleanSubSup = function (options, low, up) {
|
||||
var e_6, _a;
|
||||
var remove = [];
|
||||
try {
|
||||
for (var _b = __values(options.getList('m' + low + up)), _c = _b.next(); !_c.done; _c = _b.next()) {
|
||||
var mml = _c.value;
|
||||
var children = mml.childNodes;
|
||||
if (children[mml[low]] && children[mml[up]]) {
|
||||
continue;
|
||||
}
|
||||
var parent_2 = mml.parent;
|
||||
var newNode = (children[mml[low]] ?
|
||||
options.nodeFactory.create('node', 'm' + low, [children[mml.base], children[mml[low]]]) :
|
||||
options.nodeFactory.create('node', 'm' + up, [children[mml.base], children[mml[up]]]));
|
||||
NodeUtil_js_1.default.copyAttributes(mml, newNode);
|
||||
if (parent_2) {
|
||||
parent_2.replaceChild(newNode, mml);
|
||||
}
|
||||
else {
|
||||
options.root = newNode;
|
||||
}
|
||||
remove.push(mml);
|
||||
}
|
||||
}
|
||||
catch (e_6_1) { e_6 = { error: e_6_1 }; }
|
||||
finally {
|
||||
try {
|
||||
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
|
||||
}
|
||||
finally { if (e_6) throw e_6.error; }
|
||||
}
|
||||
options.removeFromList('m' + low + up, remove);
|
||||
};
|
||||
FilterUtil.cleanSubSup = function (arg) {
|
||||
var options = arg.data;
|
||||
if (options.error) {
|
||||
return;
|
||||
}
|
||||
_cleanSubSup(options, 'sub', 'sup');
|
||||
_cleanSubSup(options, 'under', 'over');
|
||||
};
|
||||
var _moveLimits = function (options, underover, subsup) {
|
||||
var e_7, _a;
|
||||
var remove = [];
|
||||
try {
|
||||
for (var _b = __values(options.getList(underover)), _c = _b.next(); !_c.done; _c = _b.next()) {
|
||||
var mml = _c.value;
|
||||
if (mml.attributes.get('displaystyle')) {
|
||||
continue;
|
||||
}
|
||||
var base = mml.childNodes[mml.base];
|
||||
var mo = base.coreMO();
|
||||
if (base.getProperty('movablelimits') && !mo.attributes.getExplicit('movablelimits')) {
|
||||
var node = options.nodeFactory.create('node', subsup, mml.childNodes);
|
||||
NodeUtil_js_1.default.copyAttributes(mml, node);
|
||||
if (mml.parent) {
|
||||
mml.parent.replaceChild(node, mml);
|
||||
}
|
||||
else {
|
||||
options.root = node;
|
||||
}
|
||||
remove.push(mml);
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (e_7_1) { e_7 = { error: e_7_1 }; }
|
||||
finally {
|
||||
try {
|
||||
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
|
||||
}
|
||||
finally { if (e_7) throw e_7.error; }
|
||||
}
|
||||
options.removeFromList(underover, remove);
|
||||
};
|
||||
FilterUtil.moveLimits = function (arg) {
|
||||
var options = arg.data;
|
||||
_moveLimits(options, 'munderover', 'msubsup');
|
||||
_moveLimits(options, 'munder', 'msub');
|
||||
_moveLimits(options, 'mover', 'msup');
|
||||
};
|
||||
FilterUtil.setInherited = function (arg) {
|
||||
arg.data.root.setInheritedAttributes({}, arg.math['display'], 0, false);
|
||||
};
|
||||
})(FilterUtil || (FilterUtil = {}));
|
||||
exports.default = FilterUtil;
|
||||
//# sourceMappingURL=FilterUtil.js.map
|
||||
1
node_modules/mathjax-full/js/input/tex/FilterUtil.js.map
generated
vendored
Normal file
1
node_modules/mathjax-full/js/input/tex/FilterUtil.js.map
generated
vendored
Normal file
File diff suppressed because one or more lines are too long
22
node_modules/mathjax-full/js/input/tex/FindTeX.d.ts
generated
vendored
Normal file
22
node_modules/mathjax-full/js/input/tex/FindTeX.d.ts
generated
vendored
Normal file
@@ -0,0 +1,22 @@
|
||||
import { AbstractFindMath } from '../../core/FindMath.js';
|
||||
import { OptionList } from '../../util/Options.js';
|
||||
import { ProtoItem } from '../../core/MathItem.js';
|
||||
export declare type EndItem = [string, boolean, RegExp];
|
||||
export declare type Delims = [string, string];
|
||||
export declare class FindTeX<N, T, D> extends AbstractFindMath<N, T, D> {
|
||||
static OPTIONS: OptionList;
|
||||
protected start: RegExp;
|
||||
protected end: {
|
||||
[name: string]: EndItem;
|
||||
};
|
||||
protected hasPatterns: boolean;
|
||||
protected env: number;
|
||||
protected sub: number;
|
||||
constructor(options: OptionList);
|
||||
protected getPatterns(): void;
|
||||
protected addPattern(starts: string[], delims: Delims, display: boolean): void;
|
||||
protected endPattern(end: string, endp?: string): RegExp;
|
||||
protected findEnd(text: string, n: number, start: RegExpExecArray, end: EndItem): ProtoItem<N, T>;
|
||||
protected findMathInString(math: ProtoItem<N, T>[], n: number, text: string): void;
|
||||
findMath(strings: string[]): ProtoItem<N, T>[];
|
||||
}
|
||||
155
node_modules/mathjax-full/js/input/tex/FindTeX.js
generated
vendored
Normal file
155
node_modules/mathjax-full/js/input/tex/FindTeX.js
generated
vendored
Normal file
@@ -0,0 +1,155 @@
|
||||
"use strict";
|
||||
var __extends = (this && this.__extends) || (function () {
|
||||
var extendStatics = function (d, b) {
|
||||
extendStatics = Object.setPrototypeOf ||
|
||||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
||||
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
|
||||
return extendStatics(d, b);
|
||||
};
|
||||
return function (d, b) {
|
||||
if (typeof b !== "function" && b !== null)
|
||||
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
|
||||
extendStatics(d, b);
|
||||
function __() { this.constructor = d; }
|
||||
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
||||
};
|
||||
})();
|
||||
var __read = (this && this.__read) || function (o, n) {
|
||||
var m = typeof Symbol === "function" && o[Symbol.iterator];
|
||||
if (!m) return o;
|
||||
var i = m.call(o), r, ar = [], e;
|
||||
try {
|
||||
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
|
||||
}
|
||||
catch (error) { e = { error: error }; }
|
||||
finally {
|
||||
try {
|
||||
if (r && !r.done && (m = i["return"])) m.call(i);
|
||||
}
|
||||
finally { if (e) throw e.error; }
|
||||
}
|
||||
return ar;
|
||||
};
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.FindTeX = void 0;
|
||||
var FindMath_js_1 = require("../../core/FindMath.js");
|
||||
var string_js_1 = require("../../util/string.js");
|
||||
var MathItem_js_1 = require("../../core/MathItem.js");
|
||||
var FindTeX = (function (_super) {
|
||||
__extends(FindTeX, _super);
|
||||
function FindTeX(options) {
|
||||
var _this = _super.call(this, options) || this;
|
||||
_this.getPatterns();
|
||||
return _this;
|
||||
}
|
||||
FindTeX.prototype.getPatterns = function () {
|
||||
var _this = this;
|
||||
var options = this.options;
|
||||
var starts = [], parts = [], subparts = [];
|
||||
this.end = {};
|
||||
this.env = this.sub = 0;
|
||||
var i = 1;
|
||||
options['inlineMath'].forEach(function (delims) { return _this.addPattern(starts, delims, false); });
|
||||
options['displayMath'].forEach(function (delims) { return _this.addPattern(starts, delims, true); });
|
||||
if (starts.length) {
|
||||
parts.push(starts.sort(string_js_1.sortLength).join('|'));
|
||||
}
|
||||
if (options['processEnvironments']) {
|
||||
parts.push('\\\\begin\\s*\\{([^}]*)\\}');
|
||||
this.env = i;
|
||||
i++;
|
||||
}
|
||||
if (options['processEscapes']) {
|
||||
subparts.push('\\\\([\\\\$])');
|
||||
}
|
||||
if (options['processRefs']) {
|
||||
subparts.push('(\\\\(?:eq)?ref\\s*\\{[^}]*\\})');
|
||||
}
|
||||
if (subparts.length) {
|
||||
parts.push('(' + subparts.join('|') + ')');
|
||||
this.sub = i;
|
||||
}
|
||||
this.start = new RegExp(parts.join('|'), 'g');
|
||||
this.hasPatterns = (parts.length > 0);
|
||||
};
|
||||
FindTeX.prototype.addPattern = function (starts, delims, display) {
|
||||
var _a = __read(delims, 2), open = _a[0], close = _a[1];
|
||||
starts.push((0, string_js_1.quotePattern)(open));
|
||||
this.end[open] = [close, display, this.endPattern(close)];
|
||||
};
|
||||
FindTeX.prototype.endPattern = function (end, endp) {
|
||||
return new RegExp((endp || (0, string_js_1.quotePattern)(end)) + '|\\\\(?:[a-zA-Z]|.)|[{}]', 'g');
|
||||
};
|
||||
FindTeX.prototype.findEnd = function (text, n, start, end) {
|
||||
var _a = __read(end, 3), close = _a[0], display = _a[1], pattern = _a[2];
|
||||
var i = pattern.lastIndex = start.index + start[0].length;
|
||||
var match, braces = 0;
|
||||
while ((match = pattern.exec(text))) {
|
||||
if ((match[1] || match[0]) === close && braces === 0) {
|
||||
return (0, MathItem_js_1.protoItem)(start[0], text.substr(i, match.index - i), match[0], n, start.index, match.index + match[0].length, display);
|
||||
}
|
||||
else if (match[0] === '{') {
|
||||
braces++;
|
||||
}
|
||||
else if (match[0] === '}' && braces) {
|
||||
braces--;
|
||||
}
|
||||
}
|
||||
return null;
|
||||
};
|
||||
FindTeX.prototype.findMathInString = function (math, n, text) {
|
||||
var start, match;
|
||||
this.start.lastIndex = 0;
|
||||
while ((start = this.start.exec(text))) {
|
||||
if (start[this.env] !== undefined && this.env) {
|
||||
var end = '\\\\end\\s*(\\{' + (0, string_js_1.quotePattern)(start[this.env]) + '\\})';
|
||||
match = this.findEnd(text, n, start, ['{' + start[this.env] + '}', true, this.endPattern(null, end)]);
|
||||
if (match) {
|
||||
match.math = match.open + match.math + match.close;
|
||||
match.open = match.close = '';
|
||||
}
|
||||
}
|
||||
else if (start[this.sub] !== undefined && this.sub) {
|
||||
var math_1 = start[this.sub];
|
||||
var end = start.index + start[this.sub].length;
|
||||
if (math_1.length === 2) {
|
||||
match = (0, MathItem_js_1.protoItem)('', math_1.substr(1), '', n, start.index, end);
|
||||
}
|
||||
else {
|
||||
match = (0, MathItem_js_1.protoItem)('', math_1, '', n, start.index, end, false);
|
||||
}
|
||||
}
|
||||
else {
|
||||
match = this.findEnd(text, n, start, this.end[start[0]]);
|
||||
}
|
||||
if (match) {
|
||||
math.push(match);
|
||||
this.start.lastIndex = match.end.n;
|
||||
}
|
||||
}
|
||||
};
|
||||
FindTeX.prototype.findMath = function (strings) {
|
||||
var math = [];
|
||||
if (this.hasPatterns) {
|
||||
for (var i = 0, m = strings.length; i < m; i++) {
|
||||
this.findMathInString(math, i, strings[i]);
|
||||
}
|
||||
}
|
||||
return math;
|
||||
};
|
||||
FindTeX.OPTIONS = {
|
||||
inlineMath: [
|
||||
['\\(', '\\)']
|
||||
],
|
||||
displayMath: [
|
||||
['$$', '$$'],
|
||||
['\\[', '\\]']
|
||||
],
|
||||
processEscapes: true,
|
||||
processEnvironments: true,
|
||||
processRefs: true,
|
||||
};
|
||||
return FindTeX;
|
||||
}(FindMath_js_1.AbstractFindMath));
|
||||
exports.FindTeX = FindTeX;
|
||||
//# sourceMappingURL=FindTeX.js.map
|
||||
1
node_modules/mathjax-full/js/input/tex/FindTeX.js.map
generated
vendored
Normal file
1
node_modules/mathjax-full/js/input/tex/FindTeX.js.map
generated
vendored
Normal file
File diff suppressed because one or more lines are too long
33
node_modules/mathjax-full/js/input/tex/MapHandler.d.ts
generated
vendored
Normal file
33
node_modules/mathjax-full/js/input/tex/MapHandler.d.ts
generated
vendored
Normal file
@@ -0,0 +1,33 @@
|
||||
import { SymbolMap } from './SymbolMap.js';
|
||||
import { ParseInput, ParseResult, ParseMethod } from './Types.js';
|
||||
export declare type HandlerType = 'delimiter' | 'macro' | 'character' | 'environment';
|
||||
export declare type HandlerConfig = {
|
||||
[P in HandlerType]?: string[];
|
||||
};
|
||||
export declare type FallbackConfig = {
|
||||
[P in HandlerType]?: ParseMethod;
|
||||
};
|
||||
export declare namespace MapHandler {
|
||||
let register: (map: SymbolMap) => void;
|
||||
let getMap: (name: string) => SymbolMap;
|
||||
}
|
||||
export declare class SubHandler {
|
||||
private _configuration;
|
||||
private _fallback;
|
||||
add(maps: string[], fallback: ParseMethod, priority?: number): void;
|
||||
parse(input: ParseInput): ParseResult;
|
||||
lookup<T>(symbol: string): T;
|
||||
contains(symbol: string): boolean;
|
||||
toString(): string;
|
||||
applicable(symbol: string): SymbolMap;
|
||||
retrieve(name: string): SymbolMap;
|
||||
private warn;
|
||||
}
|
||||
export declare class SubHandlers {
|
||||
private map;
|
||||
add(handlers: HandlerConfig, fallbacks: FallbackConfig, priority?: number): void;
|
||||
set(name: HandlerType, subHandler: SubHandler): void;
|
||||
get(name: HandlerType): SubHandler;
|
||||
retrieve(name: string): SymbolMap;
|
||||
keys(): IterableIterator<string>;
|
||||
}
|
||||
222
node_modules/mathjax-full/js/input/tex/MapHandler.js
generated
vendored
Normal file
222
node_modules/mathjax-full/js/input/tex/MapHandler.js
generated
vendored
Normal file
@@ -0,0 +1,222 @@
|
||||
"use strict";
|
||||
var __values = (this && this.__values) || function(o) {
|
||||
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
|
||||
if (m) return m.call(o);
|
||||
if (o && typeof o.length === "number") return {
|
||||
next: function () {
|
||||
if (o && i >= o.length) o = void 0;
|
||||
return { value: o && o[i++], done: !o };
|
||||
}
|
||||
};
|
||||
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
|
||||
};
|
||||
var __read = (this && this.__read) || function (o, n) {
|
||||
var m = typeof Symbol === "function" && o[Symbol.iterator];
|
||||
if (!m) return o;
|
||||
var i = m.call(o), r, ar = [], e;
|
||||
try {
|
||||
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
|
||||
}
|
||||
catch (error) { e = { error: error }; }
|
||||
finally {
|
||||
try {
|
||||
if (r && !r.done && (m = i["return"])) m.call(i);
|
||||
}
|
||||
finally { if (e) throw e.error; }
|
||||
}
|
||||
return ar;
|
||||
};
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.SubHandlers = exports.SubHandler = exports.MapHandler = void 0;
|
||||
var PrioritizedList_js_1 = require("../../util/PrioritizedList.js");
|
||||
var FunctionList_js_1 = require("../../util/FunctionList.js");
|
||||
var MapHandler;
|
||||
(function (MapHandler) {
|
||||
var maps = new Map();
|
||||
MapHandler.register = function (map) {
|
||||
maps.set(map.name, map);
|
||||
};
|
||||
MapHandler.getMap = function (name) {
|
||||
return maps.get(name);
|
||||
};
|
||||
})(MapHandler = exports.MapHandler || (exports.MapHandler = {}));
|
||||
var SubHandler = (function () {
|
||||
function SubHandler() {
|
||||
this._configuration = new PrioritizedList_js_1.PrioritizedList();
|
||||
this._fallback = new FunctionList_js_1.FunctionList();
|
||||
}
|
||||
SubHandler.prototype.add = function (maps, fallback, priority) {
|
||||
var e_1, _a;
|
||||
if (priority === void 0) { priority = PrioritizedList_js_1.PrioritizedList.DEFAULTPRIORITY; }
|
||||
try {
|
||||
for (var _b = __values(maps.slice().reverse()), _c = _b.next(); !_c.done; _c = _b.next()) {
|
||||
var name_1 = _c.value;
|
||||
var map = MapHandler.getMap(name_1);
|
||||
if (!map) {
|
||||
this.warn('Configuration ' + name_1 + ' not found! Omitted.');
|
||||
return;
|
||||
}
|
||||
this._configuration.add(map, priority);
|
||||
}
|
||||
}
|
||||
catch (e_1_1) { e_1 = { error: e_1_1 }; }
|
||||
finally {
|
||||
try {
|
||||
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
|
||||
}
|
||||
finally { if (e_1) throw e_1.error; }
|
||||
}
|
||||
if (fallback) {
|
||||
this._fallback.add(fallback, priority);
|
||||
}
|
||||
};
|
||||
SubHandler.prototype.parse = function (input) {
|
||||
var e_2, _a;
|
||||
try {
|
||||
for (var _b = __values(this._configuration), _c = _b.next(); !_c.done; _c = _b.next()) {
|
||||
var map = _c.value.item;
|
||||
var result = map.parse(input);
|
||||
if (result) {
|
||||
return result;
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (e_2_1) { e_2 = { error: e_2_1 }; }
|
||||
finally {
|
||||
try {
|
||||
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
|
||||
}
|
||||
finally { if (e_2) throw e_2.error; }
|
||||
}
|
||||
var _d = __read(input, 2), env = _d[0], symbol = _d[1];
|
||||
Array.from(this._fallback)[0].item(env, symbol);
|
||||
};
|
||||
SubHandler.prototype.lookup = function (symbol) {
|
||||
var map = this.applicable(symbol);
|
||||
return map ? map.lookup(symbol) : null;
|
||||
};
|
||||
SubHandler.prototype.contains = function (symbol) {
|
||||
return this.applicable(symbol) ? true : false;
|
||||
};
|
||||
SubHandler.prototype.toString = function () {
|
||||
var e_3, _a;
|
||||
var names = [];
|
||||
try {
|
||||
for (var _b = __values(this._configuration), _c = _b.next(); !_c.done; _c = _b.next()) {
|
||||
var map = _c.value.item;
|
||||
names.push(map.name);
|
||||
}
|
||||
}
|
||||
catch (e_3_1) { e_3 = { error: e_3_1 }; }
|
||||
finally {
|
||||
try {
|
||||
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
|
||||
}
|
||||
finally { if (e_3) throw e_3.error; }
|
||||
}
|
||||
return names.join(', ');
|
||||
};
|
||||
SubHandler.prototype.applicable = function (symbol) {
|
||||
var e_4, _a;
|
||||
try {
|
||||
for (var _b = __values(this._configuration), _c = _b.next(); !_c.done; _c = _b.next()) {
|
||||
var map = _c.value.item;
|
||||
if (map.contains(symbol)) {
|
||||
return map;
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (e_4_1) { e_4 = { error: e_4_1 }; }
|
||||
finally {
|
||||
try {
|
||||
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
|
||||
}
|
||||
finally { if (e_4) throw e_4.error; }
|
||||
}
|
||||
return null;
|
||||
};
|
||||
SubHandler.prototype.retrieve = function (name) {
|
||||
var e_5, _a;
|
||||
try {
|
||||
for (var _b = __values(this._configuration), _c = _b.next(); !_c.done; _c = _b.next()) {
|
||||
var map = _c.value.item;
|
||||
if (map.name === name) {
|
||||
return map;
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (e_5_1) { e_5 = { error: e_5_1 }; }
|
||||
finally {
|
||||
try {
|
||||
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
|
||||
}
|
||||
finally { if (e_5) throw e_5.error; }
|
||||
}
|
||||
return null;
|
||||
};
|
||||
SubHandler.prototype.warn = function (message) {
|
||||
console.log('TexParser Warning: ' + message);
|
||||
};
|
||||
return SubHandler;
|
||||
}());
|
||||
exports.SubHandler = SubHandler;
|
||||
var SubHandlers = (function () {
|
||||
function SubHandlers() {
|
||||
this.map = new Map();
|
||||
}
|
||||
SubHandlers.prototype.add = function (handlers, fallbacks, priority) {
|
||||
var e_6, _a;
|
||||
if (priority === void 0) { priority = PrioritizedList_js_1.PrioritizedList.DEFAULTPRIORITY; }
|
||||
try {
|
||||
for (var _b = __values(Object.keys(handlers)), _c = _b.next(); !_c.done; _c = _b.next()) {
|
||||
var key = _c.value;
|
||||
var name_2 = key;
|
||||
var subHandler = this.get(name_2);
|
||||
if (!subHandler) {
|
||||
subHandler = new SubHandler();
|
||||
this.set(name_2, subHandler);
|
||||
}
|
||||
subHandler.add(handlers[name_2], fallbacks[name_2], priority);
|
||||
}
|
||||
}
|
||||
catch (e_6_1) { e_6 = { error: e_6_1 }; }
|
||||
finally {
|
||||
try {
|
||||
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
|
||||
}
|
||||
finally { if (e_6) throw e_6.error; }
|
||||
}
|
||||
};
|
||||
SubHandlers.prototype.set = function (name, subHandler) {
|
||||
this.map.set(name, subHandler);
|
||||
};
|
||||
SubHandlers.prototype.get = function (name) {
|
||||
return this.map.get(name);
|
||||
};
|
||||
SubHandlers.prototype.retrieve = function (name) {
|
||||
var e_7, _a;
|
||||
try {
|
||||
for (var _b = __values(this.map.values()), _c = _b.next(); !_c.done; _c = _b.next()) {
|
||||
var handler = _c.value;
|
||||
var map = handler.retrieve(name);
|
||||
if (map) {
|
||||
return map;
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (e_7_1) { e_7 = { error: e_7_1 }; }
|
||||
finally {
|
||||
try {
|
||||
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
|
||||
}
|
||||
finally { if (e_7) throw e_7.error; }
|
||||
}
|
||||
return null;
|
||||
};
|
||||
SubHandlers.prototype.keys = function () {
|
||||
return this.map.keys();
|
||||
};
|
||||
return SubHandlers;
|
||||
}());
|
||||
exports.SubHandlers = SubHandlers;
|
||||
//# sourceMappingURL=MapHandler.js.map
|
||||
1
node_modules/mathjax-full/js/input/tex/MapHandler.js.map
generated
vendored
Normal file
1
node_modules/mathjax-full/js/input/tex/MapHandler.js.map
generated
vendored
Normal file
@@ -0,0 +1 @@
|
||||
{"version":3,"file":"MapHandler.js","sourceRoot":"","sources":["../../../ts/input/tex/MapHandler.ts"],"names":[],"mappings":"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"}
|
||||
20
node_modules/mathjax-full/js/input/tex/NodeFactory.d.ts
generated
vendored
Normal file
20
node_modules/mathjax-full/js/input/tex/NodeFactory.d.ts
generated
vendored
Normal file
@@ -0,0 +1,20 @@
|
||||
import { TextNode, MmlNode } from '../../core/MmlTree/MmlNode.js';
|
||||
import { MmlFactory } from '../../core/MmlTree/MmlFactory.js';
|
||||
import ParseOptions from './ParseOptions.js';
|
||||
export declare type NodeFactoryMethod = (factory: NodeFactory, kind: string, ...rest: any[]) => MmlNode;
|
||||
export declare class NodeFactory {
|
||||
configuration: ParseOptions;
|
||||
protected mmlFactory: MmlFactory;
|
||||
private factory;
|
||||
static createNode(factory: NodeFactory, kind: string, children?: MmlNode[], def?: any, text?: TextNode): MmlNode;
|
||||
static createToken(factory: NodeFactory, kind: string, def?: any, text?: string): MmlNode;
|
||||
static createText(factory: NodeFactory, text: string): TextNode;
|
||||
static createError(factory: NodeFactory, message: string): MmlNode;
|
||||
setMmlFactory(mmlFactory: MmlFactory): void;
|
||||
set(kind: string, func: NodeFactoryMethod): void;
|
||||
setCreators(maps: {
|
||||
[kind: string]: NodeFactoryMethod;
|
||||
}): void;
|
||||
create(kind: string, ...rest: any[]): MmlNode;
|
||||
get(kind: string): NodeFactoryMethod;
|
||||
}
|
||||
100
node_modules/mathjax-full/js/input/tex/NodeFactory.js
generated
vendored
Normal file
100
node_modules/mathjax-full/js/input/tex/NodeFactory.js
generated
vendored
Normal file
@@ -0,0 +1,100 @@
|
||||
"use strict";
|
||||
var __read = (this && this.__read) || function (o, n) {
|
||||
var m = typeof Symbol === "function" && o[Symbol.iterator];
|
||||
if (!m) return o;
|
||||
var i = m.call(o), r, ar = [], e;
|
||||
try {
|
||||
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
|
||||
}
|
||||
catch (error) { e = { error: error }; }
|
||||
finally {
|
||||
try {
|
||||
if (r && !r.done && (m = i["return"])) m.call(i);
|
||||
}
|
||||
finally { if (e) throw e.error; }
|
||||
}
|
||||
return ar;
|
||||
};
|
||||
var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
|
||||
if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
|
||||
if (ar || !(i in from)) {
|
||||
if (!ar) ar = Array.prototype.slice.call(from, 0, i);
|
||||
ar[i] = from[i];
|
||||
}
|
||||
}
|
||||
return to.concat(ar || Array.prototype.slice.call(from));
|
||||
};
|
||||
var __importDefault = (this && this.__importDefault) || function (mod) {
|
||||
return (mod && mod.__esModule) ? mod : { "default": mod };
|
||||
};
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.NodeFactory = void 0;
|
||||
var NodeUtil_js_1 = __importDefault(require("./NodeUtil.js"));
|
||||
var NodeFactory = (function () {
|
||||
function NodeFactory() {
|
||||
this.mmlFactory = null;
|
||||
this.factory = { 'node': NodeFactory.createNode,
|
||||
'token': NodeFactory.createToken,
|
||||
'text': NodeFactory.createText,
|
||||
'error': NodeFactory.createError
|
||||
};
|
||||
}
|
||||
NodeFactory.createNode = function (factory, kind, children, def, text) {
|
||||
if (children === void 0) { children = []; }
|
||||
if (def === void 0) { def = {}; }
|
||||
var node = factory.mmlFactory.create(kind);
|
||||
node.setChildren(children);
|
||||
if (text) {
|
||||
node.appendChild(text);
|
||||
}
|
||||
NodeUtil_js_1.default.setProperties(node, def);
|
||||
return node;
|
||||
};
|
||||
NodeFactory.createToken = function (factory, kind, def, text) {
|
||||
if (def === void 0) { def = {}; }
|
||||
if (text === void 0) { text = ''; }
|
||||
var textNode = factory.create('text', text);
|
||||
return factory.create('node', kind, [], def, textNode);
|
||||
};
|
||||
NodeFactory.createText = function (factory, text) {
|
||||
if (text == null) {
|
||||
return null;
|
||||
}
|
||||
return factory.mmlFactory.create('text').setText(text);
|
||||
};
|
||||
NodeFactory.createError = function (factory, message) {
|
||||
var text = factory.create('text', message);
|
||||
var mtext = factory.create('node', 'mtext', [], {}, text);
|
||||
var error = factory.create('node', 'merror', [mtext], { 'data-mjx-error': message });
|
||||
return error;
|
||||
};
|
||||
NodeFactory.prototype.setMmlFactory = function (mmlFactory) {
|
||||
this.mmlFactory = mmlFactory;
|
||||
};
|
||||
NodeFactory.prototype.set = function (kind, func) {
|
||||
this.factory[kind] = func;
|
||||
};
|
||||
NodeFactory.prototype.setCreators = function (maps) {
|
||||
for (var kind in maps) {
|
||||
this.set(kind, maps[kind]);
|
||||
}
|
||||
};
|
||||
NodeFactory.prototype.create = function (kind) {
|
||||
var rest = [];
|
||||
for (var _i = 1; _i < arguments.length; _i++) {
|
||||
rest[_i - 1] = arguments[_i];
|
||||
}
|
||||
var func = this.factory[kind] || this.factory['node'];
|
||||
var node = func.apply(void 0, __spreadArray([this, rest[0]], __read(rest.slice(1)), false));
|
||||
if (kind === 'node') {
|
||||
this.configuration.addNode(rest[0], node);
|
||||
}
|
||||
return node;
|
||||
};
|
||||
NodeFactory.prototype.get = function (kind) {
|
||||
return this.factory[kind];
|
||||
};
|
||||
return NodeFactory;
|
||||
}());
|
||||
exports.NodeFactory = NodeFactory;
|
||||
//# sourceMappingURL=NodeFactory.js.map
|
||||
1
node_modules/mathjax-full/js/input/tex/NodeFactory.js.map
generated
vendored
Normal file
1
node_modules/mathjax-full/js/input/tex/NodeFactory.js.map
generated
vendored
Normal file
@@ -0,0 +1 @@
|
||||
{"version":3,"file":"NodeFactory.js","sourceRoot":"","sources":["../../../ts/input/tex/NodeFactory.ts"],"names":[],"mappings":"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"}
|
||||
28
node_modules/mathjax-full/js/input/tex/NodeUtil.d.ts
generated
vendored
Normal file
28
node_modules/mathjax-full/js/input/tex/NodeUtil.d.ts
generated
vendored
Normal file
@@ -0,0 +1,28 @@
|
||||
import { TextNode, MMLNODE, MmlNode } from '../../core/MmlTree/MmlNode.js';
|
||||
import { Property, PropertyList } from '../../core/Tree/Node.js';
|
||||
import { Args } from './Types.js';
|
||||
import { OperatorDef } from '../../core/MmlTree/OperatorDictionary.js';
|
||||
declare namespace NodeUtil {
|
||||
function createEntity(code: string): string;
|
||||
function getChildren(node: MmlNode): MMLNODE[];
|
||||
function getText(node: TextNode): string;
|
||||
function appendChildren(node: MmlNode, children: MMLNODE[]): void;
|
||||
function setAttribute(node: MmlNode, attribute: string, value: Args): void;
|
||||
function setProperty(node: MmlNode, property: string, value: Args): void;
|
||||
function setProperties(node: MmlNode, properties: PropertyList): void;
|
||||
function getProperty(node: MmlNode, property: string): Property;
|
||||
function getAttribute(node: MmlNode, attr: string): Property;
|
||||
function removeProperties(node: MmlNode, ...properties: string[]): void;
|
||||
function getChildAt(node: MmlNode, position: number): MMLNODE;
|
||||
function setChild(node: MmlNode, position: number, child: MmlNode): void;
|
||||
function copyChildren(oldNode: MmlNode, newNode: MmlNode): void;
|
||||
function copyAttributes(oldNode: MmlNode, newNode: MmlNode): void;
|
||||
function isType(node: MmlNode, kind: string): boolean;
|
||||
function isEmbellished(node: MmlNode): boolean;
|
||||
function getTexClass(node: MmlNode): number;
|
||||
function getCoreMO(node: MmlNode): MmlNode;
|
||||
function isNode(item: any): boolean;
|
||||
function isInferred(node: MmlNode): boolean;
|
||||
function getForm(node: MmlNode): OperatorDef;
|
||||
}
|
||||
export default NodeUtil;
|
||||
220
node_modules/mathjax-full/js/input/tex/NodeUtil.js
generated
vendored
Normal file
220
node_modules/mathjax-full/js/input/tex/NodeUtil.js
generated
vendored
Normal file
@@ -0,0 +1,220 @@
|
||||
"use strict";
|
||||
var __values = (this && this.__values) || function(o) {
|
||||
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
|
||||
if (m) return m.call(o);
|
||||
if (o && typeof o.length === "number") return {
|
||||
next: function () {
|
||||
if (o && i >= o.length) o = void 0;
|
||||
return { value: o && o[i++], done: !o };
|
||||
}
|
||||
};
|
||||
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
|
||||
};
|
||||
var __read = (this && this.__read) || function (o, n) {
|
||||
var m = typeof Symbol === "function" && o[Symbol.iterator];
|
||||
if (!m) return o;
|
||||
var i = m.call(o), r, ar = [], e;
|
||||
try {
|
||||
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
|
||||
}
|
||||
catch (error) { e = { error: error }; }
|
||||
finally {
|
||||
try {
|
||||
if (r && !r.done && (m = i["return"])) m.call(i);
|
||||
}
|
||||
finally { if (e) throw e.error; }
|
||||
}
|
||||
return ar;
|
||||
};
|
||||
var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
|
||||
if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
|
||||
if (ar || !(i in from)) {
|
||||
if (!ar) ar = Array.prototype.slice.call(from, 0, i);
|
||||
ar[i] = from[i];
|
||||
}
|
||||
}
|
||||
return to.concat(ar || Array.prototype.slice.call(from));
|
||||
};
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
var MmlNode_js_1 = require("../../core/MmlTree/MmlNode.js");
|
||||
var mo_js_1 = require("../../core/MmlTree/MmlNodes/mo.js");
|
||||
var NodeUtil;
|
||||
(function (NodeUtil) {
|
||||
var attrs = new Map([
|
||||
['autoOP', true],
|
||||
['fnOP', true],
|
||||
['movesupsub', true],
|
||||
['subsupOK', true],
|
||||
['texprimestyle', true],
|
||||
['useHeight', true],
|
||||
['variantForm', true],
|
||||
['withDelims', true],
|
||||
['mathaccent', true],
|
||||
['open', true],
|
||||
['close', true]
|
||||
]);
|
||||
function createEntity(code) {
|
||||
return String.fromCodePoint(parseInt(code, 16));
|
||||
}
|
||||
NodeUtil.createEntity = createEntity;
|
||||
function getChildren(node) {
|
||||
return node.childNodes;
|
||||
}
|
||||
NodeUtil.getChildren = getChildren;
|
||||
function getText(node) {
|
||||
return node.getText();
|
||||
}
|
||||
NodeUtil.getText = getText;
|
||||
function appendChildren(node, children) {
|
||||
var e_1, _a;
|
||||
try {
|
||||
for (var children_1 = __values(children), children_1_1 = children_1.next(); !children_1_1.done; children_1_1 = children_1.next()) {
|
||||
var child = children_1_1.value;
|
||||
node.appendChild(child);
|
||||
}
|
||||
}
|
||||
catch (e_1_1) { e_1 = { error: e_1_1 }; }
|
||||
finally {
|
||||
try {
|
||||
if (children_1_1 && !children_1_1.done && (_a = children_1.return)) _a.call(children_1);
|
||||
}
|
||||
finally { if (e_1) throw e_1.error; }
|
||||
}
|
||||
}
|
||||
NodeUtil.appendChildren = appendChildren;
|
||||
function setAttribute(node, attribute, value) {
|
||||
node.attributes.set(attribute, value);
|
||||
}
|
||||
NodeUtil.setAttribute = setAttribute;
|
||||
function setProperty(node, property, value) {
|
||||
node.setProperty(property, value);
|
||||
}
|
||||
NodeUtil.setProperty = setProperty;
|
||||
function setProperties(node, properties) {
|
||||
var e_2, _a;
|
||||
try {
|
||||
for (var _b = __values(Object.keys(properties)), _c = _b.next(); !_c.done; _c = _b.next()) {
|
||||
var name_1 = _c.value;
|
||||
var value = properties[name_1];
|
||||
if (name_1 === 'texClass') {
|
||||
node.texClass = value;
|
||||
node.setProperty(name_1, value);
|
||||
}
|
||||
else if (name_1 === 'movablelimits') {
|
||||
node.setProperty('movablelimits', value);
|
||||
if (node.isKind('mo') || node.isKind('mstyle')) {
|
||||
node.attributes.set('movablelimits', value);
|
||||
}
|
||||
}
|
||||
else if (name_1 === 'inferred') {
|
||||
}
|
||||
else if (attrs.has(name_1)) {
|
||||
node.setProperty(name_1, value);
|
||||
}
|
||||
else {
|
||||
node.attributes.set(name_1, value);
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (e_2_1) { e_2 = { error: e_2_1 }; }
|
||||
finally {
|
||||
try {
|
||||
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
|
||||
}
|
||||
finally { if (e_2) throw e_2.error; }
|
||||
}
|
||||
}
|
||||
NodeUtil.setProperties = setProperties;
|
||||
function getProperty(node, property) {
|
||||
return node.getProperty(property);
|
||||
}
|
||||
NodeUtil.getProperty = getProperty;
|
||||
function getAttribute(node, attr) {
|
||||
return node.attributes.get(attr);
|
||||
}
|
||||
NodeUtil.getAttribute = getAttribute;
|
||||
function removeProperties(node) {
|
||||
var properties = [];
|
||||
for (var _i = 1; _i < arguments.length; _i++) {
|
||||
properties[_i - 1] = arguments[_i];
|
||||
}
|
||||
node.removeProperty.apply(node, __spreadArray([], __read(properties), false));
|
||||
}
|
||||
NodeUtil.removeProperties = removeProperties;
|
||||
function getChildAt(node, position) {
|
||||
return node.childNodes[position];
|
||||
}
|
||||
NodeUtil.getChildAt = getChildAt;
|
||||
function setChild(node, position, child) {
|
||||
var children = node.childNodes;
|
||||
children[position] = child;
|
||||
if (child) {
|
||||
child.parent = node;
|
||||
}
|
||||
}
|
||||
NodeUtil.setChild = setChild;
|
||||
function copyChildren(oldNode, newNode) {
|
||||
var children = oldNode.childNodes;
|
||||
for (var i = 0; i < children.length; i++) {
|
||||
setChild(newNode, i, children[i]);
|
||||
}
|
||||
}
|
||||
NodeUtil.copyChildren = copyChildren;
|
||||
function copyAttributes(oldNode, newNode) {
|
||||
newNode.attributes = oldNode.attributes;
|
||||
setProperties(newNode, oldNode.getAllProperties());
|
||||
}
|
||||
NodeUtil.copyAttributes = copyAttributes;
|
||||
function isType(node, kind) {
|
||||
return node.isKind(kind);
|
||||
}
|
||||
NodeUtil.isType = isType;
|
||||
function isEmbellished(node) {
|
||||
return node.isEmbellished;
|
||||
}
|
||||
NodeUtil.isEmbellished = isEmbellished;
|
||||
function getTexClass(node) {
|
||||
return node.texClass;
|
||||
}
|
||||
NodeUtil.getTexClass = getTexClass;
|
||||
function getCoreMO(node) {
|
||||
return node.coreMO();
|
||||
}
|
||||
NodeUtil.getCoreMO = getCoreMO;
|
||||
function isNode(item) {
|
||||
return item instanceof MmlNode_js_1.AbstractMmlNode || item instanceof MmlNode_js_1.AbstractMmlEmptyNode;
|
||||
}
|
||||
NodeUtil.isNode = isNode;
|
||||
function isInferred(node) {
|
||||
return node.isInferred;
|
||||
}
|
||||
NodeUtil.isInferred = isInferred;
|
||||
function getForm(node) {
|
||||
var e_3, _a;
|
||||
if (!isType(node, 'mo')) {
|
||||
return null;
|
||||
}
|
||||
var mo = node;
|
||||
var forms = mo.getForms();
|
||||
try {
|
||||
for (var forms_1 = __values(forms), forms_1_1 = forms_1.next(); !forms_1_1.done; forms_1_1 = forms_1.next()) {
|
||||
var form = forms_1_1.value;
|
||||
var symbol = mo_js_1.MmlMo.OPTABLE[form][mo.getText()];
|
||||
if (symbol) {
|
||||
return symbol;
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (e_3_1) { e_3 = { error: e_3_1 }; }
|
||||
finally {
|
||||
try {
|
||||
if (forms_1_1 && !forms_1_1.done && (_a = forms_1.return)) _a.call(forms_1);
|
||||
}
|
||||
finally { if (e_3) throw e_3.error; }
|
||||
}
|
||||
return null;
|
||||
}
|
||||
NodeUtil.getForm = getForm;
|
||||
})(NodeUtil || (NodeUtil = {}));
|
||||
exports.default = NodeUtil;
|
||||
//# sourceMappingURL=NodeUtil.js.map
|
||||
1
node_modules/mathjax-full/js/input/tex/NodeUtil.js.map
generated
vendored
Normal file
1
node_modules/mathjax-full/js/input/tex/NodeUtil.js.map
generated
vendored
Normal file
@@ -0,0 +1 @@
|
||||
{"version":3,"file":"NodeUtil.js","sourceRoot":"","sources":["../../../ts/input/tex/NodeUtil.ts"],"names":[],"mappings":"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"}
|
||||
13
node_modules/mathjax-full/js/input/tex/ParseMethods.d.ts
generated
vendored
Normal file
13
node_modules/mathjax-full/js/input/tex/ParseMethods.d.ts
generated
vendored
Normal file
@@ -0,0 +1,13 @@
|
||||
import { Symbol } from './Symbol.js';
|
||||
import TexParser from './TexParser.js';
|
||||
declare namespace ParseMethods {
|
||||
function variable(parser: TexParser, c: string): void;
|
||||
function digit(parser: TexParser, c: string): void;
|
||||
function controlSequence(parser: TexParser, _c: string): void;
|
||||
function mathchar0mi(parser: TexParser, mchar: Symbol): void;
|
||||
function mathchar0mo(parser: TexParser, mchar: Symbol): void;
|
||||
function mathchar7(parser: TexParser, mchar: Symbol): void;
|
||||
function delimiter(parser: TexParser, delim: Symbol): void;
|
||||
function environment(parser: TexParser, env: string, func: Function, args: any[]): void;
|
||||
}
|
||||
export default ParseMethods;
|
||||
110
node_modules/mathjax-full/js/input/tex/ParseMethods.js
generated
vendored
Normal file
110
node_modules/mathjax-full/js/input/tex/ParseMethods.js
generated
vendored
Normal file
@@ -0,0 +1,110 @@
|
||||
"use strict";
|
||||
var __read = (this && this.__read) || function (o, n) {
|
||||
var m = typeof Symbol === "function" && o[Symbol.iterator];
|
||||
if (!m) return o;
|
||||
var i = m.call(o), r, ar = [], e;
|
||||
try {
|
||||
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
|
||||
}
|
||||
catch (error) { e = { error: error }; }
|
||||
finally {
|
||||
try {
|
||||
if (r && !r.done && (m = i["return"])) m.call(i);
|
||||
}
|
||||
finally { if (e) throw e.error; }
|
||||
}
|
||||
return ar;
|
||||
};
|
||||
var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
|
||||
if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
|
||||
if (ar || !(i in from)) {
|
||||
if (!ar) ar = Array.prototype.slice.call(from, 0, i);
|
||||
ar[i] = from[i];
|
||||
}
|
||||
}
|
||||
return to.concat(ar || Array.prototype.slice.call(from));
|
||||
};
|
||||
var __importDefault = (this && this.__importDefault) || function (mod) {
|
||||
return (mod && mod.__esModule) ? mod : { "default": mod };
|
||||
};
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
var NodeUtil_js_1 = __importDefault(require("./NodeUtil.js"));
|
||||
var TexConstants_js_1 = require("./TexConstants.js");
|
||||
var ParseUtil_js_1 = __importDefault(require("./ParseUtil.js"));
|
||||
var ParseMethods;
|
||||
(function (ParseMethods) {
|
||||
function variable(parser, c) {
|
||||
var def = ParseUtil_js_1.default.getFontDef(parser);
|
||||
var env = parser.stack.env;
|
||||
if (env.multiLetterIdentifiers && env.font !== '') {
|
||||
c = parser.string.substr(parser.i - 1).match(env.multiLetterIdentifiers)[0];
|
||||
parser.i += c.length - 1;
|
||||
if (def.mathvariant === TexConstants_js_1.TexConstant.Variant.NORMAL && env.noAutoOP && c.length > 1) {
|
||||
def.autoOP = false;
|
||||
}
|
||||
}
|
||||
var node = parser.create('token', 'mi', def, c);
|
||||
parser.Push(node);
|
||||
}
|
||||
ParseMethods.variable = variable;
|
||||
function digit(parser, c) {
|
||||
var mml;
|
||||
var pattern = parser.configuration.options['digits'];
|
||||
var n = parser.string.slice(parser.i - 1).match(pattern);
|
||||
var def = ParseUtil_js_1.default.getFontDef(parser);
|
||||
if (n) {
|
||||
mml = parser.create('token', 'mn', def, n[0].replace(/[{}]/g, ''));
|
||||
parser.i += n[0].length - 1;
|
||||
}
|
||||
else {
|
||||
mml = parser.create('token', 'mo', def, c);
|
||||
}
|
||||
parser.Push(mml);
|
||||
}
|
||||
ParseMethods.digit = digit;
|
||||
function controlSequence(parser, _c) {
|
||||
var name = parser.GetCS();
|
||||
parser.parse('macro', [parser, name]);
|
||||
}
|
||||
ParseMethods.controlSequence = controlSequence;
|
||||
function mathchar0mi(parser, mchar) {
|
||||
var def = mchar.attributes || { mathvariant: TexConstants_js_1.TexConstant.Variant.ITALIC };
|
||||
var node = parser.create('token', 'mi', def, mchar.char);
|
||||
parser.Push(node);
|
||||
}
|
||||
ParseMethods.mathchar0mi = mathchar0mi;
|
||||
function mathchar0mo(parser, mchar) {
|
||||
var def = mchar.attributes || {};
|
||||
def['stretchy'] = false;
|
||||
var node = parser.create('token', 'mo', def, mchar.char);
|
||||
NodeUtil_js_1.default.setProperty(node, 'fixStretchy', true);
|
||||
parser.configuration.addNode('fixStretchy', node);
|
||||
parser.Push(node);
|
||||
}
|
||||
ParseMethods.mathchar0mo = mathchar0mo;
|
||||
function mathchar7(parser, mchar) {
|
||||
var def = mchar.attributes || { mathvariant: TexConstants_js_1.TexConstant.Variant.NORMAL };
|
||||
if (parser.stack.env['font']) {
|
||||
def['mathvariant'] = parser.stack.env['font'];
|
||||
}
|
||||
var node = parser.create('token', 'mi', def, mchar.char);
|
||||
parser.Push(node);
|
||||
}
|
||||
ParseMethods.mathchar7 = mathchar7;
|
||||
function delimiter(parser, delim) {
|
||||
var def = delim.attributes || {};
|
||||
def = Object.assign({ fence: false, stretchy: false }, def);
|
||||
var node = parser.create('token', 'mo', def, delim.char);
|
||||
parser.Push(node);
|
||||
}
|
||||
ParseMethods.delimiter = delimiter;
|
||||
function environment(parser, env, func, args) {
|
||||
var end = args[0];
|
||||
var mml = parser.itemFactory.create('begin').setProperties({ name: env, end: end });
|
||||
mml = func.apply(void 0, __spreadArray([parser, mml], __read(args.slice(1)), false));
|
||||
parser.Push(mml);
|
||||
}
|
||||
ParseMethods.environment = environment;
|
||||
})(ParseMethods || (ParseMethods = {}));
|
||||
exports.default = ParseMethods;
|
||||
//# sourceMappingURL=ParseMethods.js.map
|
||||
1
node_modules/mathjax-full/js/input/tex/ParseMethods.js.map
generated
vendored
Normal file
1
node_modules/mathjax-full/js/input/tex/ParseMethods.js.map
generated
vendored
Normal file
@@ -0,0 +1 @@
|
||||
{"version":3,"file":"ParseMethods.js","sourceRoot":"","sources":["../../../ts/input/tex/ParseMethods.ts"],"names":[],"mappings":"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"}
|
||||
31
node_modules/mathjax-full/js/input/tex/ParseOptions.d.ts
generated
vendored
Normal file
31
node_modules/mathjax-full/js/input/tex/ParseOptions.d.ts
generated
vendored
Normal file
@@ -0,0 +1,31 @@
|
||||
import StackItemFactory from './StackItemFactory.js';
|
||||
import { Tags } from './Tags.js';
|
||||
import { SubHandlers } from './MapHandler.js';
|
||||
import { NodeFactory } from './NodeFactory.js';
|
||||
import { MmlNode } from '../../core/MmlTree/MmlNode.js';
|
||||
import TexParser from './TexParser.js';
|
||||
import { OptionList } from '../../util/Options.js';
|
||||
import { ParserConfiguration } from './Configuration.js';
|
||||
export default class ParseOptions {
|
||||
handlers: SubHandlers;
|
||||
options: OptionList;
|
||||
itemFactory: StackItemFactory;
|
||||
nodeFactory: NodeFactory;
|
||||
tags: Tags;
|
||||
packageData: Map<string, any>;
|
||||
parsers: TexParser[];
|
||||
root: MmlNode;
|
||||
nodeLists: {
|
||||
[key: string]: MmlNode[];
|
||||
};
|
||||
error: boolean;
|
||||
constructor(configuration: ParserConfiguration, options?: OptionList[]);
|
||||
pushParser(parser: TexParser): void;
|
||||
popParser(): void;
|
||||
get parser(): TexParser;
|
||||
clear(): void;
|
||||
addNode(property: string, node: MmlNode): void;
|
||||
getList(property: string): MmlNode[];
|
||||
removeFromList(property: string, nodes: MmlNode[]): void;
|
||||
private inTree;
|
||||
}
|
||||
147
node_modules/mathjax-full/js/input/tex/ParseOptions.js
generated
vendored
Normal file
147
node_modules/mathjax-full/js/input/tex/ParseOptions.js
generated
vendored
Normal file
@@ -0,0 +1,147 @@
|
||||
"use strict";
|
||||
var __read = (this && this.__read) || function (o, n) {
|
||||
var m = typeof Symbol === "function" && o[Symbol.iterator];
|
||||
if (!m) return o;
|
||||
var i = m.call(o), r, ar = [], e;
|
||||
try {
|
||||
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
|
||||
}
|
||||
catch (error) { e = { error: error }; }
|
||||
finally {
|
||||
try {
|
||||
if (r && !r.done && (m = i["return"])) m.call(i);
|
||||
}
|
||||
finally { if (e) throw e.error; }
|
||||
}
|
||||
return ar;
|
||||
};
|
||||
var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
|
||||
if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
|
||||
if (ar || !(i in from)) {
|
||||
if (!ar) ar = Array.prototype.slice.call(from, 0, i);
|
||||
ar[i] = from[i];
|
||||
}
|
||||
}
|
||||
return to.concat(ar || Array.prototype.slice.call(from));
|
||||
};
|
||||
var __values = (this && this.__values) || function(o) {
|
||||
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
|
||||
if (m) return m.call(o);
|
||||
if (o && typeof o.length === "number") return {
|
||||
next: function () {
|
||||
if (o && i >= o.length) o = void 0;
|
||||
return { value: o && o[i++], done: !o };
|
||||
}
|
||||
};
|
||||
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
|
||||
};
|
||||
var __importDefault = (this && this.__importDefault) || function (mod) {
|
||||
return (mod && mod.__esModule) ? mod : { "default": mod };
|
||||
};
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
var StackItemFactory_js_1 = __importDefault(require("./StackItemFactory.js"));
|
||||
var NodeFactory_js_1 = require("./NodeFactory.js");
|
||||
var NodeUtil_js_1 = __importDefault(require("./NodeUtil.js"));
|
||||
var Options_js_1 = require("../../util/Options.js");
|
||||
var ParseOptions = (function () {
|
||||
function ParseOptions(configuration, options) {
|
||||
if (options === void 0) { options = []; }
|
||||
this.options = {};
|
||||
this.packageData = new Map();
|
||||
this.parsers = [];
|
||||
this.root = null;
|
||||
this.nodeLists = {};
|
||||
this.error = false;
|
||||
this.handlers = configuration.handlers;
|
||||
this.nodeFactory = new NodeFactory_js_1.NodeFactory();
|
||||
this.nodeFactory.configuration = this;
|
||||
this.nodeFactory.setCreators(configuration.nodes);
|
||||
this.itemFactory = new StackItemFactory_js_1.default(configuration.items);
|
||||
this.itemFactory.configuration = this;
|
||||
Options_js_1.defaultOptions.apply(void 0, __spreadArray([this.options], __read(options), false));
|
||||
(0, Options_js_1.defaultOptions)(this.options, configuration.options);
|
||||
}
|
||||
ParseOptions.prototype.pushParser = function (parser) {
|
||||
this.parsers.unshift(parser);
|
||||
};
|
||||
ParseOptions.prototype.popParser = function () {
|
||||
this.parsers.shift();
|
||||
};
|
||||
Object.defineProperty(ParseOptions.prototype, "parser", {
|
||||
get: function () {
|
||||
return this.parsers[0];
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
ParseOptions.prototype.clear = function () {
|
||||
this.parsers = [];
|
||||
this.root = null;
|
||||
this.nodeLists = {};
|
||||
this.error = false;
|
||||
this.tags.resetTag();
|
||||
};
|
||||
ParseOptions.prototype.addNode = function (property, node) {
|
||||
var list = this.nodeLists[property];
|
||||
if (!list) {
|
||||
list = this.nodeLists[property] = [];
|
||||
}
|
||||
list.push(node);
|
||||
if (node.kind !== property) {
|
||||
var inlists = (NodeUtil_js_1.default.getProperty(node, 'in-lists') || '');
|
||||
var lists = (inlists ? inlists.split(/,/) : []).concat(property).join(',');
|
||||
NodeUtil_js_1.default.setProperty(node, 'in-lists', lists);
|
||||
}
|
||||
};
|
||||
ParseOptions.prototype.getList = function (property) {
|
||||
var e_1, _a;
|
||||
var list = this.nodeLists[property] || [];
|
||||
var result = [];
|
||||
try {
|
||||
for (var list_1 = __values(list), list_1_1 = list_1.next(); !list_1_1.done; list_1_1 = list_1.next()) {
|
||||
var node = list_1_1.value;
|
||||
if (this.inTree(node)) {
|
||||
result.push(node);
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (e_1_1) { e_1 = { error: e_1_1 }; }
|
||||
finally {
|
||||
try {
|
||||
if (list_1_1 && !list_1_1.done && (_a = list_1.return)) _a.call(list_1);
|
||||
}
|
||||
finally { if (e_1) throw e_1.error; }
|
||||
}
|
||||
this.nodeLists[property] = result;
|
||||
return result;
|
||||
};
|
||||
ParseOptions.prototype.removeFromList = function (property, nodes) {
|
||||
var e_2, _a;
|
||||
var list = this.nodeLists[property] || [];
|
||||
try {
|
||||
for (var nodes_1 = __values(nodes), nodes_1_1 = nodes_1.next(); !nodes_1_1.done; nodes_1_1 = nodes_1.next()) {
|
||||
var node = nodes_1_1.value;
|
||||
var i = list.indexOf(node);
|
||||
if (i >= 0) {
|
||||
list.splice(i, 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (e_2_1) { e_2 = { error: e_2_1 }; }
|
||||
finally {
|
||||
try {
|
||||
if (nodes_1_1 && !nodes_1_1.done && (_a = nodes_1.return)) _a.call(nodes_1);
|
||||
}
|
||||
finally { if (e_2) throw e_2.error; }
|
||||
}
|
||||
};
|
||||
ParseOptions.prototype.inTree = function (node) {
|
||||
while (node && node !== this.root) {
|
||||
node = node.parent;
|
||||
}
|
||||
return !!node;
|
||||
};
|
||||
return ParseOptions;
|
||||
}());
|
||||
exports.default = ParseOptions;
|
||||
//# sourceMappingURL=ParseOptions.js.map
|
||||
1
node_modules/mathjax-full/js/input/tex/ParseOptions.js.map
generated
vendored
Normal file
1
node_modules/mathjax-full/js/input/tex/ParseOptions.js.map
generated
vendored
Normal file
@@ -0,0 +1 @@
|
||||
{"version":3,"file":"ParseOptions.js","sourceRoot":"","sources":["../../../ts/input/tex/ParseOptions.ts"],"names":[],"mappings":"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"}
|
||||
32
node_modules/mathjax-full/js/input/tex/ParseUtil.d.ts
generated
vendored
Normal file
32
node_modules/mathjax-full/js/input/tex/ParseUtil.d.ts
generated
vendored
Normal file
@@ -0,0 +1,32 @@
|
||||
import { MmlNode } from '../../core/MmlTree/MmlNode.js';
|
||||
import { EnvList } from './StackItem.js';
|
||||
import { ArrayItem } from './base/BaseItems.js';
|
||||
import ParseOptions from './ParseOptions.js';
|
||||
import TexParser from './TexParser.js';
|
||||
declare namespace ParseUtil {
|
||||
function matchDimen(dim: string, rest?: boolean): [string, string, number];
|
||||
function dimen2em(dim: string): number;
|
||||
function Em(m: number): string;
|
||||
function cols(...W: number[]): string;
|
||||
function fenced(configuration: ParseOptions, open: string, mml: MmlNode, close: string, big?: string, color?: string): MmlNode;
|
||||
function fixedFence(configuration: ParseOptions, open: string, mml: MmlNode, close: string): MmlNode;
|
||||
function mathPalette(configuration: ParseOptions, fence: string, side: string): MmlNode;
|
||||
function fixInitialMO(configuration: ParseOptions, nodes: MmlNode[]): void;
|
||||
function internalMath(parser: TexParser, text: string, level?: number | string, font?: string): MmlNode[];
|
||||
function internalText(parser: TexParser, text: string, def: EnvList): MmlNode;
|
||||
function underOver(parser: TexParser, base: MmlNode, script: MmlNode, pos: string, stack: boolean): MmlNode;
|
||||
function checkMovableLimits(base: MmlNode): void;
|
||||
function trimSpaces(text: string): string;
|
||||
function setArrayAlign(array: ArrayItem, align: string): ArrayItem;
|
||||
function substituteArgs(parser: TexParser, args: string[], str: string): string;
|
||||
function addArgs(parser: TexParser, s1: string, s2: string): string;
|
||||
function checkMaxMacros(parser: TexParser, isMacro?: boolean): void;
|
||||
function checkEqnEnv(parser: TexParser): void;
|
||||
function copyNode(node: MmlNode, parser: TexParser): MmlNode;
|
||||
function MmlFilterAttribute(_parser: TexParser, _name: string, value: string): string;
|
||||
function getFontDef(parser: TexParser): EnvList;
|
||||
function keyvalOptions(attrib: string, allowed?: {
|
||||
[key: string]: number;
|
||||
}, error?: boolean): EnvList;
|
||||
}
|
||||
export default ParseUtil;
|
||||
513
node_modules/mathjax-full/js/input/tex/ParseUtil.js
generated
vendored
Normal file
513
node_modules/mathjax-full/js/input/tex/ParseUtil.js
generated
vendored
Normal file
@@ -0,0 +1,513 @@
|
||||
"use strict";
|
||||
var __read = (this && this.__read) || function (o, n) {
|
||||
var m = typeof Symbol === "function" && o[Symbol.iterator];
|
||||
if (!m) return o;
|
||||
var i = m.call(o), r, ar = [], e;
|
||||
try {
|
||||
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
|
||||
}
|
||||
catch (error) { e = { error: error }; }
|
||||
finally {
|
||||
try {
|
||||
if (r && !r.done && (m = i["return"])) m.call(i);
|
||||
}
|
||||
finally { if (e) throw e.error; }
|
||||
}
|
||||
return ar;
|
||||
};
|
||||
var __values = (this && this.__values) || function(o) {
|
||||
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
|
||||
if (m) return m.call(o);
|
||||
if (o && typeof o.length === "number") return {
|
||||
next: function () {
|
||||
if (o && i >= o.length) o = void 0;
|
||||
return { value: o && o[i++], done: !o };
|
||||
}
|
||||
};
|
||||
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
|
||||
};
|
||||
var __importDefault = (this && this.__importDefault) || function (mod) {
|
||||
return (mod && mod.__esModule) ? mod : { "default": mod };
|
||||
};
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
var MmlNode_js_1 = require("../../core/MmlTree/MmlNode.js");
|
||||
var NodeUtil_js_1 = __importDefault(require("./NodeUtil.js"));
|
||||
var TexParser_js_1 = __importDefault(require("./TexParser.js"));
|
||||
var TexError_js_1 = __importDefault(require("./TexError.js"));
|
||||
var Entities_js_1 = require("../../util/Entities.js");
|
||||
var ParseUtil;
|
||||
(function (ParseUtil) {
|
||||
var emPerInch = 7.2;
|
||||
var pxPerInch = 72;
|
||||
var UNIT_CASES = {
|
||||
'em': function (m) { return m; },
|
||||
'ex': function (m) { return m * .43; },
|
||||
'pt': function (m) { return m / 10; },
|
||||
'pc': function (m) { return m * 1.2; },
|
||||
'px': function (m) { return m * emPerInch / pxPerInch; },
|
||||
'in': function (m) { return m * emPerInch; },
|
||||
'cm': function (m) { return m * emPerInch / 2.54; },
|
||||
'mm': function (m) { return m * emPerInch / 25.4; },
|
||||
'mu': function (m) { return m / 18; },
|
||||
};
|
||||
var num = '([-+]?([.,]\\d+|\\d+([.,]\\d*)?))';
|
||||
var unit = '(pt|em|ex|mu|px|mm|cm|in|pc)';
|
||||
var dimenEnd = RegExp('^\\s*' + num + '\\s*' + unit + '\\s*$');
|
||||
var dimenRest = RegExp('^\\s*' + num + '\\s*' + unit + ' ?');
|
||||
function matchDimen(dim, rest) {
|
||||
if (rest === void 0) { rest = false; }
|
||||
var match = dim.match(rest ? dimenRest : dimenEnd);
|
||||
return match ?
|
||||
muReplace([match[1].replace(/,/, '.'), match[4], match[0].length]) :
|
||||
[null, null, 0];
|
||||
}
|
||||
ParseUtil.matchDimen = matchDimen;
|
||||
function muReplace(_a) {
|
||||
var _b = __read(_a, 3), value = _b[0], unit = _b[1], length = _b[2];
|
||||
if (unit !== 'mu') {
|
||||
return [value, unit, length];
|
||||
}
|
||||
var em = Em(UNIT_CASES[unit](parseFloat(value || '1')));
|
||||
return [em.slice(0, -2), 'em', length];
|
||||
}
|
||||
function dimen2em(dim) {
|
||||
var _a = __read(matchDimen(dim), 2), value = _a[0], unit = _a[1];
|
||||
var m = parseFloat(value || '1');
|
||||
var func = UNIT_CASES[unit];
|
||||
return func ? func(m) : 0;
|
||||
}
|
||||
ParseUtil.dimen2em = dimen2em;
|
||||
function Em(m) {
|
||||
if (Math.abs(m) < .0006) {
|
||||
return '0em';
|
||||
}
|
||||
return m.toFixed(3).replace(/\.?0+$/, '') + 'em';
|
||||
}
|
||||
ParseUtil.Em = Em;
|
||||
function cols() {
|
||||
var W = [];
|
||||
for (var _i = 0; _i < arguments.length; _i++) {
|
||||
W[_i] = arguments[_i];
|
||||
}
|
||||
return W.map(function (n) { return Em(n); }).join(' ');
|
||||
}
|
||||
ParseUtil.cols = cols;
|
||||
function fenced(configuration, open, mml, close, big, color) {
|
||||
if (big === void 0) { big = ''; }
|
||||
if (color === void 0) { color = ''; }
|
||||
var nf = configuration.nodeFactory;
|
||||
var mrow = nf.create('node', 'mrow', [], { open: open, close: close, texClass: MmlNode_js_1.TEXCLASS.INNER });
|
||||
var mo;
|
||||
if (big) {
|
||||
mo = new TexParser_js_1.default('\\' + big + 'l' + open, configuration.parser.stack.env, configuration).mml();
|
||||
}
|
||||
else {
|
||||
var openNode = nf.create('text', open);
|
||||
mo = nf.create('node', 'mo', [], { fence: true, stretchy: true, symmetric: true, texClass: MmlNode_js_1.TEXCLASS.OPEN }, openNode);
|
||||
}
|
||||
NodeUtil_js_1.default.appendChildren(mrow, [mo, mml]);
|
||||
if (big) {
|
||||
mo = new TexParser_js_1.default('\\' + big + 'r' + close, configuration.parser.stack.env, configuration).mml();
|
||||
}
|
||||
else {
|
||||
var closeNode = nf.create('text', close);
|
||||
mo = nf.create('node', 'mo', [], { fence: true, stretchy: true, symmetric: true, texClass: MmlNode_js_1.TEXCLASS.CLOSE }, closeNode);
|
||||
}
|
||||
color && mo.attributes.set('mathcolor', color);
|
||||
NodeUtil_js_1.default.appendChildren(mrow, [mo]);
|
||||
return mrow;
|
||||
}
|
||||
ParseUtil.fenced = fenced;
|
||||
function fixedFence(configuration, open, mml, close) {
|
||||
var mrow = configuration.nodeFactory.create('node', 'mrow', [], { open: open, close: close, texClass: MmlNode_js_1.TEXCLASS.ORD });
|
||||
if (open) {
|
||||
NodeUtil_js_1.default.appendChildren(mrow, [mathPalette(configuration, open, 'l')]);
|
||||
}
|
||||
if (NodeUtil_js_1.default.isType(mml, 'mrow')) {
|
||||
NodeUtil_js_1.default.appendChildren(mrow, NodeUtil_js_1.default.getChildren(mml));
|
||||
}
|
||||
else {
|
||||
NodeUtil_js_1.default.appendChildren(mrow, [mml]);
|
||||
}
|
||||
if (close) {
|
||||
NodeUtil_js_1.default.appendChildren(mrow, [mathPalette(configuration, close, 'r')]);
|
||||
}
|
||||
return mrow;
|
||||
}
|
||||
ParseUtil.fixedFence = fixedFence;
|
||||
function mathPalette(configuration, fence, side) {
|
||||
if (fence === '{' || fence === '}') {
|
||||
fence = '\\' + fence;
|
||||
}
|
||||
var D = '{\\bigg' + side + ' ' + fence + '}';
|
||||
var T = '{\\big' + side + ' ' + fence + '}';
|
||||
return new TexParser_js_1.default('\\mathchoice' + D + T + T + T, {}, configuration).mml();
|
||||
}
|
||||
ParseUtil.mathPalette = mathPalette;
|
||||
function fixInitialMO(configuration, nodes) {
|
||||
for (var i = 0, m = nodes.length; i < m; i++) {
|
||||
var child = nodes[i];
|
||||
if (child && (!NodeUtil_js_1.default.isType(child, 'mspace') &&
|
||||
(!NodeUtil_js_1.default.isType(child, 'TeXAtom') ||
|
||||
(NodeUtil_js_1.default.getChildren(child)[0] &&
|
||||
NodeUtil_js_1.default.getChildren(NodeUtil_js_1.default.getChildren(child)[0]).length)))) {
|
||||
if (NodeUtil_js_1.default.isEmbellished(child) ||
|
||||
(NodeUtil_js_1.default.isType(child, 'TeXAtom') && NodeUtil_js_1.default.getTexClass(child) === MmlNode_js_1.TEXCLASS.REL)) {
|
||||
var mi = configuration.nodeFactory.create('node', 'mi');
|
||||
nodes.unshift(mi);
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
ParseUtil.fixInitialMO = fixInitialMO;
|
||||
function internalMath(parser, text, level, font) {
|
||||
if (parser.configuration.options.internalMath) {
|
||||
return parser.configuration.options.internalMath(parser, text, level, font);
|
||||
}
|
||||
var mathvariant = font || parser.stack.env.font;
|
||||
var def = (mathvariant ? { mathvariant: mathvariant } : {});
|
||||
var mml = [], i = 0, k = 0, c, node, match = '', braces = 0;
|
||||
if (text.match(/\\?[${}\\]|\\\(|\\(eq)?ref\s*\{/)) {
|
||||
while (i < text.length) {
|
||||
c = text.charAt(i++);
|
||||
if (c === '$') {
|
||||
if (match === '$' && braces === 0) {
|
||||
node = parser.create('node', 'TeXAtom', [(new TexParser_js_1.default(text.slice(k, i - 1), {}, parser.configuration)).mml()]);
|
||||
mml.push(node);
|
||||
match = '';
|
||||
k = i;
|
||||
}
|
||||
else if (match === '') {
|
||||
if (k < i - 1) {
|
||||
mml.push(internalText(parser, text.slice(k, i - 1), def));
|
||||
}
|
||||
match = '$';
|
||||
k = i;
|
||||
}
|
||||
}
|
||||
else if (c === '{' && match !== '') {
|
||||
braces++;
|
||||
}
|
||||
else if (c === '}') {
|
||||
if (match === '}' && braces === 0) {
|
||||
var atom = (new TexParser_js_1.default(text.slice(k, i), {}, parser.configuration)).mml();
|
||||
node = parser.create('node', 'TeXAtom', [atom], def);
|
||||
mml.push(node);
|
||||
match = '';
|
||||
k = i;
|
||||
}
|
||||
else if (match !== '') {
|
||||
if (braces) {
|
||||
braces--;
|
||||
}
|
||||
}
|
||||
}
|
||||
else if (c === '\\') {
|
||||
if (match === '' && text.substr(i).match(/^(eq)?ref\s*\{/)) {
|
||||
var len = RegExp['$&'].length;
|
||||
if (k < i - 1) {
|
||||
mml.push(internalText(parser, text.slice(k, i - 1), def));
|
||||
}
|
||||
match = '}';
|
||||
k = i - 1;
|
||||
i += len;
|
||||
}
|
||||
else {
|
||||
c = text.charAt(i++);
|
||||
if (c === '(' && match === '') {
|
||||
if (k < i - 2) {
|
||||
mml.push(internalText(parser, text.slice(k, i - 2), def));
|
||||
}
|
||||
match = ')';
|
||||
k = i;
|
||||
}
|
||||
else if (c === ')' && match === ')' && braces === 0) {
|
||||
node = parser.create('node', 'TeXAtom', [(new TexParser_js_1.default(text.slice(k, i - 2), {}, parser.configuration)).mml()]);
|
||||
mml.push(node);
|
||||
match = '';
|
||||
k = i;
|
||||
}
|
||||
else if (c.match(/[${}\\]/) && match === '') {
|
||||
i--;
|
||||
text = text.substr(0, i - 1) + text.substr(i);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if (match !== '') {
|
||||
throw new TexError_js_1.default('MathNotTerminated', 'Math not terminated in text box');
|
||||
}
|
||||
}
|
||||
if (k < text.length) {
|
||||
mml.push(internalText(parser, text.slice(k), def));
|
||||
}
|
||||
if (level != null) {
|
||||
mml = [parser.create('node', 'mstyle', mml, { displaystyle: false, scriptlevel: level })];
|
||||
}
|
||||
else if (mml.length > 1) {
|
||||
mml = [parser.create('node', 'mrow', mml)];
|
||||
}
|
||||
return mml;
|
||||
}
|
||||
ParseUtil.internalMath = internalMath;
|
||||
function internalText(parser, text, def) {
|
||||
text = text.replace(/^\s+/, Entities_js_1.entities.nbsp).replace(/\s+$/, Entities_js_1.entities.nbsp);
|
||||
var textNode = parser.create('text', text);
|
||||
return parser.create('node', 'mtext', [], def, textNode);
|
||||
}
|
||||
ParseUtil.internalText = internalText;
|
||||
function underOver(parser, base, script, pos, stack) {
|
||||
ParseUtil.checkMovableLimits(base);
|
||||
if (NodeUtil_js_1.default.isType(base, 'munderover') && NodeUtil_js_1.default.isEmbellished(base)) {
|
||||
NodeUtil_js_1.default.setProperties(NodeUtil_js_1.default.getCoreMO(base), { lspace: 0, rspace: 0 });
|
||||
var mo = parser.create('node', 'mo', [], { rspace: 0 });
|
||||
base = parser.create('node', 'mrow', [mo, base]);
|
||||
}
|
||||
var mml = parser.create('node', 'munderover', [base]);
|
||||
NodeUtil_js_1.default.setChild(mml, pos === 'over' ? mml.over : mml.under, script);
|
||||
var node = mml;
|
||||
if (stack) {
|
||||
node = parser.create('node', 'TeXAtom', [mml], { texClass: MmlNode_js_1.TEXCLASS.OP, movesupsub: true });
|
||||
}
|
||||
NodeUtil_js_1.default.setProperty(node, 'subsupOK', true);
|
||||
return node;
|
||||
}
|
||||
ParseUtil.underOver = underOver;
|
||||
function checkMovableLimits(base) {
|
||||
var symbol = (NodeUtil_js_1.default.isType(base, 'mo') ? NodeUtil_js_1.default.getForm(base) : null);
|
||||
if (NodeUtil_js_1.default.getProperty(base, 'movablelimits') || (symbol && symbol[3] && symbol[3].movablelimits)) {
|
||||
NodeUtil_js_1.default.setProperties(base, { movablelimits: false });
|
||||
}
|
||||
}
|
||||
ParseUtil.checkMovableLimits = checkMovableLimits;
|
||||
function trimSpaces(text) {
|
||||
if (typeof (text) !== 'string') {
|
||||
return text;
|
||||
}
|
||||
var TEXT = text.trim();
|
||||
if (TEXT.match(/\\$/) && text.match(/ $/)) {
|
||||
TEXT += ' ';
|
||||
}
|
||||
return TEXT;
|
||||
}
|
||||
ParseUtil.trimSpaces = trimSpaces;
|
||||
function setArrayAlign(array, align) {
|
||||
align = ParseUtil.trimSpaces(align || '');
|
||||
if (align === 't') {
|
||||
array.arraydef.align = 'baseline 1';
|
||||
}
|
||||
else if (align === 'b') {
|
||||
array.arraydef.align = 'baseline -1';
|
||||
}
|
||||
else if (align === 'c') {
|
||||
array.arraydef.align = 'axis';
|
||||
}
|
||||
else if (align) {
|
||||
array.arraydef.align = align;
|
||||
}
|
||||
return array;
|
||||
}
|
||||
ParseUtil.setArrayAlign = setArrayAlign;
|
||||
function substituteArgs(parser, args, str) {
|
||||
var text = '';
|
||||
var newstring = '';
|
||||
var i = 0;
|
||||
while (i < str.length) {
|
||||
var c = str.charAt(i++);
|
||||
if (c === '\\') {
|
||||
text += c + str.charAt(i++);
|
||||
}
|
||||
else if (c === '#') {
|
||||
c = str.charAt(i++);
|
||||
if (c === '#') {
|
||||
text += c;
|
||||
}
|
||||
else {
|
||||
if (!c.match(/[1-9]/) || parseInt(c, 10) > args.length) {
|
||||
throw new TexError_js_1.default('IllegalMacroParam', 'Illegal macro parameter reference');
|
||||
}
|
||||
newstring = addArgs(parser, addArgs(parser, newstring, text), args[parseInt(c, 10) - 1]);
|
||||
text = '';
|
||||
}
|
||||
}
|
||||
else {
|
||||
text += c;
|
||||
}
|
||||
}
|
||||
return addArgs(parser, newstring, text);
|
||||
}
|
||||
ParseUtil.substituteArgs = substituteArgs;
|
||||
function addArgs(parser, s1, s2) {
|
||||
if (s2.match(/^[a-z]/i) && s1.match(/(^|[^\\])(\\\\)*\\[a-z]+$/i)) {
|
||||
s1 += ' ';
|
||||
}
|
||||
if (s1.length + s2.length > parser.configuration.options['maxBuffer']) {
|
||||
throw new TexError_js_1.default('MaxBufferSize', 'MathJax internal buffer size exceeded; is there a' +
|
||||
' recursive macro call?');
|
||||
}
|
||||
return s1 + s2;
|
||||
}
|
||||
ParseUtil.addArgs = addArgs;
|
||||
function checkMaxMacros(parser, isMacro) {
|
||||
if (isMacro === void 0) { isMacro = true; }
|
||||
if (++parser.macroCount <= parser.configuration.options['maxMacros']) {
|
||||
return;
|
||||
}
|
||||
if (isMacro) {
|
||||
throw new TexError_js_1.default('MaxMacroSub1', 'MathJax maximum macro substitution count exceeded; ' +
|
||||
'is here a recursive macro call?');
|
||||
}
|
||||
else {
|
||||
throw new TexError_js_1.default('MaxMacroSub2', 'MathJax maximum substitution count exceeded; ' +
|
||||
'is there a recursive latex environment?');
|
||||
}
|
||||
}
|
||||
ParseUtil.checkMaxMacros = checkMaxMacros;
|
||||
function checkEqnEnv(parser) {
|
||||
if (parser.stack.global.eqnenv) {
|
||||
throw new TexError_js_1.default('ErroneousNestingEq', 'Erroneous nesting of equation structures');
|
||||
}
|
||||
parser.stack.global.eqnenv = true;
|
||||
}
|
||||
ParseUtil.checkEqnEnv = checkEqnEnv;
|
||||
function copyNode(node, parser) {
|
||||
var tree = node.copy();
|
||||
var options = parser.configuration;
|
||||
tree.walkTree(function (n) {
|
||||
var e_1, _a;
|
||||
options.addNode(n.kind, n);
|
||||
var lists = (n.getProperty('in-lists') || '').split(/,/);
|
||||
try {
|
||||
for (var lists_1 = __values(lists), lists_1_1 = lists_1.next(); !lists_1_1.done; lists_1_1 = lists_1.next()) {
|
||||
var list = lists_1_1.value;
|
||||
list && options.addNode(list, n);
|
||||
}
|
||||
}
|
||||
catch (e_1_1) { e_1 = { error: e_1_1 }; }
|
||||
finally {
|
||||
try {
|
||||
if (lists_1_1 && !lists_1_1.done && (_a = lists_1.return)) _a.call(lists_1);
|
||||
}
|
||||
finally { if (e_1) throw e_1.error; }
|
||||
}
|
||||
});
|
||||
return tree;
|
||||
}
|
||||
ParseUtil.copyNode = copyNode;
|
||||
function MmlFilterAttribute(_parser, _name, value) {
|
||||
return value;
|
||||
}
|
||||
ParseUtil.MmlFilterAttribute = MmlFilterAttribute;
|
||||
function getFontDef(parser) {
|
||||
var font = parser.stack.env['font'];
|
||||
return (font ? { mathvariant: font } : {});
|
||||
}
|
||||
ParseUtil.getFontDef = getFontDef;
|
||||
function keyvalOptions(attrib, allowed, error) {
|
||||
var e_2, _a;
|
||||
if (allowed === void 0) { allowed = null; }
|
||||
if (error === void 0) { error = false; }
|
||||
var def = readKeyval(attrib);
|
||||
if (allowed) {
|
||||
try {
|
||||
for (var _b = __values(Object.keys(def)), _c = _b.next(); !_c.done; _c = _b.next()) {
|
||||
var key = _c.value;
|
||||
if (!allowed.hasOwnProperty(key)) {
|
||||
if (error) {
|
||||
throw new TexError_js_1.default('InvalidOption', 'Invalid option: %1', key);
|
||||
}
|
||||
delete def[key];
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (e_2_1) { e_2 = { error: e_2_1 }; }
|
||||
finally {
|
||||
try {
|
||||
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
|
||||
}
|
||||
finally { if (e_2) throw e_2.error; }
|
||||
}
|
||||
}
|
||||
return def;
|
||||
}
|
||||
ParseUtil.keyvalOptions = keyvalOptions;
|
||||
function readKeyval(text) {
|
||||
var _a, _b;
|
||||
var options = {};
|
||||
var rest = text;
|
||||
var end, key, val;
|
||||
while (rest) {
|
||||
_a = __read(readValue(rest, ['=', ',']), 3), key = _a[0], end = _a[1], rest = _a[2];
|
||||
if (end === '=') {
|
||||
_b = __read(readValue(rest, [',']), 3), val = _b[0], end = _b[1], rest = _b[2];
|
||||
val = (val === 'false' || val === 'true') ?
|
||||
JSON.parse(val) : val;
|
||||
options[key] = val;
|
||||
}
|
||||
else if (key) {
|
||||
options[key] = true;
|
||||
}
|
||||
}
|
||||
return options;
|
||||
}
|
||||
function removeBraces(text, count) {
|
||||
while (count > 0) {
|
||||
text = text.trim().slice(1, -1);
|
||||
count--;
|
||||
}
|
||||
return text.trim();
|
||||
}
|
||||
function readValue(text, end) {
|
||||
var length = text.length;
|
||||
var braces = 0;
|
||||
var value = '';
|
||||
var index = 0;
|
||||
var start = 0;
|
||||
var startCount = true;
|
||||
var stopCount = false;
|
||||
while (index < length) {
|
||||
var c = text[index++];
|
||||
switch (c) {
|
||||
case ' ':
|
||||
break;
|
||||
case '{':
|
||||
if (startCount) {
|
||||
start++;
|
||||
}
|
||||
else {
|
||||
stopCount = false;
|
||||
if (start > braces) {
|
||||
start = braces;
|
||||
}
|
||||
}
|
||||
braces++;
|
||||
break;
|
||||
case '}':
|
||||
if (braces) {
|
||||
braces--;
|
||||
}
|
||||
if (startCount || stopCount) {
|
||||
start--;
|
||||
stopCount = true;
|
||||
}
|
||||
startCount = false;
|
||||
break;
|
||||
default:
|
||||
if (!braces && end.indexOf(c) !== -1) {
|
||||
return [stopCount ? 'true' :
|
||||
removeBraces(value, start), c, text.slice(index)];
|
||||
}
|
||||
startCount = false;
|
||||
stopCount = false;
|
||||
}
|
||||
value += c;
|
||||
}
|
||||
if (braces) {
|
||||
throw new TexError_js_1.default('ExtraOpenMissingClose', 'Extra open brace or missing close brace');
|
||||
}
|
||||
return [stopCount ? 'true' : removeBraces(value, start), '', text.slice(index)];
|
||||
}
|
||||
})(ParseUtil || (ParseUtil = {}));
|
||||
exports.default = ParseUtil;
|
||||
//# sourceMappingURL=ParseUtil.js.map
|
||||
1
node_modules/mathjax-full/js/input/tex/ParseUtil.js.map
generated
vendored
Normal file
1
node_modules/mathjax-full/js/input/tex/ParseUtil.js.map
generated
vendored
Normal file
File diff suppressed because one or more lines are too long
17
node_modules/mathjax-full/js/input/tex/Stack.d.ts
generated
vendored
Normal file
17
node_modules/mathjax-full/js/input/tex/Stack.d.ts
generated
vendored
Normal file
@@ -0,0 +1,17 @@
|
||||
import { MmlNode } from '../../core/MmlTree/MmlNode.js';
|
||||
import { StackItem, EnvList } from './StackItem.js';
|
||||
import StackItemFactory from './StackItemFactory.js';
|
||||
export default class Stack {
|
||||
private _factory;
|
||||
private _env;
|
||||
global: EnvList;
|
||||
private stack;
|
||||
constructor(_factory: StackItemFactory, _env: EnvList, inner: boolean);
|
||||
set env(env: EnvList);
|
||||
get env(): EnvList;
|
||||
Push(...args: (StackItem | MmlNode)[]): void;
|
||||
Pop(): StackItem;
|
||||
Top(n?: number): StackItem;
|
||||
Prev(noPop?: boolean): MmlNode | void;
|
||||
toString(): string;
|
||||
}
|
||||
132
node_modules/mathjax-full/js/input/tex/Stack.js
generated
vendored
Normal file
132
node_modules/mathjax-full/js/input/tex/Stack.js
generated
vendored
Normal file
@@ -0,0 +1,132 @@
|
||||
"use strict";
|
||||
var __values = (this && this.__values) || function(o) {
|
||||
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
|
||||
if (m) return m.call(o);
|
||||
if (o && typeof o.length === "number") return {
|
||||
next: function () {
|
||||
if (o && i >= o.length) o = void 0;
|
||||
return { value: o && o[i++], done: !o };
|
||||
}
|
||||
};
|
||||
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
|
||||
};
|
||||
var __read = (this && this.__read) || function (o, n) {
|
||||
var m = typeof Symbol === "function" && o[Symbol.iterator];
|
||||
if (!m) return o;
|
||||
var i = m.call(o), r, ar = [], e;
|
||||
try {
|
||||
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
|
||||
}
|
||||
catch (error) { e = { error: error }; }
|
||||
finally {
|
||||
try {
|
||||
if (r && !r.done && (m = i["return"])) m.call(i);
|
||||
}
|
||||
finally { if (e) throw e.error; }
|
||||
}
|
||||
return ar;
|
||||
};
|
||||
var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
|
||||
if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
|
||||
if (ar || !(i in from)) {
|
||||
if (!ar) ar = Array.prototype.slice.call(from, 0, i);
|
||||
ar[i] = from[i];
|
||||
}
|
||||
}
|
||||
return to.concat(ar || Array.prototype.slice.call(from));
|
||||
};
|
||||
var __importDefault = (this && this.__importDefault) || function (mod) {
|
||||
return (mod && mod.__esModule) ? mod : { "default": mod };
|
||||
};
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
var NodeUtil_js_1 = __importDefault(require("./NodeUtil.js"));
|
||||
var Stack = (function () {
|
||||
function Stack(_factory, _env, inner) {
|
||||
this._factory = _factory;
|
||||
this._env = _env;
|
||||
this.global = {};
|
||||
this.stack = [];
|
||||
this.global = { isInner: inner };
|
||||
this.stack = [this._factory.create('start', this.global)];
|
||||
if (_env) {
|
||||
this.stack[0].env = _env;
|
||||
}
|
||||
this.env = this.stack[0].env;
|
||||
}
|
||||
Object.defineProperty(Stack.prototype, "env", {
|
||||
get: function () {
|
||||
return this._env;
|
||||
},
|
||||
set: function (env) {
|
||||
this._env = env;
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
Stack.prototype.Push = function () {
|
||||
var e_1, _a;
|
||||
var args = [];
|
||||
for (var _i = 0; _i < arguments.length; _i++) {
|
||||
args[_i] = arguments[_i];
|
||||
}
|
||||
try {
|
||||
for (var args_1 = __values(args), args_1_1 = args_1.next(); !args_1_1.done; args_1_1 = args_1.next()) {
|
||||
var node = args_1_1.value;
|
||||
if (!node) {
|
||||
continue;
|
||||
}
|
||||
var item = NodeUtil_js_1.default.isNode(node) ?
|
||||
this._factory.create('mml', node) : node;
|
||||
item.global = this.global;
|
||||
var _b = __read(this.stack.length ? this.Top().checkItem(item) : [null, true], 2), top_1 = _b[0], success = _b[1];
|
||||
if (!success) {
|
||||
continue;
|
||||
}
|
||||
if (top_1) {
|
||||
this.Pop();
|
||||
this.Push.apply(this, __spreadArray([], __read(top_1), false));
|
||||
continue;
|
||||
}
|
||||
this.stack.push(item);
|
||||
if (item.env) {
|
||||
if (item.copyEnv) {
|
||||
Object.assign(item.env, this.env);
|
||||
}
|
||||
this.env = item.env;
|
||||
}
|
||||
else {
|
||||
item.env = this.env;
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (e_1_1) { e_1 = { error: e_1_1 }; }
|
||||
finally {
|
||||
try {
|
||||
if (args_1_1 && !args_1_1.done && (_a = args_1.return)) _a.call(args_1);
|
||||
}
|
||||
finally { if (e_1) throw e_1.error; }
|
||||
}
|
||||
};
|
||||
Stack.prototype.Pop = function () {
|
||||
var item = this.stack.pop();
|
||||
if (!item.isOpen) {
|
||||
delete item.env;
|
||||
}
|
||||
this.env = (this.stack.length ? this.Top().env : {});
|
||||
return item;
|
||||
};
|
||||
Stack.prototype.Top = function (n) {
|
||||
if (n === void 0) { n = 1; }
|
||||
return this.stack.length < n ? null : this.stack[this.stack.length - n];
|
||||
};
|
||||
Stack.prototype.Prev = function (noPop) {
|
||||
var top = this.Top();
|
||||
return noPop ? top.First : top.Pop();
|
||||
};
|
||||
Stack.prototype.toString = function () {
|
||||
return 'stack[\n ' + this.stack.join('\n ') + '\n]';
|
||||
};
|
||||
return Stack;
|
||||
}());
|
||||
exports.default = Stack;
|
||||
//# sourceMappingURL=Stack.js.map
|
||||
1
node_modules/mathjax-full/js/input/tex/Stack.js.map
generated
vendored
Normal file
1
node_modules/mathjax-full/js/input/tex/Stack.js.map
generated
vendored
Normal file
@@ -0,0 +1 @@
|
||||
{"version":3,"file":"Stack.js","sourceRoot":"","sources":["../../../ts/input/tex/Stack.ts"],"names":[],"mappings":"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"}
|
||||
84
node_modules/mathjax-full/js/input/tex/StackItem.d.ts
generated
vendored
Normal file
84
node_modules/mathjax-full/js/input/tex/StackItem.d.ts
generated
vendored
Normal file
@@ -0,0 +1,84 @@
|
||||
import { MmlNode } from '../../core/MmlTree/MmlNode.js';
|
||||
import { FactoryNodeClass } from '../../core/Tree/Factory.js';
|
||||
import StackItemFactory from './StackItemFactory.js';
|
||||
export declare type EnvProp = string | number | boolean;
|
||||
export declare type EnvList = {
|
||||
[key: string]: EnvProp;
|
||||
};
|
||||
export declare type Prop = string | number | boolean | MmlNode | PropList;
|
||||
export declare type PropList = {
|
||||
[key: string]: Prop;
|
||||
};
|
||||
export declare type CheckType = [(MmlNode | StackItem)[], boolean];
|
||||
export interface NodeStack {
|
||||
First: MmlNode;
|
||||
Last: MmlNode;
|
||||
Pop(): MmlNode | void;
|
||||
Push(...nodes: MmlNode[]): void;
|
||||
Peek(n?: number): MmlNode[];
|
||||
Size(): number;
|
||||
Clear(): void;
|
||||
toMml(inferred?: boolean, forceRow?: boolean): MmlNode;
|
||||
}
|
||||
export declare abstract class MmlStack implements NodeStack {
|
||||
private _nodes;
|
||||
constructor(_nodes: MmlNode[]);
|
||||
protected get nodes(): MmlNode[];
|
||||
Push(...nodes: MmlNode[]): void;
|
||||
Pop(): MmlNode;
|
||||
get First(): MmlNode;
|
||||
set First(node: MmlNode);
|
||||
get Last(): MmlNode;
|
||||
set Last(node: MmlNode);
|
||||
Peek(n?: number): MmlNode[];
|
||||
Size(): number;
|
||||
Clear(): void;
|
||||
protected abstract get factory(): StackItemFactory;
|
||||
toMml(inferred?: boolean, forceRow?: boolean): MmlNode;
|
||||
create(kind: string, ...rest: any[]): MmlNode;
|
||||
}
|
||||
export interface StackItem extends NodeStack {
|
||||
kind: string;
|
||||
isClose: boolean;
|
||||
isOpen: boolean;
|
||||
isFinal: boolean;
|
||||
global: EnvList;
|
||||
env: EnvList;
|
||||
copyEnv: boolean;
|
||||
isKind(kind: string): boolean;
|
||||
getProperty(key: string): Prop;
|
||||
setProperty(key: string, value: Prop): StackItem;
|
||||
setProperties(def: PropList): StackItem;
|
||||
getName(): string;
|
||||
checkItem(item: StackItem): CheckType;
|
||||
}
|
||||
export interface StackItemClass extends FactoryNodeClass<StackItem> {
|
||||
}
|
||||
export declare abstract class BaseItem extends MmlStack implements StackItem {
|
||||
protected factory: StackItemFactory;
|
||||
protected static fail: CheckType;
|
||||
protected static success: CheckType;
|
||||
protected static errors: {
|
||||
[key: string]: string[];
|
||||
};
|
||||
global: EnvList;
|
||||
private _env;
|
||||
private _properties;
|
||||
constructor(factory: StackItemFactory, ...nodes: MmlNode[]);
|
||||
get kind(): string;
|
||||
get env(): EnvList;
|
||||
set env(value: EnvList);
|
||||
get copyEnv(): boolean;
|
||||
getProperty(key: string): Prop;
|
||||
setProperty(key: string, value: Prop): this;
|
||||
get isOpen(): boolean;
|
||||
get isClose(): boolean;
|
||||
get isFinal(): boolean;
|
||||
isKind(kind: string): boolean;
|
||||
checkItem(item: StackItem): CheckType;
|
||||
clearEnv(): void;
|
||||
setProperties(def: PropList): this;
|
||||
getName(): string;
|
||||
toString(): string;
|
||||
getErrors(kind: string): string[];
|
||||
}
|
||||
264
node_modules/mathjax-full/js/input/tex/StackItem.js
generated
vendored
Normal file
264
node_modules/mathjax-full/js/input/tex/StackItem.js
generated
vendored
Normal file
@@ -0,0 +1,264 @@
|
||||
"use strict";
|
||||
var __extends = (this && this.__extends) || (function () {
|
||||
var extendStatics = function (d, b) {
|
||||
extendStatics = Object.setPrototypeOf ||
|
||||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
||||
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
|
||||
return extendStatics(d, b);
|
||||
};
|
||||
return function (d, b) {
|
||||
if (typeof b !== "function" && b !== null)
|
||||
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
|
||||
extendStatics(d, b);
|
||||
function __() { this.constructor = d; }
|
||||
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
||||
};
|
||||
})();
|
||||
var __read = (this && this.__read) || function (o, n) {
|
||||
var m = typeof Symbol === "function" && o[Symbol.iterator];
|
||||
if (!m) return o;
|
||||
var i = m.call(o), r, ar = [], e;
|
||||
try {
|
||||
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
|
||||
}
|
||||
catch (error) { e = { error: error }; }
|
||||
finally {
|
||||
try {
|
||||
if (r && !r.done && (m = i["return"])) m.call(i);
|
||||
}
|
||||
finally { if (e) throw e.error; }
|
||||
}
|
||||
return ar;
|
||||
};
|
||||
var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
|
||||
if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
|
||||
if (ar || !(i in from)) {
|
||||
if (!ar) ar = Array.prototype.slice.call(from, 0, i);
|
||||
ar[i] = from[i];
|
||||
}
|
||||
}
|
||||
return to.concat(ar || Array.prototype.slice.call(from));
|
||||
};
|
||||
var __values = (this && this.__values) || function(o) {
|
||||
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
|
||||
if (m) return m.call(o);
|
||||
if (o && typeof o.length === "number") return {
|
||||
next: function () {
|
||||
if (o && i >= o.length) o = void 0;
|
||||
return { value: o && o[i++], done: !o };
|
||||
}
|
||||
};
|
||||
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
|
||||
};
|
||||
var __importDefault = (this && this.__importDefault) || function (mod) {
|
||||
return (mod && mod.__esModule) ? mod : { "default": mod };
|
||||
};
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.BaseItem = exports.MmlStack = void 0;
|
||||
var TexError_js_1 = __importDefault(require("./TexError.js"));
|
||||
var MmlStack = (function () {
|
||||
function MmlStack(_nodes) {
|
||||
this._nodes = _nodes;
|
||||
}
|
||||
Object.defineProperty(MmlStack.prototype, "nodes", {
|
||||
get: function () {
|
||||
return this._nodes;
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
MmlStack.prototype.Push = function () {
|
||||
var _a;
|
||||
var nodes = [];
|
||||
for (var _i = 0; _i < arguments.length; _i++) {
|
||||
nodes[_i] = arguments[_i];
|
||||
}
|
||||
(_a = this._nodes).push.apply(_a, __spreadArray([], __read(nodes), false));
|
||||
};
|
||||
MmlStack.prototype.Pop = function () {
|
||||
return this._nodes.pop();
|
||||
};
|
||||
Object.defineProperty(MmlStack.prototype, "First", {
|
||||
get: function () {
|
||||
return this._nodes[this.Size() - 1];
|
||||
},
|
||||
set: function (node) {
|
||||
this._nodes[this.Size() - 1] = node;
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
Object.defineProperty(MmlStack.prototype, "Last", {
|
||||
get: function () {
|
||||
return this._nodes[0];
|
||||
},
|
||||
set: function (node) {
|
||||
this._nodes[0] = node;
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
MmlStack.prototype.Peek = function (n) {
|
||||
if (n == null) {
|
||||
n = 1;
|
||||
}
|
||||
return this._nodes.slice(this.Size() - n);
|
||||
};
|
||||
MmlStack.prototype.Size = function () {
|
||||
return this._nodes.length;
|
||||
};
|
||||
MmlStack.prototype.Clear = function () {
|
||||
this._nodes = [];
|
||||
};
|
||||
MmlStack.prototype.toMml = function (inferred, forceRow) {
|
||||
if (inferred === void 0) { inferred = true; }
|
||||
if (this._nodes.length === 1 && !forceRow) {
|
||||
return this.First;
|
||||
}
|
||||
return this.create('node', inferred ? 'inferredMrow' : 'mrow', this._nodes, {});
|
||||
};
|
||||
MmlStack.prototype.create = function (kind) {
|
||||
var _a;
|
||||
var rest = [];
|
||||
for (var _i = 1; _i < arguments.length; _i++) {
|
||||
rest[_i - 1] = arguments[_i];
|
||||
}
|
||||
return (_a = this.factory.configuration.nodeFactory).create.apply(_a, __spreadArray([kind], __read(rest), false));
|
||||
};
|
||||
return MmlStack;
|
||||
}());
|
||||
exports.MmlStack = MmlStack;
|
||||
var BaseItem = (function (_super) {
|
||||
__extends(BaseItem, _super);
|
||||
function BaseItem(factory) {
|
||||
var nodes = [];
|
||||
for (var _i = 1; _i < arguments.length; _i++) {
|
||||
nodes[_i - 1] = arguments[_i];
|
||||
}
|
||||
var _this = _super.call(this, nodes) || this;
|
||||
_this.factory = factory;
|
||||
_this.global = {};
|
||||
_this._properties = {};
|
||||
if (_this.isOpen) {
|
||||
_this._env = {};
|
||||
}
|
||||
return _this;
|
||||
}
|
||||
Object.defineProperty(BaseItem.prototype, "kind", {
|
||||
get: function () {
|
||||
return 'base';
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
Object.defineProperty(BaseItem.prototype, "env", {
|
||||
get: function () {
|
||||
return this._env;
|
||||
},
|
||||
set: function (value) {
|
||||
this._env = value;
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
Object.defineProperty(BaseItem.prototype, "copyEnv", {
|
||||
get: function () {
|
||||
return true;
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
BaseItem.prototype.getProperty = function (key) {
|
||||
return this._properties[key];
|
||||
};
|
||||
BaseItem.prototype.setProperty = function (key, value) {
|
||||
this._properties[key] = value;
|
||||
return this;
|
||||
};
|
||||
Object.defineProperty(BaseItem.prototype, "isOpen", {
|
||||
get: function () {
|
||||
return false;
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
Object.defineProperty(BaseItem.prototype, "isClose", {
|
||||
get: function () {
|
||||
return false;
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
Object.defineProperty(BaseItem.prototype, "isFinal", {
|
||||
get: function () {
|
||||
return false;
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
BaseItem.prototype.isKind = function (kind) {
|
||||
return kind === this.kind;
|
||||
};
|
||||
BaseItem.prototype.checkItem = function (item) {
|
||||
if (item.isKind('over') && this.isOpen) {
|
||||
item.setProperty('num', this.toMml(false));
|
||||
this.Clear();
|
||||
}
|
||||
if (item.isKind('cell') && this.isOpen) {
|
||||
if (item.getProperty('linebreak')) {
|
||||
return BaseItem.fail;
|
||||
}
|
||||
throw new TexError_js_1.default('Misplaced', 'Misplaced %1', item.getName());
|
||||
}
|
||||
if (item.isClose && this.getErrors(item.kind)) {
|
||||
var _a = __read(this.getErrors(item.kind), 2), id = _a[0], message = _a[1];
|
||||
throw new TexError_js_1.default(id, message, item.getName());
|
||||
}
|
||||
if (!item.isFinal) {
|
||||
return BaseItem.success;
|
||||
}
|
||||
this.Push(item.First);
|
||||
return BaseItem.fail;
|
||||
};
|
||||
BaseItem.prototype.clearEnv = function () {
|
||||
var e_1, _a;
|
||||
try {
|
||||
for (var _b = __values(Object.keys(this.env)), _c = _b.next(); !_c.done; _c = _b.next()) {
|
||||
var id = _c.value;
|
||||
delete this.env[id];
|
||||
}
|
||||
}
|
||||
catch (e_1_1) { e_1 = { error: e_1_1 }; }
|
||||
finally {
|
||||
try {
|
||||
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
|
||||
}
|
||||
finally { if (e_1) throw e_1.error; }
|
||||
}
|
||||
};
|
||||
BaseItem.prototype.setProperties = function (def) {
|
||||
Object.assign(this._properties, def);
|
||||
return this;
|
||||
};
|
||||
BaseItem.prototype.getName = function () {
|
||||
return this.getProperty('name');
|
||||
};
|
||||
BaseItem.prototype.toString = function () {
|
||||
return this.kind + '[' + this.nodes.join('; ') + ']';
|
||||
};
|
||||
BaseItem.prototype.getErrors = function (kind) {
|
||||
var CLASS = this.constructor;
|
||||
return (CLASS.errors || {})[kind] || BaseItem.errors[kind];
|
||||
};
|
||||
BaseItem.fail = [null, false];
|
||||
BaseItem.success = [null, true];
|
||||
BaseItem.errors = {
|
||||
end: ['MissingBeginExtraEnd', 'Missing \\begin{%1} or extra \\end{%1}'],
|
||||
close: ['ExtraCloseMissingOpen', 'Extra close brace or missing open brace'],
|
||||
right: ['MissingLeftExtraRight', 'Missing \\left or extra \\right'],
|
||||
middle: ['ExtraMiddle', 'Extra \\middle']
|
||||
};
|
||||
return BaseItem;
|
||||
}(MmlStack));
|
||||
exports.BaseItem = BaseItem;
|
||||
//# sourceMappingURL=StackItem.js.map
|
||||
1
node_modules/mathjax-full/js/input/tex/StackItem.js.map
generated
vendored
Normal file
1
node_modules/mathjax-full/js/input/tex/StackItem.js.map
generated
vendored
Normal file
@@ -0,0 +1 @@
|
||||
{"version":3,"file":"StackItem.js","sourceRoot":"","sources":["../../../ts/input/tex/StackItem.ts"],"names":[],"mappings":"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"}
|
||||
10
node_modules/mathjax-full/js/input/tex/StackItemFactory.d.ts
generated
vendored
Normal file
10
node_modules/mathjax-full/js/input/tex/StackItemFactory.d.ts
generated
vendored
Normal file
@@ -0,0 +1,10 @@
|
||||
import { StackItemClass, StackItem } from './StackItem.js';
|
||||
import ParseOptions from './ParseOptions.js';
|
||||
import { AbstractFactory } from '../../core/Tree/Factory.js';
|
||||
export default class StackItemFactory extends AbstractFactory<StackItem, StackItemClass> {
|
||||
static DefaultStackItems: {
|
||||
[kind: string]: StackItemClass;
|
||||
};
|
||||
defaultKind: string;
|
||||
configuration: ParseOptions;
|
||||
}
|
||||
42
node_modules/mathjax-full/js/input/tex/StackItemFactory.js
generated
vendored
Normal file
42
node_modules/mathjax-full/js/input/tex/StackItemFactory.js
generated
vendored
Normal file
@@ -0,0 +1,42 @@
|
||||
"use strict";
|
||||
var __extends = (this && this.__extends) || (function () {
|
||||
var extendStatics = function (d, b) {
|
||||
extendStatics = Object.setPrototypeOf ||
|
||||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
||||
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
|
||||
return extendStatics(d, b);
|
||||
};
|
||||
return function (d, b) {
|
||||
if (typeof b !== "function" && b !== null)
|
||||
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
|
||||
extendStatics(d, b);
|
||||
function __() { this.constructor = d; }
|
||||
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
||||
};
|
||||
})();
|
||||
var _a;
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
var StackItem_js_1 = require("./StackItem.js");
|
||||
var Factory_js_1 = require("../../core/Tree/Factory.js");
|
||||
var DummyItem = (function (_super) {
|
||||
__extends(DummyItem, _super);
|
||||
function DummyItem() {
|
||||
return _super !== null && _super.apply(this, arguments) || this;
|
||||
}
|
||||
return DummyItem;
|
||||
}(StackItem_js_1.BaseItem));
|
||||
var StackItemFactory = (function (_super) {
|
||||
__extends(StackItemFactory, _super);
|
||||
function StackItemFactory() {
|
||||
var _this = _super !== null && _super.apply(this, arguments) || this;
|
||||
_this.defaultKind = 'dummy';
|
||||
_this.configuration = null;
|
||||
return _this;
|
||||
}
|
||||
StackItemFactory.DefaultStackItems = (_a = {},
|
||||
_a[DummyItem.prototype.kind] = DummyItem,
|
||||
_a);
|
||||
return StackItemFactory;
|
||||
}(Factory_js_1.AbstractFactory));
|
||||
exports.default = StackItemFactory;
|
||||
//# sourceMappingURL=StackItemFactory.js.map
|
||||
1
node_modules/mathjax-full/js/input/tex/StackItemFactory.js.map
generated
vendored
Normal file
1
node_modules/mathjax-full/js/input/tex/StackItemFactory.js.map
generated
vendored
Normal file
@@ -0,0 +1 @@
|
||||
{"version":3,"file":"StackItemFactory.js","sourceRoot":"","sources":["../../../ts/input/tex/StackItemFactory.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AAyBA,+CAAmE;AAEnE,yDAA2D;AAG3D;IAAwB,6BAAQ;IAAhC;;IAAkC,CAAC;IAAD,gBAAC;AAAD,CAAC,AAAnC,CAAwB,uBAAQ,GAAG;AASnC;IAA8C,oCAA0C;IAAxF;QAAA,qEAsBC;QATQ,iBAAW,GAAG,OAAO,CAAC;QAOtB,mBAAa,GAAiB,IAAI,CAAC;;IAE5C,CAAC;IAjBe,kCAAiB;QAC7B,GAAC,SAAS,CAAC,SAAS,CAAC,IAAI,IAAG,SAAS;YACrC;IAeJ,uBAAC;CAAA,AAtBD,CAA8C,4BAAe,GAsB5D;kBAtBoB,gBAAgB"}
|
||||
19
node_modules/mathjax-full/js/input/tex/Symbol.d.ts
generated
vendored
Normal file
19
node_modules/mathjax-full/js/input/tex/Symbol.d.ts
generated
vendored
Normal file
@@ -0,0 +1,19 @@
|
||||
import { Args, Attributes, ParseMethod } from './Types.js';
|
||||
export declare class Symbol {
|
||||
private _symbol;
|
||||
private _char;
|
||||
private _attributes;
|
||||
constructor(_symbol: string, _char: string, _attributes: Attributes);
|
||||
get symbol(): string;
|
||||
get char(): string;
|
||||
get attributes(): Attributes;
|
||||
}
|
||||
export declare class Macro {
|
||||
private _symbol;
|
||||
private _func;
|
||||
private _args;
|
||||
constructor(_symbol: string, _func: ParseMethod, _args?: Args[]);
|
||||
get symbol(): string;
|
||||
get func(): ParseMethod;
|
||||
get args(): Args[];
|
||||
}
|
||||
65
node_modules/mathjax-full/js/input/tex/Symbol.js
generated
vendored
Normal file
65
node_modules/mathjax-full/js/input/tex/Symbol.js
generated
vendored
Normal file
@@ -0,0 +1,65 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.Macro = exports.Symbol = void 0;
|
||||
var Symbol = (function () {
|
||||
function Symbol(_symbol, _char, _attributes) {
|
||||
this._symbol = _symbol;
|
||||
this._char = _char;
|
||||
this._attributes = _attributes;
|
||||
}
|
||||
Object.defineProperty(Symbol.prototype, "symbol", {
|
||||
get: function () {
|
||||
return this._symbol;
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
Object.defineProperty(Symbol.prototype, "char", {
|
||||
get: function () {
|
||||
return this._char;
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
Object.defineProperty(Symbol.prototype, "attributes", {
|
||||
get: function () {
|
||||
return this._attributes;
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
return Symbol;
|
||||
}());
|
||||
exports.Symbol = Symbol;
|
||||
var Macro = (function () {
|
||||
function Macro(_symbol, _func, _args) {
|
||||
if (_args === void 0) { _args = []; }
|
||||
this._symbol = _symbol;
|
||||
this._func = _func;
|
||||
this._args = _args;
|
||||
}
|
||||
Object.defineProperty(Macro.prototype, "symbol", {
|
||||
get: function () {
|
||||
return this._symbol;
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
Object.defineProperty(Macro.prototype, "func", {
|
||||
get: function () {
|
||||
return this._func;
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
Object.defineProperty(Macro.prototype, "args", {
|
||||
get: function () {
|
||||
return this._args;
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
return Macro;
|
||||
}());
|
||||
exports.Macro = Macro;
|
||||
//# sourceMappingURL=Symbol.js.map
|
||||
1
node_modules/mathjax-full/js/input/tex/Symbol.js.map
generated
vendored
Normal file
1
node_modules/mathjax-full/js/input/tex/Symbol.js.map
generated
vendored
Normal file
@@ -0,0 +1 @@
|
||||
{"version":3,"file":"Symbol.js","sourceRoot":"","sources":["../../../ts/input/tex/Symbol.ts"],"names":[],"mappings":";;;AA8BA;IAQE,gBAAoB,OAAe,EAAU,KAAa,EACtC,WAAuB;QADvB,YAAO,GAAP,OAAO,CAAQ;QAAU,UAAK,GAAL,KAAK,CAAQ;QACtC,gBAAW,GAAX,WAAW,CAAY;IAC3C,CAAC;IAED,sBAAW,0BAAM;aAAjB;YACE,OAAO,IAAI,CAAC,OAAO,CAAC;QACtB,CAAC;;;OAAA;IAED,sBAAW,wBAAI;aAAf;YACE,OAAO,IAAI,CAAC,KAAK,CAAC;QACpB,CAAC;;;OAAA;IAED,sBAAW,8BAAU;aAArB;YACE,OAAO,IAAI,CAAC,WAAW,CAAC;QAC1B,CAAC;;;OAAA;IAEH,aAAC;AAAD,CAAC,AAxBD,IAwBC;AAxBY,wBAAM;AA2BnB;IAQE,eAAoB,OAAe,EAAU,KAAkB,EAC3C,KAAkB;QAAlB,sBAAA,EAAA,UAAkB;QADlB,YAAO,GAAP,OAAO,CAAQ;QAAU,UAAK,GAAL,KAAK,CAAa;QAC3C,UAAK,GAAL,KAAK,CAAa;IACtC,CAAC;IAED,sBAAW,yBAAM;aAAjB;YACE,OAAO,IAAI,CAAC,OAAO,CAAC;QACtB,CAAC;;;OAAA;IAED,sBAAW,uBAAI;aAAf;YACE,OAAO,IAAI,CAAC,KAAK,CAAC;QACpB,CAAC;;;OAAA;IAED,sBAAW,uBAAI;aAAf;YACE,OAAO,IAAI,CAAC,KAAK,CAAC;QACpB,CAAC;;;OAAA;IAEH,YAAC;AAAD,CAAC,AAxBD,IAwBC;AAxBY,sBAAK"}
|
||||
59
node_modules/mathjax-full/js/input/tex/SymbolMap.d.ts
generated
vendored
Normal file
59
node_modules/mathjax-full/js/input/tex/SymbolMap.d.ts
generated
vendored
Normal file
@@ -0,0 +1,59 @@
|
||||
import { Attributes, Args, ParseMethod, ParseInput, ParseResult } from './Types.js';
|
||||
import { Symbol, Macro } from './Symbol.js';
|
||||
export interface SymbolMap {
|
||||
name: string;
|
||||
parser: ParseMethod;
|
||||
contains(symbol: string): boolean;
|
||||
parserFor(symbol: string): ParseMethod;
|
||||
parse([env, symbol]: ParseInput): ParseResult;
|
||||
}
|
||||
export declare function parseResult(result: ParseResult): ParseResult;
|
||||
export declare abstract class AbstractSymbolMap<T> implements SymbolMap {
|
||||
private _name;
|
||||
private _parser;
|
||||
constructor(_name: string, _parser: ParseMethod);
|
||||
get name(): string;
|
||||
abstract contains(symbol: string): boolean;
|
||||
parserFor(symbol: string): ParseMethod;
|
||||
parse([env, symbol]: ParseInput): ParseResult;
|
||||
set parser(parser: ParseMethod);
|
||||
get parser(): ParseMethod;
|
||||
abstract lookup(symbol: string): T;
|
||||
}
|
||||
export declare class RegExpMap extends AbstractSymbolMap<string> {
|
||||
private _regExp;
|
||||
constructor(name: string, parser: ParseMethod, _regExp: RegExp);
|
||||
contains(symbol: string): boolean;
|
||||
lookup(symbol: string): string;
|
||||
}
|
||||
export declare abstract class AbstractParseMap<K> extends AbstractSymbolMap<K> {
|
||||
private map;
|
||||
lookup(symbol: string): K;
|
||||
contains(symbol: string): boolean;
|
||||
add(symbol: string, object: K): void;
|
||||
remove(symbol: string): void;
|
||||
}
|
||||
export declare class CharacterMap extends AbstractParseMap<Symbol> {
|
||||
constructor(name: string, parser: ParseMethod, json: {
|
||||
[index: string]: string | [string, Attributes];
|
||||
});
|
||||
}
|
||||
export declare class DelimiterMap extends CharacterMap {
|
||||
parse([env, symbol]: ParseInput): ParseResult;
|
||||
}
|
||||
export declare class MacroMap extends AbstractParseMap<Macro> {
|
||||
constructor(name: string, json: {
|
||||
[index: string]: string | Args[];
|
||||
}, functionMap: Record<string, ParseMethod>);
|
||||
parserFor(symbol: string): ParseMethod;
|
||||
parse([env, symbol]: ParseInput): ParseResult;
|
||||
}
|
||||
export declare class CommandMap extends MacroMap {
|
||||
parse([env, symbol]: ParseInput): ParseResult;
|
||||
}
|
||||
export declare class EnvironmentMap extends MacroMap {
|
||||
constructor(name: string, parser: ParseMethod, json: {
|
||||
[index: string]: string | Args[];
|
||||
}, functionMap: Record<string, ParseMethod>);
|
||||
parse([env, symbol]: ParseInput): ParseResult;
|
||||
}
|
||||
251
node_modules/mathjax-full/js/input/tex/SymbolMap.js
generated
vendored
Normal file
251
node_modules/mathjax-full/js/input/tex/SymbolMap.js
generated
vendored
Normal file
@@ -0,0 +1,251 @@
|
||||
"use strict";
|
||||
var __extends = (this && this.__extends) || (function () {
|
||||
var extendStatics = function (d, b) {
|
||||
extendStatics = Object.setPrototypeOf ||
|
||||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
||||
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
|
||||
return extendStatics(d, b);
|
||||
};
|
||||
return function (d, b) {
|
||||
if (typeof b !== "function" && b !== null)
|
||||
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
|
||||
extendStatics(d, b);
|
||||
function __() { this.constructor = d; }
|
||||
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
||||
};
|
||||
})();
|
||||
var __read = (this && this.__read) || function (o, n) {
|
||||
var m = typeof Symbol === "function" && o[Symbol.iterator];
|
||||
if (!m) return o;
|
||||
var i = m.call(o), r, ar = [], e;
|
||||
try {
|
||||
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
|
||||
}
|
||||
catch (error) { e = { error: error }; }
|
||||
finally {
|
||||
try {
|
||||
if (r && !r.done && (m = i["return"])) m.call(i);
|
||||
}
|
||||
finally { if (e) throw e.error; }
|
||||
}
|
||||
return ar;
|
||||
};
|
||||
var __values = (this && this.__values) || function(o) {
|
||||
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
|
||||
if (m) return m.call(o);
|
||||
if (o && typeof o.length === "number") return {
|
||||
next: function () {
|
||||
if (o && i >= o.length) o = void 0;
|
||||
return { value: o && o[i++], done: !o };
|
||||
}
|
||||
};
|
||||
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
|
||||
};
|
||||
var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
|
||||
if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
|
||||
if (ar || !(i in from)) {
|
||||
if (!ar) ar = Array.prototype.slice.call(from, 0, i);
|
||||
ar[i] = from[i];
|
||||
}
|
||||
}
|
||||
return to.concat(ar || Array.prototype.slice.call(from));
|
||||
};
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.EnvironmentMap = exports.CommandMap = exports.MacroMap = exports.DelimiterMap = exports.CharacterMap = exports.AbstractParseMap = exports.RegExpMap = exports.AbstractSymbolMap = exports.parseResult = void 0;
|
||||
var Symbol_js_1 = require("./Symbol.js");
|
||||
var MapHandler_js_1 = require("./MapHandler.js");
|
||||
function parseResult(result) {
|
||||
return result === void 0 ? true : result;
|
||||
}
|
||||
exports.parseResult = parseResult;
|
||||
var AbstractSymbolMap = (function () {
|
||||
function AbstractSymbolMap(_name, _parser) {
|
||||
this._name = _name;
|
||||
this._parser = _parser;
|
||||
MapHandler_js_1.MapHandler.register(this);
|
||||
}
|
||||
Object.defineProperty(AbstractSymbolMap.prototype, "name", {
|
||||
get: function () {
|
||||
return this._name;
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
AbstractSymbolMap.prototype.parserFor = function (symbol) {
|
||||
return this.contains(symbol) ? this.parser : null;
|
||||
};
|
||||
AbstractSymbolMap.prototype.parse = function (_a) {
|
||||
var _b = __read(_a, 2), env = _b[0], symbol = _b[1];
|
||||
var parser = this.parserFor(symbol);
|
||||
var mapped = this.lookup(symbol);
|
||||
return (parser && mapped) ? parseResult(parser(env, mapped)) : null;
|
||||
};
|
||||
Object.defineProperty(AbstractSymbolMap.prototype, "parser", {
|
||||
get: function () {
|
||||
return this._parser;
|
||||
},
|
||||
set: function (parser) {
|
||||
this._parser = parser;
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
return AbstractSymbolMap;
|
||||
}());
|
||||
exports.AbstractSymbolMap = AbstractSymbolMap;
|
||||
var RegExpMap = (function (_super) {
|
||||
__extends(RegExpMap, _super);
|
||||
function RegExpMap(name, parser, _regExp) {
|
||||
var _this = _super.call(this, name, parser) || this;
|
||||
_this._regExp = _regExp;
|
||||
return _this;
|
||||
}
|
||||
RegExpMap.prototype.contains = function (symbol) {
|
||||
return this._regExp.test(symbol);
|
||||
};
|
||||
RegExpMap.prototype.lookup = function (symbol) {
|
||||
return this.contains(symbol) ? symbol : null;
|
||||
};
|
||||
return RegExpMap;
|
||||
}(AbstractSymbolMap));
|
||||
exports.RegExpMap = RegExpMap;
|
||||
var AbstractParseMap = (function (_super) {
|
||||
__extends(AbstractParseMap, _super);
|
||||
function AbstractParseMap() {
|
||||
var _this = _super !== null && _super.apply(this, arguments) || this;
|
||||
_this.map = new Map();
|
||||
return _this;
|
||||
}
|
||||
AbstractParseMap.prototype.lookup = function (symbol) {
|
||||
return this.map.get(symbol);
|
||||
};
|
||||
AbstractParseMap.prototype.contains = function (symbol) {
|
||||
return this.map.has(symbol);
|
||||
};
|
||||
AbstractParseMap.prototype.add = function (symbol, object) {
|
||||
this.map.set(symbol, object);
|
||||
};
|
||||
AbstractParseMap.prototype.remove = function (symbol) {
|
||||
this.map.delete(symbol);
|
||||
};
|
||||
return AbstractParseMap;
|
||||
}(AbstractSymbolMap));
|
||||
exports.AbstractParseMap = AbstractParseMap;
|
||||
var CharacterMap = (function (_super) {
|
||||
__extends(CharacterMap, _super);
|
||||
function CharacterMap(name, parser, json) {
|
||||
var e_1, _a;
|
||||
var _this = _super.call(this, name, parser) || this;
|
||||
try {
|
||||
for (var _b = __values(Object.keys(json)), _c = _b.next(); !_c.done; _c = _b.next()) {
|
||||
var key = _c.value;
|
||||
var value = json[key];
|
||||
var _d = __read((typeof (value) === 'string') ? [value, null] : value, 2), char = _d[0], attrs = _d[1];
|
||||
var character = new Symbol_js_1.Symbol(key, char, attrs);
|
||||
_this.add(key, character);
|
||||
}
|
||||
}
|
||||
catch (e_1_1) { e_1 = { error: e_1_1 }; }
|
||||
finally {
|
||||
try {
|
||||
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
|
||||
}
|
||||
finally { if (e_1) throw e_1.error; }
|
||||
}
|
||||
return _this;
|
||||
}
|
||||
return CharacterMap;
|
||||
}(AbstractParseMap));
|
||||
exports.CharacterMap = CharacterMap;
|
||||
var DelimiterMap = (function (_super) {
|
||||
__extends(DelimiterMap, _super);
|
||||
function DelimiterMap() {
|
||||
return _super !== null && _super.apply(this, arguments) || this;
|
||||
}
|
||||
DelimiterMap.prototype.parse = function (_a) {
|
||||
var _b = __read(_a, 2), env = _b[0], symbol = _b[1];
|
||||
return _super.prototype.parse.call(this, [env, '\\' + symbol]);
|
||||
};
|
||||
return DelimiterMap;
|
||||
}(CharacterMap));
|
||||
exports.DelimiterMap = DelimiterMap;
|
||||
var MacroMap = (function (_super) {
|
||||
__extends(MacroMap, _super);
|
||||
function MacroMap(name, json, functionMap) {
|
||||
var e_2, _a;
|
||||
var _this = _super.call(this, name, null) || this;
|
||||
try {
|
||||
for (var _b = __values(Object.keys(json)), _c = _b.next(); !_c.done; _c = _b.next()) {
|
||||
var key = _c.value;
|
||||
var value = json[key];
|
||||
var _d = __read((typeof (value) === 'string') ? [value] : value), func = _d[0], attrs = _d.slice(1);
|
||||
var character = new Symbol_js_1.Macro(key, functionMap[func], attrs);
|
||||
_this.add(key, character);
|
||||
}
|
||||
}
|
||||
catch (e_2_1) { e_2 = { error: e_2_1 }; }
|
||||
finally {
|
||||
try {
|
||||
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
|
||||
}
|
||||
finally { if (e_2) throw e_2.error; }
|
||||
}
|
||||
return _this;
|
||||
}
|
||||
MacroMap.prototype.parserFor = function (symbol) {
|
||||
var macro = this.lookup(symbol);
|
||||
return macro ? macro.func : null;
|
||||
};
|
||||
MacroMap.prototype.parse = function (_a) {
|
||||
var _b = __read(_a, 2), env = _b[0], symbol = _b[1];
|
||||
var macro = this.lookup(symbol);
|
||||
var parser = this.parserFor(symbol);
|
||||
if (!macro || !parser) {
|
||||
return null;
|
||||
}
|
||||
return parseResult(parser.apply(void 0, __spreadArray([env, macro.symbol], __read(macro.args), false)));
|
||||
};
|
||||
return MacroMap;
|
||||
}(AbstractParseMap));
|
||||
exports.MacroMap = MacroMap;
|
||||
var CommandMap = (function (_super) {
|
||||
__extends(CommandMap, _super);
|
||||
function CommandMap() {
|
||||
return _super !== null && _super.apply(this, arguments) || this;
|
||||
}
|
||||
CommandMap.prototype.parse = function (_a) {
|
||||
var _b = __read(_a, 2), env = _b[0], symbol = _b[1];
|
||||
var macro = this.lookup(symbol);
|
||||
var parser = this.parserFor(symbol);
|
||||
if (!macro || !parser) {
|
||||
return null;
|
||||
}
|
||||
var saveCommand = env.currentCS;
|
||||
env.currentCS = '\\' + symbol;
|
||||
var result = parser.apply(void 0, __spreadArray([env, '\\' + macro.symbol], __read(macro.args), false));
|
||||
env.currentCS = saveCommand;
|
||||
return parseResult(result);
|
||||
};
|
||||
return CommandMap;
|
||||
}(MacroMap));
|
||||
exports.CommandMap = CommandMap;
|
||||
var EnvironmentMap = (function (_super) {
|
||||
__extends(EnvironmentMap, _super);
|
||||
function EnvironmentMap(name, parser, json, functionMap) {
|
||||
var _this = _super.call(this, name, json, functionMap) || this;
|
||||
_this.parser = parser;
|
||||
return _this;
|
||||
}
|
||||
EnvironmentMap.prototype.parse = function (_a) {
|
||||
var _b = __read(_a, 2), env = _b[0], symbol = _b[1];
|
||||
var macro = this.lookup(symbol);
|
||||
var envParser = this.parserFor(symbol);
|
||||
if (!macro || !envParser) {
|
||||
return null;
|
||||
}
|
||||
return parseResult(this.parser(env, macro.symbol, envParser, macro.args));
|
||||
};
|
||||
return EnvironmentMap;
|
||||
}(MacroMap));
|
||||
exports.EnvironmentMap = EnvironmentMap;
|
||||
//# sourceMappingURL=SymbolMap.js.map
|
||||
1
node_modules/mathjax-full/js/input/tex/SymbolMap.js.map
generated
vendored
Normal file
1
node_modules/mathjax-full/js/input/tex/SymbolMap.js.map
generated
vendored
Normal file
File diff suppressed because one or more lines are too long
121
node_modules/mathjax-full/js/input/tex/Tags.d.ts
generated
vendored
Normal file
121
node_modules/mathjax-full/js/input/tex/Tags.d.ts
generated
vendored
Normal file
@@ -0,0 +1,121 @@
|
||||
import { MmlNode } from '../../core/MmlTree/MmlNode.js';
|
||||
import { MathItem } from '../../core/MathItem.js';
|
||||
import { EnvList } from './StackItem.js';
|
||||
import ParseOptions from './ParseOptions.js';
|
||||
import { OptionList } from '../../util/Options.js';
|
||||
export declare class Label {
|
||||
tag: string;
|
||||
id: string;
|
||||
constructor(tag?: string, id?: string);
|
||||
}
|
||||
export declare class TagInfo {
|
||||
readonly env: string;
|
||||
readonly taggable: boolean;
|
||||
readonly defaultTags: boolean;
|
||||
tag: string;
|
||||
tagId: string;
|
||||
tagFormat: string;
|
||||
noTag: boolean;
|
||||
labelId: string;
|
||||
constructor(env?: string, taggable?: boolean, defaultTags?: boolean, tag?: string, tagId?: string, tagFormat?: string, noTag?: boolean, labelId?: string);
|
||||
}
|
||||
export interface Tags {
|
||||
configuration: ParseOptions;
|
||||
ids: {
|
||||
[key: string]: boolean;
|
||||
};
|
||||
allIds: {
|
||||
[key: string]: boolean;
|
||||
};
|
||||
labels: {
|
||||
[key: string]: Label;
|
||||
};
|
||||
allLabels: {
|
||||
[key: string]: Label;
|
||||
};
|
||||
label: string;
|
||||
redo: boolean;
|
||||
refUpdate: boolean;
|
||||
env: string;
|
||||
currentTag: TagInfo;
|
||||
formatTag(tag: string): string;
|
||||
formatUrl(id: string, base: string): string;
|
||||
autoTag(): void;
|
||||
getTag(): MmlNode | void;
|
||||
clearTag(): void;
|
||||
resetTag(): void;
|
||||
reset(offset?: number): void;
|
||||
startEquation(math: MathItem<any, any, any>): void;
|
||||
finishEquation(math: MathItem<any, any, any>): void;
|
||||
finalize(node: MmlNode, env: EnvList): MmlNode;
|
||||
start(env: string, taggable: boolean, defaultTags: boolean): void;
|
||||
end(): void;
|
||||
tag(tag: string, noFormat: boolean): void;
|
||||
notag(): void;
|
||||
enTag(node: MmlNode, tag: MmlNode): MmlNode;
|
||||
}
|
||||
export declare class AbstractTags implements Tags {
|
||||
protected counter: number;
|
||||
protected allCounter: number;
|
||||
configuration: ParseOptions;
|
||||
ids: {
|
||||
[key: string]: boolean;
|
||||
};
|
||||
allIds: {
|
||||
[key: string]: boolean;
|
||||
};
|
||||
labels: {
|
||||
[key: string]: Label;
|
||||
};
|
||||
allLabels: {
|
||||
[key: string]: Label;
|
||||
};
|
||||
redo: boolean;
|
||||
refUpdate: boolean;
|
||||
currentTag: TagInfo;
|
||||
protected history: TagInfo[];
|
||||
private stack;
|
||||
start(env: string, taggable: boolean, defaultTags: boolean): void;
|
||||
get env(): string;
|
||||
end(): void;
|
||||
tag(tag: string, noFormat: boolean): void;
|
||||
notag(): void;
|
||||
protected get noTag(): boolean;
|
||||
set label(label: string);
|
||||
get label(): string;
|
||||
formatUrl(id: string, base: string): string;
|
||||
formatTag(tag: string): string;
|
||||
protected formatId(id: string): string;
|
||||
protected formatNumber(n: number): string;
|
||||
autoTag(): void;
|
||||
clearTag(): void;
|
||||
getTag(force?: boolean): MmlNode;
|
||||
resetTag(): void;
|
||||
reset(offset?: number): void;
|
||||
startEquation(math: MathItem<any, any, any>): void;
|
||||
finishEquation(math: MathItem<any, any, any>): void;
|
||||
finalize(node: MmlNode, env: EnvList): MmlNode;
|
||||
enTag: (node: MmlNode, tag: MmlNode) => MmlNode;
|
||||
private makeId;
|
||||
private makeTag;
|
||||
}
|
||||
export declare class NoTags extends AbstractTags {
|
||||
autoTag(): void;
|
||||
getTag(): MmlNode;
|
||||
}
|
||||
export declare class AllTags extends AbstractTags {
|
||||
finalize(node: MmlNode, env: EnvList): MmlNode;
|
||||
}
|
||||
export interface TagsClass {
|
||||
new (): Tags;
|
||||
}
|
||||
export declare namespace TagsFactory {
|
||||
let OPTIONS: OptionList;
|
||||
let add: (name: string, constr: TagsClass) => void;
|
||||
let addTags: (tags: {
|
||||
[name: string]: TagsClass;
|
||||
}) => void;
|
||||
let create: (name: string) => Tags;
|
||||
let setDefault: (name: string) => void;
|
||||
let getDefault: () => Tags;
|
||||
}
|
||||
314
node_modules/mathjax-full/js/input/tex/Tags.js
generated
vendored
Normal file
314
node_modules/mathjax-full/js/input/tex/Tags.js
generated
vendored
Normal file
@@ -0,0 +1,314 @@
|
||||
"use strict";
|
||||
var __extends = (this && this.__extends) || (function () {
|
||||
var extendStatics = function (d, b) {
|
||||
extendStatics = Object.setPrototypeOf ||
|
||||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
||||
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
|
||||
return extendStatics(d, b);
|
||||
};
|
||||
return function (d, b) {
|
||||
if (typeof b !== "function" && b !== null)
|
||||
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
|
||||
extendStatics(d, b);
|
||||
function __() { this.constructor = d; }
|
||||
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
||||
};
|
||||
})();
|
||||
var __values = (this && this.__values) || function(o) {
|
||||
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
|
||||
if (m) return m.call(o);
|
||||
if (o && typeof o.length === "number") return {
|
||||
next: function () {
|
||||
if (o && i >= o.length) o = void 0;
|
||||
return { value: o && o[i++], done: !o };
|
||||
}
|
||||
};
|
||||
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
|
||||
};
|
||||
var __importDefault = (this && this.__importDefault) || function (mod) {
|
||||
return (mod && mod.__esModule) ? mod : { "default": mod };
|
||||
};
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.TagsFactory = exports.AllTags = exports.NoTags = exports.AbstractTags = exports.TagInfo = exports.Label = void 0;
|
||||
var TexParser_js_1 = __importDefault(require("./TexParser.js"));
|
||||
var Label = (function () {
|
||||
function Label(tag, id) {
|
||||
if (tag === void 0) { tag = '???'; }
|
||||
if (id === void 0) { id = ''; }
|
||||
this.tag = tag;
|
||||
this.id = id;
|
||||
}
|
||||
return Label;
|
||||
}());
|
||||
exports.Label = Label;
|
||||
var TagInfo = (function () {
|
||||
function TagInfo(env, taggable, defaultTags, tag, tagId, tagFormat, noTag, labelId) {
|
||||
if (env === void 0) { env = ''; }
|
||||
if (taggable === void 0) { taggable = false; }
|
||||
if (defaultTags === void 0) { defaultTags = false; }
|
||||
if (tag === void 0) { tag = null; }
|
||||
if (tagId === void 0) { tagId = ''; }
|
||||
if (tagFormat === void 0) { tagFormat = ''; }
|
||||
if (noTag === void 0) { noTag = false; }
|
||||
if (labelId === void 0) { labelId = ''; }
|
||||
this.env = env;
|
||||
this.taggable = taggable;
|
||||
this.defaultTags = defaultTags;
|
||||
this.tag = tag;
|
||||
this.tagId = tagId;
|
||||
this.tagFormat = tagFormat;
|
||||
this.noTag = noTag;
|
||||
this.labelId = labelId;
|
||||
}
|
||||
return TagInfo;
|
||||
}());
|
||||
exports.TagInfo = TagInfo;
|
||||
var AbstractTags = (function () {
|
||||
function AbstractTags() {
|
||||
this.counter = 0;
|
||||
this.allCounter = 0;
|
||||
this.configuration = null;
|
||||
this.ids = {};
|
||||
this.allIds = {};
|
||||
this.labels = {};
|
||||
this.allLabels = {};
|
||||
this.redo = false;
|
||||
this.refUpdate = false;
|
||||
this.currentTag = new TagInfo();
|
||||
this.history = [];
|
||||
this.stack = [];
|
||||
this.enTag = function (node, tag) {
|
||||
var nf = this.configuration.nodeFactory;
|
||||
var cell = nf.create('node', 'mtd', [node]);
|
||||
var row = nf.create('node', 'mlabeledtr', [tag, cell]);
|
||||
var table = nf.create('node', 'mtable', [row], {
|
||||
side: this.configuration.options['tagSide'],
|
||||
minlabelspacing: this.configuration.options['tagIndent'],
|
||||
displaystyle: true
|
||||
});
|
||||
return table;
|
||||
};
|
||||
}
|
||||
AbstractTags.prototype.start = function (env, taggable, defaultTags) {
|
||||
if (this.currentTag) {
|
||||
this.stack.push(this.currentTag);
|
||||
}
|
||||
this.currentTag = new TagInfo(env, taggable, defaultTags);
|
||||
};
|
||||
Object.defineProperty(AbstractTags.prototype, "env", {
|
||||
get: function () {
|
||||
return this.currentTag.env;
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
AbstractTags.prototype.end = function () {
|
||||
this.history.push(this.currentTag);
|
||||
this.currentTag = this.stack.pop();
|
||||
};
|
||||
AbstractTags.prototype.tag = function (tag, noFormat) {
|
||||
this.currentTag.tag = tag;
|
||||
this.currentTag.tagFormat = noFormat ? tag : this.formatTag(tag);
|
||||
this.currentTag.noTag = false;
|
||||
};
|
||||
AbstractTags.prototype.notag = function () {
|
||||
this.tag('', true);
|
||||
this.currentTag.noTag = true;
|
||||
};
|
||||
Object.defineProperty(AbstractTags.prototype, "noTag", {
|
||||
get: function () {
|
||||
return this.currentTag.noTag;
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
Object.defineProperty(AbstractTags.prototype, "label", {
|
||||
get: function () {
|
||||
return this.currentTag.labelId;
|
||||
},
|
||||
set: function (label) {
|
||||
this.currentTag.labelId = label;
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
AbstractTags.prototype.formatUrl = function (id, base) {
|
||||
return base + '#' + encodeURIComponent(id);
|
||||
};
|
||||
AbstractTags.prototype.formatTag = function (tag) {
|
||||
return '(' + tag + ')';
|
||||
};
|
||||
AbstractTags.prototype.formatId = function (id) {
|
||||
return 'mjx-eqn:' + id.replace(/\s/g, '_');
|
||||
};
|
||||
AbstractTags.prototype.formatNumber = function (n) {
|
||||
return n.toString();
|
||||
};
|
||||
AbstractTags.prototype.autoTag = function () {
|
||||
if (this.currentTag.tag == null) {
|
||||
this.counter++;
|
||||
this.tag(this.formatNumber(this.counter), false);
|
||||
}
|
||||
};
|
||||
AbstractTags.prototype.clearTag = function () {
|
||||
this.label = '';
|
||||
this.tag(null, true);
|
||||
this.currentTag.tagId = '';
|
||||
};
|
||||
AbstractTags.prototype.getTag = function (force) {
|
||||
if (force === void 0) { force = false; }
|
||||
if (force) {
|
||||
this.autoTag();
|
||||
return this.makeTag();
|
||||
}
|
||||
var ct = this.currentTag;
|
||||
if (ct.taggable && !ct.noTag) {
|
||||
if (ct.defaultTags) {
|
||||
this.autoTag();
|
||||
}
|
||||
if (ct.tag) {
|
||||
return this.makeTag();
|
||||
}
|
||||
}
|
||||
return null;
|
||||
};
|
||||
AbstractTags.prototype.resetTag = function () {
|
||||
this.history = [];
|
||||
this.redo = false;
|
||||
this.refUpdate = false;
|
||||
this.clearTag();
|
||||
};
|
||||
AbstractTags.prototype.reset = function (offset) {
|
||||
if (offset === void 0) { offset = 0; }
|
||||
this.resetTag();
|
||||
this.counter = this.allCounter = offset;
|
||||
this.allLabels = {};
|
||||
this.allIds = {};
|
||||
};
|
||||
AbstractTags.prototype.startEquation = function (math) {
|
||||
this.history = [];
|
||||
this.stack = [];
|
||||
this.clearTag();
|
||||
this.currentTag = new TagInfo('', undefined, undefined);
|
||||
this.labels = {};
|
||||
this.ids = {};
|
||||
this.counter = this.allCounter;
|
||||
this.redo = false;
|
||||
var recompile = math.inputData.recompile;
|
||||
if (recompile) {
|
||||
this.refUpdate = true;
|
||||
this.counter = recompile.counter;
|
||||
}
|
||||
};
|
||||
AbstractTags.prototype.finishEquation = function (math) {
|
||||
if (this.redo) {
|
||||
math.inputData.recompile = {
|
||||
state: math.state(),
|
||||
counter: this.allCounter
|
||||
};
|
||||
}
|
||||
if (!this.refUpdate) {
|
||||
this.allCounter = this.counter;
|
||||
}
|
||||
Object.assign(this.allIds, this.ids);
|
||||
Object.assign(this.allLabels, this.labels);
|
||||
};
|
||||
AbstractTags.prototype.finalize = function (node, env) {
|
||||
if (!env.display || this.currentTag.env ||
|
||||
this.currentTag.tag == null) {
|
||||
return node;
|
||||
}
|
||||
var tag = this.makeTag();
|
||||
var table = this.enTag(node, tag);
|
||||
return table;
|
||||
};
|
||||
AbstractTags.prototype.makeId = function () {
|
||||
this.currentTag.tagId = this.formatId(this.configuration.options['useLabelIds'] ?
|
||||
(this.label || this.currentTag.tag) : this.currentTag.tag);
|
||||
};
|
||||
AbstractTags.prototype.makeTag = function () {
|
||||
this.makeId();
|
||||
if (this.label) {
|
||||
this.labels[this.label] = new Label(this.currentTag.tag, this.currentTag.tagId);
|
||||
}
|
||||
var mml = new TexParser_js_1.default('\\text{' + this.currentTag.tagFormat + '}', {}, this.configuration).mml();
|
||||
return this.configuration.nodeFactory.create('node', 'mtd', [mml], { id: this.currentTag.tagId });
|
||||
};
|
||||
return AbstractTags;
|
||||
}());
|
||||
exports.AbstractTags = AbstractTags;
|
||||
var NoTags = (function (_super) {
|
||||
__extends(NoTags, _super);
|
||||
function NoTags() {
|
||||
return _super !== null && _super.apply(this, arguments) || this;
|
||||
}
|
||||
NoTags.prototype.autoTag = function () { };
|
||||
NoTags.prototype.getTag = function () {
|
||||
return !this.currentTag.tag ? null : _super.prototype.getTag.call(this);
|
||||
};
|
||||
return NoTags;
|
||||
}(AbstractTags));
|
||||
exports.NoTags = NoTags;
|
||||
var AllTags = (function (_super) {
|
||||
__extends(AllTags, _super);
|
||||
function AllTags() {
|
||||
return _super !== null && _super.apply(this, arguments) || this;
|
||||
}
|
||||
AllTags.prototype.finalize = function (node, env) {
|
||||
if (!env.display || this.history.find(function (x) { return x.taggable; })) {
|
||||
return node;
|
||||
}
|
||||
var tag = this.getTag(true);
|
||||
return this.enTag(node, tag);
|
||||
};
|
||||
return AllTags;
|
||||
}(AbstractTags));
|
||||
exports.AllTags = AllTags;
|
||||
var TagsFactory;
|
||||
(function (TagsFactory) {
|
||||
var tagsMapping = new Map([
|
||||
['none', NoTags],
|
||||
['all', AllTags]
|
||||
]);
|
||||
var defaultTags = 'none';
|
||||
TagsFactory.OPTIONS = {
|
||||
tags: defaultTags,
|
||||
tagSide: 'right',
|
||||
tagIndent: '0.8em',
|
||||
useLabelIds: true,
|
||||
ignoreDuplicateLabels: false
|
||||
};
|
||||
TagsFactory.add = function (name, constr) {
|
||||
tagsMapping.set(name, constr);
|
||||
};
|
||||
TagsFactory.addTags = function (tags) {
|
||||
var e_1, _a;
|
||||
try {
|
||||
for (var _b = __values(Object.keys(tags)), _c = _b.next(); !_c.done; _c = _b.next()) {
|
||||
var key = _c.value;
|
||||
TagsFactory.add(key, tags[key]);
|
||||
}
|
||||
}
|
||||
catch (e_1_1) { e_1 = { error: e_1_1 }; }
|
||||
finally {
|
||||
try {
|
||||
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
|
||||
}
|
||||
finally { if (e_1) throw e_1.error; }
|
||||
}
|
||||
};
|
||||
TagsFactory.create = function (name) {
|
||||
var constr = tagsMapping.get(name) || tagsMapping.get(defaultTags);
|
||||
if (!constr) {
|
||||
throw Error('Unknown tags class');
|
||||
}
|
||||
return new constr();
|
||||
};
|
||||
TagsFactory.setDefault = function (name) {
|
||||
defaultTags = name;
|
||||
};
|
||||
TagsFactory.getDefault = function () {
|
||||
return TagsFactory.create(defaultTags);
|
||||
};
|
||||
})(TagsFactory = exports.TagsFactory || (exports.TagsFactory = {}));
|
||||
//# sourceMappingURL=Tags.js.map
|
||||
1
node_modules/mathjax-full/js/input/tex/Tags.js.map
generated
vendored
Normal file
1
node_modules/mathjax-full/js/input/tex/Tags.js.map
generated
vendored
Normal file
File diff suppressed because one or more lines are too long
128
node_modules/mathjax-full/js/input/tex/TexConstants.d.ts
generated
vendored
Normal file
128
node_modules/mathjax-full/js/input/tex/TexConstants.d.ts
generated
vendored
Normal file
@@ -0,0 +1,128 @@
|
||||
export declare namespace TexConstant {
|
||||
const Variant: {
|
||||
NORMAL: string;
|
||||
BOLD: string;
|
||||
ITALIC: string;
|
||||
BOLDITALIC: string;
|
||||
DOUBLESTRUCK: string;
|
||||
FRAKTUR: string;
|
||||
BOLDFRAKTUR: string;
|
||||
SCRIPT: string;
|
||||
BOLDSCRIPT: string;
|
||||
SANSSERIF: string;
|
||||
BOLDSANSSERIF: string;
|
||||
SANSSERIFITALIC: string;
|
||||
SANSSERIFBOLDITALIC: string;
|
||||
MONOSPACE: string;
|
||||
INITIAL: string;
|
||||
TAILED: string;
|
||||
LOOPED: string;
|
||||
STRETCHED: string;
|
||||
CALLIGRAPHIC: string;
|
||||
BOLDCALLIGRAPHIC: string;
|
||||
OLDSTYLE: string;
|
||||
BOLDOLDSTYLE: string;
|
||||
MATHITALIC: string;
|
||||
};
|
||||
const Form: {
|
||||
PREFIX: string;
|
||||
INFIX: string;
|
||||
POSTFIX: string;
|
||||
};
|
||||
const LineBreak: {
|
||||
AUTO: string;
|
||||
NEWLINE: string;
|
||||
NOBREAK: string;
|
||||
GOODBREAK: string;
|
||||
BADBREAK: string;
|
||||
};
|
||||
const LineBreakStyle: {
|
||||
BEFORE: string;
|
||||
AFTER: string;
|
||||
DUPLICATE: string;
|
||||
INFIXLINBREAKSTYLE: string;
|
||||
};
|
||||
const IndentAlign: {
|
||||
LEFT: string;
|
||||
CENTER: string;
|
||||
RIGHT: string;
|
||||
AUTO: string;
|
||||
ID: string;
|
||||
INDENTALIGN: string;
|
||||
};
|
||||
const IndentShift: {
|
||||
INDENTSHIFT: string;
|
||||
};
|
||||
const LineThickness: {
|
||||
THIN: string;
|
||||
MEDIUM: string;
|
||||
THICK: string;
|
||||
};
|
||||
const Notation: {
|
||||
LONGDIV: string;
|
||||
ACTUARIAL: string;
|
||||
PHASORANGLE: string;
|
||||
RADICAL: string;
|
||||
BOX: string;
|
||||
ROUNDEDBOX: string;
|
||||
CIRCLE: string;
|
||||
LEFT: string;
|
||||
RIGHT: string;
|
||||
TOP: string;
|
||||
BOTTOM: string;
|
||||
UPDIAGONALSTRIKE: string;
|
||||
DOWNDIAGONALSTRIKE: string;
|
||||
VERTICALSTRIKE: string;
|
||||
HORIZONTALSTRIKE: string;
|
||||
NORTHEASTARROW: string;
|
||||
MADRUWB: string;
|
||||
UPDIAGONALARROW: string;
|
||||
};
|
||||
const Align: {
|
||||
TOP: string;
|
||||
BOTTOM: string;
|
||||
CENTER: string;
|
||||
BASELINE: string;
|
||||
AXIS: string;
|
||||
LEFT: string;
|
||||
RIGHT: string;
|
||||
};
|
||||
const Lines: {
|
||||
NONE: string;
|
||||
SOLID: string;
|
||||
DASHED: string;
|
||||
};
|
||||
const Side: {
|
||||
LEFT: string;
|
||||
RIGHT: string;
|
||||
LEFTOVERLAP: string;
|
||||
RIGHTOVERLAP: string;
|
||||
};
|
||||
const Width: {
|
||||
AUTO: string;
|
||||
FIT: string;
|
||||
};
|
||||
const Actiontype: {
|
||||
TOGGLE: string;
|
||||
STATUSLINE: string;
|
||||
TOOLTIP: string;
|
||||
INPUT: string;
|
||||
};
|
||||
const Overflow: {
|
||||
LINBREAK: string;
|
||||
SCROLL: string;
|
||||
ELIDE: string;
|
||||
TRUNCATE: string;
|
||||
SCALE: string;
|
||||
};
|
||||
const Unit: {
|
||||
EM: string;
|
||||
EX: string;
|
||||
PX: string;
|
||||
IN: string;
|
||||
CM: string;
|
||||
MM: string;
|
||||
PT: string;
|
||||
PC: string;
|
||||
};
|
||||
}
|
||||
133
node_modules/mathjax-full/js/input/tex/TexConstants.js
generated
vendored
Normal file
133
node_modules/mathjax-full/js/input/tex/TexConstants.js
generated
vendored
Normal file
@@ -0,0 +1,133 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.TexConstant = void 0;
|
||||
var TexConstant;
|
||||
(function (TexConstant) {
|
||||
TexConstant.Variant = {
|
||||
NORMAL: 'normal',
|
||||
BOLD: 'bold',
|
||||
ITALIC: 'italic',
|
||||
BOLDITALIC: 'bold-italic',
|
||||
DOUBLESTRUCK: 'double-struck',
|
||||
FRAKTUR: 'fraktur',
|
||||
BOLDFRAKTUR: 'bold-fraktur',
|
||||
SCRIPT: 'script',
|
||||
BOLDSCRIPT: 'bold-script',
|
||||
SANSSERIF: 'sans-serif',
|
||||
BOLDSANSSERIF: 'bold-sans-serif',
|
||||
SANSSERIFITALIC: 'sans-serif-italic',
|
||||
SANSSERIFBOLDITALIC: 'sans-serif-bold-italic',
|
||||
MONOSPACE: 'monospace',
|
||||
INITIAL: 'inital',
|
||||
TAILED: 'tailed',
|
||||
LOOPED: 'looped',
|
||||
STRETCHED: 'stretched',
|
||||
CALLIGRAPHIC: '-tex-calligraphic',
|
||||
BOLDCALLIGRAPHIC: '-tex-bold-calligraphic',
|
||||
OLDSTYLE: '-tex-oldstyle',
|
||||
BOLDOLDSTYLE: '-tex-bold-oldstyle',
|
||||
MATHITALIC: '-tex-mathit'
|
||||
};
|
||||
TexConstant.Form = {
|
||||
PREFIX: 'prefix',
|
||||
INFIX: 'infix',
|
||||
POSTFIX: 'postfix'
|
||||
};
|
||||
TexConstant.LineBreak = {
|
||||
AUTO: 'auto',
|
||||
NEWLINE: 'newline',
|
||||
NOBREAK: 'nobreak',
|
||||
GOODBREAK: 'goodbreak',
|
||||
BADBREAK: 'badbreak'
|
||||
};
|
||||
TexConstant.LineBreakStyle = {
|
||||
BEFORE: 'before',
|
||||
AFTER: 'after',
|
||||
DUPLICATE: 'duplicate',
|
||||
INFIXLINBREAKSTYLE: 'infixlinebreakstyle'
|
||||
};
|
||||
TexConstant.IndentAlign = {
|
||||
LEFT: 'left',
|
||||
CENTER: 'center',
|
||||
RIGHT: 'right',
|
||||
AUTO: 'auto',
|
||||
ID: 'id',
|
||||
INDENTALIGN: 'indentalign'
|
||||
};
|
||||
TexConstant.IndentShift = {
|
||||
INDENTSHIFT: 'indentshift'
|
||||
};
|
||||
TexConstant.LineThickness = {
|
||||
THIN: 'thin',
|
||||
MEDIUM: 'medium',
|
||||
THICK: 'thick'
|
||||
};
|
||||
TexConstant.Notation = {
|
||||
LONGDIV: 'longdiv',
|
||||
ACTUARIAL: 'actuarial',
|
||||
PHASORANGLE: 'phasorangle',
|
||||
RADICAL: 'radical',
|
||||
BOX: 'box',
|
||||
ROUNDEDBOX: 'roundedbox',
|
||||
CIRCLE: 'circle',
|
||||
LEFT: 'left',
|
||||
RIGHT: 'right',
|
||||
TOP: 'top',
|
||||
BOTTOM: 'bottom',
|
||||
UPDIAGONALSTRIKE: 'updiagonalstrike',
|
||||
DOWNDIAGONALSTRIKE: 'downdiagonalstrike',
|
||||
VERTICALSTRIKE: 'verticalstrike',
|
||||
HORIZONTALSTRIKE: 'horizontalstrike',
|
||||
NORTHEASTARROW: 'northeastarrow',
|
||||
MADRUWB: 'madruwb',
|
||||
UPDIAGONALARROW: 'updiagonalarrow'
|
||||
};
|
||||
TexConstant.Align = {
|
||||
TOP: 'top',
|
||||
BOTTOM: 'bottom',
|
||||
CENTER: 'center',
|
||||
BASELINE: 'baseline',
|
||||
AXIS: 'axis',
|
||||
LEFT: 'left',
|
||||
RIGHT: 'right'
|
||||
};
|
||||
TexConstant.Lines = {
|
||||
NONE: 'none',
|
||||
SOLID: 'solid',
|
||||
DASHED: 'dashed'
|
||||
};
|
||||
TexConstant.Side = {
|
||||
LEFT: 'left',
|
||||
RIGHT: 'right',
|
||||
LEFTOVERLAP: 'leftoverlap',
|
||||
RIGHTOVERLAP: 'rightoverlap'
|
||||
};
|
||||
TexConstant.Width = {
|
||||
AUTO: 'auto',
|
||||
FIT: 'fit'
|
||||
};
|
||||
TexConstant.Actiontype = {
|
||||
TOGGLE: 'toggle',
|
||||
STATUSLINE: 'statusline',
|
||||
TOOLTIP: 'tooltip',
|
||||
INPUT: 'input'
|
||||
};
|
||||
TexConstant.Overflow = {
|
||||
LINBREAK: 'linebreak',
|
||||
SCROLL: 'scroll',
|
||||
ELIDE: 'elide',
|
||||
TRUNCATE: 'truncate',
|
||||
SCALE: 'scale'
|
||||
};
|
||||
TexConstant.Unit = {
|
||||
EM: 'em',
|
||||
EX: 'ex',
|
||||
PX: 'px',
|
||||
IN: 'in',
|
||||
CM: 'cm',
|
||||
MM: 'mm',
|
||||
PT: 'pt',
|
||||
PC: 'pc'
|
||||
};
|
||||
})(TexConstant = exports.TexConstant || (exports.TexConstant = {}));
|
||||
//# sourceMappingURL=TexConstants.js.map
|
||||
1
node_modules/mathjax-full/js/input/tex/TexConstants.js.map
generated
vendored
Normal file
1
node_modules/mathjax-full/js/input/tex/TexConstants.js.map
generated
vendored
Normal file
@@ -0,0 +1 @@
|
||||
{"version":3,"file":"TexConstants.js","sourceRoot":"","sources":["../../../ts/input/tex/TexConstants.ts"],"names":[],"mappings":"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"}
|
||||
7
node_modules/mathjax-full/js/input/tex/TexError.d.ts
generated
vendored
Normal file
7
node_modules/mathjax-full/js/input/tex/TexError.d.ts
generated
vendored
Normal file
@@ -0,0 +1,7 @@
|
||||
export default class TexError {
|
||||
id: string;
|
||||
private static pattern;
|
||||
message: string;
|
||||
private static processString;
|
||||
constructor(id: string, message: string, ...rest: string[]);
|
||||
}
|
||||
47
node_modules/mathjax-full/js/input/tex/TexError.js
generated
vendored
Normal file
47
node_modules/mathjax-full/js/input/tex/TexError.js
generated
vendored
Normal file
@@ -0,0 +1,47 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
var TexError = (function () {
|
||||
function TexError(id, message) {
|
||||
var rest = [];
|
||||
for (var _i = 2; _i < arguments.length; _i++) {
|
||||
rest[_i - 2] = arguments[_i];
|
||||
}
|
||||
this.id = id;
|
||||
this.message = TexError.processString(message, rest);
|
||||
}
|
||||
TexError.processString = function (str, args) {
|
||||
var parts = str.split(TexError.pattern);
|
||||
for (var i = 1, m = parts.length; i < m; i += 2) {
|
||||
var c = parts[i].charAt(0);
|
||||
if (c >= '0' && c <= '9') {
|
||||
parts[i] = args[parseInt(parts[i], 10) - 1];
|
||||
if (typeof parts[i] === 'number') {
|
||||
parts[i] = parts[i].toString();
|
||||
}
|
||||
}
|
||||
else if (c === '{') {
|
||||
c = parts[i].substr(1);
|
||||
if (c >= '0' && c <= '9') {
|
||||
parts[i] = args[parseInt(parts[i].substr(1, parts[i].length - 2), 10) - 1];
|
||||
if (typeof parts[i] === 'number') {
|
||||
parts[i] = parts[i].toString();
|
||||
}
|
||||
}
|
||||
else {
|
||||
var match = parts[i].match(/^\{([a-z]+):%(\d+)\|(.*)\}$/);
|
||||
if (match) {
|
||||
parts[i] = '%' + parts[i];
|
||||
}
|
||||
}
|
||||
}
|
||||
if (parts[i] == null) {
|
||||
parts[i] = '???';
|
||||
}
|
||||
}
|
||||
return parts.join('');
|
||||
};
|
||||
TexError.pattern = /%(\d+|\{\d+\}|\{[a-z]+:\%\d+(?:\|(?:%\{\d+\}|%.|[^\}])*)+\}|.)/g;
|
||||
return TexError;
|
||||
}());
|
||||
exports.default = TexError;
|
||||
//# sourceMappingURL=TexError.js.map
|
||||
1
node_modules/mathjax-full/js/input/tex/TexError.js.map
generated
vendored
Normal file
1
node_modules/mathjax-full/js/input/tex/TexError.js.map
generated
vendored
Normal file
@@ -0,0 +1 @@
|
||||
{"version":3,"file":"TexError.js","sourceRoot":"","sources":["../../../ts/input/tex/TexError.ts"],"names":[],"mappings":";;AAyBA;IAuDE,kBAAmB,EAAU,EAAE,OAAe;QAAE,cAAiB;aAAjB,UAAiB,EAAjB,qBAAiB,EAAjB,IAAiB;YAAjB,6BAAiB;;QAA9C,OAAE,GAAF,EAAE,CAAQ;QAC3B,IAAI,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;IACvD,CAAC;IAxCc,sBAAa,GAA5B,UAA6B,GAAW,EAAE,IAAc;QACtD,IAAI,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;QACxC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE;YAC/C,IAAI,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;YAE3B,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,GAAG,EAAE;gBACxB,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;gBAC5C,IAAI,OAAO,KAAK,CAAC,CAAC,CAAC,KAAK,QAAQ,EAAE;oBAChC,KAAK,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC;iBAChC;aACF;iBAAM,IAAI,CAAC,KAAK,GAAG,EAAE;gBACpB,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;gBACvB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,GAAG,EAAE;oBACxB,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;oBAC3E,IAAI,OAAO,KAAK,CAAC,CAAC,CAAC,KAAK,QAAQ,EAAE;wBAChC,KAAK,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC;qBAChC;iBACF;qBAAM;oBACL,IAAI,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,6BAA6B,CAAC,CAAC;oBAC1D,IAAI,KAAK,EAAE;wBAET,KAAK,CAAC,CAAC,CAAC,GAAG,GAAG,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;qBAC3B;iBACF;aACF;YACD,IAAI,KAAK,CAAC,CAAC,CAAC,IAAI,IAAI,EAAE;gBACpB,KAAK,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC;aAClB;SACF;QACD,OAAO,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACxB,CAAC;IA7Cc,gBAAO,GACpB,iEAAiE,CAAC;IAwDtE,eAAC;CAAA,AA3DD,IA2DC;kBA3DoB,QAAQ"}
|
||||
46
node_modules/mathjax-full/js/input/tex/TexParser.d.ts
generated
vendored
Normal file
46
node_modules/mathjax-full/js/input/tex/TexParser.d.ts
generated
vendored
Normal file
@@ -0,0 +1,46 @@
|
||||
import { HandlerType } from './MapHandler.js';
|
||||
import Stack from './Stack.js';
|
||||
import StackItemFactory from './StackItemFactory.js';
|
||||
import { Tags } from './Tags.js';
|
||||
import { MmlNode } from '../../core/MmlTree/MmlNode.js';
|
||||
import { ParseInput, ParseResult } from './Types.js';
|
||||
import ParseOptions from './ParseOptions.js';
|
||||
import { StackItem, EnvList } from './StackItem.js';
|
||||
import { OptionList } from '../../util/Options.js';
|
||||
export default class TexParser {
|
||||
private _string;
|
||||
configuration: ParseOptions;
|
||||
macroCount: number;
|
||||
stack: Stack;
|
||||
i: number;
|
||||
currentCS: string;
|
||||
constructor(_string: string, env: EnvList, configuration: ParseOptions);
|
||||
get options(): OptionList;
|
||||
get itemFactory(): StackItemFactory;
|
||||
get tags(): Tags;
|
||||
set string(str: string);
|
||||
get string(): string;
|
||||
parse(kind: HandlerType, input: ParseInput): ParseResult;
|
||||
lookup(kind: HandlerType, symbol: string): any;
|
||||
contains(kind: HandlerType, symbol: string): boolean;
|
||||
toString(): string;
|
||||
Parse(): void;
|
||||
Push(arg: StackItem | MmlNode): void;
|
||||
PushAll(args: (StackItem | MmlNode)[]): void;
|
||||
mml(): MmlNode;
|
||||
convertDelimiter(c: string): string;
|
||||
getCodePoint(): string;
|
||||
nextIsSpace(): boolean;
|
||||
GetNext(): string;
|
||||
GetCS(): string;
|
||||
GetArgument(_name: string, noneOK?: boolean): string;
|
||||
GetBrackets(_name: string, def?: string): string;
|
||||
GetDelimiter(name: string, braceOK?: boolean): string;
|
||||
GetDimen(name: string): string;
|
||||
GetUpTo(_name: string, token: string): string;
|
||||
ParseArg(name: string): MmlNode;
|
||||
ParseUpTo(name: string, token: string): MmlNode;
|
||||
GetDelimiterArg(name: string): string;
|
||||
GetStar(): boolean;
|
||||
create(kind: string, ...rest: any[]): MmlNode;
|
||||
}
|
||||
370
node_modules/mathjax-full/js/input/tex/TexParser.js
generated
vendored
Normal file
370
node_modules/mathjax-full/js/input/tex/TexParser.js
generated
vendored
Normal file
@@ -0,0 +1,370 @@
|
||||
"use strict";
|
||||
var __values = (this && this.__values) || function(o) {
|
||||
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
|
||||
if (m) return m.call(o);
|
||||
if (o && typeof o.length === "number") return {
|
||||
next: function () {
|
||||
if (o && i >= o.length) o = void 0;
|
||||
return { value: o && o[i++], done: !o };
|
||||
}
|
||||
};
|
||||
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
|
||||
};
|
||||
var __read = (this && this.__read) || function (o, n) {
|
||||
var m = typeof Symbol === "function" && o[Symbol.iterator];
|
||||
if (!m) return o;
|
||||
var i = m.call(o), r, ar = [], e;
|
||||
try {
|
||||
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
|
||||
}
|
||||
catch (error) { e = { error: error }; }
|
||||
finally {
|
||||
try {
|
||||
if (r && !r.done && (m = i["return"])) m.call(i);
|
||||
}
|
||||
finally { if (e) throw e.error; }
|
||||
}
|
||||
return ar;
|
||||
};
|
||||
var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
|
||||
if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
|
||||
if (ar || !(i in from)) {
|
||||
if (!ar) ar = Array.prototype.slice.call(from, 0, i);
|
||||
ar[i] = from[i];
|
||||
}
|
||||
}
|
||||
return to.concat(ar || Array.prototype.slice.call(from));
|
||||
};
|
||||
var __importDefault = (this && this.__importDefault) || function (mod) {
|
||||
return (mod && mod.__esModule) ? mod : { "default": mod };
|
||||
};
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
var ParseUtil_js_1 = __importDefault(require("./ParseUtil.js"));
|
||||
var Stack_js_1 = __importDefault(require("./Stack.js"));
|
||||
var TexError_js_1 = __importDefault(require("./TexError.js"));
|
||||
var MmlNode_js_1 = require("../../core/MmlTree/MmlNode.js");
|
||||
var TexParser = (function () {
|
||||
function TexParser(_string, env, configuration) {
|
||||
var e_1, _a;
|
||||
this._string = _string;
|
||||
this.configuration = configuration;
|
||||
this.macroCount = 0;
|
||||
this.i = 0;
|
||||
this.currentCS = '';
|
||||
var inner = env.hasOwnProperty('isInner');
|
||||
var isInner = env['isInner'];
|
||||
delete env['isInner'];
|
||||
var ENV;
|
||||
if (env) {
|
||||
ENV = {};
|
||||
try {
|
||||
for (var _b = __values(Object.keys(env)), _c = _b.next(); !_c.done; _c = _b.next()) {
|
||||
var id = _c.value;
|
||||
ENV[id] = env[id];
|
||||
}
|
||||
}
|
||||
catch (e_1_1) { e_1 = { error: e_1_1 }; }
|
||||
finally {
|
||||
try {
|
||||
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
|
||||
}
|
||||
finally { if (e_1) throw e_1.error; }
|
||||
}
|
||||
}
|
||||
this.configuration.pushParser(this);
|
||||
this.stack = new Stack_js_1.default(this.itemFactory, ENV, inner ? isInner : true);
|
||||
this.Parse();
|
||||
this.Push(this.itemFactory.create('stop'));
|
||||
}
|
||||
Object.defineProperty(TexParser.prototype, "options", {
|
||||
get: function () {
|
||||
return this.configuration.options;
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
Object.defineProperty(TexParser.prototype, "itemFactory", {
|
||||
get: function () {
|
||||
return this.configuration.itemFactory;
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
Object.defineProperty(TexParser.prototype, "tags", {
|
||||
get: function () {
|
||||
return this.configuration.tags;
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
Object.defineProperty(TexParser.prototype, "string", {
|
||||
get: function () {
|
||||
return this._string;
|
||||
},
|
||||
set: function (str) {
|
||||
this._string = str;
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
TexParser.prototype.parse = function (kind, input) {
|
||||
return this.configuration.handlers.get(kind).parse(input);
|
||||
};
|
||||
TexParser.prototype.lookup = function (kind, symbol) {
|
||||
return this.configuration.handlers.get(kind).lookup(symbol);
|
||||
};
|
||||
TexParser.prototype.contains = function (kind, symbol) {
|
||||
return this.configuration.handlers.get(kind).contains(symbol);
|
||||
};
|
||||
TexParser.prototype.toString = function () {
|
||||
var e_2, _a;
|
||||
var str = '';
|
||||
try {
|
||||
for (var _b = __values(Array.from(this.configuration.handlers.keys())), _c = _b.next(); !_c.done; _c = _b.next()) {
|
||||
var config = _c.value;
|
||||
str += config + ': ' +
|
||||
this.configuration.handlers.get(config) + '\n';
|
||||
}
|
||||
}
|
||||
catch (e_2_1) { e_2 = { error: e_2_1 }; }
|
||||
finally {
|
||||
try {
|
||||
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
|
||||
}
|
||||
finally { if (e_2) throw e_2.error; }
|
||||
}
|
||||
return str;
|
||||
};
|
||||
TexParser.prototype.Parse = function () {
|
||||
var c;
|
||||
while (this.i < this.string.length) {
|
||||
c = this.getCodePoint();
|
||||
this.i += c.length;
|
||||
this.parse('character', [this, c]);
|
||||
}
|
||||
};
|
||||
TexParser.prototype.Push = function (arg) {
|
||||
if (arg instanceof MmlNode_js_1.AbstractMmlNode && arg.isInferred) {
|
||||
this.PushAll(arg.childNodes);
|
||||
}
|
||||
else {
|
||||
this.stack.Push(arg);
|
||||
}
|
||||
};
|
||||
TexParser.prototype.PushAll = function (args) {
|
||||
var e_3, _a;
|
||||
try {
|
||||
for (var args_1 = __values(args), args_1_1 = args_1.next(); !args_1_1.done; args_1_1 = args_1.next()) {
|
||||
var arg = args_1_1.value;
|
||||
this.stack.Push(arg);
|
||||
}
|
||||
}
|
||||
catch (e_3_1) { e_3 = { error: e_3_1 }; }
|
||||
finally {
|
||||
try {
|
||||
if (args_1_1 && !args_1_1.done && (_a = args_1.return)) _a.call(args_1);
|
||||
}
|
||||
finally { if (e_3) throw e_3.error; }
|
||||
}
|
||||
};
|
||||
TexParser.prototype.mml = function () {
|
||||
if (!this.stack.Top().isKind('mml')) {
|
||||
return null;
|
||||
}
|
||||
var node = this.stack.Top().First;
|
||||
this.configuration.popParser();
|
||||
return node;
|
||||
};
|
||||
TexParser.prototype.convertDelimiter = function (c) {
|
||||
var symbol = this.lookup('delimiter', c);
|
||||
return symbol ? symbol.char : null;
|
||||
};
|
||||
TexParser.prototype.getCodePoint = function () {
|
||||
var code = this.string.codePointAt(this.i);
|
||||
return code === undefined ? '' : String.fromCodePoint(code);
|
||||
};
|
||||
TexParser.prototype.nextIsSpace = function () {
|
||||
return !!this.string.charAt(this.i).match(/\s/);
|
||||
};
|
||||
TexParser.prototype.GetNext = function () {
|
||||
while (this.nextIsSpace()) {
|
||||
this.i++;
|
||||
}
|
||||
return this.getCodePoint();
|
||||
};
|
||||
TexParser.prototype.GetCS = function () {
|
||||
var CS = this.string.slice(this.i).match(/^(([a-z]+) ?|[\uD800-\uDBFF].|.)/i);
|
||||
if (CS) {
|
||||
this.i += CS[0].length;
|
||||
return CS[2] || CS[1];
|
||||
}
|
||||
else {
|
||||
this.i++;
|
||||
return ' ';
|
||||
}
|
||||
};
|
||||
TexParser.prototype.GetArgument = function (_name, noneOK) {
|
||||
switch (this.GetNext()) {
|
||||
case '':
|
||||
if (!noneOK) {
|
||||
throw new TexError_js_1.default('MissingArgFor', 'Missing argument for %1', this.currentCS);
|
||||
}
|
||||
return null;
|
||||
case '}':
|
||||
if (!noneOK) {
|
||||
throw new TexError_js_1.default('ExtraCloseMissingOpen', 'Extra close brace or missing open brace');
|
||||
}
|
||||
return null;
|
||||
case '\\':
|
||||
this.i++;
|
||||
return '\\' + this.GetCS();
|
||||
case '{':
|
||||
var j = ++this.i, parens = 1;
|
||||
while (this.i < this.string.length) {
|
||||
switch (this.string.charAt(this.i++)) {
|
||||
case '\\':
|
||||
this.i++;
|
||||
break;
|
||||
case '{':
|
||||
parens++;
|
||||
break;
|
||||
case '}':
|
||||
if (--parens === 0) {
|
||||
return this.string.slice(j, this.i - 1);
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
throw new TexError_js_1.default('MissingCloseBrace', 'Missing close brace');
|
||||
}
|
||||
var c = this.getCodePoint();
|
||||
this.i += c.length;
|
||||
return c;
|
||||
};
|
||||
TexParser.prototype.GetBrackets = function (_name, def) {
|
||||
if (this.GetNext() !== '[') {
|
||||
return def;
|
||||
}
|
||||
var j = ++this.i, parens = 0;
|
||||
while (this.i < this.string.length) {
|
||||
switch (this.string.charAt(this.i++)) {
|
||||
case '{':
|
||||
parens++;
|
||||
break;
|
||||
case '\\':
|
||||
this.i++;
|
||||
break;
|
||||
case '}':
|
||||
if (parens-- <= 0) {
|
||||
throw new TexError_js_1.default('ExtraCloseLooking', 'Extra close brace while looking for %1', '\']\'');
|
||||
}
|
||||
break;
|
||||
case ']':
|
||||
if (parens === 0) {
|
||||
return this.string.slice(j, this.i - 1);
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
throw new TexError_js_1.default('MissingCloseBracket', 'Could not find closing \']\' for argument to %1', this.currentCS);
|
||||
};
|
||||
TexParser.prototype.GetDelimiter = function (name, braceOK) {
|
||||
var c = this.GetNext();
|
||||
this.i += c.length;
|
||||
if (this.i <= this.string.length) {
|
||||
if (c === '\\') {
|
||||
c += this.GetCS();
|
||||
}
|
||||
else if (c === '{' && braceOK) {
|
||||
this.i--;
|
||||
c = this.GetArgument(name).trim();
|
||||
}
|
||||
if (this.contains('delimiter', c)) {
|
||||
return this.convertDelimiter(c);
|
||||
}
|
||||
}
|
||||
throw new TexError_js_1.default('MissingOrUnrecognizedDelim', 'Missing or unrecognized delimiter for %1', this.currentCS);
|
||||
};
|
||||
TexParser.prototype.GetDimen = function (name) {
|
||||
if (this.GetNext() === '{') {
|
||||
var dimen = this.GetArgument(name);
|
||||
var _a = __read(ParseUtil_js_1.default.matchDimen(dimen), 2), value = _a[0], unit = _a[1];
|
||||
if (value) {
|
||||
return value + unit;
|
||||
}
|
||||
}
|
||||
else {
|
||||
var dimen = this.string.slice(this.i);
|
||||
var _b = __read(ParseUtil_js_1.default.matchDimen(dimen, true), 3), value = _b[0], unit = _b[1], length_1 = _b[2];
|
||||
if (value) {
|
||||
this.i += length_1;
|
||||
return value + unit;
|
||||
}
|
||||
}
|
||||
throw new TexError_js_1.default('MissingDimOrUnits', 'Missing dimension or its units for %1', this.currentCS);
|
||||
};
|
||||
TexParser.prototype.GetUpTo = function (_name, token) {
|
||||
while (this.nextIsSpace()) {
|
||||
this.i++;
|
||||
}
|
||||
var j = this.i;
|
||||
var parens = 0;
|
||||
while (this.i < this.string.length) {
|
||||
var k = this.i;
|
||||
var c = this.GetNext();
|
||||
this.i += c.length;
|
||||
switch (c) {
|
||||
case '\\':
|
||||
c += this.GetCS();
|
||||
break;
|
||||
case '{':
|
||||
parens++;
|
||||
break;
|
||||
case '}':
|
||||
if (parens === 0) {
|
||||
throw new TexError_js_1.default('ExtraCloseLooking', 'Extra close brace while looking for %1', token);
|
||||
}
|
||||
parens--;
|
||||
break;
|
||||
}
|
||||
if (parens === 0 && c === token) {
|
||||
return this.string.slice(j, k);
|
||||
}
|
||||
}
|
||||
throw new TexError_js_1.default('TokenNotFoundForCommand', 'Could not find %1 for %2', token, this.currentCS);
|
||||
};
|
||||
TexParser.prototype.ParseArg = function (name) {
|
||||
return new TexParser(this.GetArgument(name), this.stack.env, this.configuration).mml();
|
||||
};
|
||||
TexParser.prototype.ParseUpTo = function (name, token) {
|
||||
return new TexParser(this.GetUpTo(name, token), this.stack.env, this.configuration).mml();
|
||||
};
|
||||
TexParser.prototype.GetDelimiterArg = function (name) {
|
||||
var c = ParseUtil_js_1.default.trimSpaces(this.GetArgument(name));
|
||||
if (c === '') {
|
||||
return null;
|
||||
}
|
||||
if (this.contains('delimiter', c)) {
|
||||
return c;
|
||||
}
|
||||
throw new TexError_js_1.default('MissingOrUnrecognizedDelim', 'Missing or unrecognized delimiter for %1', this.currentCS);
|
||||
};
|
||||
TexParser.prototype.GetStar = function () {
|
||||
var star = (this.GetNext() === '*');
|
||||
if (star) {
|
||||
this.i++;
|
||||
}
|
||||
return star;
|
||||
};
|
||||
TexParser.prototype.create = function (kind) {
|
||||
var _a;
|
||||
var rest = [];
|
||||
for (var _i = 1; _i < arguments.length; _i++) {
|
||||
rest[_i - 1] = arguments[_i];
|
||||
}
|
||||
return (_a = this.configuration.nodeFactory).create.apply(_a, __spreadArray([kind], __read(rest), false));
|
||||
};
|
||||
return TexParser;
|
||||
}());
|
||||
exports.default = TexParser;
|
||||
//# sourceMappingURL=TexParser.js.map
|
||||
1
node_modules/mathjax-full/js/input/tex/TexParser.js.map
generated
vendored
Normal file
1
node_modules/mathjax-full/js/input/tex/TexParser.js.map
generated
vendored
Normal file
File diff suppressed because one or more lines are too long
9
node_modules/mathjax-full/js/input/tex/Types.d.ts
generated
vendored
Normal file
9
node_modules/mathjax-full/js/input/tex/Types.d.ts
generated
vendored
Normal file
@@ -0,0 +1,9 @@
|
||||
import { StackItem } from './StackItem.js';
|
||||
import { Symbol } from './Symbol.js';
|
||||
import TexParser from './TexParser.js';
|
||||
export declare type Args = boolean | number | string | null;
|
||||
export declare type Attributes = Record<string, Args>;
|
||||
export declare type Environment = Record<string, Args>;
|
||||
export declare type ParseInput = [TexParser, string];
|
||||
export declare type ParseResult = void | boolean | StackItem;
|
||||
export declare type ParseMethod = (parser: TexParser, c: string | Symbol | StackItem, ...rest: any[]) => ParseResult;
|
||||
3
node_modules/mathjax-full/js/input/tex/Types.js
generated
vendored
Normal file
3
node_modules/mathjax-full/js/input/tex/Types.js
generated
vendored
Normal file
@@ -0,0 +1,3 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
//# sourceMappingURL=Types.js.map
|
||||
1
node_modules/mathjax-full/js/input/tex/Types.js.map
generated
vendored
Normal file
1
node_modules/mathjax-full/js/input/tex/Types.js.map
generated
vendored
Normal file
@@ -0,0 +1 @@
|
||||
{"version":3,"file":"Types.js","sourceRoot":"","sources":["../../../ts/input/tex/Types.ts"],"names":[],"mappings":""}
|
||||
4
node_modules/mathjax-full/js/input/tex/action/ActionConfiguration.d.ts
generated
vendored
Normal file
4
node_modules/mathjax-full/js/input/tex/action/ActionConfiguration.d.ts
generated
vendored
Normal file
@@ -0,0 +1,4 @@
|
||||
import { Configuration } from '../Configuration.js';
|
||||
import { ParseMethod } from '../Types.js';
|
||||
export declare let ActionMethods: Record<string, ParseMethod>;
|
||||
export declare const ActionConfiguration: Configuration;
|
||||
32
node_modules/mathjax-full/js/input/tex/action/ActionConfiguration.js
generated
vendored
Normal file
32
node_modules/mathjax-full/js/input/tex/action/ActionConfiguration.js
generated
vendored
Normal file
@@ -0,0 +1,32 @@
|
||||
"use strict";
|
||||
var __importDefault = (this && this.__importDefault) || function (mod) {
|
||||
return (mod && mod.__esModule) ? mod : { "default": mod };
|
||||
};
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.ActionConfiguration = exports.ActionMethods = void 0;
|
||||
var Configuration_js_1 = require("../Configuration.js");
|
||||
var TexParser_js_1 = __importDefault(require("../TexParser.js"));
|
||||
var SymbolMap_js_1 = require("../SymbolMap.js");
|
||||
var BaseMethods_js_1 = __importDefault(require("../base/BaseMethods.js"));
|
||||
exports.ActionMethods = {};
|
||||
exports.ActionMethods.Macro = BaseMethods_js_1.default.Macro;
|
||||
exports.ActionMethods.Toggle = function (parser, name) {
|
||||
var children = [];
|
||||
var arg;
|
||||
while ((arg = parser.GetArgument(name)) !== '\\endtoggle') {
|
||||
children.push(new TexParser_js_1.default(arg, parser.stack.env, parser.configuration).mml());
|
||||
}
|
||||
parser.Push(parser.create('node', 'maction', children, { actiontype: 'toggle' }));
|
||||
};
|
||||
exports.ActionMethods.Mathtip = function (parser, name) {
|
||||
var arg = parser.ParseArg(name);
|
||||
var tip = parser.ParseArg(name);
|
||||
parser.Push(parser.create('node', 'maction', [arg, tip], { actiontype: 'tooltip' }));
|
||||
};
|
||||
new SymbolMap_js_1.CommandMap('action-macros', {
|
||||
toggle: 'Toggle',
|
||||
mathtip: 'Mathtip',
|
||||
texttip: ['Macro', '\\mathtip{#1}{\\text{#2}}', 2]
|
||||
}, exports.ActionMethods);
|
||||
exports.ActionConfiguration = Configuration_js_1.Configuration.create('action', { handler: { macro: ['action-macros'] } });
|
||||
//# sourceMappingURL=ActionConfiguration.js.map
|
||||
1
node_modules/mathjax-full/js/input/tex/action/ActionConfiguration.js.map
generated
vendored
Normal file
1
node_modules/mathjax-full/js/input/tex/action/ActionConfiguration.js.map
generated
vendored
Normal file
@@ -0,0 +1 @@
|
||||
{"version":3,"file":"ActionConfiguration.js","sourceRoot":"","sources":["../../../../ts/input/tex/action/ActionConfiguration.ts"],"names":[],"mappings":";;;;;;AAwBA,wDAAkD;AAClD,iEAAwC;AACxC,gDAA2C;AAE3C,0EAAiD;AAItC,QAAA,aAAa,GAAgC,EAAE,CAAC;AAE3D,qBAAa,CAAC,KAAK,GAAG,wBAAW,CAAC,KAAK,CAAC;AAQxC,qBAAa,CAAC,MAAM,GAAG,UAAS,MAAiB,EAAE,IAAY;IAC7D,IAAM,QAAQ,GAAG,EAAE,CAAC;IACpB,IAAI,GAAG,CAAC;IACR,OAAO,CAAC,GAAG,GAAG,MAAM,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,KAAK,aAAa,EAAE;QACzD,QAAQ,CAAC,IAAI,CACX,IAAI,sBAAS,CAAC,GAAG,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,EAAE,MAAM,CAAC,aAAa,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC;KACrE;IACD,MAAM,CAAC,IAAI,CACT,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,EAAC,UAAU,EAAE,QAAQ,EAAC,CAAC,CAAC,CAAC;AACxE,CAAC,CAAC;AASF,qBAAa,CAAC,OAAO,GAAG,UAAS,MAAiB,EAAE,IAAY;IAC9D,IAAM,GAAG,GAAG,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;IAClC,IAAM,GAAG,GAAG,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;IAClC,MAAM,CAAC,IAAI,CACT,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,EAAC,UAAU,EAAE,SAAS,EAAC,CAAC,CAAC,CAAC;AAC3E,CAAC,CAAC;AAGF,IAAI,yBAAU,CAAC,eAAe,EAAE;IAC9B,MAAM,EAAG,QAAQ;IACjB,OAAO,EAAE,SAAS;IAClB,OAAO,EAAE,CAAC,OAAO,EAAE,2BAA2B,EAAE,CAAC,CAAC;CACnD,EAAE,qBAAa,CAAC,CAAC;AAGL,QAAA,mBAAmB,GAAG,gCAAa,CAAC,MAAM,CACrD,QAAQ,EAAE,EAAC,OAAO,EAAE,EAAC,KAAK,EAAE,CAAC,eAAe,CAAC,EAAC,EAAC,CAChD,CAAC"}
|
||||
6
node_modules/mathjax-full/js/input/tex/ams/AmsConfiguration.d.ts
generated
vendored
Normal file
6
node_modules/mathjax-full/js/input/tex/ams/AmsConfiguration.d.ts
generated
vendored
Normal file
@@ -0,0 +1,6 @@
|
||||
import { Configuration } from '../Configuration.js';
|
||||
import { AbstractTags } from '../Tags.js';
|
||||
import './AmsMappings.js';
|
||||
export declare class AmsTags extends AbstractTags {
|
||||
}
|
||||
export declare const AmsConfiguration: Configuration;
|
||||
68
node_modules/mathjax-full/js/input/tex/ams/AmsConfiguration.js
generated
vendored
Normal file
68
node_modules/mathjax-full/js/input/tex/ams/AmsConfiguration.js
generated
vendored
Normal file
@@ -0,0 +1,68 @@
|
||||
"use strict";
|
||||
var __extends = (this && this.__extends) || (function () {
|
||||
var extendStatics = function (d, b) {
|
||||
extendStatics = Object.setPrototypeOf ||
|
||||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
||||
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
|
||||
return extendStatics(d, b);
|
||||
};
|
||||
return function (d, b) {
|
||||
if (typeof b !== "function" && b !== null)
|
||||
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
|
||||
extendStatics(d, b);
|
||||
function __() { this.constructor = d; }
|
||||
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
||||
};
|
||||
})();
|
||||
var _a;
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.AmsConfiguration = exports.AmsTags = void 0;
|
||||
var Configuration_js_1 = require("../Configuration.js");
|
||||
var AmsItems_js_1 = require("./AmsItems.js");
|
||||
var Tags_js_1 = require("../Tags.js");
|
||||
var AmsMethods_js_1 = require("./AmsMethods.js");
|
||||
require("./AmsMappings.js");
|
||||
var SymbolMap_js_1 = require("../SymbolMap.js");
|
||||
var AmsTags = (function (_super) {
|
||||
__extends(AmsTags, _super);
|
||||
function AmsTags() {
|
||||
return _super !== null && _super.apply(this, arguments) || this;
|
||||
}
|
||||
return AmsTags;
|
||||
}(Tags_js_1.AbstractTags));
|
||||
exports.AmsTags = AmsTags;
|
||||
var init = function (config) {
|
||||
new SymbolMap_js_1.CommandMap(AmsMethods_js_1.NEW_OPS, {}, {});
|
||||
config.append(Configuration_js_1.Configuration.local({ handler: { macro: [AmsMethods_js_1.NEW_OPS] },
|
||||
priority: -1 }));
|
||||
};
|
||||
exports.AmsConfiguration = Configuration_js_1.Configuration.create('ams', {
|
||||
handler: {
|
||||
character: ['AMSmath-operatorLetter'],
|
||||
delimiter: ['AMSsymbols-delimiter', 'AMSmath-delimiter'],
|
||||
macro: ['AMSsymbols-mathchar0mi', 'AMSsymbols-mathchar0mo',
|
||||
'AMSsymbols-delimiter', 'AMSsymbols-macros',
|
||||
'AMSmath-mathchar0mo', 'AMSmath-macros', 'AMSmath-delimiter'],
|
||||
environment: ['AMSmath-environment']
|
||||
},
|
||||
items: (_a = {},
|
||||
_a[AmsItems_js_1.MultlineItem.prototype.kind] = AmsItems_js_1.MultlineItem,
|
||||
_a[AmsItems_js_1.FlalignItem.prototype.kind] = AmsItems_js_1.FlalignItem,
|
||||
_a),
|
||||
tags: { 'ams': AmsTags },
|
||||
init: init,
|
||||
config: function (_config, jax) {
|
||||
if (jax.parseOptions.options.multlineWidth) {
|
||||
jax.parseOptions.options.ams.multlineWidth = jax.parseOptions.options.multlineWidth;
|
||||
}
|
||||
delete jax.parseOptions.options.multlineWidth;
|
||||
},
|
||||
options: {
|
||||
multlineWidth: '',
|
||||
ams: {
|
||||
multlineWidth: '100%',
|
||||
multlineIndent: '1em',
|
||||
}
|
||||
}
|
||||
});
|
||||
//# sourceMappingURL=AmsConfiguration.js.map
|
||||
1
node_modules/mathjax-full/js/input/tex/ams/AmsConfiguration.js.map
generated
vendored
Normal file
1
node_modules/mathjax-full/js/input/tex/ams/AmsConfiguration.js.map
generated
vendored
Normal file
@@ -0,0 +1 @@
|
||||
{"version":3,"file":"AmsConfiguration.js","sourceRoot":"","sources":["../../../../ts/input/tex/ams/AmsConfiguration.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;AAwBA,wDAAuE;AACvE,6CAAwD;AACxD,sCAAwC;AACxC,iDAAwC;AACxC,4BAA0B;AAC1B,gDAA2C;AAQ3C;IAA6B,2BAAY;IAAzC;;IAA4C,CAAC;IAAD,cAAC;AAAD,CAAC,AAA7C,CAA6B,sBAAY,GAAI;AAAhC,0BAAO;AAOpB,IAAI,IAAI,GAAG,UAAS,MAA2B;IAC7C,IAAI,yBAAU,CAAC,uBAAO,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;IAChC,MAAM,CAAC,MAAM,CAAC,gCAAa,CAAC,KAAK,CAAC,EAAC,OAAO,EAAE,EAAC,KAAK,EAAE,CAAC,uBAAO,CAAC,EAAC;QAC5B,QAAQ,EAAE,CAAC,CAAC,EAAC,CAAC,CAAC,CAAC;AACpD,CAAC,CAAC;AAEW,QAAA,gBAAgB,GAAG,gCAAa,CAAC,MAAM,CAClD,KAAK,EAAE;IACL,OAAO,EAAE;QACP,SAAS,EAAE,CAAC,wBAAwB,CAAC;QACrC,SAAS,EAAE,CAAC,sBAAsB,EAAE,mBAAmB,CAAC;QACxD,KAAK,EAAE,CAAC,wBAAwB,EAAE,wBAAwB;YAClD,sBAAsB,EAAE,mBAAmB;YAC3C,qBAAqB,EAAE,gBAAgB,EAAE,mBAAmB,CAAC;QACrE,WAAW,EAAE,CAAC,qBAAqB,CAAC;KACrC;IACD,KAAK;QACH,GAAC,0BAAY,CAAC,SAAS,CAAC,IAAI,IAAG,0BAAY;QAC3C,GAAC,yBAAW,CAAC,SAAS,CAAC,IAAI,IAAG,yBAAW;WAC1C;IACD,IAAI,EAAE,EAAC,KAAK,EAAE,OAAO,EAAC;IACtB,IAAI,EAAE,IAAI;IACV,MAAM,EAAE,UAAC,OAA4B,EAAE,GAAQ;QAI7C,IAAI,GAAG,CAAC,YAAY,CAAC,OAAO,CAAC,aAAa,EAAE;YAC1C,GAAG,CAAC,YAAY,CAAC,OAAO,CAAC,GAAG,CAAC,aAAa,GAAG,GAAG,CAAC,YAAY,CAAC,OAAO,CAAC,aAAa,CAAC;SACrF;QACD,OAAO,GAAG,CAAC,YAAY,CAAC,OAAO,CAAC,aAAa,CAAC;IAChD,CAAC;IACD,OAAO,EAAE;QACP,aAAa,EAAE,EAAE;QACjB,GAAG,EAAE;YACH,aAAa,EAAE,MAAM;YACrB,cAAc,EAAE,KAAK;SACtB;KACF;CACF,CACF,CAAC"}
|
||||
19
node_modules/mathjax-full/js/input/tex/ams/AmsItems.d.ts
generated
vendored
Normal file
19
node_modules/mathjax-full/js/input/tex/ams/AmsItems.d.ts
generated
vendored
Normal file
@@ -0,0 +1,19 @@
|
||||
import { ArrayItem, EqnArrayItem } from '../base/BaseItems.js';
|
||||
export declare class MultlineItem extends ArrayItem {
|
||||
constructor(factory: any, ...args: any[]);
|
||||
get kind(): string;
|
||||
EndEntry(): void;
|
||||
EndRow(): void;
|
||||
EndTable(): void;
|
||||
}
|
||||
export declare class FlalignItem extends EqnArrayItem {
|
||||
name: string;
|
||||
numbered: boolean;
|
||||
padded: boolean;
|
||||
center: boolean;
|
||||
get kind(): string;
|
||||
constructor(factory: any, name: string, numbered: boolean, padded: boolean, center: boolean);
|
||||
EndEntry(): void;
|
||||
EndRow(): void;
|
||||
EndTable(): void;
|
||||
}
|
||||
171
node_modules/mathjax-full/js/input/tex/ams/AmsItems.js
generated
vendored
Normal file
171
node_modules/mathjax-full/js/input/tex/ams/AmsItems.js
generated
vendored
Normal file
@@ -0,0 +1,171 @@
|
||||
"use strict";
|
||||
var __extends = (this && this.__extends) || (function () {
|
||||
var extendStatics = function (d, b) {
|
||||
extendStatics = Object.setPrototypeOf ||
|
||||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
||||
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
|
||||
return extendStatics(d, b);
|
||||
};
|
||||
return function (d, b) {
|
||||
if (typeof b !== "function" && b !== null)
|
||||
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
|
||||
extendStatics(d, b);
|
||||
function __() { this.constructor = d; }
|
||||
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
||||
};
|
||||
})();
|
||||
var __assign = (this && this.__assign) || function () {
|
||||
__assign = Object.assign || function(t) {
|
||||
for (var s, i = 1, n = arguments.length; i < n; i++) {
|
||||
s = arguments[i];
|
||||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
|
||||
t[p] = s[p];
|
||||
}
|
||||
return t;
|
||||
};
|
||||
return __assign.apply(this, arguments);
|
||||
};
|
||||
var __importDefault = (this && this.__importDefault) || function (mod) {
|
||||
return (mod && mod.__esModule) ? mod : { "default": mod };
|
||||
};
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.FlalignItem = exports.MultlineItem = void 0;
|
||||
var BaseItems_js_1 = require("../base/BaseItems.js");
|
||||
var ParseUtil_js_1 = __importDefault(require("../ParseUtil.js"));
|
||||
var NodeUtil_js_1 = __importDefault(require("../NodeUtil.js"));
|
||||
var TexError_js_1 = __importDefault(require("../TexError.js"));
|
||||
var TexConstants_js_1 = require("../TexConstants.js");
|
||||
var MultlineItem = (function (_super) {
|
||||
__extends(MultlineItem, _super);
|
||||
function MultlineItem(factory) {
|
||||
var args = [];
|
||||
for (var _i = 1; _i < arguments.length; _i++) {
|
||||
args[_i - 1] = arguments[_i];
|
||||
}
|
||||
var _this = _super.call(this, factory) || this;
|
||||
_this.factory.configuration.tags.start('multline', true, args[0]);
|
||||
return _this;
|
||||
}
|
||||
Object.defineProperty(MultlineItem.prototype, "kind", {
|
||||
get: function () {
|
||||
return 'multline';
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
MultlineItem.prototype.EndEntry = function () {
|
||||
if (this.table.length) {
|
||||
ParseUtil_js_1.default.fixInitialMO(this.factory.configuration, this.nodes);
|
||||
}
|
||||
var shove = this.getProperty('shove');
|
||||
var mtd = this.create('node', 'mtd', this.nodes, shove ? { columnalign: shove } : {});
|
||||
this.setProperty('shove', null);
|
||||
this.row.push(mtd);
|
||||
this.Clear();
|
||||
};
|
||||
MultlineItem.prototype.EndRow = function () {
|
||||
if (this.row.length !== 1) {
|
||||
throw new TexError_js_1.default('MultlineRowsOneCol', 'The rows within the %1 environment must have exactly one column', 'multline');
|
||||
}
|
||||
var row = this.create('node', 'mtr', this.row);
|
||||
this.table.push(row);
|
||||
this.row = [];
|
||||
};
|
||||
MultlineItem.prototype.EndTable = function () {
|
||||
_super.prototype.EndTable.call(this);
|
||||
if (this.table.length) {
|
||||
var m = this.table.length - 1, label = -1;
|
||||
if (!NodeUtil_js_1.default.getAttribute(NodeUtil_js_1.default.getChildren(this.table[0])[0], 'columnalign')) {
|
||||
NodeUtil_js_1.default.setAttribute(NodeUtil_js_1.default.getChildren(this.table[0])[0], 'columnalign', TexConstants_js_1.TexConstant.Align.LEFT);
|
||||
}
|
||||
if (!NodeUtil_js_1.default.getAttribute(NodeUtil_js_1.default.getChildren(this.table[m])[0], 'columnalign')) {
|
||||
NodeUtil_js_1.default.setAttribute(NodeUtil_js_1.default.getChildren(this.table[m])[0], 'columnalign', TexConstants_js_1.TexConstant.Align.RIGHT);
|
||||
}
|
||||
var tag = this.factory.configuration.tags.getTag();
|
||||
if (tag) {
|
||||
label = (this.arraydef.side === TexConstants_js_1.TexConstant.Align.LEFT ? 0 : this.table.length - 1);
|
||||
var mtr = this.table[label];
|
||||
var mlabel = this.create('node', 'mlabeledtr', [tag].concat(NodeUtil_js_1.default.getChildren(mtr)));
|
||||
NodeUtil_js_1.default.copyAttributes(mtr, mlabel);
|
||||
this.table[label] = mlabel;
|
||||
}
|
||||
}
|
||||
this.factory.configuration.tags.end();
|
||||
};
|
||||
return MultlineItem;
|
||||
}(BaseItems_js_1.ArrayItem));
|
||||
exports.MultlineItem = MultlineItem;
|
||||
var FlalignItem = (function (_super) {
|
||||
__extends(FlalignItem, _super);
|
||||
function FlalignItem(factory, name, numbered, padded, center) {
|
||||
var _this = _super.call(this, factory) || this;
|
||||
_this.name = name;
|
||||
_this.numbered = numbered;
|
||||
_this.padded = padded;
|
||||
_this.center = center;
|
||||
_this.factory.configuration.tags.start(name, numbered, numbered);
|
||||
return _this;
|
||||
}
|
||||
Object.defineProperty(FlalignItem.prototype, "kind", {
|
||||
get: function () {
|
||||
return 'flalign';
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
FlalignItem.prototype.EndEntry = function () {
|
||||
_super.prototype.EndEntry.call(this);
|
||||
var n = this.getProperty('xalignat');
|
||||
if (!n)
|
||||
return;
|
||||
if (this.row.length > n) {
|
||||
throw new TexError_js_1.default('XalignOverflow', 'Extra %1 in row of %2', '&', this.name);
|
||||
}
|
||||
};
|
||||
FlalignItem.prototype.EndRow = function () {
|
||||
var cell;
|
||||
var row = this.row;
|
||||
var n = this.getProperty('xalignat');
|
||||
while (row.length < n) {
|
||||
row.push(this.create('node', 'mtd'));
|
||||
}
|
||||
this.row = [];
|
||||
if (this.padded) {
|
||||
this.row.push(this.create('node', 'mtd'));
|
||||
}
|
||||
while ((cell = row.shift())) {
|
||||
this.row.push(cell);
|
||||
cell = row.shift();
|
||||
if (cell)
|
||||
this.row.push(cell);
|
||||
if (row.length || this.padded) {
|
||||
this.row.push(this.create('node', 'mtd'));
|
||||
}
|
||||
}
|
||||
if (this.row.length > this.maxrow) {
|
||||
this.maxrow = this.row.length;
|
||||
}
|
||||
_super.prototype.EndRow.call(this);
|
||||
var mtr = this.table[this.table.length - 1];
|
||||
if (this.getProperty('zeroWidthLabel') && mtr.isKind('mlabeledtr')) {
|
||||
var mtd = NodeUtil_js_1.default.getChildren(mtr)[0];
|
||||
var side = this.factory.configuration.options['tagSide'];
|
||||
var def = __assign({ width: 0 }, (side === 'right' ? { lspace: '-1width' } : {}));
|
||||
var mpadded = this.create('node', 'mpadded', NodeUtil_js_1.default.getChildren(mtd), def);
|
||||
mtd.setChildren([mpadded]);
|
||||
}
|
||||
};
|
||||
FlalignItem.prototype.EndTable = function () {
|
||||
_super.prototype.EndTable.call(this);
|
||||
if (this.center) {
|
||||
if (this.maxrow <= 2) {
|
||||
var def = this.arraydef;
|
||||
delete def.width;
|
||||
delete this.global.indentalign;
|
||||
}
|
||||
}
|
||||
};
|
||||
return FlalignItem;
|
||||
}(BaseItems_js_1.EqnArrayItem));
|
||||
exports.FlalignItem = FlalignItem;
|
||||
//# sourceMappingURL=AmsItems.js.map
|
||||
1
node_modules/mathjax-full/js/input/tex/ams/AmsItems.js.map
generated
vendored
Normal file
1
node_modules/mathjax-full/js/input/tex/ams/AmsItems.js.map
generated
vendored
Normal file
File diff suppressed because one or more lines are too long
1
node_modules/mathjax-full/js/input/tex/ams/AmsMappings.d.ts
generated
vendored
Normal file
1
node_modules/mathjax-full/js/input/tex/ams/AmsMappings.d.ts
generated
vendored
Normal file
@@ -0,0 +1 @@
|
||||
export {};
|
||||
367
node_modules/mathjax-full/js/input/tex/ams/AmsMappings.js
generated
vendored
Normal file
367
node_modules/mathjax-full/js/input/tex/ams/AmsMappings.js
generated
vendored
Normal file
@@ -0,0 +1,367 @@
|
||||
"use strict";
|
||||
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
|
||||
if (k2 === undefined) k2 = k;
|
||||
var desc = Object.getOwnPropertyDescriptor(m, k);
|
||||
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
|
||||
desc = { enumerable: true, get: function() { return m[k]; } };
|
||||
}
|
||||
Object.defineProperty(o, k2, desc);
|
||||
}) : (function(o, m, k, k2) {
|
||||
if (k2 === undefined) k2 = k;
|
||||
o[k2] = m[k];
|
||||
}));
|
||||
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
|
||||
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
||||
}) : function(o, v) {
|
||||
o["default"] = v;
|
||||
});
|
||||
var __importStar = (this && this.__importStar) || function (mod) {
|
||||
if (mod && mod.__esModule) return mod;
|
||||
var result = {};
|
||||
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
|
||||
__setModuleDefault(result, mod);
|
||||
return result;
|
||||
};
|
||||
var __importDefault = (this && this.__importDefault) || function (mod) {
|
||||
return (mod && mod.__esModule) ? mod : { "default": mod };
|
||||
};
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
var AmsMethods_js_1 = require("./AmsMethods.js");
|
||||
var sm = __importStar(require("../SymbolMap.js"));
|
||||
var TexConstants_js_1 = require("../TexConstants.js");
|
||||
var ParseMethods_js_1 = __importDefault(require("../ParseMethods.js"));
|
||||
var ParseUtil_js_1 = __importDefault(require("../ParseUtil.js"));
|
||||
var MmlNode_js_1 = require("../../../core/MmlTree/MmlNode.js");
|
||||
var lengths_js_1 = require("../../../util/lengths.js");
|
||||
new sm.CharacterMap('AMSmath-mathchar0mo', ParseMethods_js_1.default.mathchar0mo, {
|
||||
iiiint: ['\u2A0C', { texClass: MmlNode_js_1.TEXCLASS.OP }]
|
||||
});
|
||||
new sm.RegExpMap('AMSmath-operatorLetter', AmsMethods_js_1.AmsMethods.operatorLetter, /[-*]/i);
|
||||
new sm.CommandMap('AMSmath-macros', {
|
||||
mathring: ['Accent', '02DA'],
|
||||
nobreakspace: 'Tilde',
|
||||
negmedspace: ['Spacer', lengths_js_1.MATHSPACE.negativemediummathspace],
|
||||
negthickspace: ['Spacer', lengths_js_1.MATHSPACE.negativethickmathspace],
|
||||
idotsint: ['MultiIntegral', '\\int\\cdots\\int'],
|
||||
dddot: ['Accent', '20DB'],
|
||||
ddddot: ['Accent', '20DC'],
|
||||
sideset: 'SideSet',
|
||||
boxed: ['Macro', '\\fbox{$\\displaystyle{#1}$}', 1],
|
||||
tag: 'HandleTag',
|
||||
notag: 'HandleNoTag',
|
||||
eqref: ['HandleRef', true],
|
||||
substack: ['Macro', '\\begin{subarray}{c}#1\\end{subarray}', 1],
|
||||
injlim: ['NamedOp', 'inj lim'],
|
||||
projlim: ['NamedOp', 'proj lim'],
|
||||
varliminf: ['Macro', '\\mathop{\\underline{\\mmlToken{mi}{lim}}}'],
|
||||
varlimsup: ['Macro', '\\mathop{\\overline{\\mmlToken{mi}{lim}}}'],
|
||||
varinjlim: ['Macro', '\\mathop{\\underrightarrow{\\mmlToken{mi}{lim}}}'],
|
||||
varprojlim: ['Macro', '\\mathop{\\underleftarrow{\\mmlToken{mi}{lim}}}'],
|
||||
DeclareMathOperator: 'HandleDeclareOp',
|
||||
operatorname: 'HandleOperatorName',
|
||||
genfrac: 'Genfrac',
|
||||
frac: ['Genfrac', '', '', '', ''],
|
||||
tfrac: ['Genfrac', '', '', '', '1'],
|
||||
dfrac: ['Genfrac', '', '', '', '0'],
|
||||
binom: ['Genfrac', '(', ')', '0', ''],
|
||||
tbinom: ['Genfrac', '(', ')', '0', '1'],
|
||||
dbinom: ['Genfrac', '(', ')', '0', '0'],
|
||||
cfrac: 'CFrac',
|
||||
shoveleft: ['HandleShove', TexConstants_js_1.TexConstant.Align.LEFT],
|
||||
shoveright: ['HandleShove', TexConstants_js_1.TexConstant.Align.RIGHT],
|
||||
xrightarrow: ['xArrow', 0x2192, 5, 10],
|
||||
xleftarrow: ['xArrow', 0x2190, 10, 5]
|
||||
}, AmsMethods_js_1.AmsMethods);
|
||||
new sm.EnvironmentMap('AMSmath-environment', ParseMethods_js_1.default.environment, {
|
||||
'equation*': ['Equation', null, false],
|
||||
'eqnarray*': ['EqnArray', null, false, true, 'rcl',
|
||||
ParseUtil_js_1.default.cols(0, lengths_js_1.MATHSPACE.thickmathspace), '.5em'],
|
||||
align: ['EqnArray', null, true, true, 'rl', ParseUtil_js_1.default.cols(0, 2)],
|
||||
'align*': ['EqnArray', null, false, true, 'rl', ParseUtil_js_1.default.cols(0, 2)],
|
||||
multline: ['Multline', null, true],
|
||||
'multline*': ['Multline', null, false],
|
||||
split: ['EqnArray', null, false, false, 'rl', ParseUtil_js_1.default.cols(0)],
|
||||
gather: ['EqnArray', null, true, true, 'c'],
|
||||
'gather*': ['EqnArray', null, false, true, 'c'],
|
||||
alignat: ['AlignAt', null, true, true],
|
||||
'alignat*': ['AlignAt', null, false, true],
|
||||
alignedat: ['AlignAt', null, false, false],
|
||||
aligned: ['AmsEqnArray', null, null, null, 'rl', ParseUtil_js_1.default.cols(0, 2), '.5em', 'D'],
|
||||
gathered: ['AmsEqnArray', null, null, null, 'c', null, '.5em', 'D'],
|
||||
xalignat: ['XalignAt', null, true, true],
|
||||
'xalignat*': ['XalignAt', null, false, true],
|
||||
xxalignat: ['XalignAt', null, false, false],
|
||||
flalign: ['FlalignArray', null, true, false, true, 'rlc', 'auto auto fit'],
|
||||
'flalign*': ['FlalignArray', null, false, false, true, 'rlc', 'auto auto fit'],
|
||||
subarray: ['Array', null, null, null, null, ParseUtil_js_1.default.cols(0), '0.1em', 'S', 1],
|
||||
smallmatrix: ['Array', null, null, null, 'c', ParseUtil_js_1.default.cols(1 / 3),
|
||||
'.2em', 'S', 1],
|
||||
matrix: ['Array', null, null, null, 'c'],
|
||||
pmatrix: ['Array', null, '(', ')', 'c'],
|
||||
bmatrix: ['Array', null, '[', ']', 'c'],
|
||||
Bmatrix: ['Array', null, '\\{', '\\}', 'c'],
|
||||
vmatrix: ['Array', null, '\\vert', '\\vert', 'c'],
|
||||
Vmatrix: ['Array', null, '\\Vert', '\\Vert', 'c'],
|
||||
cases: ['Array', null, '\\{', '.', 'll', null, '.2em', 'T']
|
||||
}, AmsMethods_js_1.AmsMethods);
|
||||
new sm.DelimiterMap('AMSmath-delimiter', ParseMethods_js_1.default.delimiter, {
|
||||
'\\lvert': ['\u007C', { texClass: MmlNode_js_1.TEXCLASS.OPEN }],
|
||||
'\\rvert': ['\u007C', { texClass: MmlNode_js_1.TEXCLASS.CLOSE }],
|
||||
'\\lVert': ['\u2016', { texClass: MmlNode_js_1.TEXCLASS.OPEN }],
|
||||
'\\rVert': ['\u2016', { texClass: MmlNode_js_1.TEXCLASS.CLOSE }]
|
||||
});
|
||||
new sm.CharacterMap('AMSsymbols-mathchar0mi', ParseMethods_js_1.default.mathchar0mi, {
|
||||
digamma: '\u03DD',
|
||||
varkappa: '\u03F0',
|
||||
varGamma: ['\u0393', { mathvariant: TexConstants_js_1.TexConstant.Variant.ITALIC }],
|
||||
varDelta: ['\u0394', { mathvariant: TexConstants_js_1.TexConstant.Variant.ITALIC }],
|
||||
varTheta: ['\u0398', { mathvariant: TexConstants_js_1.TexConstant.Variant.ITALIC }],
|
||||
varLambda: ['\u039B', { mathvariant: TexConstants_js_1.TexConstant.Variant.ITALIC }],
|
||||
varXi: ['\u039E', { mathvariant: TexConstants_js_1.TexConstant.Variant.ITALIC }],
|
||||
varPi: ['\u03A0', { mathvariant: TexConstants_js_1.TexConstant.Variant.ITALIC }],
|
||||
varSigma: ['\u03A3', { mathvariant: TexConstants_js_1.TexConstant.Variant.ITALIC }],
|
||||
varUpsilon: ['\u03A5', { mathvariant: TexConstants_js_1.TexConstant.Variant.ITALIC }],
|
||||
varPhi: ['\u03A6', { mathvariant: TexConstants_js_1.TexConstant.Variant.ITALIC }],
|
||||
varPsi: ['\u03A8', { mathvariant: TexConstants_js_1.TexConstant.Variant.ITALIC }],
|
||||
varOmega: ['\u03A9', { mathvariant: TexConstants_js_1.TexConstant.Variant.ITALIC }],
|
||||
beth: '\u2136',
|
||||
gimel: '\u2137',
|
||||
daleth: '\u2138',
|
||||
backprime: ['\u2035', { variantForm: true }],
|
||||
hslash: '\u210F',
|
||||
varnothing: ['\u2205', { variantForm: true }],
|
||||
blacktriangle: '\u25B4',
|
||||
triangledown: ['\u25BD', { variantForm: true }],
|
||||
blacktriangledown: '\u25BE',
|
||||
square: '\u25FB',
|
||||
Box: '\u25FB',
|
||||
blacksquare: '\u25FC',
|
||||
lozenge: '\u25CA',
|
||||
Diamond: '\u25CA',
|
||||
blacklozenge: '\u29EB',
|
||||
circledS: ['\u24C8', { mathvariant: TexConstants_js_1.TexConstant.Variant.NORMAL }],
|
||||
bigstar: '\u2605',
|
||||
sphericalangle: '\u2222',
|
||||
measuredangle: '\u2221',
|
||||
nexists: '\u2204',
|
||||
complement: '\u2201',
|
||||
mho: '\u2127',
|
||||
eth: ['\u00F0', { mathvariant: TexConstants_js_1.TexConstant.Variant.NORMAL }],
|
||||
Finv: '\u2132',
|
||||
diagup: '\u2571',
|
||||
Game: '\u2141',
|
||||
diagdown: '\u2572',
|
||||
Bbbk: ['\u006B',
|
||||
{ mathvariant: TexConstants_js_1.TexConstant.Variant.DOUBLESTRUCK }],
|
||||
yen: '\u00A5',
|
||||
circledR: '\u00AE',
|
||||
checkmark: '\u2713',
|
||||
maltese: '\u2720'
|
||||
});
|
||||
new sm.CharacterMap('AMSsymbols-mathchar0mo', ParseMethods_js_1.default.mathchar0mo, {
|
||||
dotplus: '\u2214',
|
||||
ltimes: '\u22C9',
|
||||
smallsetminus: ['\u2216', { variantForm: true }],
|
||||
rtimes: '\u22CA',
|
||||
Cap: '\u22D2',
|
||||
doublecap: '\u22D2',
|
||||
leftthreetimes: '\u22CB',
|
||||
Cup: '\u22D3',
|
||||
doublecup: '\u22D3',
|
||||
rightthreetimes: '\u22CC',
|
||||
barwedge: '\u22BC',
|
||||
curlywedge: '\u22CF',
|
||||
veebar: '\u22BB',
|
||||
curlyvee: '\u22CE',
|
||||
doublebarwedge: '\u2A5E',
|
||||
boxminus: '\u229F',
|
||||
circleddash: '\u229D',
|
||||
boxtimes: '\u22A0',
|
||||
circledast: '\u229B',
|
||||
boxdot: '\u22A1',
|
||||
circledcirc: '\u229A',
|
||||
boxplus: '\u229E',
|
||||
centerdot: ['\u22C5', { variantForm: true }],
|
||||
divideontimes: '\u22C7',
|
||||
intercal: '\u22BA',
|
||||
leqq: '\u2266',
|
||||
geqq: '\u2267',
|
||||
leqslant: '\u2A7D',
|
||||
geqslant: '\u2A7E',
|
||||
eqslantless: '\u2A95',
|
||||
eqslantgtr: '\u2A96',
|
||||
lesssim: '\u2272',
|
||||
gtrsim: '\u2273',
|
||||
lessapprox: '\u2A85',
|
||||
gtrapprox: '\u2A86',
|
||||
approxeq: '\u224A',
|
||||
lessdot: '\u22D6',
|
||||
gtrdot: '\u22D7',
|
||||
lll: '\u22D8',
|
||||
llless: '\u22D8',
|
||||
ggg: '\u22D9',
|
||||
gggtr: '\u22D9',
|
||||
lessgtr: '\u2276',
|
||||
gtrless: '\u2277',
|
||||
lesseqgtr: '\u22DA',
|
||||
gtreqless: '\u22DB',
|
||||
lesseqqgtr: '\u2A8B',
|
||||
gtreqqless: '\u2A8C',
|
||||
doteqdot: '\u2251',
|
||||
Doteq: '\u2251',
|
||||
eqcirc: '\u2256',
|
||||
risingdotseq: '\u2253',
|
||||
circeq: '\u2257',
|
||||
fallingdotseq: '\u2252',
|
||||
triangleq: '\u225C',
|
||||
backsim: '\u223D',
|
||||
thicksim: ['\u223C', { variantForm: true }],
|
||||
backsimeq: '\u22CD',
|
||||
thickapprox: ['\u2248', { variantForm: true }],
|
||||
subseteqq: '\u2AC5',
|
||||
supseteqq: '\u2AC6',
|
||||
Subset: '\u22D0',
|
||||
Supset: '\u22D1',
|
||||
sqsubset: '\u228F',
|
||||
sqsupset: '\u2290',
|
||||
preccurlyeq: '\u227C',
|
||||
succcurlyeq: '\u227D',
|
||||
curlyeqprec: '\u22DE',
|
||||
curlyeqsucc: '\u22DF',
|
||||
precsim: '\u227E',
|
||||
succsim: '\u227F',
|
||||
precapprox: '\u2AB7',
|
||||
succapprox: '\u2AB8',
|
||||
vartriangleleft: '\u22B2',
|
||||
lhd: '\u22B2',
|
||||
vartriangleright: '\u22B3',
|
||||
rhd: '\u22B3',
|
||||
trianglelefteq: '\u22B4',
|
||||
unlhd: '\u22B4',
|
||||
trianglerighteq: '\u22B5',
|
||||
unrhd: '\u22B5',
|
||||
vDash: ['\u22A8', { variantForm: true }],
|
||||
Vdash: '\u22A9',
|
||||
Vvdash: '\u22AA',
|
||||
smallsmile: ['\u2323', { variantForm: true }],
|
||||
shortmid: ['\u2223', { variantForm: true }],
|
||||
smallfrown: ['\u2322', { variantForm: true }],
|
||||
shortparallel: ['\u2225', { variantForm: true }],
|
||||
bumpeq: '\u224F',
|
||||
between: '\u226C',
|
||||
Bumpeq: '\u224E',
|
||||
pitchfork: '\u22D4',
|
||||
varpropto: ['\u221D', { variantForm: true }],
|
||||
backepsilon: '\u220D',
|
||||
blacktriangleleft: '\u25C2',
|
||||
blacktriangleright: '\u25B8',
|
||||
therefore: '\u2234',
|
||||
because: '\u2235',
|
||||
eqsim: '\u2242',
|
||||
vartriangle: ['\u25B3', { variantForm: true }],
|
||||
Join: '\u22C8',
|
||||
nless: '\u226E',
|
||||
ngtr: '\u226F',
|
||||
nleq: '\u2270',
|
||||
ngeq: '\u2271',
|
||||
nleqslant: ['\u2A87', { variantForm: true }],
|
||||
ngeqslant: ['\u2A88', { variantForm: true }],
|
||||
nleqq: ['\u2270', { variantForm: true }],
|
||||
ngeqq: ['\u2271', { variantForm: true }],
|
||||
lneq: '\u2A87',
|
||||
gneq: '\u2A88',
|
||||
lneqq: '\u2268',
|
||||
gneqq: '\u2269',
|
||||
lvertneqq: ['\u2268', { variantForm: true }],
|
||||
gvertneqq: ['\u2269', { variantForm: true }],
|
||||
lnsim: '\u22E6',
|
||||
gnsim: '\u22E7',
|
||||
lnapprox: '\u2A89',
|
||||
gnapprox: '\u2A8A',
|
||||
nprec: '\u2280',
|
||||
nsucc: '\u2281',
|
||||
npreceq: ['\u22E0', { variantForm: true }],
|
||||
nsucceq: ['\u22E1', { variantForm: true }],
|
||||
precneqq: '\u2AB5',
|
||||
succneqq: '\u2AB6',
|
||||
precnsim: '\u22E8',
|
||||
succnsim: '\u22E9',
|
||||
precnapprox: '\u2AB9',
|
||||
succnapprox: '\u2ABA',
|
||||
nsim: '\u2241',
|
||||
ncong: '\u2247',
|
||||
nshortmid: ['\u2224', { variantForm: true }],
|
||||
nshortparallel: ['\u2226', { variantForm: true }],
|
||||
nmid: '\u2224',
|
||||
nparallel: '\u2226',
|
||||
nvdash: '\u22AC',
|
||||
nvDash: '\u22AD',
|
||||
nVdash: '\u22AE',
|
||||
nVDash: '\u22AF',
|
||||
ntriangleleft: '\u22EA',
|
||||
ntriangleright: '\u22EB',
|
||||
ntrianglelefteq: '\u22EC',
|
||||
ntrianglerighteq: '\u22ED',
|
||||
nsubseteq: '\u2288',
|
||||
nsupseteq: '\u2289',
|
||||
nsubseteqq: ['\u2288', { variantForm: true }],
|
||||
nsupseteqq: ['\u2289', { variantForm: true }],
|
||||
subsetneq: '\u228A',
|
||||
supsetneq: '\u228B',
|
||||
varsubsetneq: ['\u228A', { variantForm: true }],
|
||||
varsupsetneq: ['\u228B', { variantForm: true }],
|
||||
subsetneqq: '\u2ACB',
|
||||
supsetneqq: '\u2ACC',
|
||||
varsubsetneqq: ['\u2ACB', { variantForm: true }],
|
||||
varsupsetneqq: ['\u2ACC', { variantForm: true }],
|
||||
leftleftarrows: '\u21C7',
|
||||
rightrightarrows: '\u21C9',
|
||||
leftrightarrows: '\u21C6',
|
||||
rightleftarrows: '\u21C4',
|
||||
Lleftarrow: '\u21DA',
|
||||
Rrightarrow: '\u21DB',
|
||||
twoheadleftarrow: '\u219E',
|
||||
twoheadrightarrow: '\u21A0',
|
||||
leftarrowtail: '\u21A2',
|
||||
rightarrowtail: '\u21A3',
|
||||
looparrowleft: '\u21AB',
|
||||
looparrowright: '\u21AC',
|
||||
leftrightharpoons: '\u21CB',
|
||||
rightleftharpoons: ['\u21CC', { variantForm: true }],
|
||||
curvearrowleft: '\u21B6',
|
||||
curvearrowright: '\u21B7',
|
||||
circlearrowleft: '\u21BA',
|
||||
circlearrowright: '\u21BB',
|
||||
Lsh: '\u21B0',
|
||||
Rsh: '\u21B1',
|
||||
upuparrows: '\u21C8',
|
||||
downdownarrows: '\u21CA',
|
||||
upharpoonleft: '\u21BF',
|
||||
upharpoonright: '\u21BE',
|
||||
downharpoonleft: '\u21C3',
|
||||
restriction: '\u21BE',
|
||||
multimap: '\u22B8',
|
||||
downharpoonright: '\u21C2',
|
||||
leftrightsquigarrow: '\u21AD',
|
||||
rightsquigarrow: '\u21DD',
|
||||
leadsto: '\u21DD',
|
||||
dashrightarrow: '\u21E2',
|
||||
dashleftarrow: '\u21E0',
|
||||
nleftarrow: '\u219A',
|
||||
nrightarrow: '\u219B',
|
||||
nLeftarrow: '\u21CD',
|
||||
nRightarrow: '\u21CF',
|
||||
nleftrightarrow: '\u21AE',
|
||||
nLeftrightarrow: '\u21CE'
|
||||
});
|
||||
new sm.DelimiterMap('AMSsymbols-delimiter', ParseMethods_js_1.default.delimiter, {
|
||||
'\\ulcorner': '\u231C',
|
||||
'\\urcorner': '\u231D',
|
||||
'\\llcorner': '\u231E',
|
||||
'\\lrcorner': '\u231F'
|
||||
});
|
||||
new sm.CommandMap('AMSsymbols-macros', {
|
||||
implies: ['Macro', '\\;\\Longrightarrow\\;'],
|
||||
impliedby: ['Macro', '\\;\\Longleftarrow\\;']
|
||||
}, AmsMethods_js_1.AmsMethods);
|
||||
//# sourceMappingURL=AmsMappings.js.map
|
||||
1
node_modules/mathjax-full/js/input/tex/ams/AmsMappings.js.map
generated
vendored
Normal file
1
node_modules/mathjax-full/js/input/tex/ams/AmsMappings.js.map
generated
vendored
Normal file
File diff suppressed because one or more lines are too long
3
node_modules/mathjax-full/js/input/tex/ams/AmsMethods.d.ts
generated
vendored
Normal file
3
node_modules/mathjax-full/js/input/tex/ams/AmsMethods.d.ts
generated
vendored
Normal file
@@ -0,0 +1,3 @@
|
||||
import { ParseMethod } from '../Types.js';
|
||||
export declare const AmsMethods: Record<string, ParseMethod>;
|
||||
export declare const NEW_OPS = "ams-declare-ops";
|
||||
341
node_modules/mathjax-full/js/input/tex/ams/AmsMethods.js
generated
vendored
Normal file
341
node_modules/mathjax-full/js/input/tex/ams/AmsMethods.js
generated
vendored
Normal file
@@ -0,0 +1,341 @@
|
||||
"use strict";
|
||||
var __assign = (this && this.__assign) || function () {
|
||||
__assign = Object.assign || function(t) {
|
||||
for (var s, i = 1, n = arguments.length; i < n; i++) {
|
||||
s = arguments[i];
|
||||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
|
||||
t[p] = s[p];
|
||||
}
|
||||
return t;
|
||||
};
|
||||
return __assign.apply(this, arguments);
|
||||
};
|
||||
var __read = (this && this.__read) || function (o, n) {
|
||||
var m = typeof Symbol === "function" && o[Symbol.iterator];
|
||||
if (!m) return o;
|
||||
var i = m.call(o), r, ar = [], e;
|
||||
try {
|
||||
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
|
||||
}
|
||||
catch (error) { e = { error: error }; }
|
||||
finally {
|
||||
try {
|
||||
if (r && !r.done && (m = i["return"])) m.call(i);
|
||||
}
|
||||
finally { if (e) throw e.error; }
|
||||
}
|
||||
return ar;
|
||||
};
|
||||
var __importDefault = (this && this.__importDefault) || function (mod) {
|
||||
return (mod && mod.__esModule) ? mod : { "default": mod };
|
||||
};
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.NEW_OPS = exports.AmsMethods = void 0;
|
||||
var ParseUtil_js_1 = __importDefault(require("../ParseUtil.js"));
|
||||
var ParseMethods_js_1 = __importDefault(require("../ParseMethods.js"));
|
||||
var NodeUtil_js_1 = __importDefault(require("../NodeUtil.js"));
|
||||
var TexConstants_js_1 = require("../TexConstants.js");
|
||||
var TexParser_js_1 = __importDefault(require("../TexParser.js"));
|
||||
var TexError_js_1 = __importDefault(require("../TexError.js"));
|
||||
var Symbol_js_1 = require("../Symbol.js");
|
||||
var BaseMethods_js_1 = __importDefault(require("../base/BaseMethods.js"));
|
||||
var MmlNode_js_1 = require("../../../core/MmlTree/MmlNode.js");
|
||||
exports.AmsMethods = {};
|
||||
exports.AmsMethods.AmsEqnArray = function (parser, begin, numbered, taggable, align, spacing, style) {
|
||||
var args = parser.GetBrackets('\\begin{' + begin.getName() + '}');
|
||||
var array = BaseMethods_js_1.default.EqnArray(parser, begin, numbered, taggable, align, spacing, style);
|
||||
return ParseUtil_js_1.default.setArrayAlign(array, args);
|
||||
};
|
||||
exports.AmsMethods.AlignAt = function (parser, begin, numbered, taggable) {
|
||||
var name = begin.getName();
|
||||
var n, valign, align = '', spacing = [];
|
||||
if (!taggable) {
|
||||
valign = parser.GetBrackets('\\begin{' + name + '}');
|
||||
}
|
||||
n = parser.GetArgument('\\begin{' + name + '}');
|
||||
if (n.match(/[^0-9]/)) {
|
||||
throw new TexError_js_1.default('PositiveIntegerArg', 'Argument to %1 must me a positive integer', '\\begin{' + name + '}');
|
||||
}
|
||||
var count = parseInt(n, 10);
|
||||
while (count > 0) {
|
||||
align += 'rl';
|
||||
spacing.push('0em 0em');
|
||||
count--;
|
||||
}
|
||||
var spaceStr = spacing.join(' ');
|
||||
if (taggable) {
|
||||
return exports.AmsMethods.EqnArray(parser, begin, numbered, taggable, align, spaceStr);
|
||||
}
|
||||
var array = exports.AmsMethods.EqnArray(parser, begin, numbered, taggable, align, spaceStr);
|
||||
return ParseUtil_js_1.default.setArrayAlign(array, valign);
|
||||
};
|
||||
exports.AmsMethods.Multline = function (parser, begin, numbered) {
|
||||
parser.Push(begin);
|
||||
ParseUtil_js_1.default.checkEqnEnv(parser);
|
||||
var item = parser.itemFactory.create('multline', numbered, parser.stack);
|
||||
item.arraydef = {
|
||||
displaystyle: true,
|
||||
rowspacing: '.5em',
|
||||
columnspacing: '100%',
|
||||
width: parser.options.ams['multlineWidth'],
|
||||
side: parser.options['tagSide'],
|
||||
minlabelspacing: parser.options['tagIndent'],
|
||||
framespacing: parser.options.ams['multlineIndent'] + ' 0',
|
||||
frame: '',
|
||||
'data-width-includes-label': true
|
||||
};
|
||||
return item;
|
||||
};
|
||||
exports.AmsMethods.XalignAt = function (parser, begin, numbered, padded) {
|
||||
var n = parser.GetArgument('\\begin{' + begin.getName() + '}');
|
||||
if (n.match(/[^0-9]/)) {
|
||||
throw new TexError_js_1.default('PositiveIntegerArg', 'Argument to %1 must me a positive integer', '\\begin{' + begin.getName() + '}');
|
||||
}
|
||||
var align = (padded ? 'crl' : 'rlc');
|
||||
var width = (padded ? 'fit auto auto' : 'auto auto fit');
|
||||
var item = exports.AmsMethods.FlalignArray(parser, begin, numbered, padded, false, align, width, true);
|
||||
item.setProperty('xalignat', 2 * parseInt(n));
|
||||
return item;
|
||||
};
|
||||
exports.AmsMethods.FlalignArray = function (parser, begin, numbered, padded, center, align, width, zeroWidthLabel) {
|
||||
if (zeroWidthLabel === void 0) { zeroWidthLabel = false; }
|
||||
parser.Push(begin);
|
||||
ParseUtil_js_1.default.checkEqnEnv(parser);
|
||||
align = align
|
||||
.split('')
|
||||
.join(' ')
|
||||
.replace(/r/g, 'right')
|
||||
.replace(/l/g, 'left')
|
||||
.replace(/c/g, 'center');
|
||||
var item = parser.itemFactory.create('flalign', begin.getName(), numbered, padded, center, parser.stack);
|
||||
item.arraydef = {
|
||||
width: '100%',
|
||||
displaystyle: true,
|
||||
columnalign: align,
|
||||
columnspacing: '0em',
|
||||
columnwidth: width,
|
||||
rowspacing: '3pt',
|
||||
side: parser.options['tagSide'],
|
||||
minlabelspacing: (zeroWidthLabel ? '0' : parser.options['tagIndent']),
|
||||
'data-width-includes-label': true,
|
||||
};
|
||||
item.setProperty('zeroWidthLabel', zeroWidthLabel);
|
||||
return item;
|
||||
};
|
||||
exports.NEW_OPS = 'ams-declare-ops';
|
||||
exports.AmsMethods.HandleDeclareOp = function (parser, name) {
|
||||
var star = (parser.GetStar() ? '*' : '');
|
||||
var cs = ParseUtil_js_1.default.trimSpaces(parser.GetArgument(name));
|
||||
if (cs.charAt(0) === '\\') {
|
||||
cs = cs.substr(1);
|
||||
}
|
||||
var op = parser.GetArgument(name);
|
||||
parser.configuration.handlers.retrieve(exports.NEW_OPS).
|
||||
add(cs, new Symbol_js_1.Macro(cs, exports.AmsMethods.Macro, ["\\operatorname".concat(star, "{").concat(op, "}")]));
|
||||
};
|
||||
exports.AmsMethods.HandleOperatorName = function (parser, name) {
|
||||
var star = parser.GetStar();
|
||||
var op = ParseUtil_js_1.default.trimSpaces(parser.GetArgument(name));
|
||||
var mml = new TexParser_js_1.default(op, __assign(__assign({}, parser.stack.env), { font: TexConstants_js_1.TexConstant.Variant.NORMAL, multiLetterIdentifiers: /^[-*a-z]+/i, operatorLetters: true }), parser.configuration).mml();
|
||||
if (!mml.isKind('mi')) {
|
||||
mml = parser.create('node', 'TeXAtom', [mml]);
|
||||
}
|
||||
NodeUtil_js_1.default.setProperties(mml, { movesupsub: star, movablelimits: true, texClass: MmlNode_js_1.TEXCLASS.OP });
|
||||
if (!star) {
|
||||
var c = parser.GetNext(), i = parser.i;
|
||||
if (c === '\\' && ++parser.i && parser.GetCS() !== 'limits') {
|
||||
parser.i = i;
|
||||
}
|
||||
}
|
||||
parser.Push(mml);
|
||||
};
|
||||
exports.AmsMethods.SideSet = function (parser, name) {
|
||||
var _a = __read(splitSideSet(parser.ParseArg(name)), 2), preScripts = _a[0], preRest = _a[1];
|
||||
var _b = __read(splitSideSet(parser.ParseArg(name)), 2), postScripts = _b[0], postRest = _b[1];
|
||||
var base = parser.ParseArg(name);
|
||||
var mml = base;
|
||||
if (preScripts) {
|
||||
if (preRest) {
|
||||
preScripts.replaceChild(parser.create('node', 'mphantom', [
|
||||
parser.create('node', 'mpadded', [ParseUtil_js_1.default.copyNode(base, parser)], { width: 0 })
|
||||
]), NodeUtil_js_1.default.getChildAt(preScripts, 0));
|
||||
}
|
||||
else {
|
||||
mml = parser.create('node', 'mmultiscripts', [base]);
|
||||
if (postScripts) {
|
||||
NodeUtil_js_1.default.appendChildren(mml, [
|
||||
NodeUtil_js_1.default.getChildAt(postScripts, 1) || parser.create('node', 'none'),
|
||||
NodeUtil_js_1.default.getChildAt(postScripts, 2) || parser.create('node', 'none')
|
||||
]);
|
||||
}
|
||||
NodeUtil_js_1.default.setProperty(mml, 'scriptalign', 'left');
|
||||
NodeUtil_js_1.default.appendChildren(mml, [
|
||||
parser.create('node', 'mprescripts'),
|
||||
NodeUtil_js_1.default.getChildAt(preScripts, 1) || parser.create('node', 'none'),
|
||||
NodeUtil_js_1.default.getChildAt(preScripts, 2) || parser.create('node', 'none')
|
||||
]);
|
||||
}
|
||||
}
|
||||
if (postScripts && mml === base) {
|
||||
postScripts.replaceChild(base, NodeUtil_js_1.default.getChildAt(postScripts, 0));
|
||||
mml = postScripts;
|
||||
}
|
||||
var mrow = parser.create('node', 'TeXAtom', [], { texClass: MmlNode_js_1.TEXCLASS.OP, movesupsub: true, movablelimits: true });
|
||||
if (preRest) {
|
||||
preScripts && mrow.appendChild(preScripts);
|
||||
mrow.appendChild(preRest);
|
||||
}
|
||||
mrow.appendChild(mml);
|
||||
postRest && mrow.appendChild(postRest);
|
||||
parser.Push(mrow);
|
||||
};
|
||||
function splitSideSet(mml) {
|
||||
if (!mml || (mml.isInferred && mml.childNodes.length === 0))
|
||||
return [null, null];
|
||||
if (mml.isKind('msubsup') && checkSideSetBase(mml))
|
||||
return [mml, null];
|
||||
var child = NodeUtil_js_1.default.getChildAt(mml, 0);
|
||||
if (!(mml.isInferred && child && checkSideSetBase(child)))
|
||||
return [null, mml];
|
||||
mml.childNodes.splice(0, 1);
|
||||
return [child, mml];
|
||||
}
|
||||
function checkSideSetBase(mml) {
|
||||
var base = mml.childNodes[0];
|
||||
return base && base.isKind('mi') && base.getText() === '';
|
||||
}
|
||||
exports.AmsMethods.operatorLetter = function (parser, c) {
|
||||
return parser.stack.env.operatorLetters ? ParseMethods_js_1.default.variable(parser, c) : false;
|
||||
};
|
||||
exports.AmsMethods.MultiIntegral = function (parser, name, integral) {
|
||||
var next = parser.GetNext();
|
||||
if (next === '\\') {
|
||||
var i = parser.i;
|
||||
next = parser.GetArgument(name);
|
||||
parser.i = i;
|
||||
if (next === '\\limits') {
|
||||
if (name === '\\idotsint') {
|
||||
integral = '\\!\\!\\mathop{\\,\\,' + integral + '}';
|
||||
}
|
||||
else {
|
||||
integral = '\\!\\!\\!\\mathop{\\,\\,\\,' + integral + '}';
|
||||
}
|
||||
}
|
||||
}
|
||||
parser.string = integral + ' ' + parser.string.slice(parser.i);
|
||||
parser.i = 0;
|
||||
};
|
||||
exports.AmsMethods.xArrow = function (parser, name, chr, l, r) {
|
||||
var def = { width: '+' + ParseUtil_js_1.default.Em((l + r) / 18), lspace: ParseUtil_js_1.default.Em(l / 18) };
|
||||
var bot = parser.GetBrackets(name);
|
||||
var first = parser.ParseArg(name);
|
||||
var dstrut = parser.create('node', 'mspace', [], { depth: '.25em' });
|
||||
var arrow = parser.create('token', 'mo', { stretchy: true, texClass: MmlNode_js_1.TEXCLASS.REL }, String.fromCodePoint(chr));
|
||||
arrow = parser.create('node', 'mstyle', [arrow], { scriptlevel: 0 });
|
||||
var mml = parser.create('node', 'munderover', [arrow]);
|
||||
var mpadded = parser.create('node', 'mpadded', [first, dstrut], def);
|
||||
NodeUtil_js_1.default.setAttribute(mpadded, 'voffset', '-.2em');
|
||||
NodeUtil_js_1.default.setAttribute(mpadded, 'height', '-.2em');
|
||||
NodeUtil_js_1.default.setChild(mml, mml.over, mpadded);
|
||||
if (bot) {
|
||||
var bottom = new TexParser_js_1.default(bot, parser.stack.env, parser.configuration).mml();
|
||||
var bstrut = parser.create('node', 'mspace', [], { height: '.75em' });
|
||||
mpadded = parser.create('node', 'mpadded', [bottom, bstrut], def);
|
||||
NodeUtil_js_1.default.setAttribute(mpadded, 'voffset', '.15em');
|
||||
NodeUtil_js_1.default.setAttribute(mpadded, 'depth', '-.15em');
|
||||
NodeUtil_js_1.default.setChild(mml, mml.under, mpadded);
|
||||
}
|
||||
NodeUtil_js_1.default.setProperty(mml, 'subsupOK', true);
|
||||
parser.Push(mml);
|
||||
};
|
||||
exports.AmsMethods.HandleShove = function (parser, _name, shove) {
|
||||
var top = parser.stack.Top();
|
||||
if (top.kind !== 'multline') {
|
||||
throw new TexError_js_1.default('CommandOnlyAllowedInEnv', '%1 only allowed in %2 environment', parser.currentCS, 'multline');
|
||||
}
|
||||
if (top.Size()) {
|
||||
throw new TexError_js_1.default('CommandAtTheBeginingOfLine', '%1 must come at the beginning of the line', parser.currentCS);
|
||||
}
|
||||
top.setProperty('shove', shove);
|
||||
};
|
||||
exports.AmsMethods.CFrac = function (parser, name) {
|
||||
var lr = ParseUtil_js_1.default.trimSpaces(parser.GetBrackets(name, ''));
|
||||
var num = parser.GetArgument(name);
|
||||
var den = parser.GetArgument(name);
|
||||
var lrMap = {
|
||||
l: TexConstants_js_1.TexConstant.Align.LEFT, r: TexConstants_js_1.TexConstant.Align.RIGHT, '': ''
|
||||
};
|
||||
var numNode = new TexParser_js_1.default('\\strut\\textstyle{' + num + '}', parser.stack.env, parser.configuration).mml();
|
||||
var denNode = new TexParser_js_1.default('\\strut\\textstyle{' + den + '}', parser.stack.env, parser.configuration).mml();
|
||||
var frac = parser.create('node', 'mfrac', [numNode, denNode]);
|
||||
lr = lrMap[lr];
|
||||
if (lr == null) {
|
||||
throw new TexError_js_1.default('IllegalAlign', 'Illegal alignment specified in %1', parser.currentCS);
|
||||
}
|
||||
if (lr) {
|
||||
NodeUtil_js_1.default.setProperties(frac, { numalign: lr, denomalign: lr });
|
||||
}
|
||||
parser.Push(frac);
|
||||
};
|
||||
exports.AmsMethods.Genfrac = function (parser, name, left, right, thick, style) {
|
||||
if (left == null) {
|
||||
left = parser.GetDelimiterArg(name);
|
||||
}
|
||||
if (right == null) {
|
||||
right = parser.GetDelimiterArg(name);
|
||||
}
|
||||
if (thick == null) {
|
||||
thick = parser.GetArgument(name);
|
||||
}
|
||||
if (style == null) {
|
||||
style = ParseUtil_js_1.default.trimSpaces(parser.GetArgument(name));
|
||||
}
|
||||
var num = parser.ParseArg(name);
|
||||
var den = parser.ParseArg(name);
|
||||
var frac = parser.create('node', 'mfrac', [num, den]);
|
||||
if (thick !== '') {
|
||||
NodeUtil_js_1.default.setAttribute(frac, 'linethickness', thick);
|
||||
}
|
||||
if (left || right) {
|
||||
NodeUtil_js_1.default.setProperty(frac, 'withDelims', true);
|
||||
frac = ParseUtil_js_1.default.fixedFence(parser.configuration, left, frac, right);
|
||||
}
|
||||
if (style !== '') {
|
||||
var styleDigit = parseInt(style, 10);
|
||||
var styleAlpha = ['D', 'T', 'S', 'SS'][styleDigit];
|
||||
if (styleAlpha == null) {
|
||||
throw new TexError_js_1.default('BadMathStyleFor', 'Bad math style for %1', parser.currentCS);
|
||||
}
|
||||
frac = parser.create('node', 'mstyle', [frac]);
|
||||
if (styleAlpha === 'D') {
|
||||
NodeUtil_js_1.default.setProperties(frac, { displaystyle: true, scriptlevel: 0 });
|
||||
}
|
||||
else {
|
||||
NodeUtil_js_1.default.setProperties(frac, { displaystyle: false,
|
||||
scriptlevel: styleDigit - 1 });
|
||||
}
|
||||
}
|
||||
parser.Push(frac);
|
||||
};
|
||||
exports.AmsMethods.HandleTag = function (parser, name) {
|
||||
if (!parser.tags.currentTag.taggable && parser.tags.env) {
|
||||
throw new TexError_js_1.default('CommandNotAllowedInEnv', '%1 not allowed in %2 environment', parser.currentCS, parser.tags.env);
|
||||
}
|
||||
if (parser.tags.currentTag.tag) {
|
||||
throw new TexError_js_1.default('MultipleCommand', 'Multiple %1', parser.currentCS);
|
||||
}
|
||||
var star = parser.GetStar();
|
||||
var tagId = ParseUtil_js_1.default.trimSpaces(parser.GetArgument(name));
|
||||
parser.tags.tag(tagId, star);
|
||||
};
|
||||
exports.AmsMethods.HandleNoTag = BaseMethods_js_1.default.HandleNoTag;
|
||||
exports.AmsMethods.HandleRef = BaseMethods_js_1.default.HandleRef;
|
||||
exports.AmsMethods.Macro = BaseMethods_js_1.default.Macro;
|
||||
exports.AmsMethods.Accent = BaseMethods_js_1.default.Accent;
|
||||
exports.AmsMethods.Tilde = BaseMethods_js_1.default.Tilde;
|
||||
exports.AmsMethods.Array = BaseMethods_js_1.default.Array;
|
||||
exports.AmsMethods.Spacer = BaseMethods_js_1.default.Spacer;
|
||||
exports.AmsMethods.NamedOp = BaseMethods_js_1.default.NamedOp;
|
||||
exports.AmsMethods.EqnArray = BaseMethods_js_1.default.EqnArray;
|
||||
exports.AmsMethods.Equation = BaseMethods_js_1.default.Equation;
|
||||
//# sourceMappingURL=AmsMethods.js.map
|
||||
1
node_modules/mathjax-full/js/input/tex/ams/AmsMethods.js.map
generated
vendored
Normal file
1
node_modules/mathjax-full/js/input/tex/ams/AmsMethods.js.map
generated
vendored
Normal file
File diff suppressed because one or more lines are too long
3
node_modules/mathjax-full/js/input/tex/amscd/AmsCdConfiguration.d.ts
generated
vendored
Normal file
3
node_modules/mathjax-full/js/input/tex/amscd/AmsCdConfiguration.d.ts
generated
vendored
Normal file
@@ -0,0 +1,3 @@
|
||||
import { Configuration } from '../Configuration.js';
|
||||
import './AmsCdMappings.js';
|
||||
export declare const AmsCdConfiguration: Configuration;
|
||||
22
node_modules/mathjax-full/js/input/tex/amscd/AmsCdConfiguration.js
generated
vendored
Normal file
22
node_modules/mathjax-full/js/input/tex/amscd/AmsCdConfiguration.js
generated
vendored
Normal file
@@ -0,0 +1,22 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.AmsCdConfiguration = void 0;
|
||||
var Configuration_js_1 = require("../Configuration.js");
|
||||
require("./AmsCdMappings.js");
|
||||
exports.AmsCdConfiguration = Configuration_js_1.Configuration.create('amscd', {
|
||||
handler: {
|
||||
character: ['amscd_special'],
|
||||
macro: ['amscd_macros'],
|
||||
environment: ['amscd_environment']
|
||||
},
|
||||
options: {
|
||||
amscd: {
|
||||
colspace: '5pt',
|
||||
rowspace: '5pt',
|
||||
harrowsize: '2.75em',
|
||||
varrowsize: '1.75em',
|
||||
hideHorizontalLabels: false
|
||||
}
|
||||
}
|
||||
});
|
||||
//# sourceMappingURL=AmsCdConfiguration.js.map
|
||||
1
node_modules/mathjax-full/js/input/tex/amscd/AmsCdConfiguration.js.map
generated
vendored
Normal file
1
node_modules/mathjax-full/js/input/tex/amscd/AmsCdConfiguration.js.map
generated
vendored
Normal file
@@ -0,0 +1 @@
|
||||
{"version":3,"file":"AmsCdConfiguration.js","sourceRoot":"","sources":["../../../../ts/input/tex/amscd/AmsCdConfiguration.ts"],"names":[],"mappings":";;;AAwBA,wDAAkD;AAClD,8BAA4B;AAGf,QAAA,kBAAkB,GAAG,gCAAa,CAAC,MAAM,CACpD,OAAO,EAAE;IACP,OAAO,EAAE;QACP,SAAS,EAAE,CAAC,eAAe,CAAC;QAC5B,KAAK,EAAE,CAAC,cAAc,CAAC;QACvB,WAAW,EAAE,CAAC,mBAAmB,CAAC;KACnC;IACD,OAAO,EAAE;QACP,KAAK,EAAE;YACL,QAAQ,EAAE,KAAK;YACf,QAAQ,EAAE,KAAK;YACf,UAAU,EAAE,QAAQ;YACpB,UAAU,EAAE,QAAQ;YACpB,oBAAoB,EAAE,KAAK;SAC5B;KACF;CACF,CACF,CAAC"}
|
||||
1
node_modules/mathjax-full/js/input/tex/amscd/AmsCdMappings.d.ts
generated
vendored
Normal file
1
node_modules/mathjax-full/js/input/tex/amscd/AmsCdMappings.d.ts
generated
vendored
Normal file
@@ -0,0 +1 @@
|
||||
export {};
|
||||
38
node_modules/mathjax-full/js/input/tex/amscd/AmsCdMappings.js
generated
vendored
Normal file
38
node_modules/mathjax-full/js/input/tex/amscd/AmsCdMappings.js
generated
vendored
Normal file
@@ -0,0 +1,38 @@
|
||||
"use strict";
|
||||
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
|
||||
if (k2 === undefined) k2 = k;
|
||||
var desc = Object.getOwnPropertyDescriptor(m, k);
|
||||
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
|
||||
desc = { enumerable: true, get: function() { return m[k]; } };
|
||||
}
|
||||
Object.defineProperty(o, k2, desc);
|
||||
}) : (function(o, m, k, k2) {
|
||||
if (k2 === undefined) k2 = k;
|
||||
o[k2] = m[k];
|
||||
}));
|
||||
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
|
||||
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
||||
}) : function(o, v) {
|
||||
o["default"] = v;
|
||||
});
|
||||
var __importStar = (this && this.__importStar) || function (mod) {
|
||||
if (mod && mod.__esModule) return mod;
|
||||
var result = {};
|
||||
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
|
||||
__setModuleDefault(result, mod);
|
||||
return result;
|
||||
};
|
||||
var __importDefault = (this && this.__importDefault) || function (mod) {
|
||||
return (mod && mod.__esModule) ? mod : { "default": mod };
|
||||
};
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
var sm = __importStar(require("../SymbolMap.js"));
|
||||
var ParseMethods_js_1 = __importDefault(require("../ParseMethods.js"));
|
||||
var AmsCdMethods_js_1 = __importDefault(require("./AmsCdMethods.js"));
|
||||
new sm.EnvironmentMap('amscd_environment', ParseMethods_js_1.default.environment, { CD: 'CD' }, AmsCdMethods_js_1.default);
|
||||
new sm.CommandMap('amscd_macros', {
|
||||
minCDarrowwidth: 'minCDarrowwidth',
|
||||
minCDarrowheight: 'minCDarrowheight',
|
||||
}, AmsCdMethods_js_1.default);
|
||||
new sm.MacroMap('amscd_special', { '@': 'arrow' }, AmsCdMethods_js_1.default);
|
||||
//# sourceMappingURL=AmsCdMappings.js.map
|
||||
1
node_modules/mathjax-full/js/input/tex/amscd/AmsCdMappings.js.map
generated
vendored
Normal file
1
node_modules/mathjax-full/js/input/tex/amscd/AmsCdMappings.js.map
generated
vendored
Normal file
@@ -0,0 +1 @@
|
||||
{"version":3,"file":"AmsCdMappings.js","sourceRoot":"","sources":["../../../../ts/input/tex/amscd/AmsCdMappings.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,kDAAsC;AACtC,uEAA8C;AAC9C,sEAA6C;AAG7C,IAAI,EAAE,CAAC,cAAc,CAAC,mBAAmB,EAAE,yBAAY,CAAC,WAAW,EAC7C,EAAC,EAAE,EAAE,IAAI,EAAC,EAAE,yBAAY,CAAC,CAAC;AAEhD,IAAI,EAAE,CAAC,UAAU,CAAC,cAAc,EAAE;IAChC,eAAe,EAAE,iBAAiB;IAClC,gBAAgB,EAAE,kBAAkB;CACrC,EAAE,yBAAY,CAAC,CAAC;AAEjB,IAAI,EAAE,CAAC,QAAQ,CAAC,eAAe,EAAE,EAAC,GAAG,EAAE,OAAO,EAAC,EAAE,yBAAY,CAAC,CAAC"}
|
||||
3
node_modules/mathjax-full/js/input/tex/amscd/AmsCdMethods.d.ts
generated
vendored
Normal file
3
node_modules/mathjax-full/js/input/tex/amscd/AmsCdMethods.d.ts
generated
vendored
Normal file
@@ -0,0 +1,3 @@
|
||||
import { ParseMethod } from '../Types.js';
|
||||
declare let AmsCdMethods: Record<string, ParseMethod>;
|
||||
export default AmsCdMethods;
|
||||
122
node_modules/mathjax-full/js/input/tex/amscd/AmsCdMethods.js
generated
vendored
Normal file
122
node_modules/mathjax-full/js/input/tex/amscd/AmsCdMethods.js
generated
vendored
Normal file
@@ -0,0 +1,122 @@
|
||||
"use strict";
|
||||
var __importDefault = (this && this.__importDefault) || function (mod) {
|
||||
return (mod && mod.__esModule) ? mod : { "default": mod };
|
||||
};
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
var TexParser_js_1 = __importDefault(require("../TexParser.js"));
|
||||
var BaseConfiguration_js_1 = require("../base/BaseConfiguration.js");
|
||||
var MmlNode_js_1 = require("../../../core/MmlTree/MmlNode.js");
|
||||
var NodeUtil_js_1 = __importDefault(require("../NodeUtil.js"));
|
||||
var AmsCdMethods = {};
|
||||
AmsCdMethods.CD = function (parser, begin) {
|
||||
parser.Push(begin);
|
||||
var item = parser.itemFactory.create('array');
|
||||
var options = parser.configuration.options.amscd;
|
||||
item.setProperties({
|
||||
minw: parser.stack.env.CD_minw || options.harrowsize,
|
||||
minh: parser.stack.env.CD_minh || options.varrowsize
|
||||
});
|
||||
item.arraydef = {
|
||||
columnalign: 'center',
|
||||
columnspacing: options.colspace,
|
||||
rowspacing: options.rowspace,
|
||||
displaystyle: true
|
||||
};
|
||||
return item;
|
||||
};
|
||||
AmsCdMethods.arrow = function (parser, name) {
|
||||
var c = parser.string.charAt(parser.i);
|
||||
if (!c.match(/[><VA.|=]/)) {
|
||||
return (0, BaseConfiguration_js_1.Other)(parser, name);
|
||||
}
|
||||
else {
|
||||
parser.i++;
|
||||
}
|
||||
var first = parser.stack.Top();
|
||||
if (!first.isKind('array') || first.Size()) {
|
||||
AmsCdMethods.cell(parser, name);
|
||||
first = parser.stack.Top();
|
||||
}
|
||||
var top = first;
|
||||
var arrowRow = ((top.table.length % 2) === 1);
|
||||
var n = (top.row.length + (arrowRow ? 0 : 1)) % 2;
|
||||
while (n) {
|
||||
AmsCdMethods.cell(parser, name);
|
||||
n--;
|
||||
}
|
||||
var mml;
|
||||
var hdef = { minsize: top.getProperty('minw'), stretchy: true }, vdef = { minsize: top.getProperty('minh'),
|
||||
stretchy: true, symmetric: true, lspace: 0, rspace: 0 };
|
||||
if (c === '.') {
|
||||
}
|
||||
else if (c === '|') {
|
||||
mml = parser.create('token', 'mo', vdef, '\u2225');
|
||||
}
|
||||
else if (c === '=') {
|
||||
mml = parser.create('token', 'mo', hdef, '=');
|
||||
}
|
||||
else {
|
||||
var arrow = {
|
||||
'>': '\u2192', '<': '\u2190', 'V': '\u2193', 'A': '\u2191'
|
||||
}[c];
|
||||
var a = parser.GetUpTo(name + c, c);
|
||||
var b = parser.GetUpTo(name + c, c);
|
||||
if (c === '>' || c === '<') {
|
||||
mml = parser.create('token', 'mo', hdef, arrow);
|
||||
if (!a) {
|
||||
a = '\\kern ' + top.getProperty('minw');
|
||||
}
|
||||
if (a || b) {
|
||||
var pad = { width: '+.67em', lspace: '.33em' };
|
||||
mml = parser.create('node', 'munderover', [mml]);
|
||||
if (a) {
|
||||
var nodeA = new TexParser_js_1.default(a, parser.stack.env, parser.configuration).mml();
|
||||
var mpadded = parser.create('node', 'mpadded', [nodeA], pad);
|
||||
NodeUtil_js_1.default.setAttribute(mpadded, 'voffset', '.1em');
|
||||
NodeUtil_js_1.default.setChild(mml, mml.over, mpadded);
|
||||
}
|
||||
if (b) {
|
||||
var nodeB = new TexParser_js_1.default(b, parser.stack.env, parser.configuration).mml();
|
||||
NodeUtil_js_1.default.setChild(mml, mml.under, parser.create('node', 'mpadded', [nodeB], pad));
|
||||
}
|
||||
if (parser.configuration.options.amscd.hideHorizontalLabels) {
|
||||
mml = parser.create('node', 'mpadded', mml, { depth: 0, height: '.67em' });
|
||||
}
|
||||
}
|
||||
}
|
||||
else {
|
||||
var arrowNode = parser.create('token', 'mo', vdef, arrow);
|
||||
mml = arrowNode;
|
||||
if (a || b) {
|
||||
mml = parser.create('node', 'mrow');
|
||||
if (a) {
|
||||
NodeUtil_js_1.default.appendChildren(mml, [new TexParser_js_1.default('\\scriptstyle\\llap{' + a + '}', parser.stack.env, parser.configuration).mml()]);
|
||||
}
|
||||
arrowNode.texClass = MmlNode_js_1.TEXCLASS.ORD;
|
||||
NodeUtil_js_1.default.appendChildren(mml, [arrowNode]);
|
||||
if (b) {
|
||||
NodeUtil_js_1.default.appendChildren(mml, [new TexParser_js_1.default('\\scriptstyle\\rlap{' + b + '}', parser.stack.env, parser.configuration).mml()]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if (mml) {
|
||||
parser.Push(mml);
|
||||
}
|
||||
AmsCdMethods.cell(parser, name);
|
||||
};
|
||||
AmsCdMethods.cell = function (parser, name) {
|
||||
var top = parser.stack.Top();
|
||||
if ((top.table || []).length % 2 === 0 && (top.row || []).length === 0) {
|
||||
parser.Push(parser.create('node', 'mpadded', [], { height: '8.5pt', depth: '2pt' }));
|
||||
}
|
||||
parser.Push(parser.itemFactory.create('cell').setProperties({ isEntry: true, name: name }));
|
||||
};
|
||||
AmsCdMethods.minCDarrowwidth = function (parser, name) {
|
||||
parser.stack.env.CD_minw = parser.GetDimen(name);
|
||||
};
|
||||
AmsCdMethods.minCDarrowheight = function (parser, name) {
|
||||
parser.stack.env.CD_minh = parser.GetDimen(name);
|
||||
};
|
||||
exports.default = AmsCdMethods;
|
||||
//# sourceMappingURL=AmsCdMethods.js.map
|
||||
1
node_modules/mathjax-full/js/input/tex/amscd/AmsCdMethods.js.map
generated
vendored
Normal file
1
node_modules/mathjax-full/js/input/tex/amscd/AmsCdMethods.js.map
generated
vendored
Normal file
File diff suppressed because one or more lines are too long
2
node_modules/mathjax-full/js/input/tex/autoload/AutoloadConfiguration.d.ts
generated
vendored
Normal file
2
node_modules/mathjax-full/js/input/tex/autoload/AutoloadConfiguration.d.ts
generated
vendored
Normal file
@@ -0,0 +1,2 @@
|
||||
import { Configuration } from '../Configuration.js';
|
||||
export declare const AutoloadConfiguration: Configuration;
|
||||
163
node_modules/mathjax-full/js/input/tex/autoload/AutoloadConfiguration.js
generated
vendored
Normal file
163
node_modules/mathjax-full/js/input/tex/autoload/AutoloadConfiguration.js
generated
vendored
Normal file
@@ -0,0 +1,163 @@
|
||||
"use strict";
|
||||
var __read = (this && this.__read) || function (o, n) {
|
||||
var m = typeof Symbol === "function" && o[Symbol.iterator];
|
||||
if (!m) return o;
|
||||
var i = m.call(o), r, ar = [], e;
|
||||
try {
|
||||
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
|
||||
}
|
||||
catch (error) { e = { error: error }; }
|
||||
finally {
|
||||
try {
|
||||
if (r && !r.done && (m = i["return"])) m.call(i);
|
||||
}
|
||||
finally { if (e) throw e.error; }
|
||||
}
|
||||
return ar;
|
||||
};
|
||||
var __values = (this && this.__values) || function(o) {
|
||||
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
|
||||
if (m) return m.call(o);
|
||||
if (o && typeof o.length === "number") return {
|
||||
next: function () {
|
||||
if (o && i >= o.length) o = void 0;
|
||||
return { value: o && o[i++], done: !o };
|
||||
}
|
||||
};
|
||||
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
|
||||
};
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.AutoloadConfiguration = void 0;
|
||||
var Configuration_js_1 = require("../Configuration.js");
|
||||
var SymbolMap_js_1 = require("../SymbolMap.js");
|
||||
var Symbol_js_1 = require("../Symbol.js");
|
||||
var RequireConfiguration_js_1 = require("../require/RequireConfiguration.js");
|
||||
var package_js_1 = require("../../../components/package.js");
|
||||
var Options_js_1 = require("../../../util/Options.js");
|
||||
function Autoload(parser, name, extension, isMacro) {
|
||||
var e_1, _a, e_2, _b;
|
||||
if (package_js_1.Package.packages.has(parser.options.require.prefix + extension)) {
|
||||
var def = parser.options.autoload[extension];
|
||||
var _c = __read((def.length === 2 && Array.isArray(def[0]) ? def : [def, []]), 2), macros = _c[0], envs = _c[1];
|
||||
try {
|
||||
for (var macros_1 = __values(macros), macros_1_1 = macros_1.next(); !macros_1_1.done; macros_1_1 = macros_1.next()) {
|
||||
var macro = macros_1_1.value;
|
||||
AutoloadMacros.remove(macro);
|
||||
}
|
||||
}
|
||||
catch (e_1_1) { e_1 = { error: e_1_1 }; }
|
||||
finally {
|
||||
try {
|
||||
if (macros_1_1 && !macros_1_1.done && (_a = macros_1.return)) _a.call(macros_1);
|
||||
}
|
||||
finally { if (e_1) throw e_1.error; }
|
||||
}
|
||||
try {
|
||||
for (var envs_1 = __values(envs), envs_1_1 = envs_1.next(); !envs_1_1.done; envs_1_1 = envs_1.next()) {
|
||||
var env = envs_1_1.value;
|
||||
AutoloadEnvironments.remove(env);
|
||||
}
|
||||
}
|
||||
catch (e_2_1) { e_2 = { error: e_2_1 }; }
|
||||
finally {
|
||||
try {
|
||||
if (envs_1_1 && !envs_1_1.done && (_b = envs_1.return)) _b.call(envs_1);
|
||||
}
|
||||
finally { if (e_2) throw e_2.error; }
|
||||
}
|
||||
parser.string = (isMacro ? name + ' ' : '\\begin{' + name.slice(1) + '}') + parser.string.slice(parser.i);
|
||||
parser.i = 0;
|
||||
}
|
||||
(0, RequireConfiguration_js_1.RequireLoad)(parser, extension);
|
||||
}
|
||||
function initAutoload(config) {
|
||||
if (!config.options.require) {
|
||||
(0, Options_js_1.defaultOptions)(config.options, RequireConfiguration_js_1.RequireConfiguration.options);
|
||||
}
|
||||
}
|
||||
function configAutoload(config, jax) {
|
||||
var e_3, _a, e_4, _b, e_5, _c;
|
||||
var parser = jax.parseOptions;
|
||||
var macros = parser.handlers.get('macro');
|
||||
var environments = parser.handlers.get('environment');
|
||||
var autoload = parser.options.autoload;
|
||||
parser.packageData.set('autoload', { Autoload: Autoload });
|
||||
try {
|
||||
for (var _d = __values(Object.keys(autoload)), _e = _d.next(); !_e.done; _e = _d.next()) {
|
||||
var extension = _e.value;
|
||||
var def = autoload[extension];
|
||||
var _f = __read((def.length === 2 && Array.isArray(def[0]) ? def : [def, []]), 2), macs = _f[0], envs = _f[1];
|
||||
try {
|
||||
for (var macs_1 = (e_4 = void 0, __values(macs)), macs_1_1 = macs_1.next(); !macs_1_1.done; macs_1_1 = macs_1.next()) {
|
||||
var name_1 = macs_1_1.value;
|
||||
if (!macros.lookup(name_1) || name_1 === 'color') {
|
||||
AutoloadMacros.add(name_1, new Symbol_js_1.Macro(name_1, Autoload, [extension, true]));
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (e_4_1) { e_4 = { error: e_4_1 }; }
|
||||
finally {
|
||||
try {
|
||||
if (macs_1_1 && !macs_1_1.done && (_b = macs_1.return)) _b.call(macs_1);
|
||||
}
|
||||
finally { if (e_4) throw e_4.error; }
|
||||
}
|
||||
try {
|
||||
for (var envs_2 = (e_5 = void 0, __values(envs)), envs_2_1 = envs_2.next(); !envs_2_1.done; envs_2_1 = envs_2.next()) {
|
||||
var name_2 = envs_2_1.value;
|
||||
if (!environments.lookup(name_2)) {
|
||||
AutoloadEnvironments.add(name_2, new Symbol_js_1.Macro(name_2, Autoload, [extension, false]));
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (e_5_1) { e_5 = { error: e_5_1 }; }
|
||||
finally {
|
||||
try {
|
||||
if (envs_2_1 && !envs_2_1.done && (_c = envs_2.return)) _c.call(envs_2);
|
||||
}
|
||||
finally { if (e_5) throw e_5.error; }
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (e_3_1) { e_3 = { error: e_3_1 }; }
|
||||
finally {
|
||||
try {
|
||||
if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
|
||||
}
|
||||
finally { if (e_3) throw e_3.error; }
|
||||
}
|
||||
if (!parser.packageData.get('require')) {
|
||||
RequireConfiguration_js_1.RequireConfiguration.config(config, jax);
|
||||
}
|
||||
}
|
||||
var AutoloadMacros = new SymbolMap_js_1.CommandMap('autoload-macros', {}, {});
|
||||
var AutoloadEnvironments = new SymbolMap_js_1.CommandMap('autoload-environments', {}, {});
|
||||
exports.AutoloadConfiguration = Configuration_js_1.Configuration.create('autoload', {
|
||||
handler: {
|
||||
macro: ['autoload-macros'],
|
||||
environment: ['autoload-environments']
|
||||
},
|
||||
options: {
|
||||
autoload: (0, Options_js_1.expandable)({
|
||||
action: ['toggle', 'mathtip', 'texttip'],
|
||||
amscd: [[], ['CD']],
|
||||
bbox: ['bbox'],
|
||||
boldsymbol: ['boldsymbol'],
|
||||
braket: ['bra', 'ket', 'braket', 'set', 'Bra', 'Ket', 'Braket', 'Set', 'ketbra', 'Ketbra'],
|
||||
bussproofs: [[], ['prooftree']],
|
||||
cancel: ['cancel', 'bcancel', 'xcancel', 'cancelto'],
|
||||
color: ['color', 'definecolor', 'textcolor', 'colorbox', 'fcolorbox'],
|
||||
enclose: ['enclose'],
|
||||
extpfeil: ['xtwoheadrightarrow', 'xtwoheadleftarrow', 'xmapsto', 'xlongequal', 'xtofrom', 'Newextarrow'],
|
||||
html: ['href', 'class', 'style', 'cssId'],
|
||||
mhchem: ['ce', 'pu'],
|
||||
newcommand: ['newcommand', 'renewcommand', 'newenvironment', 'renewenvironment', 'def', 'let'],
|
||||
unicode: ['unicode'],
|
||||
verb: ['verb']
|
||||
})
|
||||
},
|
||||
config: configAutoload,
|
||||
init: initAutoload,
|
||||
priority: 10
|
||||
});
|
||||
//# sourceMappingURL=AutoloadConfiguration.js.map
|
||||
1
node_modules/mathjax-full/js/input/tex/autoload/AutoloadConfiguration.js.map
generated
vendored
Normal file
1
node_modules/mathjax-full/js/input/tex/autoload/AutoloadConfiguration.js.map
generated
vendored
Normal file
@@ -0,0 +1 @@
|
||||
{"version":3,"file":"AutoloadConfiguration.js","sourceRoot":"","sources":["../../../../ts/input/tex/autoload/AutoloadConfiguration.ts"],"names":[],"mappings":"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"}
|
||||
8
node_modules/mathjax-full/js/input/tex/base/BaseConfiguration.d.ts
generated
vendored
Normal file
8
node_modules/mathjax-full/js/input/tex/base/BaseConfiguration.d.ts
generated
vendored
Normal file
@@ -0,0 +1,8 @@
|
||||
import { Configuration } from '../Configuration.js';
|
||||
import TexParser from '../TexParser.js';
|
||||
import { AbstractTags } from '../Tags.js';
|
||||
import './BaseMappings.js';
|
||||
export declare function Other(parser: TexParser, char: string): void;
|
||||
export declare class BaseTags extends AbstractTags {
|
||||
}
|
||||
export declare const BaseConfiguration: Configuration;
|
||||
179
node_modules/mathjax-full/js/input/tex/base/BaseConfiguration.js
generated
vendored
Normal file
179
node_modules/mathjax-full/js/input/tex/base/BaseConfiguration.js
generated
vendored
Normal file
@@ -0,0 +1,179 @@
|
||||
"use strict";
|
||||
var __extends = (this && this.__extends) || (function () {
|
||||
var extendStatics = function (d, b) {
|
||||
extendStatics = Object.setPrototypeOf ||
|
||||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
||||
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
|
||||
return extendStatics(d, b);
|
||||
};
|
||||
return function (d, b) {
|
||||
if (typeof b !== "function" && b !== null)
|
||||
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
|
||||
extendStatics(d, b);
|
||||
function __() { this.constructor = d; }
|
||||
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
||||
};
|
||||
})();
|
||||
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
|
||||
if (k2 === undefined) k2 = k;
|
||||
var desc = Object.getOwnPropertyDescriptor(m, k);
|
||||
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
|
||||
desc = { enumerable: true, get: function() { return m[k]; } };
|
||||
}
|
||||
Object.defineProperty(o, k2, desc);
|
||||
}) : (function(o, m, k, k2) {
|
||||
if (k2 === undefined) k2 = k;
|
||||
o[k2] = m[k];
|
||||
}));
|
||||
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
|
||||
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
||||
}) : function(o, v) {
|
||||
o["default"] = v;
|
||||
});
|
||||
var __importStar = (this && this.__importStar) || function (mod) {
|
||||
if (mod && mod.__esModule) return mod;
|
||||
var result = {};
|
||||
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
|
||||
__setModuleDefault(result, mod);
|
||||
return result;
|
||||
};
|
||||
var __values = (this && this.__values) || function(o) {
|
||||
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
|
||||
if (m) return m.call(o);
|
||||
if (o && typeof o.length === "number") return {
|
||||
next: function () {
|
||||
if (o && i >= o.length) o = void 0;
|
||||
return { value: o && o[i++], done: !o };
|
||||
}
|
||||
};
|
||||
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
|
||||
};
|
||||
var __importDefault = (this && this.__importDefault) || function (mod) {
|
||||
return (mod && mod.__esModule) ? mod : { "default": mod };
|
||||
};
|
||||
var _a;
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.BaseConfiguration = exports.BaseTags = exports.Other = void 0;
|
||||
var Configuration_js_1 = require("../Configuration.js");
|
||||
var MapHandler_js_1 = require("../MapHandler.js");
|
||||
var TexError_js_1 = __importDefault(require("../TexError.js"));
|
||||
var NodeUtil_js_1 = __importDefault(require("../NodeUtil.js"));
|
||||
var SymbolMap_js_1 = require("../SymbolMap.js");
|
||||
var bitem = __importStar(require("./BaseItems.js"));
|
||||
var Tags_js_1 = require("../Tags.js");
|
||||
require("./BaseMappings.js");
|
||||
var OperatorDictionary_js_1 = require("../../../core/MmlTree/OperatorDictionary.js");
|
||||
new SymbolMap_js_1.CharacterMap('remap', null, {
|
||||
'-': '\u2212',
|
||||
'*': '\u2217',
|
||||
'`': '\u2018'
|
||||
});
|
||||
function Other(parser, char) {
|
||||
var font = parser.stack.env['font'];
|
||||
var def = font ?
|
||||
{ mathvariant: parser.stack.env['font'] } : {};
|
||||
var remap = MapHandler_js_1.MapHandler.getMap('remap').lookup(char);
|
||||
var range = (0, OperatorDictionary_js_1.getRange)(char);
|
||||
var type = (range ? range[3] : 'mo');
|
||||
var mo = parser.create('token', type, def, (remap ? remap.char : char));
|
||||
range[4] && mo.attributes.set('mathvariant', range[4]);
|
||||
if (type === 'mo') {
|
||||
NodeUtil_js_1.default.setProperty(mo, 'fixStretchy', true);
|
||||
parser.configuration.addNode('fixStretchy', mo);
|
||||
}
|
||||
parser.Push(mo);
|
||||
}
|
||||
exports.Other = Other;
|
||||
function csUndefined(_parser, name) {
|
||||
throw new TexError_js_1.default('UndefinedControlSequence', 'Undefined control sequence %1', '\\' + name);
|
||||
}
|
||||
function envUndefined(_parser, env) {
|
||||
throw new TexError_js_1.default('UnknownEnv', 'Unknown environment \'%1\'', env);
|
||||
}
|
||||
function filterNonscript(_a) {
|
||||
var e_1, _b;
|
||||
var data = _a.data;
|
||||
try {
|
||||
for (var _c = __values(data.getList('nonscript')), _d = _c.next(); !_d.done; _d = _c.next()) {
|
||||
var mml = _d.value;
|
||||
if (mml.attributes.get('scriptlevel') > 0) {
|
||||
var parent_1 = mml.parent;
|
||||
parent_1.childNodes.splice(parent_1.childIndex(mml), 1);
|
||||
data.removeFromList(mml.kind, [mml]);
|
||||
if (mml.isKind('mrow')) {
|
||||
var mstyle = mml.childNodes[0];
|
||||
data.removeFromList('mstyle', [mstyle]);
|
||||
data.removeFromList('mspace', mstyle.childNodes[0].childNodes);
|
||||
}
|
||||
}
|
||||
else if (mml.isKind('mrow')) {
|
||||
mml.parent.replaceChild(mml.childNodes[0], mml);
|
||||
data.removeFromList('mrow', [mml]);
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (e_1_1) { e_1 = { error: e_1_1 }; }
|
||||
finally {
|
||||
try {
|
||||
if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
|
||||
}
|
||||
finally { if (e_1) throw e_1.error; }
|
||||
}
|
||||
}
|
||||
var BaseTags = (function (_super) {
|
||||
__extends(BaseTags, _super);
|
||||
function BaseTags() {
|
||||
return _super !== null && _super.apply(this, arguments) || this;
|
||||
}
|
||||
return BaseTags;
|
||||
}(Tags_js_1.AbstractTags));
|
||||
exports.BaseTags = BaseTags;
|
||||
exports.BaseConfiguration = Configuration_js_1.Configuration.create('base', {
|
||||
handler: {
|
||||
character: ['command', 'special', 'letter', 'digit'],
|
||||
delimiter: ['delimiter'],
|
||||
macro: ['delimiter', 'macros', 'mathchar0mi', 'mathchar0mo', 'mathchar7'],
|
||||
environment: ['environment']
|
||||
},
|
||||
fallback: {
|
||||
character: Other,
|
||||
macro: csUndefined,
|
||||
environment: envUndefined
|
||||
},
|
||||
items: (_a = {},
|
||||
_a[bitem.StartItem.prototype.kind] = bitem.StartItem,
|
||||
_a[bitem.StopItem.prototype.kind] = bitem.StopItem,
|
||||
_a[bitem.OpenItem.prototype.kind] = bitem.OpenItem,
|
||||
_a[bitem.CloseItem.prototype.kind] = bitem.CloseItem,
|
||||
_a[bitem.PrimeItem.prototype.kind] = bitem.PrimeItem,
|
||||
_a[bitem.SubsupItem.prototype.kind] = bitem.SubsupItem,
|
||||
_a[bitem.OverItem.prototype.kind] = bitem.OverItem,
|
||||
_a[bitem.LeftItem.prototype.kind] = bitem.LeftItem,
|
||||
_a[bitem.Middle.prototype.kind] = bitem.Middle,
|
||||
_a[bitem.RightItem.prototype.kind] = bitem.RightItem,
|
||||
_a[bitem.BeginItem.prototype.kind] = bitem.BeginItem,
|
||||
_a[bitem.EndItem.prototype.kind] = bitem.EndItem,
|
||||
_a[bitem.StyleItem.prototype.kind] = bitem.StyleItem,
|
||||
_a[bitem.PositionItem.prototype.kind] = bitem.PositionItem,
|
||||
_a[bitem.CellItem.prototype.kind] = bitem.CellItem,
|
||||
_a[bitem.MmlItem.prototype.kind] = bitem.MmlItem,
|
||||
_a[bitem.FnItem.prototype.kind] = bitem.FnItem,
|
||||
_a[bitem.NotItem.prototype.kind] = bitem.NotItem,
|
||||
_a[bitem.NonscriptItem.prototype.kind] = bitem.NonscriptItem,
|
||||
_a[bitem.DotsItem.prototype.kind] = bitem.DotsItem,
|
||||
_a[bitem.ArrayItem.prototype.kind] = bitem.ArrayItem,
|
||||
_a[bitem.EqnArrayItem.prototype.kind] = bitem.EqnArrayItem,
|
||||
_a[bitem.EquationItem.prototype.kind] = bitem.EquationItem,
|
||||
_a),
|
||||
options: {
|
||||
maxMacros: 1000,
|
||||
baseURL: (typeof (document) === 'undefined' ||
|
||||
document.getElementsByTagName('base').length === 0) ?
|
||||
'' : String(document.location).replace(/#.*$/, '')
|
||||
},
|
||||
tags: {
|
||||
base: BaseTags
|
||||
},
|
||||
postprocessors: [[filterNonscript, -4]]
|
||||
});
|
||||
//# sourceMappingURL=BaseConfiguration.js.map
|
||||
1
node_modules/mathjax-full/js/input/tex/base/BaseConfiguration.js.map
generated
vendored
Normal file
1
node_modules/mathjax-full/js/input/tex/base/BaseConfiguration.js.map
generated
vendored
Normal file
@@ -0,0 +1 @@
|
||||
{"version":3,"file":"BaseConfiguration.js","sourceRoot":"","sources":["../../../../ts/input/tex/base/BaseConfiguration.ts"],"names":[],"mappings":"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"}
|
||||
134
node_modules/mathjax-full/js/input/tex/base/BaseItems.d.ts
generated
vendored
Normal file
134
node_modules/mathjax-full/js/input/tex/base/BaseItems.d.ts
generated
vendored
Normal file
@@ -0,0 +1,134 @@
|
||||
import { MmlNode } from '../../../core/MmlTree/MmlNode.js';
|
||||
import StackItemFactory from '../StackItemFactory.js';
|
||||
import { CheckType, BaseItem, StackItem, EnvList } from '../StackItem.js';
|
||||
export declare class StartItem extends BaseItem {
|
||||
global: EnvList;
|
||||
constructor(factory: StackItemFactory, global: EnvList);
|
||||
get kind(): string;
|
||||
get isOpen(): boolean;
|
||||
checkItem(item: StackItem): CheckType;
|
||||
}
|
||||
export declare class StopItem extends BaseItem {
|
||||
get kind(): string;
|
||||
get isClose(): boolean;
|
||||
}
|
||||
export declare class OpenItem extends BaseItem {
|
||||
protected static errors: any;
|
||||
get kind(): string;
|
||||
get isOpen(): boolean;
|
||||
checkItem(item: StackItem): CheckType;
|
||||
}
|
||||
export declare class CloseItem extends BaseItem {
|
||||
get kind(): string;
|
||||
get isClose(): boolean;
|
||||
}
|
||||
export declare class PrimeItem extends BaseItem {
|
||||
get kind(): string;
|
||||
checkItem(item: StackItem): CheckType;
|
||||
}
|
||||
export declare class SubsupItem extends BaseItem {
|
||||
protected static errors: any;
|
||||
get kind(): string;
|
||||
checkItem(item: StackItem): CheckType | null;
|
||||
}
|
||||
export declare class OverItem extends BaseItem {
|
||||
constructor(factory: StackItemFactory);
|
||||
get kind(): string;
|
||||
get isClose(): boolean;
|
||||
checkItem(item: StackItem): CheckType;
|
||||
toString(): string;
|
||||
}
|
||||
export declare class LeftItem extends BaseItem {
|
||||
protected static errors: any;
|
||||
constructor(factory: StackItemFactory, delim: string);
|
||||
get kind(): string;
|
||||
get isOpen(): boolean;
|
||||
checkItem(item: StackItem): CheckType;
|
||||
}
|
||||
export declare class Middle extends BaseItem {
|
||||
constructor(factory: StackItemFactory, delim: string, color: string);
|
||||
get kind(): string;
|
||||
get isClose(): boolean;
|
||||
}
|
||||
export declare class RightItem extends BaseItem {
|
||||
constructor(factory: StackItemFactory, delim: string, color: string);
|
||||
get kind(): string;
|
||||
get isClose(): boolean;
|
||||
}
|
||||
export declare class BeginItem extends BaseItem {
|
||||
get kind(): string;
|
||||
get isOpen(): boolean;
|
||||
checkItem(item: StackItem): CheckType;
|
||||
}
|
||||
export declare class EndItem extends BaseItem {
|
||||
get kind(): string;
|
||||
get isClose(): boolean;
|
||||
}
|
||||
export declare class StyleItem extends BaseItem {
|
||||
get kind(): string;
|
||||
checkItem(item: StackItem): CheckType;
|
||||
}
|
||||
export declare class PositionItem extends BaseItem {
|
||||
get kind(): string;
|
||||
checkItem(item: StackItem): CheckType;
|
||||
}
|
||||
export declare class CellItem extends BaseItem {
|
||||
get kind(): string;
|
||||
get isClose(): boolean;
|
||||
}
|
||||
export declare class MmlItem extends BaseItem {
|
||||
get isFinal(): boolean;
|
||||
get kind(): string;
|
||||
}
|
||||
export declare class FnItem extends BaseItem {
|
||||
get kind(): string;
|
||||
checkItem(item: StackItem): CheckType;
|
||||
}
|
||||
export declare class NotItem extends BaseItem {
|
||||
private remap;
|
||||
get kind(): string;
|
||||
checkItem(item: StackItem): CheckType;
|
||||
}
|
||||
export declare class NonscriptItem extends BaseItem {
|
||||
get kind(): string;
|
||||
checkItem(item: StackItem): CheckType;
|
||||
}
|
||||
export declare class DotsItem extends BaseItem {
|
||||
get kind(): string;
|
||||
checkItem(item: StackItem): CheckType;
|
||||
}
|
||||
export declare class ArrayItem extends BaseItem {
|
||||
table: MmlNode[];
|
||||
row: MmlNode[];
|
||||
frame: string[];
|
||||
hfill: number[];
|
||||
arraydef: {
|
||||
[key: string]: string | number | boolean;
|
||||
};
|
||||
dashed: boolean;
|
||||
get kind(): string;
|
||||
get isOpen(): boolean;
|
||||
get copyEnv(): boolean;
|
||||
checkItem(item: StackItem): CheckType;
|
||||
createMml(): MmlNode;
|
||||
EndEntry(): void;
|
||||
EndRow(): void;
|
||||
EndTable(): void;
|
||||
checkLines(): void;
|
||||
addRowSpacing(spacing: string): void;
|
||||
}
|
||||
export declare class EqnArrayItem extends ArrayItem {
|
||||
maxrow: number;
|
||||
constructor(factory: any, ...args: any[]);
|
||||
get kind(): string;
|
||||
EndEntry(): void;
|
||||
EndRow(): void;
|
||||
EndTable(): void;
|
||||
protected extendArray(name: string, max: number): void;
|
||||
}
|
||||
export declare class EquationItem extends BaseItem {
|
||||
constructor(factory: any, ...args: any[]);
|
||||
get kind(): string;
|
||||
get isOpen(): boolean;
|
||||
checkItem(item: StackItem): CheckType;
|
||||
}
|
||||
953
node_modules/mathjax-full/js/input/tex/base/BaseItems.js
generated
vendored
Normal file
953
node_modules/mathjax-full/js/input/tex/base/BaseItems.js
generated
vendored
Normal file
@@ -0,0 +1,953 @@
|
||||
"use strict";
|
||||
var __extends = (this && this.__extends) || (function () {
|
||||
var extendStatics = function (d, b) {
|
||||
extendStatics = Object.setPrototypeOf ||
|
||||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
||||
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
|
||||
return extendStatics(d, b);
|
||||
};
|
||||
return function (d, b) {
|
||||
if (typeof b !== "function" && b !== null)
|
||||
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
|
||||
extendStatics(d, b);
|
||||
function __() { this.constructor = d; }
|
||||
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
||||
};
|
||||
})();
|
||||
var __read = (this && this.__read) || function (o, n) {
|
||||
var m = typeof Symbol === "function" && o[Symbol.iterator];
|
||||
if (!m) return o;
|
||||
var i = m.call(o), r, ar = [], e;
|
||||
try {
|
||||
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
|
||||
}
|
||||
catch (error) { e = { error: error }; }
|
||||
finally {
|
||||
try {
|
||||
if (r && !r.done && (m = i["return"])) m.call(i);
|
||||
}
|
||||
finally { if (e) throw e.error; }
|
||||
}
|
||||
return ar;
|
||||
};
|
||||
var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
|
||||
if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
|
||||
if (ar || !(i in from)) {
|
||||
if (!ar) ar = Array.prototype.slice.call(from, 0, i);
|
||||
ar[i] = from[i];
|
||||
}
|
||||
}
|
||||
return to.concat(ar || Array.prototype.slice.call(from));
|
||||
};
|
||||
var __importDefault = (this && this.__importDefault) || function (mod) {
|
||||
return (mod && mod.__esModule) ? mod : { "default": mod };
|
||||
};
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.EquationItem = exports.EqnArrayItem = exports.ArrayItem = exports.DotsItem = exports.NonscriptItem = exports.NotItem = exports.FnItem = exports.MmlItem = exports.CellItem = exports.PositionItem = exports.StyleItem = exports.EndItem = exports.BeginItem = exports.RightItem = exports.Middle = exports.LeftItem = exports.OverItem = exports.SubsupItem = exports.PrimeItem = exports.CloseItem = exports.OpenItem = exports.StopItem = exports.StartItem = void 0;
|
||||
var MapHandler_js_1 = require("../MapHandler.js");
|
||||
var Entities_js_1 = require("../../../util/Entities.js");
|
||||
var MmlNode_js_1 = require("../../../core/MmlTree/MmlNode.js");
|
||||
var TexError_js_1 = __importDefault(require("../TexError.js"));
|
||||
var ParseUtil_js_1 = __importDefault(require("../ParseUtil.js"));
|
||||
var NodeUtil_js_1 = __importDefault(require("../NodeUtil.js"));
|
||||
var StackItem_js_1 = require("../StackItem.js");
|
||||
var StartItem = (function (_super) {
|
||||
__extends(StartItem, _super);
|
||||
function StartItem(factory, global) {
|
||||
var _this = _super.call(this, factory) || this;
|
||||
_this.global = global;
|
||||
return _this;
|
||||
}
|
||||
Object.defineProperty(StartItem.prototype, "kind", {
|
||||
get: function () {
|
||||
return 'start';
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
Object.defineProperty(StartItem.prototype, "isOpen", {
|
||||
get: function () {
|
||||
return true;
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
StartItem.prototype.checkItem = function (item) {
|
||||
if (item.isKind('stop')) {
|
||||
var node = this.toMml();
|
||||
if (!this.global.isInner) {
|
||||
node = this.factory.configuration.tags.finalize(node, this.env);
|
||||
}
|
||||
return [[this.factory.create('mml', node)], true];
|
||||
}
|
||||
return _super.prototype.checkItem.call(this, item);
|
||||
};
|
||||
return StartItem;
|
||||
}(StackItem_js_1.BaseItem));
|
||||
exports.StartItem = StartItem;
|
||||
var StopItem = (function (_super) {
|
||||
__extends(StopItem, _super);
|
||||
function StopItem() {
|
||||
return _super !== null && _super.apply(this, arguments) || this;
|
||||
}
|
||||
Object.defineProperty(StopItem.prototype, "kind", {
|
||||
get: function () {
|
||||
return 'stop';
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
Object.defineProperty(StopItem.prototype, "isClose", {
|
||||
get: function () {
|
||||
return true;
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
return StopItem;
|
||||
}(StackItem_js_1.BaseItem));
|
||||
exports.StopItem = StopItem;
|
||||
var OpenItem = (function (_super) {
|
||||
__extends(OpenItem, _super);
|
||||
function OpenItem() {
|
||||
return _super !== null && _super.apply(this, arguments) || this;
|
||||
}
|
||||
Object.defineProperty(OpenItem.prototype, "kind", {
|
||||
get: function () {
|
||||
return 'open';
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
Object.defineProperty(OpenItem.prototype, "isOpen", {
|
||||
get: function () {
|
||||
return true;
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
OpenItem.prototype.checkItem = function (item) {
|
||||
if (item.isKind('close')) {
|
||||
var mml = this.toMml();
|
||||
var node = this.create('node', 'TeXAtom', [mml]);
|
||||
return [[this.factory.create('mml', node)], true];
|
||||
}
|
||||
return _super.prototype.checkItem.call(this, item);
|
||||
};
|
||||
OpenItem.errors = Object.assign(Object.create(StackItem_js_1.BaseItem.errors), {
|
||||
'stop': ['ExtraOpenMissingClose',
|
||||
'Extra open brace or missing close brace']
|
||||
});
|
||||
return OpenItem;
|
||||
}(StackItem_js_1.BaseItem));
|
||||
exports.OpenItem = OpenItem;
|
||||
var CloseItem = (function (_super) {
|
||||
__extends(CloseItem, _super);
|
||||
function CloseItem() {
|
||||
return _super !== null && _super.apply(this, arguments) || this;
|
||||
}
|
||||
Object.defineProperty(CloseItem.prototype, "kind", {
|
||||
get: function () {
|
||||
return 'close';
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
Object.defineProperty(CloseItem.prototype, "isClose", {
|
||||
get: function () {
|
||||
return true;
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
return CloseItem;
|
||||
}(StackItem_js_1.BaseItem));
|
||||
exports.CloseItem = CloseItem;
|
||||
var PrimeItem = (function (_super) {
|
||||
__extends(PrimeItem, _super);
|
||||
function PrimeItem() {
|
||||
return _super !== null && _super.apply(this, arguments) || this;
|
||||
}
|
||||
Object.defineProperty(PrimeItem.prototype, "kind", {
|
||||
get: function () {
|
||||
return 'prime';
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
PrimeItem.prototype.checkItem = function (item) {
|
||||
var _a = __read(this.Peek(2), 2), top0 = _a[0], top1 = _a[1];
|
||||
if (!NodeUtil_js_1.default.isType(top0, 'msubsup') || NodeUtil_js_1.default.isType(top0, 'msup')) {
|
||||
var node = this.create('node', 'msup', [top0, top1]);
|
||||
return [[node, item], true];
|
||||
}
|
||||
NodeUtil_js_1.default.setChild(top0, top0.sup, top1);
|
||||
return [[top0, item], true];
|
||||
};
|
||||
return PrimeItem;
|
||||
}(StackItem_js_1.BaseItem));
|
||||
exports.PrimeItem = PrimeItem;
|
||||
var SubsupItem = (function (_super) {
|
||||
__extends(SubsupItem, _super);
|
||||
function SubsupItem() {
|
||||
return _super !== null && _super.apply(this, arguments) || this;
|
||||
}
|
||||
Object.defineProperty(SubsupItem.prototype, "kind", {
|
||||
get: function () {
|
||||
return 'subsup';
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
SubsupItem.prototype.checkItem = function (item) {
|
||||
if (item.isKind('open') || item.isKind('left')) {
|
||||
return StackItem_js_1.BaseItem.success;
|
||||
}
|
||||
var top = this.First;
|
||||
var position = this.getProperty('position');
|
||||
if (item.isKind('mml')) {
|
||||
if (this.getProperty('primes')) {
|
||||
if (position !== 2) {
|
||||
NodeUtil_js_1.default.setChild(top, 2, this.getProperty('primes'));
|
||||
}
|
||||
else {
|
||||
NodeUtil_js_1.default.setProperty(this.getProperty('primes'), 'variantForm', true);
|
||||
var node = this.create('node', 'mrow', [this.getProperty('primes'), item.First]);
|
||||
item.First = node;
|
||||
}
|
||||
}
|
||||
NodeUtil_js_1.default.setChild(top, position, item.First);
|
||||
if (this.getProperty('movesupsub') != null) {
|
||||
NodeUtil_js_1.default.setProperty(top, 'movesupsub', this.getProperty('movesupsub'));
|
||||
}
|
||||
var result = this.factory.create('mml', top);
|
||||
return [[result], true];
|
||||
}
|
||||
if (_super.prototype.checkItem.call(this, item)[1]) {
|
||||
var error = this.getErrors(['', 'sub', 'sup'][position]);
|
||||
throw new (TexError_js_1.default.bind.apply(TexError_js_1.default, __spreadArray([void 0, error[0], error[1]], __read(error.splice(2)), false)))();
|
||||
}
|
||||
return null;
|
||||
};
|
||||
SubsupItem.errors = Object.assign(Object.create(StackItem_js_1.BaseItem.errors), {
|
||||
'stop': ['MissingScript',
|
||||
'Missing superscript or subscript argument'],
|
||||
'sup': ['MissingOpenForSup',
|
||||
'Missing open brace for superscript'],
|
||||
'sub': ['MissingOpenForSub',
|
||||
'Missing open brace for subscript']
|
||||
});
|
||||
return SubsupItem;
|
||||
}(StackItem_js_1.BaseItem));
|
||||
exports.SubsupItem = SubsupItem;
|
||||
var OverItem = (function (_super) {
|
||||
__extends(OverItem, _super);
|
||||
function OverItem(factory) {
|
||||
var _this = _super.call(this, factory) || this;
|
||||
_this.setProperty('name', '\\over');
|
||||
return _this;
|
||||
}
|
||||
Object.defineProperty(OverItem.prototype, "kind", {
|
||||
get: function () {
|
||||
return 'over';
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
Object.defineProperty(OverItem.prototype, "isClose", {
|
||||
get: function () {
|
||||
return true;
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
OverItem.prototype.checkItem = function (item) {
|
||||
if (item.isKind('over')) {
|
||||
throw new TexError_js_1.default('AmbiguousUseOf', 'Ambiguous use of %1', item.getName());
|
||||
}
|
||||
if (item.isClose) {
|
||||
var mml = this.create('node', 'mfrac', [this.getProperty('num'), this.toMml(false)]);
|
||||
if (this.getProperty('thickness') != null) {
|
||||
NodeUtil_js_1.default.setAttribute(mml, 'linethickness', this.getProperty('thickness'));
|
||||
}
|
||||
if (this.getProperty('open') || this.getProperty('close')) {
|
||||
NodeUtil_js_1.default.setProperty(mml, 'withDelims', true);
|
||||
mml = ParseUtil_js_1.default.fixedFence(this.factory.configuration, this.getProperty('open'), mml, this.getProperty('close'));
|
||||
}
|
||||
return [[this.factory.create('mml', mml), item], true];
|
||||
}
|
||||
return _super.prototype.checkItem.call(this, item);
|
||||
};
|
||||
OverItem.prototype.toString = function () {
|
||||
return 'over[' + this.getProperty('num') +
|
||||
' / ' + this.nodes.join('; ') + ']';
|
||||
};
|
||||
return OverItem;
|
||||
}(StackItem_js_1.BaseItem));
|
||||
exports.OverItem = OverItem;
|
||||
var LeftItem = (function (_super) {
|
||||
__extends(LeftItem, _super);
|
||||
function LeftItem(factory, delim) {
|
||||
var _this = _super.call(this, factory) || this;
|
||||
_this.setProperty('delim', delim);
|
||||
return _this;
|
||||
}
|
||||
Object.defineProperty(LeftItem.prototype, "kind", {
|
||||
get: function () {
|
||||
return 'left';
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
Object.defineProperty(LeftItem.prototype, "isOpen", {
|
||||
get: function () {
|
||||
return true;
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
LeftItem.prototype.checkItem = function (item) {
|
||||
if (item.isKind('right')) {
|
||||
return [[this.factory.create('mml', ParseUtil_js_1.default.fenced(this.factory.configuration, this.getProperty('delim'), this.toMml(), item.getProperty('delim'), '', item.getProperty('color')))], true];
|
||||
}
|
||||
if (item.isKind('middle')) {
|
||||
var def = { stretchy: true };
|
||||
if (item.getProperty('color')) {
|
||||
def.mathcolor = item.getProperty('color');
|
||||
}
|
||||
this.Push(this.create('node', 'TeXAtom', [], { texClass: MmlNode_js_1.TEXCLASS.CLOSE }), this.create('token', 'mo', def, item.getProperty('delim')), this.create('node', 'TeXAtom', [], { texClass: MmlNode_js_1.TEXCLASS.OPEN }));
|
||||
this.env = {};
|
||||
return [[this], true];
|
||||
}
|
||||
return _super.prototype.checkItem.call(this, item);
|
||||
};
|
||||
LeftItem.errors = Object.assign(Object.create(StackItem_js_1.BaseItem.errors), {
|
||||
'stop': ['ExtraLeftMissingRight',
|
||||
'Extra \\left or missing \\right']
|
||||
});
|
||||
return LeftItem;
|
||||
}(StackItem_js_1.BaseItem));
|
||||
exports.LeftItem = LeftItem;
|
||||
var Middle = (function (_super) {
|
||||
__extends(Middle, _super);
|
||||
function Middle(factory, delim, color) {
|
||||
var _this = _super.call(this, factory) || this;
|
||||
_this.setProperty('delim', delim);
|
||||
color && _this.setProperty('color', color);
|
||||
return _this;
|
||||
}
|
||||
Object.defineProperty(Middle.prototype, "kind", {
|
||||
get: function () {
|
||||
return 'middle';
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
Object.defineProperty(Middle.prototype, "isClose", {
|
||||
get: function () {
|
||||
return true;
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
return Middle;
|
||||
}(StackItem_js_1.BaseItem));
|
||||
exports.Middle = Middle;
|
||||
var RightItem = (function (_super) {
|
||||
__extends(RightItem, _super);
|
||||
function RightItem(factory, delim, color) {
|
||||
var _this = _super.call(this, factory) || this;
|
||||
_this.setProperty('delim', delim);
|
||||
color && _this.setProperty('color', color);
|
||||
return _this;
|
||||
}
|
||||
Object.defineProperty(RightItem.prototype, "kind", {
|
||||
get: function () {
|
||||
return 'right';
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
Object.defineProperty(RightItem.prototype, "isClose", {
|
||||
get: function () {
|
||||
return true;
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
return RightItem;
|
||||
}(StackItem_js_1.BaseItem));
|
||||
exports.RightItem = RightItem;
|
||||
var BeginItem = (function (_super) {
|
||||
__extends(BeginItem, _super);
|
||||
function BeginItem() {
|
||||
return _super !== null && _super.apply(this, arguments) || this;
|
||||
}
|
||||
Object.defineProperty(BeginItem.prototype, "kind", {
|
||||
get: function () {
|
||||
return 'begin';
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
Object.defineProperty(BeginItem.prototype, "isOpen", {
|
||||
get: function () {
|
||||
return true;
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
BeginItem.prototype.checkItem = function (item) {
|
||||
if (item.isKind('end')) {
|
||||
if (item.getName() !== this.getName()) {
|
||||
throw new TexError_js_1.default('EnvBadEnd', '\\begin{%1} ended with \\end{%2}', this.getName(), item.getName());
|
||||
}
|
||||
if (!this.getProperty('end')) {
|
||||
return [[this.factory.create('mml', this.toMml())], true];
|
||||
}
|
||||
return StackItem_js_1.BaseItem.fail;
|
||||
}
|
||||
if (item.isKind('stop')) {
|
||||
throw new TexError_js_1.default('EnvMissingEnd', 'Missing \\end{%1}', this.getName());
|
||||
}
|
||||
return _super.prototype.checkItem.call(this, item);
|
||||
};
|
||||
return BeginItem;
|
||||
}(StackItem_js_1.BaseItem));
|
||||
exports.BeginItem = BeginItem;
|
||||
var EndItem = (function (_super) {
|
||||
__extends(EndItem, _super);
|
||||
function EndItem() {
|
||||
return _super !== null && _super.apply(this, arguments) || this;
|
||||
}
|
||||
Object.defineProperty(EndItem.prototype, "kind", {
|
||||
get: function () {
|
||||
return 'end';
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
Object.defineProperty(EndItem.prototype, "isClose", {
|
||||
get: function () {
|
||||
return true;
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
return EndItem;
|
||||
}(StackItem_js_1.BaseItem));
|
||||
exports.EndItem = EndItem;
|
||||
var StyleItem = (function (_super) {
|
||||
__extends(StyleItem, _super);
|
||||
function StyleItem() {
|
||||
return _super !== null && _super.apply(this, arguments) || this;
|
||||
}
|
||||
Object.defineProperty(StyleItem.prototype, "kind", {
|
||||
get: function () {
|
||||
return 'style';
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
StyleItem.prototype.checkItem = function (item) {
|
||||
if (!item.isClose) {
|
||||
return _super.prototype.checkItem.call(this, item);
|
||||
}
|
||||
var mml = this.create('node', 'mstyle', this.nodes, this.getProperty('styles'));
|
||||
return [[this.factory.create('mml', mml), item], true];
|
||||
};
|
||||
return StyleItem;
|
||||
}(StackItem_js_1.BaseItem));
|
||||
exports.StyleItem = StyleItem;
|
||||
var PositionItem = (function (_super) {
|
||||
__extends(PositionItem, _super);
|
||||
function PositionItem() {
|
||||
return _super !== null && _super.apply(this, arguments) || this;
|
||||
}
|
||||
Object.defineProperty(PositionItem.prototype, "kind", {
|
||||
get: function () {
|
||||
return 'position';
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
PositionItem.prototype.checkItem = function (item) {
|
||||
if (item.isClose) {
|
||||
throw new TexError_js_1.default('MissingBoxFor', 'Missing box for %1', this.getName());
|
||||
}
|
||||
if (item.isFinal) {
|
||||
var mml = item.toMml();
|
||||
switch (this.getProperty('move')) {
|
||||
case 'vertical':
|
||||
mml = this.create('node', 'mpadded', [mml], { height: this.getProperty('dh'),
|
||||
depth: this.getProperty('dd'),
|
||||
voffset: this.getProperty('dh') });
|
||||
return [[this.factory.create('mml', mml)], true];
|
||||
case 'horizontal':
|
||||
return [[this.factory.create('mml', this.getProperty('left')), item,
|
||||
this.factory.create('mml', this.getProperty('right'))], true];
|
||||
}
|
||||
}
|
||||
return _super.prototype.checkItem.call(this, item);
|
||||
};
|
||||
return PositionItem;
|
||||
}(StackItem_js_1.BaseItem));
|
||||
exports.PositionItem = PositionItem;
|
||||
var CellItem = (function (_super) {
|
||||
__extends(CellItem, _super);
|
||||
function CellItem() {
|
||||
return _super !== null && _super.apply(this, arguments) || this;
|
||||
}
|
||||
Object.defineProperty(CellItem.prototype, "kind", {
|
||||
get: function () {
|
||||
return 'cell';
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
Object.defineProperty(CellItem.prototype, "isClose", {
|
||||
get: function () {
|
||||
return true;
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
return CellItem;
|
||||
}(StackItem_js_1.BaseItem));
|
||||
exports.CellItem = CellItem;
|
||||
var MmlItem = (function (_super) {
|
||||
__extends(MmlItem, _super);
|
||||
function MmlItem() {
|
||||
return _super !== null && _super.apply(this, arguments) || this;
|
||||
}
|
||||
Object.defineProperty(MmlItem.prototype, "isFinal", {
|
||||
get: function () {
|
||||
return true;
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
Object.defineProperty(MmlItem.prototype, "kind", {
|
||||
get: function () {
|
||||
return 'mml';
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
return MmlItem;
|
||||
}(StackItem_js_1.BaseItem));
|
||||
exports.MmlItem = MmlItem;
|
||||
var FnItem = (function (_super) {
|
||||
__extends(FnItem, _super);
|
||||
function FnItem() {
|
||||
return _super !== null && _super.apply(this, arguments) || this;
|
||||
}
|
||||
Object.defineProperty(FnItem.prototype, "kind", {
|
||||
get: function () {
|
||||
return 'fn';
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
FnItem.prototype.checkItem = function (item) {
|
||||
var top = this.First;
|
||||
if (top) {
|
||||
if (item.isOpen) {
|
||||
return StackItem_js_1.BaseItem.success;
|
||||
}
|
||||
if (!item.isKind('fn')) {
|
||||
var mml = item.First;
|
||||
if (!item.isKind('mml') || !mml) {
|
||||
return [[top, item], true];
|
||||
}
|
||||
if ((NodeUtil_js_1.default.isType(mml, 'mstyle') && mml.childNodes.length &&
|
||||
NodeUtil_js_1.default.isType(mml.childNodes[0].childNodes[0], 'mspace')) ||
|
||||
NodeUtil_js_1.default.isType(mml, 'mspace')) {
|
||||
return [[top, item], true];
|
||||
}
|
||||
if (NodeUtil_js_1.default.isEmbellished(mml)) {
|
||||
mml = NodeUtil_js_1.default.getCoreMO(mml);
|
||||
}
|
||||
var form = NodeUtil_js_1.default.getForm(mml);
|
||||
if (form != null && [0, 0, 1, 1, 0, 1, 1, 0, 0, 0][form[2]]) {
|
||||
return [[top, item], true];
|
||||
}
|
||||
}
|
||||
var node = this.create('token', 'mo', { texClass: MmlNode_js_1.TEXCLASS.NONE }, Entities_js_1.entities.ApplyFunction);
|
||||
return [[top, node, item], true];
|
||||
}
|
||||
return _super.prototype.checkItem.apply(this, arguments);
|
||||
};
|
||||
return FnItem;
|
||||
}(StackItem_js_1.BaseItem));
|
||||
exports.FnItem = FnItem;
|
||||
var NotItem = (function (_super) {
|
||||
__extends(NotItem, _super);
|
||||
function NotItem() {
|
||||
var _this = _super !== null && _super.apply(this, arguments) || this;
|
||||
_this.remap = MapHandler_js_1.MapHandler.getMap('not_remap');
|
||||
return _this;
|
||||
}
|
||||
Object.defineProperty(NotItem.prototype, "kind", {
|
||||
get: function () {
|
||||
return 'not';
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
NotItem.prototype.checkItem = function (item) {
|
||||
var mml;
|
||||
var c;
|
||||
var textNode;
|
||||
if (item.isKind('open') || item.isKind('left')) {
|
||||
return StackItem_js_1.BaseItem.success;
|
||||
}
|
||||
if (item.isKind('mml') &&
|
||||
(NodeUtil_js_1.default.isType(item.First, 'mo') || NodeUtil_js_1.default.isType(item.First, 'mi') ||
|
||||
NodeUtil_js_1.default.isType(item.First, 'mtext'))) {
|
||||
mml = item.First;
|
||||
c = NodeUtil_js_1.default.getText(mml);
|
||||
if (c.length === 1 && !NodeUtil_js_1.default.getProperty(mml, 'movesupsub') &&
|
||||
NodeUtil_js_1.default.getChildren(mml).length === 1) {
|
||||
if (this.remap.contains(c)) {
|
||||
textNode = this.create('text', this.remap.lookup(c).char);
|
||||
NodeUtil_js_1.default.setChild(mml, 0, textNode);
|
||||
}
|
||||
else {
|
||||
textNode = this.create('text', '\u0338');
|
||||
NodeUtil_js_1.default.appendChildren(mml, [textNode]);
|
||||
}
|
||||
return [[item], true];
|
||||
}
|
||||
}
|
||||
textNode = this.create('text', '\u29F8');
|
||||
var mtextNode = this.create('node', 'mtext', [], {}, textNode);
|
||||
var paddedNode = this.create('node', 'mpadded', [mtextNode], { width: 0 });
|
||||
mml = this.create('node', 'TeXAtom', [paddedNode], { texClass: MmlNode_js_1.TEXCLASS.REL });
|
||||
return [[mml, item], true];
|
||||
};
|
||||
return NotItem;
|
||||
}(StackItem_js_1.BaseItem));
|
||||
exports.NotItem = NotItem;
|
||||
var NonscriptItem = (function (_super) {
|
||||
__extends(NonscriptItem, _super);
|
||||
function NonscriptItem() {
|
||||
return _super !== null && _super.apply(this, arguments) || this;
|
||||
}
|
||||
Object.defineProperty(NonscriptItem.prototype, "kind", {
|
||||
get: function () {
|
||||
return 'nonscript';
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
NonscriptItem.prototype.checkItem = function (item) {
|
||||
if (item.isKind('mml') && item.Size() === 1) {
|
||||
var mml = item.First;
|
||||
if (mml.isKind('mstyle') && mml.notParent) {
|
||||
mml = NodeUtil_js_1.default.getChildren(NodeUtil_js_1.default.getChildren(mml)[0])[0];
|
||||
}
|
||||
if (mml.isKind('mspace')) {
|
||||
if (mml !== item.First) {
|
||||
var mrow = this.create('node', 'mrow', [item.Pop()]);
|
||||
item.Push(mrow);
|
||||
}
|
||||
this.factory.configuration.addNode('nonscript', item.First);
|
||||
}
|
||||
}
|
||||
return [[item], true];
|
||||
};
|
||||
return NonscriptItem;
|
||||
}(StackItem_js_1.BaseItem));
|
||||
exports.NonscriptItem = NonscriptItem;
|
||||
var DotsItem = (function (_super) {
|
||||
__extends(DotsItem, _super);
|
||||
function DotsItem() {
|
||||
return _super !== null && _super.apply(this, arguments) || this;
|
||||
}
|
||||
Object.defineProperty(DotsItem.prototype, "kind", {
|
||||
get: function () {
|
||||
return 'dots';
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
DotsItem.prototype.checkItem = function (item) {
|
||||
if (item.isKind('open') || item.isKind('left')) {
|
||||
return StackItem_js_1.BaseItem.success;
|
||||
}
|
||||
var dots = this.getProperty('ldots');
|
||||
var top = item.First;
|
||||
if (item.isKind('mml') && NodeUtil_js_1.default.isEmbellished(top)) {
|
||||
var tclass = NodeUtil_js_1.default.getTexClass(NodeUtil_js_1.default.getCoreMO(top));
|
||||
if (tclass === MmlNode_js_1.TEXCLASS.BIN || tclass === MmlNode_js_1.TEXCLASS.REL) {
|
||||
dots = this.getProperty('cdots');
|
||||
}
|
||||
}
|
||||
return [[dots, item], true];
|
||||
};
|
||||
return DotsItem;
|
||||
}(StackItem_js_1.BaseItem));
|
||||
exports.DotsItem = DotsItem;
|
||||
var ArrayItem = (function (_super) {
|
||||
__extends(ArrayItem, _super);
|
||||
function ArrayItem() {
|
||||
var _this = _super !== null && _super.apply(this, arguments) || this;
|
||||
_this.table = [];
|
||||
_this.row = [];
|
||||
_this.frame = [];
|
||||
_this.hfill = [];
|
||||
_this.arraydef = {};
|
||||
_this.dashed = false;
|
||||
return _this;
|
||||
}
|
||||
Object.defineProperty(ArrayItem.prototype, "kind", {
|
||||
get: function () {
|
||||
return 'array';
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
Object.defineProperty(ArrayItem.prototype, "isOpen", {
|
||||
get: function () {
|
||||
return true;
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
Object.defineProperty(ArrayItem.prototype, "copyEnv", {
|
||||
get: function () {
|
||||
return false;
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
ArrayItem.prototype.checkItem = function (item) {
|
||||
if (item.isClose && !item.isKind('over')) {
|
||||
if (item.getProperty('isEntry')) {
|
||||
this.EndEntry();
|
||||
this.clearEnv();
|
||||
return StackItem_js_1.BaseItem.fail;
|
||||
}
|
||||
if (item.getProperty('isCR')) {
|
||||
this.EndEntry();
|
||||
this.EndRow();
|
||||
this.clearEnv();
|
||||
return StackItem_js_1.BaseItem.fail;
|
||||
}
|
||||
this.EndTable();
|
||||
this.clearEnv();
|
||||
var newItem = this.factory.create('mml', this.createMml());
|
||||
if (this.getProperty('requireClose')) {
|
||||
if (item.isKind('close')) {
|
||||
return [[newItem], true];
|
||||
}
|
||||
throw new TexError_js_1.default('MissingCloseBrace', 'Missing close brace');
|
||||
}
|
||||
return [[newItem, item], true];
|
||||
}
|
||||
return _super.prototype.checkItem.call(this, item);
|
||||
};
|
||||
ArrayItem.prototype.createMml = function () {
|
||||
var scriptlevel = this.arraydef['scriptlevel'];
|
||||
delete this.arraydef['scriptlevel'];
|
||||
var mml = this.create('node', 'mtable', this.table, this.arraydef);
|
||||
if (scriptlevel) {
|
||||
mml.setProperty('scriptlevel', scriptlevel);
|
||||
}
|
||||
if (this.frame.length === 4) {
|
||||
NodeUtil_js_1.default.setAttribute(mml, 'frame', this.dashed ? 'dashed' : 'solid');
|
||||
}
|
||||
else if (this.frame.length) {
|
||||
if (this.arraydef['rowlines']) {
|
||||
this.arraydef['rowlines'] =
|
||||
this.arraydef['rowlines'].replace(/none( none)+$/, 'none');
|
||||
}
|
||||
NodeUtil_js_1.default.setAttribute(mml, 'frame', '');
|
||||
mml = this.create('node', 'menclose', [mml], { notation: this.frame.join(' ') });
|
||||
if ((this.arraydef['columnlines'] || 'none') !== 'none' ||
|
||||
(this.arraydef['rowlines'] || 'none') !== 'none') {
|
||||
NodeUtil_js_1.default.setAttribute(mml, 'data-padding', 0);
|
||||
}
|
||||
}
|
||||
if (this.getProperty('open') || this.getProperty('close')) {
|
||||
mml = ParseUtil_js_1.default.fenced(this.factory.configuration, this.getProperty('open'), mml, this.getProperty('close'));
|
||||
}
|
||||
return mml;
|
||||
};
|
||||
ArrayItem.prototype.EndEntry = function () {
|
||||
var mtd = this.create('node', 'mtd', this.nodes);
|
||||
if (this.hfill.length) {
|
||||
if (this.hfill[0] === 0) {
|
||||
NodeUtil_js_1.default.setAttribute(mtd, 'columnalign', 'right');
|
||||
}
|
||||
if (this.hfill[this.hfill.length - 1] === this.Size()) {
|
||||
NodeUtil_js_1.default.setAttribute(mtd, 'columnalign', NodeUtil_js_1.default.getAttribute(mtd, 'columnalign') ? 'center' : 'left');
|
||||
}
|
||||
}
|
||||
this.row.push(mtd);
|
||||
this.Clear();
|
||||
this.hfill = [];
|
||||
};
|
||||
ArrayItem.prototype.EndRow = function () {
|
||||
var node;
|
||||
if (this.getProperty('isNumbered') && this.row.length === 3) {
|
||||
this.row.unshift(this.row.pop());
|
||||
node = this.create('node', 'mlabeledtr', this.row);
|
||||
}
|
||||
else {
|
||||
node = this.create('node', 'mtr', this.row);
|
||||
}
|
||||
this.table.push(node);
|
||||
this.row = [];
|
||||
};
|
||||
ArrayItem.prototype.EndTable = function () {
|
||||
if (this.Size() || this.row.length) {
|
||||
this.EndEntry();
|
||||
this.EndRow();
|
||||
}
|
||||
this.checkLines();
|
||||
};
|
||||
ArrayItem.prototype.checkLines = function () {
|
||||
if (this.arraydef['rowlines']) {
|
||||
var lines = this.arraydef['rowlines'].split(/ /);
|
||||
if (lines.length === this.table.length) {
|
||||
this.frame.push('bottom');
|
||||
lines.pop();
|
||||
this.arraydef['rowlines'] = lines.join(' ');
|
||||
}
|
||||
else if (lines.length < this.table.length - 1) {
|
||||
this.arraydef['rowlines'] += ' none';
|
||||
}
|
||||
}
|
||||
if (this.getProperty('rowspacing')) {
|
||||
var rows = this.arraydef['rowspacing'].split(/ /);
|
||||
while (rows.length < this.table.length) {
|
||||
rows.push(this.getProperty('rowspacing') + 'em');
|
||||
}
|
||||
this.arraydef['rowspacing'] = rows.join(' ');
|
||||
}
|
||||
};
|
||||
ArrayItem.prototype.addRowSpacing = function (spacing) {
|
||||
if (this.arraydef['rowspacing']) {
|
||||
var rows = this.arraydef['rowspacing'].split(/ /);
|
||||
if (!this.getProperty('rowspacing')) {
|
||||
var dimem = ParseUtil_js_1.default.dimen2em(rows[0]);
|
||||
this.setProperty('rowspacing', dimem);
|
||||
}
|
||||
var rowspacing = this.getProperty('rowspacing');
|
||||
while (rows.length < this.table.length) {
|
||||
rows.push(ParseUtil_js_1.default.Em(rowspacing));
|
||||
}
|
||||
rows[this.table.length - 1] = ParseUtil_js_1.default.Em(Math.max(0, rowspacing + ParseUtil_js_1.default.dimen2em(spacing)));
|
||||
this.arraydef['rowspacing'] = rows.join(' ');
|
||||
}
|
||||
};
|
||||
return ArrayItem;
|
||||
}(StackItem_js_1.BaseItem));
|
||||
exports.ArrayItem = ArrayItem;
|
||||
var EqnArrayItem = (function (_super) {
|
||||
__extends(EqnArrayItem, _super);
|
||||
function EqnArrayItem(factory) {
|
||||
var args = [];
|
||||
for (var _i = 1; _i < arguments.length; _i++) {
|
||||
args[_i - 1] = arguments[_i];
|
||||
}
|
||||
var _this = _super.call(this, factory) || this;
|
||||
_this.maxrow = 0;
|
||||
_this.factory.configuration.tags.start(args[0], args[2], args[1]);
|
||||
return _this;
|
||||
}
|
||||
Object.defineProperty(EqnArrayItem.prototype, "kind", {
|
||||
get: function () {
|
||||
return 'eqnarray';
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
EqnArrayItem.prototype.EndEntry = function () {
|
||||
if (this.row.length) {
|
||||
ParseUtil_js_1.default.fixInitialMO(this.factory.configuration, this.nodes);
|
||||
}
|
||||
var node = this.create('node', 'mtd', this.nodes);
|
||||
this.row.push(node);
|
||||
this.Clear();
|
||||
};
|
||||
EqnArrayItem.prototype.EndRow = function () {
|
||||
if (this.row.length > this.maxrow) {
|
||||
this.maxrow = this.row.length;
|
||||
}
|
||||
var mtr = 'mtr';
|
||||
var tag = this.factory.configuration.tags.getTag();
|
||||
if (tag) {
|
||||
this.row = [tag].concat(this.row);
|
||||
mtr = 'mlabeledtr';
|
||||
}
|
||||
this.factory.configuration.tags.clearTag();
|
||||
var node = this.create('node', mtr, this.row);
|
||||
this.table.push(node);
|
||||
this.row = [];
|
||||
};
|
||||
EqnArrayItem.prototype.EndTable = function () {
|
||||
_super.prototype.EndTable.call(this);
|
||||
this.factory.configuration.tags.end();
|
||||
this.extendArray('columnalign', this.maxrow);
|
||||
this.extendArray('columnwidth', this.maxrow);
|
||||
this.extendArray('columnspacing', this.maxrow - 1);
|
||||
};
|
||||
EqnArrayItem.prototype.extendArray = function (name, max) {
|
||||
if (!this.arraydef[name])
|
||||
return;
|
||||
var repeat = this.arraydef[name].split(/ /);
|
||||
var columns = __spreadArray([], __read(repeat), false);
|
||||
if (columns.length > 1) {
|
||||
while (columns.length < max) {
|
||||
columns.push.apply(columns, __spreadArray([], __read(repeat), false));
|
||||
}
|
||||
this.arraydef[name] = columns.slice(0, max).join(' ');
|
||||
}
|
||||
};
|
||||
return EqnArrayItem;
|
||||
}(ArrayItem));
|
||||
exports.EqnArrayItem = EqnArrayItem;
|
||||
var EquationItem = (function (_super) {
|
||||
__extends(EquationItem, _super);
|
||||
function EquationItem(factory) {
|
||||
var args = [];
|
||||
for (var _i = 1; _i < arguments.length; _i++) {
|
||||
args[_i - 1] = arguments[_i];
|
||||
}
|
||||
var _this = _super.call(this, factory) || this;
|
||||
_this.factory.configuration.tags.start('equation', true, args[0]);
|
||||
return _this;
|
||||
}
|
||||
Object.defineProperty(EquationItem.prototype, "kind", {
|
||||
get: function () {
|
||||
return 'equation';
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
Object.defineProperty(EquationItem.prototype, "isOpen", {
|
||||
get: function () {
|
||||
return true;
|
||||
},
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
EquationItem.prototype.checkItem = function (item) {
|
||||
if (item.isKind('end')) {
|
||||
var mml = this.toMml();
|
||||
var tag = this.factory.configuration.tags.getTag();
|
||||
this.factory.configuration.tags.end();
|
||||
return [[tag ? this.factory.configuration.tags.enTag(mml, tag) : mml, item], true];
|
||||
}
|
||||
if (item.isKind('stop')) {
|
||||
throw new TexError_js_1.default('EnvMissingEnd', 'Missing \\end{%1}', this.getName());
|
||||
}
|
||||
return _super.prototype.checkItem.call(this, item);
|
||||
};
|
||||
return EquationItem;
|
||||
}(StackItem_js_1.BaseItem));
|
||||
exports.EquationItem = EquationItem;
|
||||
//# sourceMappingURL=BaseItems.js.map
|
||||
1
node_modules/mathjax-full/js/input/tex/base/BaseItems.js.map
generated
vendored
Normal file
1
node_modules/mathjax-full/js/input/tex/base/BaseItems.js.map
generated
vendored
Normal file
File diff suppressed because one or more lines are too long
1
node_modules/mathjax-full/js/input/tex/base/BaseMappings.d.ts
generated
vendored
Normal file
1
node_modules/mathjax-full/js/input/tex/base/BaseMappings.d.ts
generated
vendored
Normal file
@@ -0,0 +1 @@
|
||||
export {};
|
||||
652
node_modules/mathjax-full/js/input/tex/base/BaseMappings.js
generated
vendored
Normal file
652
node_modules/mathjax-full/js/input/tex/base/BaseMappings.js
generated
vendored
Normal file
@@ -0,0 +1,652 @@
|
||||
"use strict";
|
||||
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
|
||||
if (k2 === undefined) k2 = k;
|
||||
var desc = Object.getOwnPropertyDescriptor(m, k);
|
||||
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
|
||||
desc = { enumerable: true, get: function() { return m[k]; } };
|
||||
}
|
||||
Object.defineProperty(o, k2, desc);
|
||||
}) : (function(o, m, k, k2) {
|
||||
if (k2 === undefined) k2 = k;
|
||||
o[k2] = m[k];
|
||||
}));
|
||||
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
|
||||
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
||||
}) : function(o, v) {
|
||||
o["default"] = v;
|
||||
});
|
||||
var __importStar = (this && this.__importStar) || function (mod) {
|
||||
if (mod && mod.__esModule) return mod;
|
||||
var result = {};
|
||||
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
|
||||
__setModuleDefault(result, mod);
|
||||
return result;
|
||||
};
|
||||
var __importDefault = (this && this.__importDefault) || function (mod) {
|
||||
return (mod && mod.__esModule) ? mod : { "default": mod };
|
||||
};
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
var sm = __importStar(require("../SymbolMap.js"));
|
||||
var TexConstants_js_1 = require("../TexConstants.js");
|
||||
var BaseMethods_js_1 = __importDefault(require("./BaseMethods.js"));
|
||||
var ParseMethods_js_1 = __importDefault(require("../ParseMethods.js"));
|
||||
var ParseUtil_js_1 = __importDefault(require("../ParseUtil.js"));
|
||||
var MmlNode_js_1 = require("../../../core/MmlTree/MmlNode.js");
|
||||
var lengths_js_1 = require("../../../util/lengths.js");
|
||||
new sm.RegExpMap('letter', ParseMethods_js_1.default.variable, /[a-z]/i);
|
||||
new sm.RegExpMap('digit', ParseMethods_js_1.default.digit, /[0-9.,]/);
|
||||
new sm.RegExpMap('command', ParseMethods_js_1.default.controlSequence, /^\\/);
|
||||
new sm.MacroMap('special', {
|
||||
'{': 'Open',
|
||||
'}': 'Close',
|
||||
'~': 'Tilde',
|
||||
'^': 'Superscript',
|
||||
'_': 'Subscript',
|
||||
' ': 'Space',
|
||||
'\t': 'Space',
|
||||
'\r': 'Space',
|
||||
'\n': 'Space',
|
||||
'\'': 'Prime',
|
||||
'%': 'Comment',
|
||||
'&': 'Entry',
|
||||
'#': 'Hash',
|
||||
'\u00A0': 'Space',
|
||||
'\u2019': 'Prime'
|
||||
}, BaseMethods_js_1.default);
|
||||
new sm.CharacterMap('mathchar0mi', ParseMethods_js_1.default.mathchar0mi, {
|
||||
alpha: '\u03B1',
|
||||
beta: '\u03B2',
|
||||
gamma: '\u03B3',
|
||||
delta: '\u03B4',
|
||||
epsilon: '\u03F5',
|
||||
zeta: '\u03B6',
|
||||
eta: '\u03B7',
|
||||
theta: '\u03B8',
|
||||
iota: '\u03B9',
|
||||
kappa: '\u03BA',
|
||||
lambda: '\u03BB',
|
||||
mu: '\u03BC',
|
||||
nu: '\u03BD',
|
||||
xi: '\u03BE',
|
||||
omicron: '\u03BF',
|
||||
pi: '\u03C0',
|
||||
rho: '\u03C1',
|
||||
sigma: '\u03C3',
|
||||
tau: '\u03C4',
|
||||
upsilon: '\u03C5',
|
||||
phi: '\u03D5',
|
||||
chi: '\u03C7',
|
||||
psi: '\u03C8',
|
||||
omega: '\u03C9',
|
||||
varepsilon: '\u03B5',
|
||||
vartheta: '\u03D1',
|
||||
varpi: '\u03D6',
|
||||
varrho: '\u03F1',
|
||||
varsigma: '\u03C2',
|
||||
varphi: '\u03C6',
|
||||
S: ['\u00A7', { mathvariant: TexConstants_js_1.TexConstant.Variant.NORMAL }],
|
||||
aleph: ['\u2135', { mathvariant: TexConstants_js_1.TexConstant.Variant.NORMAL }],
|
||||
hbar: ['\u210F', { variantForm: true }],
|
||||
imath: '\u0131',
|
||||
jmath: '\u0237',
|
||||
ell: '\u2113',
|
||||
wp: ['\u2118', { mathvariant: TexConstants_js_1.TexConstant.Variant.NORMAL }],
|
||||
Re: ['\u211C', { mathvariant: TexConstants_js_1.TexConstant.Variant.NORMAL }],
|
||||
Im: ['\u2111', { mathvariant: TexConstants_js_1.TexConstant.Variant.NORMAL }],
|
||||
partial: ['\u2202', { mathvariant: TexConstants_js_1.TexConstant.Variant.ITALIC }],
|
||||
infty: ['\u221E', { mathvariant: TexConstants_js_1.TexConstant.Variant.NORMAL }],
|
||||
prime: ['\u2032', { variantForm: true }],
|
||||
emptyset: ['\u2205', { mathvariant: TexConstants_js_1.TexConstant.Variant.NORMAL }],
|
||||
nabla: ['\u2207', { mathvariant: TexConstants_js_1.TexConstant.Variant.NORMAL }],
|
||||
top: ['\u22A4', { mathvariant: TexConstants_js_1.TexConstant.Variant.NORMAL }],
|
||||
bot: ['\u22A5', { mathvariant: TexConstants_js_1.TexConstant.Variant.NORMAL }],
|
||||
angle: ['\u2220', { mathvariant: TexConstants_js_1.TexConstant.Variant.NORMAL }],
|
||||
triangle: ['\u25B3', { mathvariant: TexConstants_js_1.TexConstant.Variant.NORMAL }],
|
||||
backslash: ['\u2216', { mathvariant: TexConstants_js_1.TexConstant.Variant.NORMAL }],
|
||||
forall: ['\u2200', { mathvariant: TexConstants_js_1.TexConstant.Variant.NORMAL }],
|
||||
exists: ['\u2203', { mathvariant: TexConstants_js_1.TexConstant.Variant.NORMAL }],
|
||||
neg: ['\u00AC', { mathvariant: TexConstants_js_1.TexConstant.Variant.NORMAL }],
|
||||
lnot: ['\u00AC', { mathvariant: TexConstants_js_1.TexConstant.Variant.NORMAL }],
|
||||
flat: ['\u266D', { mathvariant: TexConstants_js_1.TexConstant.Variant.NORMAL }],
|
||||
natural: ['\u266E', { mathvariant: TexConstants_js_1.TexConstant.Variant.NORMAL }],
|
||||
sharp: ['\u266F', { mathvariant: TexConstants_js_1.TexConstant.Variant.NORMAL }],
|
||||
clubsuit: ['\u2663', { mathvariant: TexConstants_js_1.TexConstant.Variant.NORMAL }],
|
||||
diamondsuit: ['\u2662', { mathvariant: TexConstants_js_1.TexConstant.Variant.NORMAL }],
|
||||
heartsuit: ['\u2661', { mathvariant: TexConstants_js_1.TexConstant.Variant.NORMAL }],
|
||||
spadesuit: ['\u2660', { mathvariant: TexConstants_js_1.TexConstant.Variant.NORMAL }]
|
||||
});
|
||||
new sm.CharacterMap('mathchar0mo', ParseMethods_js_1.default.mathchar0mo, {
|
||||
surd: '\u221A',
|
||||
coprod: ['\u2210', { texClass: MmlNode_js_1.TEXCLASS.OP,
|
||||
movesupsub: true }],
|
||||
bigvee: ['\u22C1', { texClass: MmlNode_js_1.TEXCLASS.OP,
|
||||
movesupsub: true }],
|
||||
bigwedge: ['\u22C0', { texClass: MmlNode_js_1.TEXCLASS.OP,
|
||||
movesupsub: true }],
|
||||
biguplus: ['\u2A04', { texClass: MmlNode_js_1.TEXCLASS.OP,
|
||||
movesupsub: true }],
|
||||
bigcap: ['\u22C2', { texClass: MmlNode_js_1.TEXCLASS.OP,
|
||||
movesupsub: true }],
|
||||
bigcup: ['\u22C3', { texClass: MmlNode_js_1.TEXCLASS.OP,
|
||||
movesupsub: true }],
|
||||
'int': ['\u222B', { texClass: MmlNode_js_1.TEXCLASS.OP }],
|
||||
intop: ['\u222B', { texClass: MmlNode_js_1.TEXCLASS.OP,
|
||||
movesupsub: true, movablelimits: true }],
|
||||
iint: ['\u222C', { texClass: MmlNode_js_1.TEXCLASS.OP }],
|
||||
iiint: ['\u222D', { texClass: MmlNode_js_1.TEXCLASS.OP }],
|
||||
prod: ['\u220F', { texClass: MmlNode_js_1.TEXCLASS.OP,
|
||||
movesupsub: true }],
|
||||
sum: ['\u2211', { texClass: MmlNode_js_1.TEXCLASS.OP,
|
||||
movesupsub: true }],
|
||||
bigotimes: ['\u2A02', { texClass: MmlNode_js_1.TEXCLASS.OP,
|
||||
movesupsub: true }],
|
||||
bigoplus: ['\u2A01', { texClass: MmlNode_js_1.TEXCLASS.OP,
|
||||
movesupsub: true }],
|
||||
bigodot: ['\u2A00', { texClass: MmlNode_js_1.TEXCLASS.OP,
|
||||
movesupsub: true }],
|
||||
oint: ['\u222E', { texClass: MmlNode_js_1.TEXCLASS.OP }],
|
||||
bigsqcup: ['\u2A06', { texClass: MmlNode_js_1.TEXCLASS.OP,
|
||||
movesupsub: true }],
|
||||
smallint: ['\u222B', { largeop: false }],
|
||||
triangleleft: '\u25C3',
|
||||
triangleright: '\u25B9',
|
||||
bigtriangleup: '\u25B3',
|
||||
bigtriangledown: '\u25BD',
|
||||
wedge: '\u2227',
|
||||
land: '\u2227',
|
||||
vee: '\u2228',
|
||||
lor: '\u2228',
|
||||
cap: '\u2229',
|
||||
cup: '\u222A',
|
||||
ddagger: '\u2021',
|
||||
dagger: '\u2020',
|
||||
sqcap: '\u2293',
|
||||
sqcup: '\u2294',
|
||||
uplus: '\u228E',
|
||||
amalg: '\u2A3F',
|
||||
diamond: '\u22C4',
|
||||
bullet: '\u2219',
|
||||
wr: '\u2240',
|
||||
div: '\u00F7',
|
||||
divsymbol: '\u00F7',
|
||||
odot: ['\u2299', { largeop: false }],
|
||||
oslash: ['\u2298', { largeop: false }],
|
||||
otimes: ['\u2297', { largeop: false }],
|
||||
ominus: ['\u2296', { largeop: false }],
|
||||
oplus: ['\u2295', { largeop: false }],
|
||||
mp: '\u2213',
|
||||
pm: '\u00B1',
|
||||
circ: '\u2218',
|
||||
bigcirc: '\u25EF',
|
||||
setminus: '\u2216',
|
||||
cdot: '\u22C5',
|
||||
ast: '\u2217',
|
||||
times: '\u00D7',
|
||||
star: '\u22C6',
|
||||
propto: '\u221D',
|
||||
sqsubseteq: '\u2291',
|
||||
sqsupseteq: '\u2292',
|
||||
parallel: '\u2225',
|
||||
mid: '\u2223',
|
||||
dashv: '\u22A3',
|
||||
vdash: '\u22A2',
|
||||
leq: '\u2264',
|
||||
le: '\u2264',
|
||||
geq: '\u2265',
|
||||
ge: '\u2265',
|
||||
lt: '\u003C',
|
||||
gt: '\u003E',
|
||||
succ: '\u227B',
|
||||
prec: '\u227A',
|
||||
approx: '\u2248',
|
||||
succeq: '\u2AB0',
|
||||
preceq: '\u2AAF',
|
||||
supset: '\u2283',
|
||||
subset: '\u2282',
|
||||
supseteq: '\u2287',
|
||||
subseteq: '\u2286',
|
||||
'in': '\u2208',
|
||||
ni: '\u220B',
|
||||
notin: '\u2209',
|
||||
owns: '\u220B',
|
||||
gg: '\u226B',
|
||||
ll: '\u226A',
|
||||
sim: '\u223C',
|
||||
simeq: '\u2243',
|
||||
perp: '\u22A5',
|
||||
equiv: '\u2261',
|
||||
asymp: '\u224D',
|
||||
smile: '\u2323',
|
||||
frown: '\u2322',
|
||||
ne: '\u2260',
|
||||
neq: '\u2260',
|
||||
cong: '\u2245',
|
||||
doteq: '\u2250',
|
||||
bowtie: '\u22C8',
|
||||
models: '\u22A8',
|
||||
notChar: '\u29F8',
|
||||
Leftrightarrow: '\u21D4',
|
||||
Leftarrow: '\u21D0',
|
||||
Rightarrow: '\u21D2',
|
||||
leftrightarrow: '\u2194',
|
||||
leftarrow: '\u2190',
|
||||
gets: '\u2190',
|
||||
rightarrow: '\u2192',
|
||||
to: ['\u2192', { accent: false }],
|
||||
mapsto: '\u21A6',
|
||||
leftharpoonup: '\u21BC',
|
||||
leftharpoondown: '\u21BD',
|
||||
rightharpoonup: '\u21C0',
|
||||
rightharpoondown: '\u21C1',
|
||||
nearrow: '\u2197',
|
||||
searrow: '\u2198',
|
||||
nwarrow: '\u2196',
|
||||
swarrow: '\u2199',
|
||||
rightleftharpoons: '\u21CC',
|
||||
hookrightarrow: '\u21AA',
|
||||
hookleftarrow: '\u21A9',
|
||||
longleftarrow: '\u27F5',
|
||||
Longleftarrow: '\u27F8',
|
||||
longrightarrow: '\u27F6',
|
||||
Longrightarrow: '\u27F9',
|
||||
Longleftrightarrow: '\u27FA',
|
||||
longleftrightarrow: '\u27F7',
|
||||
longmapsto: '\u27FC',
|
||||
ldots: '\u2026',
|
||||
cdots: '\u22EF',
|
||||
vdots: '\u22EE',
|
||||
ddots: '\u22F1',
|
||||
dotsc: '\u2026',
|
||||
dotsb: '\u22EF',
|
||||
dotsm: '\u22EF',
|
||||
dotsi: '\u22EF',
|
||||
dotso: '\u2026',
|
||||
ldotp: ['\u002E', { texClass: MmlNode_js_1.TEXCLASS.PUNCT }],
|
||||
cdotp: ['\u22C5', { texClass: MmlNode_js_1.TEXCLASS.PUNCT }],
|
||||
colon: ['\u003A', { texClass: MmlNode_js_1.TEXCLASS.PUNCT }]
|
||||
});
|
||||
new sm.CharacterMap('mathchar7', ParseMethods_js_1.default.mathchar7, {
|
||||
Gamma: '\u0393',
|
||||
Delta: '\u0394',
|
||||
Theta: '\u0398',
|
||||
Lambda: '\u039B',
|
||||
Xi: '\u039E',
|
||||
Pi: '\u03A0',
|
||||
Sigma: '\u03A3',
|
||||
Upsilon: '\u03A5',
|
||||
Phi: '\u03A6',
|
||||
Psi: '\u03A8',
|
||||
Omega: '\u03A9',
|
||||
'_': '\u005F',
|
||||
'#': '\u0023',
|
||||
'$': '\u0024',
|
||||
'%': '\u0025',
|
||||
'&': '\u0026',
|
||||
And: '\u0026'
|
||||
});
|
||||
new sm.DelimiterMap('delimiter', ParseMethods_js_1.default.delimiter, {
|
||||
'(': '(',
|
||||
')': ')',
|
||||
'[': '[',
|
||||
']': ']',
|
||||
'<': '\u27E8',
|
||||
'>': '\u27E9',
|
||||
'\\lt': '\u27E8',
|
||||
'\\gt': '\u27E9',
|
||||
'/': '/',
|
||||
'|': ['|', { texClass: MmlNode_js_1.TEXCLASS.ORD }],
|
||||
'.': '',
|
||||
'\\\\': '\\',
|
||||
'\\lmoustache': '\u23B0',
|
||||
'\\rmoustache': '\u23B1',
|
||||
'\\lgroup': '\u27EE',
|
||||
'\\rgroup': '\u27EF',
|
||||
'\\arrowvert': '\u23D0',
|
||||
'\\Arrowvert': '\u2016',
|
||||
'\\bracevert': '\u23AA',
|
||||
'\\Vert': ['\u2016', { texClass: MmlNode_js_1.TEXCLASS.ORD }],
|
||||
'\\|': ['\u2016', { texClass: MmlNode_js_1.TEXCLASS.ORD }],
|
||||
'\\vert': ['|', { texClass: MmlNode_js_1.TEXCLASS.ORD }],
|
||||
'\\uparrow': '\u2191',
|
||||
'\\downarrow': '\u2193',
|
||||
'\\updownarrow': '\u2195',
|
||||
'\\Uparrow': '\u21D1',
|
||||
'\\Downarrow': '\u21D3',
|
||||
'\\Updownarrow': '\u21D5',
|
||||
'\\backslash': '\\',
|
||||
'\\rangle': '\u27E9',
|
||||
'\\langle': '\u27E8',
|
||||
'\\rbrace': '}',
|
||||
'\\lbrace': '{',
|
||||
'\\}': '}',
|
||||
'\\{': '{',
|
||||
'\\rceil': '\u2309',
|
||||
'\\lceil': '\u2308',
|
||||
'\\rfloor': '\u230B',
|
||||
'\\lfloor': '\u230A',
|
||||
'\\lbrack': '[',
|
||||
'\\rbrack': ']'
|
||||
});
|
||||
new sm.CommandMap('macros', {
|
||||
displaystyle: ['SetStyle', 'D', true, 0],
|
||||
textstyle: ['SetStyle', 'T', false, 0],
|
||||
scriptstyle: ['SetStyle', 'S', false, 1],
|
||||
scriptscriptstyle: ['SetStyle', 'SS', false, 2],
|
||||
rm: ['SetFont', TexConstants_js_1.TexConstant.Variant.NORMAL],
|
||||
mit: ['SetFont', TexConstants_js_1.TexConstant.Variant.ITALIC],
|
||||
oldstyle: ['SetFont', TexConstants_js_1.TexConstant.Variant.OLDSTYLE],
|
||||
cal: ['SetFont', TexConstants_js_1.TexConstant.Variant.CALLIGRAPHIC],
|
||||
it: ['SetFont', TexConstants_js_1.TexConstant.Variant.MATHITALIC],
|
||||
bf: ['SetFont', TexConstants_js_1.TexConstant.Variant.BOLD],
|
||||
bbFont: ['SetFont', TexConstants_js_1.TexConstant.Variant.DOUBLESTRUCK],
|
||||
scr: ['SetFont', TexConstants_js_1.TexConstant.Variant.SCRIPT],
|
||||
frak: ['SetFont', TexConstants_js_1.TexConstant.Variant.FRAKTUR],
|
||||
sf: ['SetFont', TexConstants_js_1.TexConstant.Variant.SANSSERIF],
|
||||
tt: ['SetFont', TexConstants_js_1.TexConstant.Variant.MONOSPACE],
|
||||
mathrm: ['MathFont', TexConstants_js_1.TexConstant.Variant.NORMAL],
|
||||
mathup: ['MathFont', TexConstants_js_1.TexConstant.Variant.NORMAL],
|
||||
mathnormal: ['MathFont', ''],
|
||||
mathbf: ['MathFont', TexConstants_js_1.TexConstant.Variant.BOLD],
|
||||
mathbfup: ['MathFont', TexConstants_js_1.TexConstant.Variant.BOLD],
|
||||
mathit: ['MathFont', TexConstants_js_1.TexConstant.Variant.MATHITALIC],
|
||||
mathbfit: ['MathFont', TexConstants_js_1.TexConstant.Variant.BOLDITALIC],
|
||||
mathbb: ['MathFont', TexConstants_js_1.TexConstant.Variant.DOUBLESTRUCK],
|
||||
Bbb: ['MathFont', TexConstants_js_1.TexConstant.Variant.DOUBLESTRUCK],
|
||||
mathfrak: ['MathFont', TexConstants_js_1.TexConstant.Variant.FRAKTUR],
|
||||
mathbffrak: ['MathFont', TexConstants_js_1.TexConstant.Variant.BOLDFRAKTUR],
|
||||
mathscr: ['MathFont', TexConstants_js_1.TexConstant.Variant.SCRIPT],
|
||||
mathbfscr: ['MathFont', TexConstants_js_1.TexConstant.Variant.BOLDSCRIPT],
|
||||
mathsf: ['MathFont', TexConstants_js_1.TexConstant.Variant.SANSSERIF],
|
||||
mathsfup: ['MathFont', TexConstants_js_1.TexConstant.Variant.SANSSERIF],
|
||||
mathbfsf: ['MathFont', TexConstants_js_1.TexConstant.Variant.BOLDSANSSERIF],
|
||||
mathbfsfup: ['MathFont', TexConstants_js_1.TexConstant.Variant.BOLDSANSSERIF],
|
||||
mathsfit: ['MathFont', TexConstants_js_1.TexConstant.Variant.SANSSERIFITALIC],
|
||||
mathbfsfit: ['MathFont', TexConstants_js_1.TexConstant.Variant.SANSSERIFBOLDITALIC],
|
||||
mathtt: ['MathFont', TexConstants_js_1.TexConstant.Variant.MONOSPACE],
|
||||
mathcal: ['MathFont', TexConstants_js_1.TexConstant.Variant.CALLIGRAPHIC],
|
||||
mathbfcal: ['MathFont', TexConstants_js_1.TexConstant.Variant.BOLDCALLIGRAPHIC],
|
||||
symrm: ['MathFont', TexConstants_js_1.TexConstant.Variant.NORMAL],
|
||||
symup: ['MathFont', TexConstants_js_1.TexConstant.Variant.NORMAL],
|
||||
symnormal: ['MathFont', ''],
|
||||
symbf: ['MathFont', TexConstants_js_1.TexConstant.Variant.BOLD],
|
||||
symbfup: ['MathFont', TexConstants_js_1.TexConstant.Variant.BOLD],
|
||||
symit: ['MathFont', TexConstants_js_1.TexConstant.Variant.ITALIC],
|
||||
symbfit: ['MathFont', TexConstants_js_1.TexConstant.Variant.BOLDITALIC],
|
||||
symbb: ['MathFont', TexConstants_js_1.TexConstant.Variant.DOUBLESTRUCK],
|
||||
symfrak: ['MathFont', TexConstants_js_1.TexConstant.Variant.FRAKTUR],
|
||||
symbffrak: ['MathFont', TexConstants_js_1.TexConstant.Variant.BOLDFRAKTUR],
|
||||
symscr: ['MathFont', TexConstants_js_1.TexConstant.Variant.SCRIPT],
|
||||
symbfscr: ['MathFont', TexConstants_js_1.TexConstant.Variant.BOLDSCRIPT],
|
||||
symsf: ['MathFont', TexConstants_js_1.TexConstant.Variant.SANSSERIF],
|
||||
symsfup: ['MathFont', TexConstants_js_1.TexConstant.Variant.SANSSERIF],
|
||||
symbfsf: ['MathFont', TexConstants_js_1.TexConstant.Variant.BOLDSANSSERIF],
|
||||
symbfsfup: ['MathFont', TexConstants_js_1.TexConstant.Variant.BOLDSANSSERIF],
|
||||
symsfit: ['MathFont', TexConstants_js_1.TexConstant.Variant.SANSSERIFITALIC],
|
||||
symbfsfit: ['MathFont', TexConstants_js_1.TexConstant.Variant.SANSSERIFBOLDITALIC],
|
||||
symtt: ['MathFont', TexConstants_js_1.TexConstant.Variant.MONOSPACE],
|
||||
symcal: ['MathFont', TexConstants_js_1.TexConstant.Variant.CALLIGRAPHIC],
|
||||
symbfcal: ['MathFont', TexConstants_js_1.TexConstant.Variant.BOLDCALLIGRAPHIC],
|
||||
textrm: ['HBox', null, TexConstants_js_1.TexConstant.Variant.NORMAL],
|
||||
textup: ['HBox', null, TexConstants_js_1.TexConstant.Variant.NORMAL],
|
||||
textnormal: ['HBox'],
|
||||
textit: ['HBox', null, TexConstants_js_1.TexConstant.Variant.ITALIC],
|
||||
textbf: ['HBox', null, TexConstants_js_1.TexConstant.Variant.BOLD],
|
||||
textsf: ['HBox', null, TexConstants_js_1.TexConstant.Variant.SANSSERIF],
|
||||
texttt: ['HBox', null, TexConstants_js_1.TexConstant.Variant.MONOSPACE],
|
||||
tiny: ['SetSize', 0.5],
|
||||
Tiny: ['SetSize', 0.6],
|
||||
scriptsize: ['SetSize', 0.7],
|
||||
small: ['SetSize', 0.85],
|
||||
normalsize: ['SetSize', 1.0],
|
||||
large: ['SetSize', 1.2],
|
||||
Large: ['SetSize', 1.44],
|
||||
LARGE: ['SetSize', 1.73],
|
||||
huge: ['SetSize', 2.07],
|
||||
Huge: ['SetSize', 2.49],
|
||||
arcsin: 'NamedFn',
|
||||
arccos: 'NamedFn',
|
||||
arctan: 'NamedFn',
|
||||
arg: 'NamedFn',
|
||||
cos: 'NamedFn',
|
||||
cosh: 'NamedFn',
|
||||
cot: 'NamedFn',
|
||||
coth: 'NamedFn',
|
||||
csc: 'NamedFn',
|
||||
deg: 'NamedFn',
|
||||
det: 'NamedOp',
|
||||
dim: 'NamedFn',
|
||||
exp: 'NamedFn',
|
||||
gcd: 'NamedOp',
|
||||
hom: 'NamedFn',
|
||||
inf: 'NamedOp',
|
||||
ker: 'NamedFn',
|
||||
lg: 'NamedFn',
|
||||
lim: 'NamedOp',
|
||||
liminf: ['NamedOp', 'lim inf'],
|
||||
limsup: ['NamedOp', 'lim sup'],
|
||||
ln: 'NamedFn',
|
||||
log: 'NamedFn',
|
||||
max: 'NamedOp',
|
||||
min: 'NamedOp',
|
||||
Pr: 'NamedOp',
|
||||
sec: 'NamedFn',
|
||||
sin: 'NamedFn',
|
||||
sinh: 'NamedFn',
|
||||
sup: 'NamedOp',
|
||||
tan: 'NamedFn',
|
||||
tanh: 'NamedFn',
|
||||
limits: ['Limits', 1],
|
||||
nolimits: ['Limits', 0],
|
||||
overline: ['UnderOver', '2015'],
|
||||
underline: ['UnderOver', '2015'],
|
||||
overbrace: ['UnderOver', '23DE', 1],
|
||||
underbrace: ['UnderOver', '23DF', 1],
|
||||
overparen: ['UnderOver', '23DC'],
|
||||
underparen: ['UnderOver', '23DD'],
|
||||
overrightarrow: ['UnderOver', '2192'],
|
||||
underrightarrow: ['UnderOver', '2192'],
|
||||
overleftarrow: ['UnderOver', '2190'],
|
||||
underleftarrow: ['UnderOver', '2190'],
|
||||
overleftrightarrow: ['UnderOver', '2194'],
|
||||
underleftrightarrow: ['UnderOver', '2194'],
|
||||
overset: 'Overset',
|
||||
underset: 'Underset',
|
||||
overunderset: 'Overunderset',
|
||||
stackrel: ['Macro', '\\mathrel{\\mathop{#2}\\limits^{#1}}', 2],
|
||||
stackbin: ['Macro', '\\mathbin{\\mathop{#2}\\limits^{#1}}', 2],
|
||||
over: 'Over',
|
||||
overwithdelims: 'Over',
|
||||
atop: 'Over',
|
||||
atopwithdelims: 'Over',
|
||||
above: 'Over',
|
||||
abovewithdelims: 'Over',
|
||||
brace: ['Over', '{', '}'],
|
||||
brack: ['Over', '[', ']'],
|
||||
choose: ['Over', '(', ')'],
|
||||
frac: 'Frac',
|
||||
sqrt: 'Sqrt',
|
||||
root: 'Root',
|
||||
uproot: ['MoveRoot', 'upRoot'],
|
||||
leftroot: ['MoveRoot', 'leftRoot'],
|
||||
left: 'LeftRight',
|
||||
right: 'LeftRight',
|
||||
middle: 'LeftRight',
|
||||
llap: 'Lap',
|
||||
rlap: 'Lap',
|
||||
raise: 'RaiseLower',
|
||||
lower: 'RaiseLower',
|
||||
moveleft: 'MoveLeftRight',
|
||||
moveright: 'MoveLeftRight',
|
||||
',': ['Spacer', lengths_js_1.MATHSPACE.thinmathspace],
|
||||
':': ['Spacer', lengths_js_1.MATHSPACE.mediummathspace],
|
||||
'>': ['Spacer', lengths_js_1.MATHSPACE.mediummathspace],
|
||||
';': ['Spacer', lengths_js_1.MATHSPACE.thickmathspace],
|
||||
'!': ['Spacer', lengths_js_1.MATHSPACE.negativethinmathspace],
|
||||
enspace: ['Spacer', .5],
|
||||
quad: ['Spacer', 1],
|
||||
qquad: ['Spacer', 2],
|
||||
thinspace: ['Spacer', lengths_js_1.MATHSPACE.thinmathspace],
|
||||
negthinspace: ['Spacer', lengths_js_1.MATHSPACE.negativethinmathspace],
|
||||
hskip: 'Hskip',
|
||||
hspace: 'Hskip',
|
||||
kern: 'Hskip',
|
||||
mskip: 'Hskip',
|
||||
mspace: 'Hskip',
|
||||
mkern: 'Hskip',
|
||||
rule: 'rule',
|
||||
Rule: ['Rule'],
|
||||
Space: ['Rule', 'blank'],
|
||||
nonscript: 'Nonscript',
|
||||
big: ['MakeBig', MmlNode_js_1.TEXCLASS.ORD, 0.85],
|
||||
Big: ['MakeBig', MmlNode_js_1.TEXCLASS.ORD, 1.15],
|
||||
bigg: ['MakeBig', MmlNode_js_1.TEXCLASS.ORD, 1.45],
|
||||
Bigg: ['MakeBig', MmlNode_js_1.TEXCLASS.ORD, 1.75],
|
||||
bigl: ['MakeBig', MmlNode_js_1.TEXCLASS.OPEN, 0.85],
|
||||
Bigl: ['MakeBig', MmlNode_js_1.TEXCLASS.OPEN, 1.15],
|
||||
biggl: ['MakeBig', MmlNode_js_1.TEXCLASS.OPEN, 1.45],
|
||||
Biggl: ['MakeBig', MmlNode_js_1.TEXCLASS.OPEN, 1.75],
|
||||
bigr: ['MakeBig', MmlNode_js_1.TEXCLASS.CLOSE, 0.85],
|
||||
Bigr: ['MakeBig', MmlNode_js_1.TEXCLASS.CLOSE, 1.15],
|
||||
biggr: ['MakeBig', MmlNode_js_1.TEXCLASS.CLOSE, 1.45],
|
||||
Biggr: ['MakeBig', MmlNode_js_1.TEXCLASS.CLOSE, 1.75],
|
||||
bigm: ['MakeBig', MmlNode_js_1.TEXCLASS.REL, 0.85],
|
||||
Bigm: ['MakeBig', MmlNode_js_1.TEXCLASS.REL, 1.15],
|
||||
biggm: ['MakeBig', MmlNode_js_1.TEXCLASS.REL, 1.45],
|
||||
Biggm: ['MakeBig', MmlNode_js_1.TEXCLASS.REL, 1.75],
|
||||
mathord: ['TeXAtom', MmlNode_js_1.TEXCLASS.ORD],
|
||||
mathop: ['TeXAtom', MmlNode_js_1.TEXCLASS.OP],
|
||||
mathopen: ['TeXAtom', MmlNode_js_1.TEXCLASS.OPEN],
|
||||
mathclose: ['TeXAtom', MmlNode_js_1.TEXCLASS.CLOSE],
|
||||
mathbin: ['TeXAtom', MmlNode_js_1.TEXCLASS.BIN],
|
||||
mathrel: ['TeXAtom', MmlNode_js_1.TEXCLASS.REL],
|
||||
mathpunct: ['TeXAtom', MmlNode_js_1.TEXCLASS.PUNCT],
|
||||
mathinner: ['TeXAtom', MmlNode_js_1.TEXCLASS.INNER],
|
||||
vcenter: ['TeXAtom', MmlNode_js_1.TEXCLASS.VCENTER],
|
||||
buildrel: 'BuildRel',
|
||||
hbox: ['HBox', 0],
|
||||
text: 'HBox',
|
||||
mbox: ['HBox', 0],
|
||||
fbox: 'FBox',
|
||||
boxed: ['Macro', '\\fbox{$\\displaystyle{#1}$}', 1],
|
||||
framebox: 'FrameBox',
|
||||
strut: 'Strut',
|
||||
mathstrut: ['Macro', '\\vphantom{(}'],
|
||||
phantom: 'Phantom',
|
||||
vphantom: ['Phantom', 1, 0],
|
||||
hphantom: ['Phantom', 0, 1],
|
||||
smash: 'Smash',
|
||||
acute: ['Accent', '00B4'],
|
||||
grave: ['Accent', '0060'],
|
||||
ddot: ['Accent', '00A8'],
|
||||
tilde: ['Accent', '007E'],
|
||||
bar: ['Accent', '00AF'],
|
||||
breve: ['Accent', '02D8'],
|
||||
check: ['Accent', '02C7'],
|
||||
hat: ['Accent', '005E'],
|
||||
vec: ['Accent', '2192'],
|
||||
dot: ['Accent', '02D9'],
|
||||
widetilde: ['Accent', '007E', 1],
|
||||
widehat: ['Accent', '005E', 1],
|
||||
matrix: 'Matrix',
|
||||
array: 'Matrix',
|
||||
pmatrix: ['Matrix', '(', ')'],
|
||||
cases: ['Matrix', '{', '', 'left left', null, '.1em', null,
|
||||
true],
|
||||
eqalign: ['Matrix', null, null, 'right left',
|
||||
(0, lengths_js_1.em)(lengths_js_1.MATHSPACE.thickmathspace), '.5em', 'D'],
|
||||
displaylines: ['Matrix', null, null, 'center', null, '.5em', 'D'],
|
||||
cr: 'Cr',
|
||||
'\\': 'CrLaTeX',
|
||||
newline: ['CrLaTeX', true],
|
||||
hline: ['HLine', 'solid'],
|
||||
hdashline: ['HLine', 'dashed'],
|
||||
eqalignno: ['Matrix', null, null, 'right left',
|
||||
(0, lengths_js_1.em)(lengths_js_1.MATHSPACE.thickmathspace), '.5em', 'D', null,
|
||||
'right'],
|
||||
leqalignno: ['Matrix', null, null, 'right left',
|
||||
(0, lengths_js_1.em)(lengths_js_1.MATHSPACE.thickmathspace), '.5em', 'D', null,
|
||||
'left'],
|
||||
hfill: 'HFill',
|
||||
hfil: 'HFill',
|
||||
hfilll: 'HFill',
|
||||
bmod: ['Macro', '\\mmlToken{mo}[lspace="thickmathspace"' +
|
||||
' rspace="thickmathspace"]{mod}'],
|
||||
pmod: ['Macro', '\\pod{\\mmlToken{mi}{mod}\\kern 6mu #1}', 1],
|
||||
mod: ['Macro', '\\mathchoice{\\kern18mu}{\\kern12mu}' +
|
||||
'{\\kern12mu}{\\kern12mu}\\mmlToken{mi}{mod}\\,\\,#1',
|
||||
1],
|
||||
pod: ['Macro', '\\mathchoice{\\kern18mu}{\\kern8mu}' +
|
||||
'{\\kern8mu}{\\kern8mu}(#1)', 1],
|
||||
iff: ['Macro', '\\;\\Longleftrightarrow\\;'],
|
||||
skew: ['Macro', '{{#2{#3\\mkern#1mu}\\mkern-#1mu}{}}', 3],
|
||||
pmb: ['Macro', '\\rlap{#1}\\kern1px{#1}', 1],
|
||||
TeX: ['Macro', 'T\\kern-.14em\\lower.5ex{E}\\kern-.115em X'],
|
||||
LaTeX: ['Macro', 'L\\kern-.325em\\raise.21em' +
|
||||
'{\\scriptstyle{A}}\\kern-.17em\\TeX'],
|
||||
' ': ['Macro', '\\text{ }'],
|
||||
not: 'Not',
|
||||
dots: 'Dots',
|
||||
space: 'Tilde',
|
||||
'\u00A0': 'Tilde',
|
||||
begin: 'BeginEnd',
|
||||
end: 'BeginEnd',
|
||||
label: 'HandleLabel',
|
||||
ref: 'HandleRef',
|
||||
nonumber: 'HandleNoTag',
|
||||
mathchoice: 'MathChoice',
|
||||
mmlToken: 'MmlToken'
|
||||
}, BaseMethods_js_1.default);
|
||||
new sm.EnvironmentMap('environment', ParseMethods_js_1.default.environment, {
|
||||
array: ['AlignedArray'],
|
||||
equation: ['Equation', null, true],
|
||||
eqnarray: ['EqnArray', null, true, true, 'rcl',
|
||||
ParseUtil_js_1.default.cols(0, lengths_js_1.MATHSPACE.thickmathspace), '.5em']
|
||||
}, BaseMethods_js_1.default);
|
||||
new sm.CharacterMap('not_remap', null, {
|
||||
'\u2190': '\u219A',
|
||||
'\u2192': '\u219B',
|
||||
'\u2194': '\u21AE',
|
||||
'\u21D0': '\u21CD',
|
||||
'\u21D2': '\u21CF',
|
||||
'\u21D4': '\u21CE',
|
||||
'\u2208': '\u2209',
|
||||
'\u220B': '\u220C',
|
||||
'\u2223': '\u2224',
|
||||
'\u2225': '\u2226',
|
||||
'\u223C': '\u2241',
|
||||
'\u007E': '\u2241',
|
||||
'\u2243': '\u2244',
|
||||
'\u2245': '\u2247',
|
||||
'\u2248': '\u2249',
|
||||
'\u224D': '\u226D',
|
||||
'\u003D': '\u2260',
|
||||
'\u2261': '\u2262',
|
||||
'\u003C': '\u226E',
|
||||
'\u003E': '\u226F',
|
||||
'\u2264': '\u2270',
|
||||
'\u2265': '\u2271',
|
||||
'\u2272': '\u2274',
|
||||
'\u2273': '\u2275',
|
||||
'\u2276': '\u2278',
|
||||
'\u2277': '\u2279',
|
||||
'\u227A': '\u2280',
|
||||
'\u227B': '\u2281',
|
||||
'\u2282': '\u2284',
|
||||
'\u2283': '\u2285',
|
||||
'\u2286': '\u2288',
|
||||
'\u2287': '\u2289',
|
||||
'\u22A2': '\u22AC',
|
||||
'\u22A8': '\u22AD',
|
||||
'\u22A9': '\u22AE',
|
||||
'\u22AB': '\u22AF',
|
||||
'\u227C': '\u22E0',
|
||||
'\u227D': '\u22E1',
|
||||
'\u2291': '\u22E2',
|
||||
'\u2292': '\u22E3',
|
||||
'\u22B2': '\u22EA',
|
||||
'\u22B3': '\u22EB',
|
||||
'\u22B4': '\u22EC',
|
||||
'\u22B5': '\u22ED',
|
||||
'\u2203': '\u2204'
|
||||
});
|
||||
//# sourceMappingURL=BaseMappings.js.map
|
||||
1
node_modules/mathjax-full/js/input/tex/base/BaseMappings.js.map
generated
vendored
Normal file
1
node_modules/mathjax-full/js/input/tex/base/BaseMappings.js.map
generated
vendored
Normal file
File diff suppressed because one or more lines are too long
3
node_modules/mathjax-full/js/input/tex/base/BaseMethods.d.ts
generated
vendored
Normal file
3
node_modules/mathjax-full/js/input/tex/base/BaseMethods.d.ts
generated
vendored
Normal file
@@ -0,0 +1,3 @@
|
||||
import { ParseMethod } from '../Types.js';
|
||||
declare let BaseMethods: Record<string, ParseMethod>;
|
||||
export default BaseMethods;
|
||||
960
node_modules/mathjax-full/js/input/tex/base/BaseMethods.js
generated
vendored
Normal file
960
node_modules/mathjax-full/js/input/tex/base/BaseMethods.js
generated
vendored
Normal file
@@ -0,0 +1,960 @@
|
||||
"use strict";
|
||||
var __assign = (this && this.__assign) || function () {
|
||||
__assign = Object.assign || function(t) {
|
||||
for (var s, i = 1, n = arguments.length; i < n; i++) {
|
||||
s = arguments[i];
|
||||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
|
||||
t[p] = s[p];
|
||||
}
|
||||
return t;
|
||||
};
|
||||
return __assign.apply(this, arguments);
|
||||
};
|
||||
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
|
||||
if (k2 === undefined) k2 = k;
|
||||
var desc = Object.getOwnPropertyDescriptor(m, k);
|
||||
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
|
||||
desc = { enumerable: true, get: function() { return m[k]; } };
|
||||
}
|
||||
Object.defineProperty(o, k2, desc);
|
||||
}) : (function(o, m, k, k2) {
|
||||
if (k2 === undefined) k2 = k;
|
||||
o[k2] = m[k];
|
||||
}));
|
||||
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
|
||||
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
||||
}) : function(o, v) {
|
||||
o["default"] = v;
|
||||
});
|
||||
var __importStar = (this && this.__importStar) || function (mod) {
|
||||
if (mod && mod.__esModule) return mod;
|
||||
var result = {};
|
||||
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
|
||||
__setModuleDefault(result, mod);
|
||||
return result;
|
||||
};
|
||||
var __read = (this && this.__read) || function (o, n) {
|
||||
var m = typeof Symbol === "function" && o[Symbol.iterator];
|
||||
if (!m) return o;
|
||||
var i = m.call(o), r, ar = [], e;
|
||||
try {
|
||||
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
|
||||
}
|
||||
catch (error) { e = { error: error }; }
|
||||
finally {
|
||||
try {
|
||||
if (r && !r.done && (m = i["return"])) m.call(i);
|
||||
}
|
||||
finally { if (e) throw e.error; }
|
||||
}
|
||||
return ar;
|
||||
};
|
||||
var __importDefault = (this && this.__importDefault) || function (mod) {
|
||||
return (mod && mod.__esModule) ? mod : { "default": mod };
|
||||
};
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
var sitem = __importStar(require("./BaseItems.js"));
|
||||
var NodeUtil_js_1 = __importDefault(require("../NodeUtil.js"));
|
||||
var TexError_js_1 = __importDefault(require("../TexError.js"));
|
||||
var TexParser_js_1 = __importDefault(require("../TexParser.js"));
|
||||
var TexConstants_js_1 = require("../TexConstants.js");
|
||||
var ParseUtil_js_1 = __importDefault(require("../ParseUtil.js"));
|
||||
var MmlNode_js_1 = require("../../../core/MmlTree/MmlNode.js");
|
||||
var Tags_js_1 = require("../Tags.js");
|
||||
var lengths_js_1 = require("../../../util/lengths.js");
|
||||
var Entities_js_1 = require("../../../util/Entities.js");
|
||||
var Options_js_1 = require("../../../util/Options.js");
|
||||
var BaseMethods = {};
|
||||
var P_HEIGHT = 1.2 / .85;
|
||||
var MmlTokenAllow = {
|
||||
fontfamily: 1, fontsize: 1, fontweight: 1, fontstyle: 1,
|
||||
color: 1, background: 1,
|
||||
id: 1, 'class': 1, href: 1, style: 1
|
||||
};
|
||||
BaseMethods.Open = function (parser, _c) {
|
||||
parser.Push(parser.itemFactory.create('open'));
|
||||
};
|
||||
BaseMethods.Close = function (parser, _c) {
|
||||
parser.Push(parser.itemFactory.create('close'));
|
||||
};
|
||||
BaseMethods.Tilde = function (parser, _c) {
|
||||
parser.Push(parser.create('token', 'mtext', {}, Entities_js_1.entities.nbsp));
|
||||
};
|
||||
BaseMethods.Space = function (_parser, _c) { };
|
||||
BaseMethods.Superscript = function (parser, _c) {
|
||||
var _a;
|
||||
if (parser.GetNext().match(/\d/)) {
|
||||
parser.string = parser.string.substr(0, parser.i + 1) +
|
||||
' ' + parser.string.substr(parser.i + 1);
|
||||
}
|
||||
var primes;
|
||||
var base;
|
||||
var top = parser.stack.Top();
|
||||
if (top.isKind('prime')) {
|
||||
_a = __read(top.Peek(2), 2), base = _a[0], primes = _a[1];
|
||||
parser.stack.Pop();
|
||||
}
|
||||
else {
|
||||
base = parser.stack.Prev();
|
||||
if (!base) {
|
||||
base = parser.create('token', 'mi', {}, '');
|
||||
}
|
||||
}
|
||||
var movesupsub = NodeUtil_js_1.default.getProperty(base, 'movesupsub');
|
||||
var position = NodeUtil_js_1.default.isType(base, 'msubsup') ? base.sup :
|
||||
base.over;
|
||||
if ((NodeUtil_js_1.default.isType(base, 'msubsup') && !NodeUtil_js_1.default.isType(base, 'msup') &&
|
||||
NodeUtil_js_1.default.getChildAt(base, base.sup)) ||
|
||||
(NodeUtil_js_1.default.isType(base, 'munderover') && !NodeUtil_js_1.default.isType(base, 'mover') &&
|
||||
NodeUtil_js_1.default.getChildAt(base, base.over) &&
|
||||
!NodeUtil_js_1.default.getProperty(base, 'subsupOK'))) {
|
||||
throw new TexError_js_1.default('DoubleExponent', 'Double exponent: use braces to clarify');
|
||||
}
|
||||
if (!NodeUtil_js_1.default.isType(base, 'msubsup') || NodeUtil_js_1.default.isType(base, 'msup')) {
|
||||
if (movesupsub) {
|
||||
if (!NodeUtil_js_1.default.isType(base, 'munderover') || NodeUtil_js_1.default.isType(base, 'mover') ||
|
||||
NodeUtil_js_1.default.getChildAt(base, base.over)) {
|
||||
base = parser.create('node', 'munderover', [base], { movesupsub: true });
|
||||
}
|
||||
position = base.over;
|
||||
}
|
||||
else {
|
||||
base = parser.create('node', 'msubsup', [base]);
|
||||
position = base.sup;
|
||||
}
|
||||
}
|
||||
parser.Push(parser.itemFactory.create('subsup', base).setProperties({
|
||||
position: position, primes: primes, movesupsub: movesupsub
|
||||
}));
|
||||
};
|
||||
BaseMethods.Subscript = function (parser, _c) {
|
||||
var _a;
|
||||
if (parser.GetNext().match(/\d/)) {
|
||||
parser.string =
|
||||
parser.string.substr(0, parser.i + 1) + ' ' +
|
||||
parser.string.substr(parser.i + 1);
|
||||
}
|
||||
var primes, base;
|
||||
var top = parser.stack.Top();
|
||||
if (top.isKind('prime')) {
|
||||
_a = __read(top.Peek(2), 2), base = _a[0], primes = _a[1];
|
||||
parser.stack.Pop();
|
||||
}
|
||||
else {
|
||||
base = parser.stack.Prev();
|
||||
if (!base) {
|
||||
base = parser.create('token', 'mi', {}, '');
|
||||
}
|
||||
}
|
||||
var movesupsub = NodeUtil_js_1.default.getProperty(base, 'movesupsub');
|
||||
var position = NodeUtil_js_1.default.isType(base, 'msubsup') ?
|
||||
base.sub : base.under;
|
||||
if ((NodeUtil_js_1.default.isType(base, 'msubsup') && !NodeUtil_js_1.default.isType(base, 'msup') &&
|
||||
NodeUtil_js_1.default.getChildAt(base, base.sub)) ||
|
||||
(NodeUtil_js_1.default.isType(base, 'munderover') && !NodeUtil_js_1.default.isType(base, 'mover') &&
|
||||
NodeUtil_js_1.default.getChildAt(base, base.under) &&
|
||||
!NodeUtil_js_1.default.getProperty(base, 'subsupOK'))) {
|
||||
throw new TexError_js_1.default('DoubleSubscripts', 'Double subscripts: use braces to clarify');
|
||||
}
|
||||
if (!NodeUtil_js_1.default.isType(base, 'msubsup') || NodeUtil_js_1.default.isType(base, 'msup')) {
|
||||
if (movesupsub) {
|
||||
if (!NodeUtil_js_1.default.isType(base, 'munderover') || NodeUtil_js_1.default.isType(base, 'mover') ||
|
||||
NodeUtil_js_1.default.getChildAt(base, base.under)) {
|
||||
base = parser.create('node', 'munderover', [base], { movesupsub: true });
|
||||
}
|
||||
position = base.under;
|
||||
}
|
||||
else {
|
||||
base = parser.create('node', 'msubsup', [base]);
|
||||
position = base.sub;
|
||||
}
|
||||
}
|
||||
parser.Push(parser.itemFactory.create('subsup', base).setProperties({
|
||||
position: position, primes: primes, movesupsub: movesupsub
|
||||
}));
|
||||
};
|
||||
BaseMethods.Prime = function (parser, c) {
|
||||
var base = parser.stack.Prev();
|
||||
if (!base) {
|
||||
base = parser.create('node', 'mi');
|
||||
}
|
||||
if (NodeUtil_js_1.default.isType(base, 'msubsup') && !NodeUtil_js_1.default.isType(base, 'msup') &&
|
||||
NodeUtil_js_1.default.getChildAt(base, base.sup)) {
|
||||
throw new TexError_js_1.default('DoubleExponentPrime', 'Prime causes double exponent: use braces to clarify');
|
||||
}
|
||||
var sup = '';
|
||||
parser.i--;
|
||||
do {
|
||||
sup += Entities_js_1.entities.prime;
|
||||
parser.i++, c = parser.GetNext();
|
||||
} while (c === '\'' || c === Entities_js_1.entities.rsquo);
|
||||
sup = ['', '\u2032', '\u2033', '\u2034', '\u2057'][sup.length] || sup;
|
||||
var node = parser.create('token', 'mo', { variantForm: true }, sup);
|
||||
parser.Push(parser.itemFactory.create('prime', base, node));
|
||||
};
|
||||
BaseMethods.Comment = function (parser, _c) {
|
||||
while (parser.i < parser.string.length && parser.string.charAt(parser.i) !== '\n') {
|
||||
parser.i++;
|
||||
}
|
||||
};
|
||||
BaseMethods.Hash = function (_parser, _c) {
|
||||
throw new TexError_js_1.default('CantUseHash1', 'You can\'t use \'macro parameter character #\' in math mode');
|
||||
};
|
||||
BaseMethods.MathFont = function (parser, name, variant) {
|
||||
var text = parser.GetArgument(name);
|
||||
var mml = new TexParser_js_1.default(text, __assign(__assign({}, parser.stack.env), { font: variant, multiLetterIdentifiers: /^[a-zA-Z]+/, noAutoOP: true }), parser.configuration).mml();
|
||||
parser.Push(parser.create('node', 'TeXAtom', [mml]));
|
||||
};
|
||||
BaseMethods.SetFont = function (parser, _name, font) {
|
||||
parser.stack.env['font'] = font;
|
||||
};
|
||||
BaseMethods.SetStyle = function (parser, _name, texStyle, style, level) {
|
||||
parser.stack.env['style'] = texStyle;
|
||||
parser.stack.env['level'] = level;
|
||||
parser.Push(parser.itemFactory.create('style').setProperty('styles', { displaystyle: style, scriptlevel: level }));
|
||||
};
|
||||
BaseMethods.SetSize = function (parser, _name, size) {
|
||||
parser.stack.env['size'] = size;
|
||||
parser.Push(parser.itemFactory.create('style').setProperty('styles', { mathsize: (0, lengths_js_1.em)(size) }));
|
||||
};
|
||||
BaseMethods.Spacer = function (parser, _name, space) {
|
||||
var node = parser.create('node', 'mspace', [], { width: (0, lengths_js_1.em)(space) });
|
||||
var style = parser.create('node', 'mstyle', [node], { scriptlevel: 0 });
|
||||
parser.Push(style);
|
||||
};
|
||||
BaseMethods.LeftRight = function (parser, name) {
|
||||
var first = name.substr(1);
|
||||
parser.Push(parser.itemFactory.create(first, parser.GetDelimiter(name), parser.stack.env.color));
|
||||
};
|
||||
BaseMethods.NamedFn = function (parser, name, id) {
|
||||
if (!id) {
|
||||
id = name.substr(1);
|
||||
}
|
||||
var mml = parser.create('token', 'mi', { texClass: MmlNode_js_1.TEXCLASS.OP }, id);
|
||||
parser.Push(parser.itemFactory.create('fn', mml));
|
||||
};
|
||||
BaseMethods.NamedOp = function (parser, name, id) {
|
||||
if (!id) {
|
||||
id = name.substr(1);
|
||||
}
|
||||
id = id.replace(/ /, '\u2006');
|
||||
var mml = parser.create('token', 'mo', {
|
||||
movablelimits: true,
|
||||
movesupsub: true,
|
||||
form: TexConstants_js_1.TexConstant.Form.PREFIX,
|
||||
texClass: MmlNode_js_1.TEXCLASS.OP
|
||||
}, id);
|
||||
parser.Push(mml);
|
||||
};
|
||||
BaseMethods.Limits = function (parser, _name, limits) {
|
||||
var op = parser.stack.Prev(true);
|
||||
if (!op || (NodeUtil_js_1.default.getTexClass(NodeUtil_js_1.default.getCoreMO(op)) !== MmlNode_js_1.TEXCLASS.OP &&
|
||||
NodeUtil_js_1.default.getProperty(op, 'movesupsub') == null)) {
|
||||
throw new TexError_js_1.default('MisplacedLimits', '%1 is allowed only on operators', parser.currentCS);
|
||||
}
|
||||
var top = parser.stack.Top();
|
||||
var node;
|
||||
if (NodeUtil_js_1.default.isType(op, 'munderover') && !limits) {
|
||||
node = parser.create('node', 'msubsup');
|
||||
NodeUtil_js_1.default.copyChildren(op, node);
|
||||
op = top.Last = node;
|
||||
}
|
||||
else if (NodeUtil_js_1.default.isType(op, 'msubsup') && limits) {
|
||||
node = parser.create('node', 'munderover');
|
||||
NodeUtil_js_1.default.copyChildren(op, node);
|
||||
op = top.Last = node;
|
||||
}
|
||||
NodeUtil_js_1.default.setProperty(op, 'movesupsub', limits ? true : false);
|
||||
NodeUtil_js_1.default.setProperties(NodeUtil_js_1.default.getCoreMO(op), { 'movablelimits': false });
|
||||
if (NodeUtil_js_1.default.getAttribute(op, 'movablelimits') ||
|
||||
NodeUtil_js_1.default.getProperty(op, 'movablelimits')) {
|
||||
NodeUtil_js_1.default.setProperties(op, { 'movablelimits': false });
|
||||
}
|
||||
};
|
||||
BaseMethods.Over = function (parser, name, open, close) {
|
||||
var mml = parser.itemFactory.create('over').setProperty('name', parser.currentCS);
|
||||
if (open || close) {
|
||||
mml.setProperty('open', open);
|
||||
mml.setProperty('close', close);
|
||||
}
|
||||
else if (name.match(/withdelims$/)) {
|
||||
mml.setProperty('open', parser.GetDelimiter(name));
|
||||
mml.setProperty('close', parser.GetDelimiter(name));
|
||||
}
|
||||
if (name.match(/^\\above/)) {
|
||||
mml.setProperty('thickness', parser.GetDimen(name));
|
||||
}
|
||||
else if (name.match(/^\\atop/) || open || close) {
|
||||
mml.setProperty('thickness', 0);
|
||||
}
|
||||
parser.Push(mml);
|
||||
};
|
||||
BaseMethods.Frac = function (parser, name) {
|
||||
var num = parser.ParseArg(name);
|
||||
var den = parser.ParseArg(name);
|
||||
var node = parser.create('node', 'mfrac', [num, den]);
|
||||
parser.Push(node);
|
||||
};
|
||||
BaseMethods.Sqrt = function (parser, name) {
|
||||
var n = parser.GetBrackets(name);
|
||||
var arg = parser.GetArgument(name);
|
||||
if (arg === '\\frac') {
|
||||
arg += '{' + parser.GetArgument(arg) + '}{' + parser.GetArgument(arg) + '}';
|
||||
}
|
||||
var mml = new TexParser_js_1.default(arg, parser.stack.env, parser.configuration).mml();
|
||||
if (!n) {
|
||||
mml = parser.create('node', 'msqrt', [mml]);
|
||||
}
|
||||
else {
|
||||
mml = parser.create('node', 'mroot', [mml, parseRoot(parser, n)]);
|
||||
}
|
||||
parser.Push(mml);
|
||||
};
|
||||
function parseRoot(parser, n) {
|
||||
var env = parser.stack.env;
|
||||
var inRoot = env['inRoot'];
|
||||
env['inRoot'] = true;
|
||||
var newParser = new TexParser_js_1.default(n, env, parser.configuration);
|
||||
var node = newParser.mml();
|
||||
var global = newParser.stack.global;
|
||||
if (global['leftRoot'] || global['upRoot']) {
|
||||
var def = {};
|
||||
if (global['leftRoot']) {
|
||||
def['width'] = global['leftRoot'];
|
||||
}
|
||||
if (global['upRoot']) {
|
||||
def['voffset'] = global['upRoot'];
|
||||
def['height'] = global['upRoot'];
|
||||
}
|
||||
node = parser.create('node', 'mpadded', [node], def);
|
||||
}
|
||||
env['inRoot'] = inRoot;
|
||||
return node;
|
||||
}
|
||||
BaseMethods.Root = function (parser, name) {
|
||||
var n = parser.GetUpTo(name, '\\of');
|
||||
var arg = parser.ParseArg(name);
|
||||
var node = parser.create('node', 'mroot', [arg, parseRoot(parser, n)]);
|
||||
parser.Push(node);
|
||||
};
|
||||
BaseMethods.MoveRoot = function (parser, name, id) {
|
||||
if (!parser.stack.env['inRoot']) {
|
||||
throw new TexError_js_1.default('MisplacedMoveRoot', '%1 can appear only within a root', parser.currentCS);
|
||||
}
|
||||
if (parser.stack.global[id]) {
|
||||
throw new TexError_js_1.default('MultipleMoveRoot', 'Multiple use of %1', parser.currentCS);
|
||||
}
|
||||
var n = parser.GetArgument(name);
|
||||
if (!n.match(/-?[0-9]+/)) {
|
||||
throw new TexError_js_1.default('IntegerArg', 'The argument to %1 must be an integer', parser.currentCS);
|
||||
}
|
||||
n = (parseInt(n, 10) / 15) + 'em';
|
||||
if (n.substr(0, 1) !== '-') {
|
||||
n = '+' + n;
|
||||
}
|
||||
parser.stack.global[id] = n;
|
||||
};
|
||||
BaseMethods.Accent = function (parser, name, accent, stretchy) {
|
||||
var c = parser.ParseArg(name);
|
||||
var def = __assign(__assign({}, ParseUtil_js_1.default.getFontDef(parser)), { accent: true, mathaccent: true });
|
||||
var entity = NodeUtil_js_1.default.createEntity(accent);
|
||||
var moNode = parser.create('token', 'mo', def, entity);
|
||||
var mml = moNode;
|
||||
NodeUtil_js_1.default.setAttribute(mml, 'stretchy', stretchy ? true : false);
|
||||
var mo = (NodeUtil_js_1.default.isEmbellished(c) ? NodeUtil_js_1.default.getCoreMO(c) : c);
|
||||
if (NodeUtil_js_1.default.isType(mo, 'mo') || NodeUtil_js_1.default.getProperty(mo, 'movablelimits')) {
|
||||
NodeUtil_js_1.default.setProperties(mo, { 'movablelimits': false });
|
||||
}
|
||||
var muoNode = parser.create('node', 'munderover');
|
||||
NodeUtil_js_1.default.setChild(muoNode, 0, c);
|
||||
NodeUtil_js_1.default.setChild(muoNode, 1, null);
|
||||
NodeUtil_js_1.default.setChild(muoNode, 2, mml);
|
||||
var texAtom = parser.create('node', 'TeXAtom', [muoNode]);
|
||||
parser.Push(texAtom);
|
||||
};
|
||||
BaseMethods.UnderOver = function (parser, name, c, stack) {
|
||||
var entity = NodeUtil_js_1.default.createEntity(c);
|
||||
var mo = parser.create('token', 'mo', { stretchy: true, accent: true }, entity);
|
||||
var pos = (name.charAt(1) === 'o' ? 'over' : 'under');
|
||||
var base = parser.ParseArg(name);
|
||||
parser.Push(ParseUtil_js_1.default.underOver(parser, base, mo, pos, stack));
|
||||
};
|
||||
BaseMethods.Overset = function (parser, name) {
|
||||
var top = parser.ParseArg(name);
|
||||
var base = parser.ParseArg(name);
|
||||
ParseUtil_js_1.default.checkMovableLimits(base);
|
||||
if (top.isKind('mo')) {
|
||||
NodeUtil_js_1.default.setAttribute(top, 'accent', false);
|
||||
}
|
||||
var node = parser.create('node', 'mover', [base, top]);
|
||||
parser.Push(node);
|
||||
};
|
||||
BaseMethods.Underset = function (parser, name) {
|
||||
var bot = parser.ParseArg(name);
|
||||
var base = parser.ParseArg(name);
|
||||
ParseUtil_js_1.default.checkMovableLimits(base);
|
||||
if (bot.isKind('mo')) {
|
||||
NodeUtil_js_1.default.setAttribute(bot, 'accent', false);
|
||||
}
|
||||
var node = parser.create('node', 'munder', [base, bot], { accentunder: false });
|
||||
parser.Push(node);
|
||||
};
|
||||
BaseMethods.Overunderset = function (parser, name) {
|
||||
var top = parser.ParseArg(name);
|
||||
var bot = parser.ParseArg(name);
|
||||
var base = parser.ParseArg(name);
|
||||
ParseUtil_js_1.default.checkMovableLimits(base);
|
||||
if (top.isKind('mo')) {
|
||||
NodeUtil_js_1.default.setAttribute(top, 'accent', false);
|
||||
}
|
||||
if (bot.isKind('mo')) {
|
||||
NodeUtil_js_1.default.setAttribute(bot, 'accent', false);
|
||||
}
|
||||
var node = parser.create('node', 'munderover', [base, bot, top], { accent: false, accentunder: false });
|
||||
parser.Push(node);
|
||||
};
|
||||
BaseMethods.TeXAtom = function (parser, name, mclass) {
|
||||
var def = { texClass: mclass };
|
||||
var mml;
|
||||
var node;
|
||||
var parsed;
|
||||
if (mclass === MmlNode_js_1.TEXCLASS.OP) {
|
||||
def['movesupsub'] = def['movablelimits'] = true;
|
||||
var arg = parser.GetArgument(name);
|
||||
var match = arg.match(/^\s*\\rm\s+([a-zA-Z0-9 ]+)$/);
|
||||
if (match) {
|
||||
def['mathvariant'] = TexConstants_js_1.TexConstant.Variant.NORMAL;
|
||||
node = parser.create('token', 'mi', def, match[1]);
|
||||
}
|
||||
else {
|
||||
parsed = new TexParser_js_1.default(arg, parser.stack.env, parser.configuration).mml();
|
||||
node = parser.create('node', 'TeXAtom', [parsed], def);
|
||||
}
|
||||
mml = parser.itemFactory.create('fn', node);
|
||||
}
|
||||
else {
|
||||
parsed = parser.ParseArg(name);
|
||||
mml = parser.create('node', 'TeXAtom', [parsed], def);
|
||||
}
|
||||
parser.Push(mml);
|
||||
};
|
||||
BaseMethods.MmlToken = function (parser, name) {
|
||||
var kind = parser.GetArgument(name);
|
||||
var attr = parser.GetBrackets(name, '').replace(/^\s+/, '');
|
||||
var text = parser.GetArgument(name);
|
||||
var def = {};
|
||||
var keep = [];
|
||||
var node;
|
||||
try {
|
||||
node = parser.create('node', kind);
|
||||
}
|
||||
catch (e) {
|
||||
node = null;
|
||||
}
|
||||
if (!node || !node.isToken) {
|
||||
throw new TexError_js_1.default('NotMathMLToken', '%1 is not a token element', kind);
|
||||
}
|
||||
while (attr !== '') {
|
||||
var match = attr.match(/^([a-z]+)\s*=\s*('[^']*'|"[^"]*"|[^ ,]*)\s*,?\s*/i);
|
||||
if (!match) {
|
||||
throw new TexError_js_1.default('InvalidMathMLAttr', 'Invalid MathML attribute: %1', attr);
|
||||
}
|
||||
if (!node.attributes.hasDefault(match[1]) && !MmlTokenAllow[match[1]]) {
|
||||
throw new TexError_js_1.default('UnknownAttrForElement', '%1 is not a recognized attribute for %2', match[1], kind);
|
||||
}
|
||||
var value = ParseUtil_js_1.default.MmlFilterAttribute(parser, match[1], match[2].replace(/^(['"])(.*)\1$/, '$2'));
|
||||
if (value) {
|
||||
if (value.toLowerCase() === 'true') {
|
||||
value = true;
|
||||
}
|
||||
else if (value.toLowerCase() === 'false') {
|
||||
value = false;
|
||||
}
|
||||
def[match[1]] = value;
|
||||
keep.push(match[1]);
|
||||
}
|
||||
attr = attr.substr(match[0].length);
|
||||
}
|
||||
if (keep.length) {
|
||||
def['mjx-keep-attrs'] = keep.join(' ');
|
||||
}
|
||||
var textNode = parser.create('text', text);
|
||||
node.appendChild(textNode);
|
||||
NodeUtil_js_1.default.setProperties(node, def);
|
||||
parser.Push(node);
|
||||
};
|
||||
BaseMethods.Strut = function (parser, _name) {
|
||||
var row = parser.create('node', 'mrow');
|
||||
var padded = parser.create('node', 'mpadded', [row], { height: '8.6pt', depth: '3pt', width: 0 });
|
||||
parser.Push(padded);
|
||||
};
|
||||
BaseMethods.Phantom = function (parser, name, v, h) {
|
||||
var box = parser.create('node', 'mphantom', [parser.ParseArg(name)]);
|
||||
if (v || h) {
|
||||
box = parser.create('node', 'mpadded', [box]);
|
||||
if (h) {
|
||||
NodeUtil_js_1.default.setAttribute(box, 'height', 0);
|
||||
NodeUtil_js_1.default.setAttribute(box, 'depth', 0);
|
||||
}
|
||||
if (v) {
|
||||
NodeUtil_js_1.default.setAttribute(box, 'width', 0);
|
||||
}
|
||||
}
|
||||
var atom = parser.create('node', 'TeXAtom', [box]);
|
||||
parser.Push(atom);
|
||||
};
|
||||
BaseMethods.Smash = function (parser, name) {
|
||||
var bt = ParseUtil_js_1.default.trimSpaces(parser.GetBrackets(name, ''));
|
||||
var smash = parser.create('node', 'mpadded', [parser.ParseArg(name)]);
|
||||
switch (bt) {
|
||||
case 'b':
|
||||
NodeUtil_js_1.default.setAttribute(smash, 'depth', 0);
|
||||
break;
|
||||
case 't':
|
||||
NodeUtil_js_1.default.setAttribute(smash, 'height', 0);
|
||||
break;
|
||||
default:
|
||||
NodeUtil_js_1.default.setAttribute(smash, 'height', 0);
|
||||
NodeUtil_js_1.default.setAttribute(smash, 'depth', 0);
|
||||
}
|
||||
var atom = parser.create('node', 'TeXAtom', [smash]);
|
||||
parser.Push(atom);
|
||||
};
|
||||
BaseMethods.Lap = function (parser, name) {
|
||||
var mml = parser.create('node', 'mpadded', [parser.ParseArg(name)], { width: 0 });
|
||||
if (name === '\\llap') {
|
||||
NodeUtil_js_1.default.setAttribute(mml, 'lspace', '-1width');
|
||||
}
|
||||
var atom = parser.create('node', 'TeXAtom', [mml]);
|
||||
parser.Push(atom);
|
||||
};
|
||||
BaseMethods.RaiseLower = function (parser, name) {
|
||||
var h = parser.GetDimen(name);
|
||||
var item = parser.itemFactory.create('position').setProperties({ name: parser.currentCS, move: 'vertical' });
|
||||
if (h.charAt(0) === '-') {
|
||||
h = h.slice(1);
|
||||
name = name.substr(1) === 'raise' ? '\\lower' : '\\raise';
|
||||
}
|
||||
if (name === '\\lower') {
|
||||
item.setProperty('dh', '-' + h);
|
||||
item.setProperty('dd', '+' + h);
|
||||
}
|
||||
else {
|
||||
item.setProperty('dh', '+' + h);
|
||||
item.setProperty('dd', '-' + h);
|
||||
}
|
||||
parser.Push(item);
|
||||
};
|
||||
BaseMethods.MoveLeftRight = function (parser, name) {
|
||||
var h = parser.GetDimen(name);
|
||||
var nh = (h.charAt(0) === '-' ? h.slice(1) : '-' + h);
|
||||
if (name === '\\moveleft') {
|
||||
var tmp = h;
|
||||
h = nh;
|
||||
nh = tmp;
|
||||
}
|
||||
parser.Push(parser.itemFactory.create('position').setProperties({
|
||||
name: parser.currentCS, move: 'horizontal',
|
||||
left: parser.create('node', 'mspace', [], { width: h }),
|
||||
right: parser.create('node', 'mspace', [], { width: nh })
|
||||
}));
|
||||
};
|
||||
BaseMethods.Hskip = function (parser, name) {
|
||||
var node = parser.create('node', 'mspace', [], { width: parser.GetDimen(name) });
|
||||
parser.Push(node);
|
||||
};
|
||||
BaseMethods.Nonscript = function (parser, _name) {
|
||||
parser.Push(parser.itemFactory.create('nonscript'));
|
||||
};
|
||||
BaseMethods.Rule = function (parser, name, style) {
|
||||
var w = parser.GetDimen(name), h = parser.GetDimen(name), d = parser.GetDimen(name);
|
||||
var def = { width: w, height: h, depth: d };
|
||||
if (style !== 'blank') {
|
||||
def['mathbackground'] = (parser.stack.env['color'] || 'black');
|
||||
}
|
||||
var node = parser.create('node', 'mspace', [], def);
|
||||
parser.Push(node);
|
||||
};
|
||||
BaseMethods.rule = function (parser, name) {
|
||||
var v = parser.GetBrackets(name), w = parser.GetDimen(name), h = parser.GetDimen(name);
|
||||
var mml = parser.create('node', 'mspace', [], {
|
||||
width: w, height: h,
|
||||
mathbackground: (parser.stack.env['color'] || 'black')
|
||||
});
|
||||
if (v) {
|
||||
mml = parser.create('node', 'mpadded', [mml], { voffset: v });
|
||||
if (v.match(/^\-/)) {
|
||||
NodeUtil_js_1.default.setAttribute(mml, 'height', v);
|
||||
NodeUtil_js_1.default.setAttribute(mml, 'depth', '+' + v.substr(1));
|
||||
}
|
||||
else {
|
||||
NodeUtil_js_1.default.setAttribute(mml, 'height', '+' + v);
|
||||
}
|
||||
}
|
||||
parser.Push(mml);
|
||||
};
|
||||
BaseMethods.MakeBig = function (parser, name, mclass, size) {
|
||||
size *= P_HEIGHT;
|
||||
var sizeStr = String(size).replace(/(\.\d\d\d).+/, '$1') + 'em';
|
||||
var delim = parser.GetDelimiter(name, true);
|
||||
var mo = parser.create('token', 'mo', {
|
||||
minsize: sizeStr, maxsize: sizeStr,
|
||||
fence: true, stretchy: true, symmetric: true
|
||||
}, delim);
|
||||
var node = parser.create('node', 'TeXAtom', [mo], { texClass: mclass });
|
||||
parser.Push(node);
|
||||
};
|
||||
BaseMethods.BuildRel = function (parser, name) {
|
||||
var top = parser.ParseUpTo(name, '\\over');
|
||||
var bot = parser.ParseArg(name);
|
||||
var node = parser.create('node', 'munderover');
|
||||
NodeUtil_js_1.default.setChild(node, 0, bot);
|
||||
NodeUtil_js_1.default.setChild(node, 1, null);
|
||||
NodeUtil_js_1.default.setChild(node, 2, top);
|
||||
var atom = parser.create('node', 'TeXAtom', [node], { texClass: MmlNode_js_1.TEXCLASS.REL });
|
||||
parser.Push(atom);
|
||||
};
|
||||
BaseMethods.HBox = function (parser, name, style, font) {
|
||||
parser.PushAll(ParseUtil_js_1.default.internalMath(parser, parser.GetArgument(name), style, font));
|
||||
};
|
||||
BaseMethods.FBox = function (parser, name) {
|
||||
var internal = ParseUtil_js_1.default.internalMath(parser, parser.GetArgument(name));
|
||||
var node = parser.create('node', 'menclose', internal, { notation: 'box' });
|
||||
parser.Push(node);
|
||||
};
|
||||
BaseMethods.FrameBox = function (parser, name) {
|
||||
var width = parser.GetBrackets(name);
|
||||
var pos = parser.GetBrackets(name) || 'c';
|
||||
var mml = ParseUtil_js_1.default.internalMath(parser, parser.GetArgument(name));
|
||||
if (width) {
|
||||
mml = [parser.create('node', 'mpadded', mml, {
|
||||
width: width,
|
||||
'data-align': (0, Options_js_1.lookup)(pos, { l: 'left', r: 'right' }, 'center')
|
||||
})];
|
||||
}
|
||||
var node = parser.create('node', 'TeXAtom', [parser.create('node', 'menclose', mml, { notation: 'box' })], { texClass: MmlNode_js_1.TEXCLASS.ORD });
|
||||
parser.Push(node);
|
||||
};
|
||||
BaseMethods.Not = function (parser, _name) {
|
||||
parser.Push(parser.itemFactory.create('not'));
|
||||
};
|
||||
BaseMethods.Dots = function (parser, _name) {
|
||||
var ldotsEntity = NodeUtil_js_1.default.createEntity('2026');
|
||||
var cdotsEntity = NodeUtil_js_1.default.createEntity('22EF');
|
||||
var ldots = parser.create('token', 'mo', { stretchy: false }, ldotsEntity);
|
||||
var cdots = parser.create('token', 'mo', { stretchy: false }, cdotsEntity);
|
||||
parser.Push(parser.itemFactory.create('dots').setProperties({
|
||||
ldots: ldots,
|
||||
cdots: cdots
|
||||
}));
|
||||
};
|
||||
BaseMethods.Matrix = function (parser, _name, open, close, align, spacing, vspacing, style, cases, numbered) {
|
||||
var c = parser.GetNext();
|
||||
if (c === '') {
|
||||
throw new TexError_js_1.default('MissingArgFor', 'Missing argument for %1', parser.currentCS);
|
||||
}
|
||||
if (c === '{') {
|
||||
parser.i++;
|
||||
}
|
||||
else {
|
||||
parser.string = c + '}' + parser.string.slice(parser.i + 1);
|
||||
parser.i = 0;
|
||||
}
|
||||
var array = parser.itemFactory.create('array').setProperty('requireClose', true);
|
||||
array.arraydef = {
|
||||
rowspacing: (vspacing || '4pt'),
|
||||
columnspacing: (spacing || '1em')
|
||||
};
|
||||
if (cases) {
|
||||
array.setProperty('isCases', true);
|
||||
}
|
||||
if (numbered) {
|
||||
array.setProperty('isNumbered', true);
|
||||
array.arraydef.side = numbered;
|
||||
}
|
||||
if (open || close) {
|
||||
array.setProperty('open', open);
|
||||
array.setProperty('close', close);
|
||||
}
|
||||
if (style === 'D') {
|
||||
array.arraydef.displaystyle = true;
|
||||
}
|
||||
if (align != null) {
|
||||
array.arraydef.columnalign = align;
|
||||
}
|
||||
parser.Push(array);
|
||||
};
|
||||
BaseMethods.Entry = function (parser, name) {
|
||||
parser.Push(parser.itemFactory.create('cell').setProperties({ isEntry: true, name: name }));
|
||||
var top = parser.stack.Top();
|
||||
var env = top.getProperty('casesEnv');
|
||||
var cases = top.getProperty('isCases');
|
||||
if (!cases && !env)
|
||||
return;
|
||||
var str = parser.string;
|
||||
var braces = 0, close = -1, i = parser.i, m = str.length;
|
||||
var end = (env ? new RegExp("^\\\\end\\s*\\{".concat(env.replace(/\*/, '\\*'), "\\}")) : null);
|
||||
while (i < m) {
|
||||
var c = str.charAt(i);
|
||||
if (c === '{') {
|
||||
braces++;
|
||||
i++;
|
||||
}
|
||||
else if (c === '}') {
|
||||
if (braces === 0) {
|
||||
m = 0;
|
||||
}
|
||||
else {
|
||||
braces--;
|
||||
if (braces === 0 && close < 0) {
|
||||
close = i - parser.i;
|
||||
}
|
||||
i++;
|
||||
}
|
||||
}
|
||||
else if (c === '&' && braces === 0) {
|
||||
throw new TexError_js_1.default('ExtraAlignTab', 'Extra alignment tab in \\cases text');
|
||||
}
|
||||
else if (c === '\\') {
|
||||
var rest = str.substr(i);
|
||||
if (rest.match(/^((\\cr)[^a-zA-Z]|\\\\)/) || (end && rest.match(end))) {
|
||||
m = 0;
|
||||
}
|
||||
else {
|
||||
i += 2;
|
||||
}
|
||||
}
|
||||
else {
|
||||
i++;
|
||||
}
|
||||
}
|
||||
var text = str.substr(parser.i, i - parser.i);
|
||||
if (!text.match(/^\s*\\text[^a-zA-Z]/) || close !== text.replace(/\s+$/, '').length - 1) {
|
||||
var internal = ParseUtil_js_1.default.internalMath(parser, ParseUtil_js_1.default.trimSpaces(text), 0);
|
||||
parser.PushAll(internal);
|
||||
parser.i = i;
|
||||
}
|
||||
};
|
||||
BaseMethods.Cr = function (parser, name) {
|
||||
parser.Push(parser.itemFactory.create('cell').setProperties({ isCR: true, name: name }));
|
||||
};
|
||||
BaseMethods.CrLaTeX = function (parser, name, nobrackets) {
|
||||
if (nobrackets === void 0) { nobrackets = false; }
|
||||
var n;
|
||||
if (!nobrackets) {
|
||||
if (parser.string.charAt(parser.i) === '*') {
|
||||
parser.i++;
|
||||
}
|
||||
if (parser.string.charAt(parser.i) === '[') {
|
||||
var dim = parser.GetBrackets(name, '');
|
||||
var _a = __read(ParseUtil_js_1.default.matchDimen(dim), 2), value = _a[0], unit = _a[1];
|
||||
if (dim && !value) {
|
||||
throw new TexError_js_1.default('BracketMustBeDimension', 'Bracket argument to %1 must be a dimension', parser.currentCS);
|
||||
}
|
||||
n = value + unit;
|
||||
}
|
||||
}
|
||||
parser.Push(parser.itemFactory.create('cell').setProperties({ isCR: true, name: name, linebreak: true }));
|
||||
var top = parser.stack.Top();
|
||||
var node;
|
||||
if (top instanceof sitem.ArrayItem) {
|
||||
if (n) {
|
||||
top.addRowSpacing(n);
|
||||
}
|
||||
}
|
||||
else {
|
||||
if (n) {
|
||||
node = parser.create('node', 'mspace', [], { depth: n });
|
||||
parser.Push(node);
|
||||
}
|
||||
node = parser.create('node', 'mspace', [], { linebreak: TexConstants_js_1.TexConstant.LineBreak.NEWLINE });
|
||||
parser.Push(node);
|
||||
}
|
||||
};
|
||||
BaseMethods.HLine = function (parser, _name, style) {
|
||||
if (style == null) {
|
||||
style = 'solid';
|
||||
}
|
||||
var top = parser.stack.Top();
|
||||
if (!(top instanceof sitem.ArrayItem) || top.Size()) {
|
||||
throw new TexError_js_1.default('Misplaced', 'Misplaced %1', parser.currentCS);
|
||||
}
|
||||
if (!top.table.length) {
|
||||
top.frame.push('top');
|
||||
}
|
||||
else {
|
||||
var lines = (top.arraydef['rowlines'] ? top.arraydef['rowlines'].split(/ /) : []);
|
||||
while (lines.length < top.table.length) {
|
||||
lines.push('none');
|
||||
}
|
||||
lines[top.table.length - 1] = style;
|
||||
top.arraydef['rowlines'] = lines.join(' ');
|
||||
}
|
||||
};
|
||||
BaseMethods.HFill = function (parser, _name) {
|
||||
var top = parser.stack.Top();
|
||||
if (top instanceof sitem.ArrayItem) {
|
||||
top.hfill.push(top.Size());
|
||||
}
|
||||
else {
|
||||
throw new TexError_js_1.default('UnsupportedHFill', 'Unsupported use of %1', parser.currentCS);
|
||||
}
|
||||
};
|
||||
BaseMethods.BeginEnd = function (parser, name) {
|
||||
var env = parser.GetArgument(name);
|
||||
if (env.match(/\\/i)) {
|
||||
throw new TexError_js_1.default('InvalidEnv', 'Invalid environment name \'%1\'', env);
|
||||
}
|
||||
var macro = parser.configuration.handlers.get('environment').lookup(env);
|
||||
if (macro && name === '\\end') {
|
||||
if (!macro.args[0]) {
|
||||
var mml = parser.itemFactory.create('end').setProperty('name', env);
|
||||
parser.Push(mml);
|
||||
return;
|
||||
}
|
||||
parser.stack.env['closing'] = env;
|
||||
}
|
||||
ParseUtil_js_1.default.checkMaxMacros(parser, false);
|
||||
parser.parse('environment', [parser, env]);
|
||||
};
|
||||
BaseMethods.Array = function (parser, begin, open, close, align, spacing, vspacing, style, raggedHeight) {
|
||||
if (!align) {
|
||||
align = parser.GetArgument('\\begin{' + begin.getName() + '}');
|
||||
}
|
||||
var lines = ('c' + align).replace(/[^clr|:]/g, '').replace(/[^|:]([|:])+/g, '$1');
|
||||
align = align.replace(/[^clr]/g, '').split('').join(' ');
|
||||
align = align.replace(/l/g, 'left').replace(/r/g, 'right').replace(/c/g, 'center');
|
||||
var array = parser.itemFactory.create('array');
|
||||
array.arraydef = {
|
||||
columnalign: align,
|
||||
columnspacing: (spacing || '1em'),
|
||||
rowspacing: (vspacing || '4pt')
|
||||
};
|
||||
if (lines.match(/[|:]/)) {
|
||||
if (lines.charAt(0).match(/[|:]/)) {
|
||||
array.frame.push('left');
|
||||
array.dashed = lines.charAt(0) === ':';
|
||||
}
|
||||
if (lines.charAt(lines.length - 1).match(/[|:]/)) {
|
||||
array.frame.push('right');
|
||||
}
|
||||
lines = lines.substr(1, lines.length - 2);
|
||||
array.arraydef.columnlines =
|
||||
lines.split('').join(' ').replace(/[^|: ]/g, 'none').replace(/\|/g, 'solid').replace(/:/g, 'dashed');
|
||||
}
|
||||
if (open) {
|
||||
array.setProperty('open', parser.convertDelimiter(open));
|
||||
}
|
||||
if (close) {
|
||||
array.setProperty('close', parser.convertDelimiter(close));
|
||||
}
|
||||
if ((style || '').charAt(1) === '\'') {
|
||||
array.arraydef['data-cramped'] = true;
|
||||
style = style.charAt(0);
|
||||
}
|
||||
if (style === 'D') {
|
||||
array.arraydef['displaystyle'] = true;
|
||||
}
|
||||
else if (style) {
|
||||
array.arraydef['displaystyle'] = false;
|
||||
}
|
||||
if (style === 'S') {
|
||||
array.arraydef['scriptlevel'] = 1;
|
||||
}
|
||||
if (raggedHeight) {
|
||||
array.arraydef['useHeight'] = false;
|
||||
}
|
||||
parser.Push(begin);
|
||||
return array;
|
||||
};
|
||||
BaseMethods.AlignedArray = function (parser, begin) {
|
||||
var align = parser.GetBrackets('\\begin{' + begin.getName() + '}');
|
||||
var item = BaseMethods.Array(parser, begin);
|
||||
return ParseUtil_js_1.default.setArrayAlign(item, align);
|
||||
};
|
||||
BaseMethods.Equation = function (parser, begin, numbered) {
|
||||
parser.Push(begin);
|
||||
ParseUtil_js_1.default.checkEqnEnv(parser);
|
||||
return parser.itemFactory.create('equation', numbered).
|
||||
setProperty('name', begin.getName());
|
||||
};
|
||||
BaseMethods.EqnArray = function (parser, begin, numbered, taggable, align, spacing) {
|
||||
parser.Push(begin);
|
||||
if (taggable) {
|
||||
ParseUtil_js_1.default.checkEqnEnv(parser);
|
||||
}
|
||||
align = align.replace(/[^clr]/g, '').split('').join(' ');
|
||||
align = align.replace(/l/g, 'left').replace(/r/g, 'right').replace(/c/g, 'center');
|
||||
var newItem = parser.itemFactory.create('eqnarray', begin.getName(), numbered, taggable, parser.stack.global);
|
||||
newItem.arraydef = {
|
||||
displaystyle: true,
|
||||
columnalign: align,
|
||||
columnspacing: (spacing || '1em'),
|
||||
rowspacing: '3pt',
|
||||
side: parser.options['tagSide'],
|
||||
minlabelspacing: parser.options['tagIndent']
|
||||
};
|
||||
return newItem;
|
||||
};
|
||||
BaseMethods.HandleNoTag = function (parser, _name) {
|
||||
parser.tags.notag();
|
||||
};
|
||||
BaseMethods.HandleLabel = function (parser, name) {
|
||||
var label = parser.GetArgument(name);
|
||||
if (label === '') {
|
||||
return;
|
||||
}
|
||||
if (!parser.tags.refUpdate) {
|
||||
if (parser.tags.label) {
|
||||
throw new TexError_js_1.default('MultipleCommand', 'Multiple %1', parser.currentCS);
|
||||
}
|
||||
parser.tags.label = label;
|
||||
if ((parser.tags.allLabels[label] || parser.tags.labels[label]) && !parser.options['ignoreDuplicateLabels']) {
|
||||
throw new TexError_js_1.default('MultipleLabel', 'Label \'%1\' multiply defined', label);
|
||||
}
|
||||
parser.tags.labels[label] = new Tags_js_1.Label();
|
||||
}
|
||||
};
|
||||
BaseMethods.HandleRef = function (parser, name, eqref) {
|
||||
var label = parser.GetArgument(name);
|
||||
var ref = parser.tags.allLabels[label] || parser.tags.labels[label];
|
||||
if (!ref) {
|
||||
if (!parser.tags.refUpdate) {
|
||||
parser.tags.redo = true;
|
||||
}
|
||||
ref = new Tags_js_1.Label();
|
||||
}
|
||||
var tag = ref.tag;
|
||||
if (eqref) {
|
||||
tag = parser.tags.formatTag(tag);
|
||||
}
|
||||
var node = parser.create('node', 'mrow', ParseUtil_js_1.default.internalMath(parser, tag), {
|
||||
href: parser.tags.formatUrl(ref.id, parser.options.baseURL), 'class': 'MathJax_ref'
|
||||
});
|
||||
parser.Push(node);
|
||||
};
|
||||
BaseMethods.Macro = function (parser, name, macro, argcount, def) {
|
||||
if (argcount) {
|
||||
var args = [];
|
||||
if (def != null) {
|
||||
var optional = parser.GetBrackets(name);
|
||||
args.push(optional == null ? def : optional);
|
||||
}
|
||||
for (var i = args.length; i < argcount; i++) {
|
||||
args.push(parser.GetArgument(name));
|
||||
}
|
||||
macro = ParseUtil_js_1.default.substituteArgs(parser, args, macro);
|
||||
}
|
||||
parser.string = ParseUtil_js_1.default.addArgs(parser, macro, parser.string.slice(parser.i));
|
||||
parser.i = 0;
|
||||
ParseUtil_js_1.default.checkMaxMacros(parser);
|
||||
};
|
||||
BaseMethods.MathChoice = function (parser, name) {
|
||||
var D = parser.ParseArg(name);
|
||||
var T = parser.ParseArg(name);
|
||||
var S = parser.ParseArg(name);
|
||||
var SS = parser.ParseArg(name);
|
||||
parser.Push(parser.create('node', 'MathChoice', [D, T, S, SS]));
|
||||
};
|
||||
exports.default = BaseMethods;
|
||||
//# sourceMappingURL=BaseMethods.js.map
|
||||
1
node_modules/mathjax-full/js/input/tex/base/BaseMethods.js.map
generated
vendored
Normal file
1
node_modules/mathjax-full/js/input/tex/base/BaseMethods.js.map
generated
vendored
Normal file
File diff suppressed because one or more lines are too long
4
node_modules/mathjax-full/js/input/tex/bbox/BboxConfiguration.d.ts
generated
vendored
Normal file
4
node_modules/mathjax-full/js/input/tex/bbox/BboxConfiguration.d.ts
generated
vendored
Normal file
@@ -0,0 +1,4 @@
|
||||
import { Configuration } from '../Configuration.js';
|
||||
import { ParseMethod } from '../Types.js';
|
||||
export declare let BboxMethods: Record<string, ParseMethod>;
|
||||
export declare const BboxConfiguration: Configuration;
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user