add initial marp implementation with sample content and build configuration

node_modules/mathjax-full/js/input/tex/cases/CasesConfiguration.d.ts

@@ -0,0 +1,20 @@
+import { Configuration } from '../Configuration.js';
+import TexParser from '../TexParser.js';
+import { BeginItem, EqnArrayItem } from '../base/BaseItems.js';
+import { AmsTags } from '../ams/AmsConfiguration.js';
+import { StackItem, CheckType } from '../StackItem.js';
+export declare class CasesBeginItem extends BeginItem {
+    get kind(): string;
+    checkItem(item: StackItem): CheckType;
+}
+export declare class CasesTags extends AmsTags {
+    protected subcounter: number;
+    start(env: string, taggable: boolean, defaultTags: boolean): void;
+    autoTag(): void;
+    formatNumber(n: number, m?: number): string;
+}
+export declare const CasesMethods: {
+    NumCases(parser: TexParser, begin: CasesBeginItem): EqnArrayItem;
+    Entry(parser: TexParser, name: string): import("../Types.js").ParseResult;
+};
+export declare const CasesConfiguration: Configuration;

node_modules/mathjax-full/js/input/tex/cases/CasesConfiguration.js

@@ -0,0 +1,172 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CasesConfiguration = exports.CasesMethods = exports.CasesTags = exports.CasesBeginItem = void 0;
+var Configuration_js_1 = require("../Configuration.js");
+var SymbolMap_js_1 = require("../SymbolMap.js");
+var ParseUtil_js_1 = __importDefault(require("../ParseUtil.js"));
+var BaseMethods_js_1 = __importDefault(require("../base/BaseMethods.js"));
+var TexError_js_1 = __importDefault(require("../TexError.js"));
+var BaseItems_js_1 = require("../base/BaseItems.js");
+var AmsConfiguration_js_1 = require("../ams/AmsConfiguration.js");
+var EmpheqUtil_js_1 = require("../empheq/EmpheqUtil.js");
+var CasesBeginItem = (function (_super) {
+    __extends(CasesBeginItem, _super);
+    function CasesBeginItem() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Object.defineProperty(CasesBeginItem.prototype, "kind", {
+        get: function () {
+            return 'cases-begin';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    CasesBeginItem.prototype.checkItem = function (item) {
+        if (item.isKind('end') && item.getName() === this.getName()) {
+            if (this.getProperty('end')) {
+                this.setProperty('end', false);
+                return [[], true];
+            }
+        }
+        return _super.prototype.checkItem.call(this, item);
+    };
+    return CasesBeginItem;
+}(BaseItems_js_1.BeginItem));
+exports.CasesBeginItem = CasesBeginItem;
+var CasesTags = (function (_super) {
+    __extends(CasesTags, _super);
+    function CasesTags() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.subcounter = 0;
+        return _this;
+    }
+    CasesTags.prototype.start = function (env, taggable, defaultTags) {
+        this.subcounter = 0;
+        _super.prototype.start.call(this, env, taggable, defaultTags);
+    };
+    CasesTags.prototype.autoTag = function () {
+        if (this.currentTag.tag != null)
+            return;
+        if (this.currentTag.env === 'subnumcases') {
+            if (this.subcounter === 0)
+                this.counter++;
+            this.subcounter++;
+            this.tag(this.formatNumber(this.counter, this.subcounter), false);
+        }
+        else {
+            if (this.subcounter === 0 || this.currentTag.env !== 'numcases-left')
+                this.counter++;
+            this.tag(this.formatNumber(this.counter), false);
+        }
+    };
+    CasesTags.prototype.formatNumber = function (n, m) {
+        if (m === void 0) { m = null; }
+        return n.toString() + (m === null ? '' : String.fromCharCode(0x60 + m));
+    };
+    return CasesTags;
+}(AmsConfiguration_js_1.AmsTags));
+exports.CasesTags = CasesTags;
+exports.CasesMethods = {
+    NumCases: function (parser, begin) {
+        if (parser.stack.env.closing === begin.getName()) {
+            delete parser.stack.env.closing;
+            parser.Push(parser.itemFactory.create('end').setProperty('name', begin.getName()));
+            var cases = parser.stack.Top();
+            var table = cases.Last;
+            var original = ParseUtil_js_1.default.copyNode(table, parser);
+            var left = cases.getProperty('left');
+            EmpheqUtil_js_1.EmpheqUtil.left(table, original, left + '\\empheqlbrace\\,', parser, 'numcases-left');
+            parser.Push(parser.itemFactory.create('end').setProperty('name', begin.getName()));
+            return null;
+        }
+        else {
+            var left = parser.GetArgument('\\begin{' + begin.getName() + '}');
+            begin.setProperty('left', left);
+            var array = BaseMethods_js_1.default.EqnArray(parser, begin, true, true, 'll');
+            array.arraydef.displaystyle = false;
+            array.arraydef.rowspacing = '.2em';
+            array.setProperty('numCases', true);
+            parser.Push(begin);
+            return array;
+        }
+    },
+    Entry: function (parser, name) {
+        if (!parser.stack.Top().getProperty('numCases')) {
+            return BaseMethods_js_1.default.Entry(parser, name);
+        }
+        parser.Push(parser.itemFactory.create('cell').setProperties({ isEntry: true, name: name }));
+        var tex = parser.string;
+        var braces = 0, i = parser.i, m = tex.length;
+        while (i < m) {
+            var c = tex.charAt(i);
+            if (c === '{') {
+                braces++;
+                i++;
+            }
+            else if (c === '}') {
+                if (braces === 0) {
+                    break;
+                }
+                else {
+                    braces--;
+                    i++;
+                }
+            }
+            else if (c === '&' && braces === 0) {
+                throw new TexError_js_1.default('ExtraCasesAlignTab', 'Extra alignment tab in text for numcase environment');
+            }
+            else if (c === '\\' && braces === 0) {
+                var cs = (tex.slice(i + 1).match(/^[a-z]+|./i) || [])[0];
+                if (cs === '\\' || cs === 'cr' || cs === 'end' || cs === 'label') {
+                    break;
+                }
+                else {
+                    i += cs.length;
+                }
+            }
+            else {
+                i++;
+            }
+        }
+        var text = tex.substr(parser.i, i - parser.i).replace(/^\s*/, '');
+        parser.PushAll(ParseUtil_js_1.default.internalMath(parser, text, 0));
+        parser.i = i;
+    }
+};
+new SymbolMap_js_1.EnvironmentMap('cases-env', EmpheqUtil_js_1.EmpheqUtil.environment, {
+    numcases: ['NumCases', 'cases'],
+    subnumcases: ['NumCases', 'cases']
+}, exports.CasesMethods);
+new SymbolMap_js_1.MacroMap('cases-macros', {
+    '&': 'Entry'
+}, exports.CasesMethods);
+exports.CasesConfiguration = Configuration_js_1.Configuration.create('cases', {
+    handler: {
+        environment: ['cases-env'],
+        character: ['cases-macros']
+    },
+    items: (_a = {},
+        _a[CasesBeginItem.prototype.kind] = CasesBeginItem,
+        _a),
+    tags: { 'cases': CasesTags }
+});
+//# sourceMappingURL=CasesConfiguration.js.map