add initial marp implementation with sample content and build configuration

node_modules/mathjax-full/js/components/global.d.ts

@@ -0,0 +1,16 @@
+export interface MathJaxConfig {
+    [name: string]: any;
+}
+export interface MathJaxLibrary {
+    [name: string]: any;
+}
+export interface MathJaxObject {
+    version: string;
+    _: MathJaxLibrary;
+    config: MathJaxConfig;
+}
+export declare function isObject(x: any): boolean;
+export declare function combineConfig(dst: any, src: any): any;
+export declare function combineDefaults(dst: any, name: string, src: any): any;
+export declare function combineWithMathJax(config: any): MathJaxObject;
+export declare const MathJax: MathJaxObject;

node_modules/mathjax-full/js/components/global.js

@@ -0,0 +1,88 @@
+"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.");
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MathJax = exports.combineWithMathJax = exports.combineDefaults = exports.combineConfig = exports.isObject = void 0;
+var version_js_1 = require("./version.js");
+function isObject(x) {
+    return typeof x === 'object' && x !== null;
+}
+exports.isObject = isObject;
+function combineConfig(dst, src) {
+    var e_1, _a;
+    try {
+        for (var _b = __values(Object.keys(src)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var id = _c.value;
+            if (id === '__esModule')
+                continue;
+            if (isObject(dst[id]) && isObject(src[id]) &&
+                !(src[id] instanceof Promise)) {
+                combineConfig(dst[id], src[id]);
+            }
+            else if (src[id] !== null && src[id] !== undefined) {
+                dst[id] = src[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; }
+    }
+    return dst;
+}
+exports.combineConfig = combineConfig;
+function combineDefaults(dst, name, src) {
+    var e_2, _a;
+    if (!dst[name]) {
+        dst[name] = {};
+    }
+    dst = dst[name];
+    try {
+        for (var _b = __values(Object.keys(src)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var id = _c.value;
+            if (isObject(dst[id]) && isObject(src[id])) {
+                combineDefaults(dst, id, src[id]);
+            }
+            else if (dst[id] == null && src[id] != null) {
+                dst[id] = src[id];
+            }
+        }
+    }
+    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 dst;
+}
+exports.combineDefaults = combineDefaults;
+function combineWithMathJax(config) {
+    return combineConfig(exports.MathJax, config);
+}
+exports.combineWithMathJax = combineWithMathJax;
+if (typeof global.MathJax === 'undefined') {
+    global.MathJax = {};
+}
+if (!global.MathJax.version) {
+    global.MathJax = {
+        version: version_js_1.VERSION,
+        _: {},
+        config: global.MathJax
+    };
+}
+exports.MathJax = global.MathJax;
+//# sourceMappingURL=global.js.map

node_modules/mathjax-full/js/components/global.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"global.js","sourceRoot":"","sources":["../../ts/components/global.ts"],"names":[],"mappings":";;;;;;;;;;;;;;AAwBA,2CAAqC;AAiCrC,SAAgB,QAAQ,CAAC,CAAM;IAC7B,OAAO,OAAO,CAAC,KAAK,QAAQ,IAAI,CAAC,KAAK,IAAI,CAAC;AAC7C,CAAC;AAFD,4BAEC;AAUD,SAAgB,aAAa,CAAC,GAAQ,EAAE,GAAQ;;;QAC9C,KAAiB,IAAA,KAAA,SAAA,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA,gBAAA,4BAAE;YAA9B,IAAM,EAAE,WAAA;YACX,IAAI,EAAE,KAAK,YAAY;gBAAE,SAAS;YAClC,IAAI,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,IAAI,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;gBACtC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,YAAY,OAAO,CAAC,EAA+B;gBAC9D,aAAa,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC;aACjC;iBAAM,IAAI,GAAG,CAAC,EAAE,CAAC,KAAK,IAAI,IAAI,GAAG,CAAC,EAAE,CAAC,KAAK,SAAS,EAAE;gBACpD,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,CAAC,EAAE,CAAC,CAAC;aACnB;SACF;;;;;;;;;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAXD,sCAWC;AAYD,SAAgB,eAAe,CAAC,GAAQ,EAAE,IAAY,EAAE,GAAQ;;IAC9D,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE;QACd,GAAG,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC;KAChB;IACD,GAAG,GAAG,GAAG,CAAC,IAAI,CAAC,CAAC;;QAChB,KAAiB,IAAA,KAAA,SAAA,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA,gBAAA,4BAAE;YAA9B,IAAM,EAAE,WAAA;YACX,IAAI,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,IAAI,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,EAAE;gBAC1C,eAAe,CAAC,GAAG,EAAE,EAAE,EAAE,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC;aACnC;iBAAM,IAAI,GAAG,CAAC,EAAE,CAAC,IAAI,IAAI,IAAI,GAAG,CAAC,EAAE,CAAC,IAAI,IAAI,EAAE;gBAC7C,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,CAAC,EAAE,CAAC,CAAC;aACnB;SACF;;;;;;;;;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAbD,0CAaC;AAOD,SAAgB,kBAAkB,CAAC,MAAW;IAC5C,OAAO,aAAa,CAAC,eAAO,EAAE,MAAM,CAAC,CAAC;AACxC,CAAC;AAFD,gDAEC;AAMD,IAAI,OAAO,MAAM,CAAC,OAAO,KAAK,WAAW,EAAE;IACzC,MAAM,CAAC,OAAO,GAAG,EAAmB,CAAC;CACtC;AAOD,IAAI,CAAE,MAAM,CAAC,OAAyB,CAAC,OAAO,EAAE;IAC9C,MAAM,CAAC,OAAO,GAAG;QACf,OAAO,EAAE,oBAAO;QAChB,CAAC,EAAE,EAAE;QACL,MAAM,EAAE,MAAM,CAAC,OAAO;KACvB,CAAC;CACH;AAKY,QAAA,OAAO,GAAG,MAAM,CAAC,OAAwB,CAAC"}

node_modules/mathjax-full/js/components/latest.d.ts

@@ -0,0 +1 @@
+export declare function loadLatest(): void;

node_modules/mathjax-full/js/components/latest.js

@@ -0,0 +1,288 @@
+"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.loadLatest = void 0;
+var CDN = new Map([
+    ['cdnjs.cloudflare.com', {
+            api: 'https://api.cdnjs.com/libraries/mathjax?fields=version',
+            key: 'version',
+            base: 'https://cdnjs.cloudflare.com/ajax/libs/mathjax/'
+        }],
+    ['rawcdn.githack.com', {
+            api: 'https://api.github.com/repos/mathjax/mathjax/releases/latest',
+            key: 'tag_name',
+            base: 'https://rawcdn.githack.com/mathjax/MathJax/'
+        }],
+    ['gitcdn.xyz', {
+            api: 'https://api.github.com/repos/mathjax/mathjax/releases/latest',
+            key: 'tag_name',
+            base: 'https://gitcdn.xyz/mathjax/MathJax/'
+        }],
+    ['cdn.statically.io', {
+            api: 'https://api.github.com/repos/mathjax/mathjax/releases/latest',
+            key: 'tag_name',
+            base: 'https://cdn.statically.io/gh/mathjax/MathJax/'
+        }],
+    ['unpkg.com', {
+            api: 'https://api.github.com/repos/mathjax/mathjax/releases/latest',
+            key: 'tag_name',
+            base: 'https://unpkg.com/mathjax@'
+        }],
+    ['cdn.jsdelivr.net', {
+            api: 'https://api.github.com/repos/mathjax/mathjax/releases/latest',
+            key: 'tag_name',
+            base: 'https://cdn.jsdelivr.net/npm/mathjax@'
+        }]
+]);
+var GITHUB = {
+    api: 'https://api.github.com/repos/mathjax/mathjax/releases',
+    key: 'tag_name'
+};
+var MJX_VERSION = 3;
+var MJX_LATEST = 'mjx-latest-version';
+var SAVE_TIME = 1000 * 60 * 60 * 24 * 7;
+var script = null;
+function Error(message) {
+    if (console && console.error) {
+        console.error('MathJax(latest.js): ' + message);
+    }
+}
+function scriptData(script, cdn) {
+    if (cdn === void 0) { cdn = null; }
+    script.parentNode.removeChild(script);
+    var src = script.src;
+    var file = src.replace(/.*?\/latest\.js(\?|$)/, '');
+    if (file === '') {
+        file = 'startup.js';
+        src = src.replace(/\?$/, '') + '?' + file;
+    }
+    var version = (src.match(/(\d+\.\d+\.\d+)(\/es\d+)?\/latest.js\?/) || ['', ''])[1];
+    var dir = (src.match(/(\/es\d+)\/latest.js\?/) || ['', ''])[1] || '';
+    return {
+        tag: script,
+        src: src,
+        id: script.id,
+        version: version,
+        dir: dir,
+        file: file,
+        cdn: cdn
+    };
+}
+function checkScript(script) {
+    var e_1, _a;
+    try {
+        for (var _b = __values(CDN.keys()), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var server = _c.value;
+            var cdn = CDN.get(server);
+            var url = cdn.base;
+            var src = script.src;
+            if (src && src.substr(0, url.length) === url && src.match(/\/latest\.js(\?|$)/)) {
+                return scriptData(script, cdn);
+            }
+        }
+    }
+    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 null;
+}
+function getScript() {
+    var e_2, _a;
+    if (document.currentScript) {
+        return scriptData(document.currentScript);
+    }
+    var script = document.getElementById('MathJax-script');
+    if (script && script.nodeName.toLowerCase() === 'script') {
+        return checkScript(script);
+    }
+    var scripts = document.getElementsByTagName('script');
+    try {
+        for (var _b = __values(Array.from(scripts)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var script_1 = _c.value;
+            var data = checkScript(script_1);
+            if (data) {
+                return data;
+            }
+        }
+    }
+    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 null;
+}
+function saveVersion(version) {
+    try {
+        var data = version + ' ' + Date.now();
+        localStorage.setItem(MJX_LATEST, data);
+    }
+    catch (err) { }
+}
+function getSavedVersion() {
+    try {
+        var _a = __read(localStorage.getItem(MJX_LATEST).split(/ /), 2), version = _a[0], date = _a[1];
+        if (date && Date.now() - parseInt(date) < SAVE_TIME) {
+            return version;
+        }
+    }
+    catch (err) { }
+    return null;
+}
+function loadMathJax(url, id) {
+    var script = document.createElement('script');
+    script.type = 'text/javascript';
+    script.async = true;
+    script.src = url;
+    if (id) {
+        script.id = id;
+    }
+    var head = document.head || document.getElementsByTagName('head')[0] || document.body;
+    if (head) {
+        head.appendChild(script);
+    }
+    else {
+        Error('Can\'t find the document <head> element');
+    }
+}
+function loadDefaultMathJax() {
+    if (script) {
+        loadMathJax(script.src.replace(/\/latest\.js\?/, '/'), script.id);
+    }
+    else {
+        Error('Can\'t determine the URL for loading MathJax');
+    }
+}
+function loadVersion(version) {
+    if (script.version && script.version !== version) {
+        script.file = 'latest.js?' + script.file;
+    }
+    loadMathJax(script.cdn.base + version + script.dir + '/' + script.file, script.id);
+}
+function checkVersion(version) {
+    var major = parseInt(version.split(/\./)[0]);
+    if (major === MJX_VERSION && !version.match(/-(beta|rc)/)) {
+        saveVersion(version);
+        loadVersion(version);
+        return true;
+    }
+    return false;
+}
+function getXMLHttpRequest() {
+    if (window.XMLHttpRequest) {
+        return new XMLHttpRequest();
+    }
+    if (window.ActiveXObject) {
+        try {
+            return new window.ActiveXObject('Msxml2.XMLHTTP');
+        }
+        catch (err) { }
+        try {
+            return new window.ActiveXObject('Microsoft.XMLHTTP');
+        }
+        catch (err) { }
+    }
+    return null;
+}
+function requestXML(cdn, action, failure) {
+    var request = getXMLHttpRequest();
+    if (request) {
+        request.onreadystatechange = function () {
+            if (request.readyState === 4) {
+                if (request.status === 200) {
+                    !action(JSON.parse(request.responseText)) && failure();
+                }
+                else {
+                    Error('Problem acquiring MathJax version: status = ' + request.status);
+                    failure();
+                }
+            }
+        };
+        request.open('GET', cdn.api, true);
+        request.send(null);
+    }
+    else {
+        Error('Can\'t create XMLHttpRequest object');
+        failure();
+    }
+}
+function loadLatestGitVersion() {
+    requestXML(GITHUB, function (json) {
+        var e_3, _a;
+        if (!(json instanceof Array))
+            return false;
+        try {
+            for (var json_1 = __values(json), json_1_1 = json_1.next(); !json_1_1.done; json_1_1 = json_1.next()) {
+                var data = json_1_1.value;
+                if (checkVersion(data[GITHUB.key])) {
+                    return true;
+                }
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (json_1_1 && !json_1_1.done && (_a = json_1.return)) _a.call(json_1);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        return false;
+    }, loadDefaultMathJax);
+}
+function loadLatestCdnVersion() {
+    requestXML(script.cdn, function (json) {
+        if (json instanceof Array) {
+            json = json[0];
+        }
+        if (!checkVersion(json[script.cdn.key])) {
+            loadLatestGitVersion();
+        }
+        return true;
+    }, loadDefaultMathJax);
+}
+function loadLatest() {
+    script = getScript();
+    if (script && script.cdn) {
+        var version = getSavedVersion();
+        version ?
+            loadVersion(version) :
+            loadLatestCdnVersion();
+    }
+    else {
+        loadDefaultMathJax();
+    }
+}
+exports.loadLatest = loadLatest;
+//# sourceMappingURL=latest.js.map

node_modules/mathjax-full/js/components/loader.d.ts

@@ -0,0 +1,83 @@
+import { MathJaxObject as MJObject, MathJaxLibrary, MathJaxConfig as MJConfig } from './global.js';
+import { PackageReady, PackageFailed } from './package.js';
+export { Package, PackageError, PackageReady, PackageFailed } from './package.js';
+export { MathJaxLibrary } from './global.js';
+import { FunctionList } from '../util/FunctionList.js';
+export declare type PathFilterFunction = (data: {
+    name: string;
+    original: string;
+    addExtension: boolean;
+}) => boolean;
+export declare type PathFilterList = (PathFilterFunction | [PathFilterFunction, number])[];
+export interface MathJaxConfig extends MJConfig {
+    loader?: {
+        paths?: {
+            [name: string]: string;
+        };
+        source?: {
+            [name: string]: string;
+        };
+        dependencies?: {
+            [name: string]: string[];
+        };
+        provides?: {
+            [name: string]: string[];
+        };
+        load?: string[];
+        ready?: PackageReady;
+        failed?: PackageFailed;
+        require?: (url: string) => any;
+        pathFilters?: PathFilterList;
+        versionWarnings?: boolean;
+        [name: string]: any;
+    };
+}
+export interface MathJaxObject extends MJObject {
+    _: MathJaxLibrary;
+    config: MathJaxConfig;
+    loader: {
+        ready: (...names: string[]) => Promise<string[]>;
+        load: (...names: string[]) => Promise<string>;
+        preLoad: (...names: string[]) => void;
+        defaultReady: () => void;
+        getRoot: () => string;
+        checkVersion: (name: string, version: string) => boolean;
+        pathFilters: FunctionList;
+    };
+    startup?: any;
+}
+export declare const PathFilters: {
+    [name: string]: PathFilterFunction;
+};
+export declare namespace Loader {
+    const versions: Map<string, string>;
+    function ready(...names: string[]): Promise<string[]>;
+    function load(...names: string[]): Promise<void | string[]>;
+    function preLoad(...names: string[]): void;
+    function defaultReady(): void;
+    function getRoot(): string;
+    function checkVersion(name: string, version: string, _type?: string): boolean;
+    const pathFilters: FunctionList;
+}
+export declare const MathJax: MathJaxObject;
+export declare const CONFIG: {
+    [name: string]: any;
+    paths?: {
+        [name: string]: string;
+    };
+    source?: {
+        [name: string]: string;
+    };
+    dependencies?: {
+        [name: string]: string[];
+    };
+    provides?: {
+        [name: string]: string[];
+    };
+    load?: string[];
+    ready?: PackageReady;
+    failed?: PackageFailed;
+    require?: (url: string) => any;
+    pathFilters?: PathFilterList;
+    versionWarnings?: boolean;
+};

node_modules/mathjax-full/js/components/loader.js

@@ -0,0 +1,218 @@
+"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 e_1, _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONFIG = exports.MathJax = exports.Loader = exports.PathFilters = exports.PackageError = exports.Package = void 0;
+var global_js_1 = require("./global.js");
+var package_js_1 = require("./package.js");
+var package_js_2 = require("./package.js");
+Object.defineProperty(exports, "Package", { enumerable: true, get: function () { return package_js_2.Package; } });
+Object.defineProperty(exports, "PackageError", { enumerable: true, get: function () { return package_js_2.PackageError; } });
+var FunctionList_js_1 = require("../util/FunctionList.js");
+exports.PathFilters = {
+    source: function (data) {
+        if (exports.CONFIG.source.hasOwnProperty(data.name)) {
+            data.name = exports.CONFIG.source[data.name];
+        }
+        return true;
+    },
+    normalize: function (data) {
+        var name = data.name;
+        if (!name.match(/^(?:[a-z]+:\/)?\/|[a-z]:\\|\[/i)) {
+            data.name = '[mathjax]/' + name.replace(/^\.\//, '');
+        }
+        if (data.addExtension && !name.match(/\.[^\/]+$/)) {
+            data.name += '.js';
+        }
+        return true;
+    },
+    prefix: function (data) {
+        var match;
+        while ((match = data.name.match(/^\[([^\]]*)\]/))) {
+            if (!exports.CONFIG.paths.hasOwnProperty(match[1]))
+                break;
+            data.name = exports.CONFIG.paths[match[1]] + data.name.substr(match[0].length);
+        }
+        return true;
+    }
+};
+var Loader;
+(function (Loader) {
+    var VERSION = global_js_1.MathJax.version;
+    Loader.versions = new Map();
+    function ready() {
+        var e_2, _a;
+        var names = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            names[_i] = arguments[_i];
+        }
+        if (names.length === 0) {
+            names = Array.from(package_js_1.Package.packages.keys());
+        }
+        var promises = [];
+        try {
+            for (var names_1 = __values(names), names_1_1 = names_1.next(); !names_1_1.done; names_1_1 = names_1.next()) {
+                var name_1 = names_1_1.value;
+                var extension = package_js_1.Package.packages.get(name_1) || new package_js_1.Package(name_1, true);
+                promises.push(extension.promise);
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (names_1_1 && !names_1_1.done && (_a = names_1.return)) _a.call(names_1);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        return Promise.all(promises);
+    }
+    Loader.ready = ready;
+    function load() {
+        var e_3, _a;
+        var names = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            names[_i] = arguments[_i];
+        }
+        if (names.length === 0) {
+            return Promise.resolve();
+        }
+        var promises = [];
+        var _loop_1 = function (name_2) {
+            var extension = package_js_1.Package.packages.get(name_2);
+            if (!extension) {
+                extension = new package_js_1.Package(name_2);
+                extension.provides(exports.CONFIG.provides[name_2]);
+            }
+            extension.checkNoLoad();
+            promises.push(extension.promise.then(function () {
+                if (!exports.CONFIG.versionWarnings)
+                    return;
+                if (extension.isLoaded && !Loader.versions.has(package_js_1.Package.resolvePath(name_2))) {
+                    console.warn("No version information available for component ".concat(name_2));
+                }
+            }));
+        };
+        try {
+            for (var names_2 = __values(names), names_2_1 = names_2.next(); !names_2_1.done; names_2_1 = names_2.next()) {
+                var name_2 = names_2_1.value;
+                _loop_1(name_2);
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (names_2_1 && !names_2_1.done && (_a = names_2.return)) _a.call(names_2);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        package_js_1.Package.loadAll();
+        return Promise.all(promises);
+    }
+    Loader.load = load;
+    function preLoad() {
+        var e_4, _a;
+        var names = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            names[_i] = arguments[_i];
+        }
+        try {
+            for (var names_3 = __values(names), names_3_1 = names_3.next(); !names_3_1.done; names_3_1 = names_3.next()) {
+                var name_3 = names_3_1.value;
+                var extension = package_js_1.Package.packages.get(name_3);
+                if (!extension) {
+                    extension = new package_js_1.Package(name_3, true);
+                    extension.provides(exports.CONFIG.provides[name_3]);
+                }
+                extension.loaded();
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (names_3_1 && !names_3_1.done && (_a = names_3.return)) _a.call(names_3);
+            }
+            finally { if (e_4) throw e_4.error; }
+        }
+    }
+    Loader.preLoad = preLoad;
+    function defaultReady() {
+        if (typeof exports.MathJax.startup !== 'undefined') {
+            exports.MathJax.config.startup.ready();
+        }
+    }
+    Loader.defaultReady = defaultReady;
+    function getRoot() {
+        var root = __dirname + '/../../es5';
+        if (typeof document !== 'undefined') {
+            var script = document.currentScript || document.getElementById('MathJax-script');
+            if (script) {
+                root = script.src.replace(/\/[^\/]*$/, '');
+            }
+        }
+        return root;
+    }
+    Loader.getRoot = getRoot;
+    function checkVersion(name, version, _type) {
+        Loader.versions.set(package_js_1.Package.resolvePath(name), VERSION);
+        if (exports.CONFIG.versionWarnings && version !== VERSION) {
+            console.warn("Component ".concat(name, " uses ").concat(version, " of MathJax; version in use is ").concat(VERSION));
+            return true;
+        }
+        return false;
+    }
+    Loader.checkVersion = checkVersion;
+    Loader.pathFilters = new FunctionList_js_1.FunctionList();
+    Loader.pathFilters.add(exports.PathFilters.source, 0);
+    Loader.pathFilters.add(exports.PathFilters.normalize, 10);
+    Loader.pathFilters.add(exports.PathFilters.prefix, 20);
+})(Loader = exports.Loader || (exports.Loader = {}));
+exports.MathJax = global_js_1.MathJax;
+if (typeof exports.MathJax.loader === 'undefined') {
+    (0, global_js_1.combineDefaults)(exports.MathJax.config, 'loader', {
+        paths: {
+            mathjax: Loader.getRoot()
+        },
+        source: {},
+        dependencies: {},
+        provides: {},
+        load: [],
+        ready: Loader.defaultReady.bind(Loader),
+        failed: function (error) { return console.log("MathJax(".concat(error.package || '?', "): ").concat(error.message)); },
+        require: null,
+        pathFilters: [],
+        versionWarnings: true
+    });
+    (0, global_js_1.combineWithMathJax)({
+        loader: Loader
+    });
+    try {
+        for (var _b = __values(exports.MathJax.config.loader.pathFilters), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var filter = _c.value;
+            if (Array.isArray(filter)) {
+                Loader.pathFilters.add(filter[0], filter[1]);
+            }
+            else {
+                Loader.pathFilters.add(filter);
+            }
+        }
+    }
+    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; }
+    }
+}
+exports.CONFIG = exports.MathJax.config.loader;
+//# sourceMappingURL=loader.js.map

node_modules/mathjax-full/js/components/package.d.ts

@@ -0,0 +1,44 @@
+export declare type PackageMap = Map<string, Package>;
+export declare class PackageError extends Error {
+    package: string;
+    constructor(message: string, name: string);
+}
+export declare type PackageReady = (name: string) => string | void;
+export declare type PackageFailed = (message: PackageError) => void;
+export declare type PackagePromise = (resolve: PackageReady, reject: PackageFailed) => void;
+export interface PackageConfig {
+    ready?: PackageReady;
+    failed?: PackageFailed;
+    checkReady?: () => Promise<void>;
+}
+export declare class Package {
+    static packages: PackageMap;
+    name: string;
+    isLoaded: boolean;
+    promise: Promise<string>;
+    protected isLoading: boolean;
+    protected hasFailed: boolean;
+    protected noLoad: boolean;
+    protected resolve: PackageReady;
+    protected reject: PackageFailed;
+    protected dependents: Package[];
+    protected dependencies: Package[];
+    protected dependencyCount: number;
+    protected provided: Package[];
+    get canLoad(): boolean;
+    static resolvePath(name: string, addExtension?: boolean): string;
+    static loadAll(): void;
+    constructor(name: string, noLoad?: boolean);
+    protected makeDependencies(): Promise<string>[];
+    protected makePromise(promises: Promise<string>[]): Promise<string>;
+    load(): void;
+    protected loadCustom(url: string): void;
+    protected loadScript(url: string): void;
+    loaded(): void;
+    protected failed(message: string): void;
+    protected checkLoad(): void;
+    requirementSatisfied(): void;
+    provides(names?: string[]): void;
+    addDependent(extension: Package, noLoad: boolean): void;
+    checkNoLoad(): void;
+}

node_modules/mathjax-full/js/components/package.js

@@ -0,0 +1,311 @@
+"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 __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 });
+exports.Package = exports.PackageError = void 0;
+var loader_js_1 = require("./loader.js");
+var PackageError = (function (_super) {
+    __extends(PackageError, _super);
+    function PackageError(message, name) {
+        var _this = _super.call(this, message) || this;
+        _this.package = name;
+        return _this;
+    }
+    return PackageError;
+}(Error));
+exports.PackageError = PackageError;
+var Package = (function () {
+    function Package(name, noLoad) {
+        if (noLoad === void 0) { noLoad = false; }
+        this.isLoaded = false;
+        this.isLoading = false;
+        this.hasFailed = false;
+        this.dependents = [];
+        this.dependencies = [];
+        this.dependencyCount = 0;
+        this.provided = [];
+        this.name = name;
+        this.noLoad = noLoad;
+        Package.packages.set(name, this);
+        this.promise = this.makePromise(this.makeDependencies());
+    }
+    Object.defineProperty(Package.prototype, "canLoad", {
+        get: function () {
+            return this.dependencyCount === 0 && !this.noLoad && !this.isLoading && !this.hasFailed;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Package.resolvePath = function (name, addExtension) {
+        if (addExtension === void 0) { addExtension = true; }
+        var data = { name: name, original: name, addExtension: addExtension };
+        loader_js_1.Loader.pathFilters.execute(data);
+        return data.name;
+    };
+    Package.loadAll = function () {
+        var e_1, _a;
+        try {
+            for (var _b = __values(this.packages.values()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var extension = _c.value;
+                if (extension.canLoad) {
+                    extension.load();
+                }
+            }
+        }
+        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; }
+        }
+    };
+    Package.prototype.makeDependencies = function () {
+        var e_2, _a;
+        var promises = [];
+        var map = Package.packages;
+        var noLoad = this.noLoad;
+        var name = this.name;
+        var dependencies = [];
+        if (loader_js_1.CONFIG.dependencies.hasOwnProperty(name)) {
+            dependencies.push.apply(dependencies, __spreadArray([], __read(loader_js_1.CONFIG.dependencies[name]), false));
+        }
+        else if (name !== 'core') {
+            dependencies.push('core');
+        }
+        try {
+            for (var dependencies_1 = __values(dependencies), dependencies_1_1 = dependencies_1.next(); !dependencies_1_1.done; dependencies_1_1 = dependencies_1.next()) {
+                var dependent = dependencies_1_1.value;
+                var extension = map.get(dependent) || new Package(dependent, noLoad);
+                if (this.dependencies.indexOf(extension) < 0) {
+                    extension.addDependent(this, noLoad);
+                    this.dependencies.push(extension);
+                    if (!extension.isLoaded) {
+                        this.dependencyCount++;
+                        promises.push(extension.promise);
+                    }
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (dependencies_1_1 && !dependencies_1_1.done && (_a = dependencies_1.return)) _a.call(dependencies_1);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        return promises;
+    };
+    Package.prototype.makePromise = function (promises) {
+        var _this = this;
+        var promise = new Promise((function (resolve, reject) {
+            _this.resolve = resolve;
+            _this.reject = reject;
+        }));
+        var config = (loader_js_1.CONFIG[this.name] || {});
+        if (config.ready) {
+            promise = promise.then(function (_name) { return config.ready(_this.name); });
+        }
+        if (promises.length) {
+            promises.push(promise);
+            promise = Promise.all(promises).then(function (names) { return names.join(', '); });
+        }
+        if (config.failed) {
+            promise.catch(function (message) { return config.failed(new PackageError(message, _this.name)); });
+        }
+        return promise;
+    };
+    Package.prototype.load = function () {
+        if (!this.isLoaded && !this.isLoading && !this.noLoad) {
+            this.isLoading = true;
+            var url = Package.resolvePath(this.name);
+            if (loader_js_1.CONFIG.require) {
+                this.loadCustom(url);
+            }
+            else {
+                this.loadScript(url);
+            }
+        }
+    };
+    Package.prototype.loadCustom = function (url) {
+        var _this = this;
+        try {
+            var result = loader_js_1.CONFIG.require(url);
+            if (result instanceof Promise) {
+                result.then(function () { return _this.checkLoad(); })
+                    .catch(function (err) { return _this.failed('Can\'t load "' + url + '"\n' + err.message.trim()); });
+            }
+            else {
+                this.checkLoad();
+            }
+        }
+        catch (err) {
+            this.failed(err.message);
+        }
+    };
+    Package.prototype.loadScript = function (url) {
+        var _this = this;
+        var script = document.createElement('script');
+        script.src = url;
+        script.charset = 'UTF-8';
+        script.onload = function (_event) { return _this.checkLoad(); };
+        script.onerror = function (_event) { return _this.failed('Can\'t load "' + url + '"'); };
+        document.head.appendChild(script);
+    };
+    Package.prototype.loaded = function () {
+        var e_3, _a, e_4, _b;
+        this.isLoaded = true;
+        this.isLoading = false;
+        try {
+            for (var _c = __values(this.dependents), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var dependent = _d.value;
+                dependent.requirementSatisfied();
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        try {
+            for (var _e = __values(this.provided), _f = _e.next(); !_f.done; _f = _e.next()) {
+                var provided = _f.value;
+                provided.loaded();
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+            }
+            finally { if (e_4) throw e_4.error; }
+        }
+        this.resolve(this.name);
+    };
+    Package.prototype.failed = function (message) {
+        this.hasFailed = true;
+        this.isLoading = false;
+        this.reject(new PackageError(message, this.name));
+    };
+    Package.prototype.checkLoad = function () {
+        var _this = this;
+        var config = (loader_js_1.CONFIG[this.name] || {});
+        var checkReady = config.checkReady || (function () { return Promise.resolve(); });
+        checkReady().then(function () { return _this.loaded(); })
+            .catch(function (message) { return _this.failed(message); });
+    };
+    Package.prototype.requirementSatisfied = function () {
+        if (this.dependencyCount) {
+            this.dependencyCount--;
+            if (this.canLoad) {
+                this.load();
+            }
+        }
+    };
+    Package.prototype.provides = function (names) {
+        var e_5, _a;
+        if (names === void 0) { names = []; }
+        try {
+            for (var names_1 = __values(names), names_1_1 = names_1.next(); !names_1_1.done; names_1_1 = names_1.next()) {
+                var name_1 = names_1_1.value;
+                var provided = Package.packages.get(name_1);
+                if (!provided) {
+                    if (!loader_js_1.CONFIG.dependencies[name_1]) {
+                        loader_js_1.CONFIG.dependencies[name_1] = [];
+                    }
+                    loader_js_1.CONFIG.dependencies[name_1].push(name_1);
+                    provided = new Package(name_1, true);
+                    provided.isLoading = true;
+                }
+                this.provided.push(provided);
+            }
+        }
+        catch (e_5_1) { e_5 = { error: e_5_1 }; }
+        finally {
+            try {
+                if (names_1_1 && !names_1_1.done && (_a = names_1.return)) _a.call(names_1);
+            }
+            finally { if (e_5) throw e_5.error; }
+        }
+    };
+    Package.prototype.addDependent = function (extension, noLoad) {
+        this.dependents.push(extension);
+        if (!noLoad) {
+            this.checkNoLoad();
+        }
+    };
+    Package.prototype.checkNoLoad = function () {
+        var e_6, _a;
+        if (this.noLoad) {
+            this.noLoad = false;
+            try {
+                for (var _b = __values(this.dependencies), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var dependency = _c.value;
+                    dependency.checkNoLoad();
+                }
+            }
+            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; }
+            }
+        }
+    };
+    Package.packages = new Map();
+    return Package;
+}());
+exports.Package = Package;
+//# sourceMappingURL=package.js.map

node_modules/mathjax-full/js/components/startup.d.ts

@@ -0,0 +1,118 @@
+import { MathJaxObject as MJObject, MathJaxConfig as MJConfig } from './global.js';
+import { MathDocument } from '../core/MathDocument.js';
+import { MmlNode } from '../core/MmlTree/MmlNode.js';
+import { Handler } from '../core/Handler.js';
+import { InputJax } from '../core/InputJax.js';
+import { OutputJax } from '../core/OutputJax.js';
+import { CommonOutputJax } from '../output/common/OutputJax.js';
+import { DOMAdaptor } from '../core/DOMAdaptor.js';
+import { TeX } from '../input/tex.js';
+export interface MathJaxConfig extends MJConfig {
+    startup?: {
+        input?: string[];
+        output?: string;
+        handler?: string;
+        adaptor?: string;
+        document?: any;
+        elements?: any[];
+        typeset?: boolean;
+        ready?: () => void;
+        pageReady?: () => void;
+        invalidOption?: 'fatal' | 'warn';
+        optionError?: (message: string, key: string) => void;
+        [name: string]: any;
+    };
+}
+export declare type MATHDOCUMENT = MathDocument<any, any, any>;
+export declare type HANDLER = Handler<any, any, any>;
+export declare type DOMADAPTOR = DOMAdaptor<any, any, any>;
+export declare type INPUTJAX = InputJax<any, any, any>;
+export declare type OUTPUTJAX = OutputJax<any, any, any>;
+export declare type COMMONJAX = CommonOutputJax<any, any, any, any, any, any, any>;
+export declare type TEX = TeX<any, any, any>;
+export declare type HandlerExtension = (handler: HANDLER) => HANDLER;
+export interface MathJaxObject extends MJObject {
+    config: MathJaxConfig;
+    startup: {
+        constructors: {
+            [name: string]: any;
+        };
+        input: INPUTJAX[];
+        output: OUTPUTJAX;
+        handler: HANDLER;
+        adaptor: DOMADAPTOR;
+        elements: any[];
+        document: MATHDOCUMENT;
+        promise: Promise<void>;
+        registerConstructor(name: string, constructor: any): void;
+        useHandler(name: string, force?: boolean): void;
+        useAdaptor(name: string, force?: boolean): void;
+        useOutput(name: string, force?: boolean): void;
+        useInput(name: string, force?: boolean): void;
+        extendHandler(extend: HandlerExtension): void;
+        toMML(node: MmlNode): string;
+        defaultReady(): void;
+        defaultPageReady(): Promise<void>;
+        getComponents(): void;
+        makeMethods(): void;
+        makeTypesetMethods(): void;
+        makeOutputMethods(iname: string, oname: string, input: INPUTJAX): void;
+        makeMmlMethods(name: string, input: INPUTJAX): void;
+        makeResetMethod(name: string, input: INPUTJAX): void;
+        getInputJax(): INPUTJAX[];
+        getOutputJax(): OUTPUTJAX;
+        getAdaptor(): DOMADAPTOR;
+        getHandler(): HANDLER;
+    };
+    [name: string]: any;
+}
+export declare namespace Startup {
+    const constructors: {
+        [name: string]: any;
+    };
+    let input: INPUTJAX[];
+    let output: OUTPUTJAX;
+    let handler: HANDLER;
+    let adaptor: DOMADAPTOR;
+    let elements: any[];
+    let document: MATHDOCUMENT;
+    let promiseResolve: () => void;
+    let promiseReject: (reason: any) => void;
+    let promise: Promise<void>;
+    let pagePromise: Promise<void>;
+    function toMML(node: MmlNode): string;
+    function registerConstructor(name: string, constructor: any): void;
+    function useHandler(name: string, force?: boolean): void;
+    function useAdaptor(name: string, force?: boolean): void;
+    function useInput(name: string, force?: boolean): void;
+    function useOutput(name: string, force?: boolean): void;
+    function extendHandler(extend: HandlerExtension, priority?: number): void;
+    function defaultReady(): void;
+    function defaultPageReady(): Promise<void>;
+    function getComponents(): void;
+    function makeMethods(): void;
+    function makeTypesetMethods(): void;
+    function makeOutputMethods(iname: string, oname: string, input: INPUTJAX): void;
+    function makeMmlMethods(name: string, input: INPUTJAX): void;
+    function makeResetMethod(name: string, input: INPUTJAX): void;
+    function getInputJax(): INPUTJAX[];
+    function getOutputJax(): OUTPUTJAX;
+    function getAdaptor(): DOMADAPTOR;
+    function getHandler(): HANDLER;
+    function getDocument(root?: any): MathDocument<any, any, any>;
+}
+export declare const MathJax: MathJaxObject;
+export declare const CONFIG: {
+    [name: string]: any;
+    input?: string[];
+    output?: string;
+    handler?: string;
+    adaptor?: string;
+    document?: any;
+    elements?: any[];
+    typeset?: boolean;
+    ready?: () => void;
+    pageReady?: () => void;
+    invalidOption?: 'fatal' | 'warn';
+    optionError?: (message: string, key: string) => void;
+};

node_modules/mathjax-full/js/components/startup.js

@@ -0,0 +1,360 @@
+"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 __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 });
+exports.CONFIG = exports.MathJax = exports.Startup = void 0;
+var global_js_1 = require("./global.js");
+var PrioritizedList_js_1 = require("../util/PrioritizedList.js");
+var Options_js_1 = require("../util/Options.js");
+var Startup;
+(function (Startup) {
+    var extensions = new PrioritizedList_js_1.PrioritizedList();
+    var visitor;
+    var mathjax;
+    Startup.constructors = {};
+    Startup.input = [];
+    Startup.output = null;
+    Startup.handler = null;
+    Startup.adaptor = null;
+    Startup.elements = null;
+    Startup.document = null;
+    Startup.promise = new Promise(function (resolve, reject) {
+        Startup.promiseResolve = resolve;
+        Startup.promiseReject = reject;
+    });
+    Startup.pagePromise = new Promise(function (resolve, _reject) {
+        var doc = global.document;
+        if (!doc || !doc.readyState || doc.readyState === 'complete' || doc.readyState === 'interactive') {
+            resolve();
+        }
+        else {
+            var listener = function () { return resolve(); };
+            doc.defaultView.addEventListener('load', listener, true);
+            doc.defaultView.addEventListener('DOMContentLoaded', listener, true);
+        }
+    });
+    function toMML(node) {
+        return visitor.visitTree(node, Startup.document);
+    }
+    Startup.toMML = toMML;
+    function registerConstructor(name, constructor) {
+        Startup.constructors[name] = constructor;
+    }
+    Startup.registerConstructor = registerConstructor;
+    function useHandler(name, force) {
+        if (force === void 0) { force = false; }
+        if (!exports.CONFIG.handler || force) {
+            exports.CONFIG.handler = name;
+        }
+    }
+    Startup.useHandler = useHandler;
+    function useAdaptor(name, force) {
+        if (force === void 0) { force = false; }
+        if (!exports.CONFIG.adaptor || force) {
+            exports.CONFIG.adaptor = name;
+        }
+    }
+    Startup.useAdaptor = useAdaptor;
+    function useInput(name, force) {
+        if (force === void 0) { force = false; }
+        if (!inputSpecified || force) {
+            exports.CONFIG.input.push(name);
+        }
+    }
+    Startup.useInput = useInput;
+    function useOutput(name, force) {
+        if (force === void 0) { force = false; }
+        if (!exports.CONFIG.output || force) {
+            exports.CONFIG.output = name;
+        }
+    }
+    Startup.useOutput = useOutput;
+    function extendHandler(extend, priority) {
+        if (priority === void 0) { priority = 10; }
+        extensions.add(extend, priority);
+    }
+    Startup.extendHandler = extendHandler;
+    function defaultReady() {
+        getComponents();
+        makeMethods();
+        Startup.pagePromise
+            .then(function () { return exports.CONFIG.pageReady(); })
+            .then(function () { return Startup.promiseResolve(); })
+            .catch(function (err) { return Startup.promiseReject(err); });
+    }
+    Startup.defaultReady = defaultReady;
+    function defaultPageReady() {
+        return (exports.CONFIG.typeset && exports.MathJax.typesetPromise ?
+            exports.MathJax.typesetPromise(exports.CONFIG.elements) :
+            Promise.resolve());
+    }
+    Startup.defaultPageReady = defaultPageReady;
+    function getComponents() {
+        visitor = new exports.MathJax._.core.MmlTree.SerializedMmlVisitor.SerializedMmlVisitor();
+        mathjax = exports.MathJax._.mathjax.mathjax;
+        Startup.input = getInputJax();
+        Startup.output = getOutputJax();
+        Startup.adaptor = getAdaptor();
+        if (Startup.handler) {
+            mathjax.handlers.unregister(Startup.handler);
+        }
+        Startup.handler = getHandler();
+        if (Startup.handler) {
+            mathjax.handlers.register(Startup.handler);
+            Startup.document = getDocument();
+        }
+    }
+    Startup.getComponents = getComponents;
+    function makeMethods() {
+        var e_1, _a;
+        if (Startup.input && Startup.output) {
+            makeTypesetMethods();
+        }
+        var oname = (Startup.output ? Startup.output.name.toLowerCase() : '');
+        try {
+            for (var input_1 = __values(Startup.input), input_1_1 = input_1.next(); !input_1_1.done; input_1_1 = input_1.next()) {
+                var jax = input_1_1.value;
+                var iname = jax.name.toLowerCase();
+                makeMmlMethods(iname, jax);
+                makeResetMethod(iname, jax);
+                if (Startup.output) {
+                    makeOutputMethods(iname, oname, jax);
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (input_1_1 && !input_1_1.done && (_a = input_1.return)) _a.call(input_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    }
+    Startup.makeMethods = makeMethods;
+    function makeTypesetMethods() {
+        exports.MathJax.typeset = function (elements) {
+            if (elements === void 0) { elements = null; }
+            Startup.document.options.elements = elements;
+            Startup.document.reset();
+            Startup.document.render();
+        };
+        exports.MathJax.typesetPromise = function (elements) {
+            if (elements === void 0) { elements = null; }
+            Startup.document.options.elements = elements;
+            Startup.document.reset();
+            return mathjax.handleRetriesFor(function () {
+                Startup.document.render();
+            });
+        };
+        exports.MathJax.typesetClear = function (elements) {
+            if (elements === void 0) { elements = null; }
+            if (elements) {
+                Startup.document.clearMathItemsWithin(elements);
+            }
+            else {
+                Startup.document.clear();
+            }
+        };
+    }
+    Startup.makeTypesetMethods = makeTypesetMethods;
+    function makeOutputMethods(iname, oname, input) {
+        var name = iname + '2' + oname;
+        exports.MathJax[name] =
+            function (math, options) {
+                if (options === void 0) { options = {}; }
+                options.format = input.name;
+                return Startup.document.convert(math, options);
+            };
+        exports.MathJax[name + 'Promise'] =
+            function (math, options) {
+                if (options === void 0) { options = {}; }
+                options.format = input.name;
+                return mathjax.handleRetriesFor(function () { return Startup.document.convert(math, options); });
+            };
+        exports.MathJax[oname + 'Stylesheet'] = function () { return Startup.output.styleSheet(Startup.document); };
+        if ('getMetricsFor' in Startup.output) {
+            exports.MathJax.getMetricsFor = function (node, display) {
+                return Startup.output.getMetricsFor(node, display);
+            };
+        }
+    }
+    Startup.makeOutputMethods = makeOutputMethods;
+    function makeMmlMethods(name, input) {
+        var STATE = exports.MathJax._.core.MathItem.STATE;
+        exports.MathJax[name + '2mml'] =
+            function (math, options) {
+                if (options === void 0) { options = {}; }
+                options.end = STATE.CONVERT;
+                options.format = input.name;
+                return toMML(Startup.document.convert(math, options));
+            };
+        exports.MathJax[name + '2mmlPromise'] =
+            function (math, options) {
+                if (options === void 0) { options = {}; }
+                options.end = STATE.CONVERT;
+                options.format = input.name;
+                return mathjax.handleRetriesFor(function () { return toMML(Startup.document.convert(math, options)); });
+            };
+    }
+    Startup.makeMmlMethods = makeMmlMethods;
+    function makeResetMethod(name, input) {
+        exports.MathJax[name + 'Reset'] = function () {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            return input.reset.apply(input, __spreadArray([], __read(args), false));
+        };
+    }
+    Startup.makeResetMethod = makeResetMethod;
+    function getInputJax() {
+        var e_2, _a;
+        var jax = [];
+        try {
+            for (var _b = __values(exports.CONFIG.input), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var name_1 = _c.value;
+                var inputClass = Startup.constructors[name_1];
+                if (inputClass) {
+                    jax.push(new inputClass(exports.MathJax.config[name_1]));
+                }
+                else {
+                    throw Error('Input Jax "' + name_1 + '" is not defined (has it been loaded?)');
+                }
+            }
+        }
+        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 jax;
+    }
+    Startup.getInputJax = getInputJax;
+    function getOutputJax() {
+        var name = exports.CONFIG.output;
+        if (!name)
+            return null;
+        var outputClass = Startup.constructors[name];
+        if (!outputClass) {
+            throw Error('Output Jax "' + name + '" is not defined (has it been loaded?)');
+        }
+        return new outputClass(exports.MathJax.config[name]);
+    }
+    Startup.getOutputJax = getOutputJax;
+    function getAdaptor() {
+        var name = exports.CONFIG.adaptor;
+        if (!name || name === 'none')
+            return null;
+        var adaptor = Startup.constructors[name];
+        if (!adaptor) {
+            throw Error('DOMAdaptor "' + name + '" is not defined (has it been loaded?)');
+        }
+        return adaptor(exports.MathJax.config[name]);
+    }
+    Startup.getAdaptor = getAdaptor;
+    function getHandler() {
+        var e_3, _a;
+        var name = exports.CONFIG.handler;
+        if (!name || name === 'none' || !Startup.adaptor)
+            return null;
+        var handlerClass = Startup.constructors[name];
+        if (!handlerClass) {
+            throw Error('Handler "' + name + '" is not defined (has it been loaded?)');
+        }
+        var handler = new handlerClass(Startup.adaptor, 5);
+        try {
+            for (var extensions_1 = __values(extensions), extensions_1_1 = extensions_1.next(); !extensions_1_1.done; extensions_1_1 = extensions_1.next()) {
+                var extend = extensions_1_1.value;
+                handler = extend.item(handler);
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (extensions_1_1 && !extensions_1_1.done && (_a = extensions_1.return)) _a.call(extensions_1);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        return handler;
+    }
+    Startup.getHandler = getHandler;
+    function getDocument(root) {
+        if (root === void 0) { root = null; }
+        return mathjax.document(root || exports.CONFIG.document, __assign(__assign({}, exports.MathJax.config.options), { InputJax: Startup.input, OutputJax: Startup.output }));
+    }
+    Startup.getDocument = getDocument;
+})(Startup = exports.Startup || (exports.Startup = {}));
+exports.MathJax = global_js_1.MathJax;
+if (typeof exports.MathJax._.startup === 'undefined') {
+    (0, global_js_1.combineDefaults)(exports.MathJax.config, 'startup', {
+        input: [],
+        output: '',
+        handler: null,
+        adaptor: null,
+        document: (typeof document === 'undefined' ? '' : document),
+        elements: null,
+        typeset: true,
+        ready: Startup.defaultReady.bind(Startup),
+        pageReady: Startup.defaultPageReady.bind(Startup)
+    });
+    (0, global_js_1.combineWithMathJax)({
+        startup: Startup,
+        options: {}
+    });
+    if (exports.MathJax.config.startup.invalidOption) {
+        Options_js_1.OPTIONS.invalidOption = exports.MathJax.config.startup.invalidOption;
+    }
+    if (exports.MathJax.config.startup.optionError) {
+        Options_js_1.OPTIONS.optionError = exports.MathJax.config.startup.optionError;
+    }
+}
+exports.CONFIG = exports.MathJax.config.startup;
+var inputSpecified = exports.CONFIG.input.length !== 0;
+//# sourceMappingURL=startup.js.map

node_modules/mathjax-full/js/components/version.d.ts

@@ -0,0 +1 @@
+export declare const VERSION = "3.2.2";

node_modules/mathjax-full/js/components/version.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERSION = void 0;
+exports.VERSION = '3.2.2';
+//# sourceMappingURL=version.js.map

node_modules/mathjax-full/js/components/version.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.js","sourceRoot":"","sources":["../../ts/components/version.ts"],"names":[],"mappings":";;;AAwBa,QAAA,OAAO,GAAG,OAAO,CAAC"}