add initial marp implementation with sample content and build configuration

node_modules/mathjax-full/js/input/tex/ams/AmsConfiguration.d.ts

@@ -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;

node_modules/mathjax-full/js/input/tex/ams/AmsConfiguration.js

@@ -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

node_modules/mathjax-full/js/input/tex/ams/AmsConfiguration.js.map

@@ -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"}

node_modules/mathjax-full/js/input/tex/ams/AmsItems.d.ts

@@ -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;
+}

node_modules/mathjax-full/js/input/tex/ams/AmsItems.js

@@ -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

node_modules/mathjax-full/js/input/tex/ams/AmsMappings.d.ts

@@ -0,0 +1 @@
+export {};

node_modules/mathjax-full/js/input/tex/ams/AmsMappings.js

@@ -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

node_modules/mathjax-full/js/input/tex/ams/AmsMethods.d.ts

@@ -0,0 +1,3 @@
+import { ParseMethod } from '../Types.js';
+export declare const AmsMethods: Record<string, ParseMethod>;
+export declare const NEW_OPS = "ams-declare-ops";

node_modules/mathjax-full/js/input/tex/ams/AmsMethods.js

@@ -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