stuff

node_modules/mathjax-full/js/core/Tree/Factory.d.ts

@@ -0,0 +1,31 @@
+export interface FactoryNode {
+    readonly kind: string;
+}
+export interface FactoryNodeClass<N extends FactoryNode> {
+    new (factory: Factory<N, FactoryNodeClass<N>>, ...args: any[]): N;
+}
+export interface Factory<N extends FactoryNode, C extends FactoryNodeClass<N>> {
+    create(kind: string): N;
+    setNodeClass(kind: string, nodeClass: C): void;
+    getNodeClass(kind: string): C;
+    deleteNodeClass(kind: string): void;
+    nodeIsKind(node: N, kind: string): boolean;
+    getKinds(): string[];
+}
+export declare abstract class AbstractFactory<N extends FactoryNode, C extends FactoryNodeClass<N>> implements Factory<N, C> {
+    static defaultNodes: {};
+    defaultKind: string;
+    protected nodeMap: Map<string, C>;
+    protected node: {
+        [kind: string]: (...args: any[]) => N;
+    };
+    constructor(nodes?: {
+        [kind: string]: C;
+    });
+    create(kind: string, ...args: any[]): N;
+    setNodeClass(kind: string, nodeClass: C): void;
+    getNodeClass(kind: string): C;
+    deleteNodeClass(kind: string): void;
+    nodeIsKind(node: N, kind: string): boolean;
+    getKinds(): string[];
+}

node_modules/mathjax-full/js/core/Tree/Factory.js

@@ -0,0 +1,100 @@
+"use strict";
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractFactory = void 0;
+var AbstractFactory = (function () {
+    function AbstractFactory(nodes) {
+        var e_1, _a;
+        if (nodes === void 0) { nodes = null; }
+        this.defaultKind = 'unknown';
+        this.nodeMap = new Map();
+        this.node = {};
+        if (nodes === null) {
+            nodes = this.constructor.defaultNodes;
+        }
+        try {
+            for (var _b = __values(Object.keys(nodes)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var kind = _c.value;
+                this.setNodeClass(kind, nodes[kind]);
+            }
+        }
+        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; }
+        }
+    }
+    AbstractFactory.prototype.create = function (kind) {
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        return (this.node[kind] || this.node[this.defaultKind]).apply(void 0, __spreadArray([], __read(args), false));
+    };
+    AbstractFactory.prototype.setNodeClass = function (kind, nodeClass) {
+        this.nodeMap.set(kind, nodeClass);
+        var THIS = this;
+        var KIND = this.nodeMap.get(kind);
+        this.node[kind] = function () {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            return new (KIND.bind.apply(KIND, __spreadArray([void 0, THIS], __read(args), false)))();
+        };
+    };
+    AbstractFactory.prototype.getNodeClass = function (kind) {
+        return this.nodeMap.get(kind);
+    };
+    AbstractFactory.prototype.deleteNodeClass = function (kind) {
+        this.nodeMap.delete(kind);
+        delete this.node[kind];
+    };
+    AbstractFactory.prototype.nodeIsKind = function (node, kind) {
+        return (node instanceof this.getNodeClass(kind));
+    };
+    AbstractFactory.prototype.getKinds = function () {
+        return Array.from(this.nodeMap.keys());
+    };
+    AbstractFactory.defaultNodes = {};
+    return AbstractFactory;
+}());
+exports.AbstractFactory = AbstractFactory;
+//# sourceMappingURL=Factory.js.map

node_modules/mathjax-full/js/core/Tree/Factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Factory.js","sourceRoot":"","sources":["../../../ts/core/Tree/Factory.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsHA;IAyBE,yBAAY,KAAiC;;QAAjC,sBAAA,EAAA,YAAiC;QAftC,gBAAW,GAAG,SAAS,CAAC;QAKrB,YAAO,GAAmB,IAAI,GAAG,EAAE,CAAC;QAKpC,SAAI,GAA4C,EAAE,CAAC;QAM3D,IAAI,KAAK,KAAK,IAAI,EAAE;YAClB,KAAK,GAAI,IAAI,CAAC,WAA0C,CAAC,YAAY,CAAC;SACvE;;YACD,KAAmB,IAAA,KAAA,SAAA,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA,gBAAA,4BAAE;gBAAlC,IAAM,IAAI,WAAA;gBACb,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC;aACtC;;;;;;;;;IACH,CAAC;IAKM,gCAAM,GAAb,UAAc,IAAY;QAAE,cAAc;aAAd,UAAc,EAAd,qBAAc,EAAd,IAAc;YAAd,6BAAc;;QACxC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,wCAAI,IAAI,WAAE;IACnE,CAAC;IAKM,sCAAY,GAAnB,UAAoB,IAAY,EAAE,SAAY;QAC5C,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;QAClC,IAAI,IAAI,GAAG,IAAI,CAAC;QAChB,IAAI,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAClC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG;YAAC,cAAc;iBAAd,UAAc,EAAd,qBAAc,EAAd,IAAc;gBAAd,yBAAc;;YAC/B,YAAW,IAAI,YAAJ,IAAI,yBAAC,IAAI,UAAK,IAAI,cAAE;QACjC,CAAC,CAAC;IACJ,CAAC;IAIM,sCAAY,GAAnB,UAAoB,IAAY;QAC9B,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAChC,CAAC;IAKM,yCAAe,GAAtB,UAAuB,IAAY;QACjC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QAC1B,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACzB,CAAC;IAKM,oCAAU,GAAjB,UAAkB,IAAO,EAAE,IAAY;QACrC,OAAO,CAAC,IAAI,YAAY,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,CAAC;IACnD,CAAC;IAKM,kCAAQ,GAAf;QACE,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC;IACzC,CAAC;IA1Ea,4BAAY,GAAG,EAAE,CAAC;IA4ElC,sBAAC;CAAA,AAjFD,IAiFC;AAjFqB,0CAAe"}

node_modules/mathjax-full/js/core/Tree/Node.d.ts

@@ -0,0 +1,59 @@
+import { NodeFactory } from './NodeFactory.js';
+export declare type Property = string | number | boolean;
+export declare type PropertyList = {
+    [key: string]: Property;
+};
+export interface Node {
+    readonly kind: string;
+    readonly factory: NodeFactory<Node, NodeClass>;
+    parent: Node;
+    childNodes: Node[];
+    setProperty(name: string, value: Property): void;
+    getProperty(name: string): Property;
+    getPropertyNames(): string[];
+    getAllProperties(): PropertyList;
+    removeProperty(...names: string[]): void;
+    isKind(kind: string): boolean;
+    setChildren(children: Node[]): void;
+    appendChild(child: Node): Node;
+    replaceChild(newChild: Node, oldChild: Node): Node;
+    removeChild(child: Node): Node;
+    childIndex(child: Node): number;
+    copy(): Node;
+    findNodes(kind: string): Node[];
+    walkTree(func: (node: Node, data?: any) => void, data?: any): void;
+}
+export interface NodeClass {
+    new (factory: NodeFactory<Node, NodeClass>, properties?: PropertyList, children?: Node[]): Node;
+}
+export declare abstract class AbstractNode implements Node {
+    readonly factory: NodeFactory<Node, NodeClass>;
+    parent: Node;
+    protected properties: PropertyList;
+    childNodes: Node[];
+    constructor(factory: NodeFactory<Node, NodeClass>, properties?: PropertyList, children?: Node[]);
+    get kind(): string;
+    setProperty(name: string, value: Property): void;
+    getProperty(name: string): Property;
+    getPropertyNames(): string[];
+    getAllProperties(): PropertyList;
+    removeProperty(...names: string[]): void;
+    isKind(kind: string): boolean;
+    setChildren(children: Node[]): void;
+    appendChild(child: Node): Node;
+    replaceChild(newChild: Node, oldChild: Node): Node;
+    removeChild(child: Node): Node;
+    childIndex(node: Node): number;
+    copy(): AbstractNode;
+    findNodes(kind: string): Node[];
+    walkTree(func: (node: Node, data?: any) => void, data?: any): any;
+    toString(): string;
+}
+export declare abstract class AbstractEmptyNode extends AbstractNode {
+    setChildren(_children: Node[]): void;
+    appendChild(child: Node): Node;
+    replaceChild(_newChild: Node, oldChild: Node): Node;
+    childIndex(_node: Node): number;
+    walkTree(func: (node: Node, data?: any) => void, data?: any): any;
+    toString(): string;
+}

node_modules/mathjax-full/js/core/Tree/Node.js

@@ -0,0 +1,234 @@
+"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 __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.AbstractEmptyNode = exports.AbstractNode = void 0;
+var AbstractNode = (function () {
+    function AbstractNode(factory, properties, children) {
+        var e_1, _a;
+        if (properties === void 0) { properties = {}; }
+        if (children === void 0) { children = []; }
+        this.factory = factory;
+        this.parent = null;
+        this.properties = {};
+        this.childNodes = [];
+        try {
+            for (var _b = __values(Object.keys(properties)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var name_1 = _c.value;
+                this.setProperty(name_1, properties[name_1]);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        if (children.length) {
+            this.setChildren(children);
+        }
+    }
+    Object.defineProperty(AbstractNode.prototype, "kind", {
+        get: function () {
+            return 'unknown';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    AbstractNode.prototype.setProperty = function (name, value) {
+        this.properties[name] = value;
+    };
+    AbstractNode.prototype.getProperty = function (name) {
+        return this.properties[name];
+    };
+    AbstractNode.prototype.getPropertyNames = function () {
+        return Object.keys(this.properties);
+    };
+    AbstractNode.prototype.getAllProperties = function () {
+        return this.properties;
+    };
+    AbstractNode.prototype.removeProperty = function () {
+        var e_2, _a;
+        var names = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            names[_i] = arguments[_i];
+        }
+        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_2 = names_1_1.value;
+                delete this.properties[name_2];
+            }
+        }
+        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; }
+        }
+    };
+    AbstractNode.prototype.isKind = function (kind) {
+        return this.factory.nodeIsKind(this, kind);
+    };
+    AbstractNode.prototype.setChildren = function (children) {
+        var e_3, _a;
+        this.childNodes = [];
+        try {
+            for (var children_1 = __values(children), children_1_1 = children_1.next(); !children_1_1.done; children_1_1 = children_1.next()) {
+                var child = children_1_1.value;
+                this.appendChild(child);
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (children_1_1 && !children_1_1.done && (_a = children_1.return)) _a.call(children_1);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+    };
+    AbstractNode.prototype.appendChild = function (child) {
+        this.childNodes.push(child);
+        child.parent = this;
+        return child;
+    };
+    AbstractNode.prototype.replaceChild = function (newChild, oldChild) {
+        var i = this.childIndex(oldChild);
+        if (i !== null) {
+            this.childNodes[i] = newChild;
+            newChild.parent = this;
+            oldChild.parent = null;
+        }
+        return newChild;
+    };
+    AbstractNode.prototype.removeChild = function (child) {
+        var i = this.childIndex(child);
+        if (i !== null) {
+            this.childNodes.splice(i, 1);
+            child.parent = null;
+        }
+        return child;
+    };
+    AbstractNode.prototype.childIndex = function (node) {
+        var i = this.childNodes.indexOf(node);
+        return (i === -1 ? null : i);
+    };
+    AbstractNode.prototype.copy = function () {
+        var e_4, _a;
+        var node = this.factory.create(this.kind);
+        node.properties = __assign({}, this.properties);
+        try {
+            for (var _b = __values(this.childNodes || []), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var child = _c.value;
+                if (child) {
+                    node.appendChild(child.copy());
+                }
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_4) throw e_4.error; }
+        }
+        return node;
+    };
+    AbstractNode.prototype.findNodes = function (kind) {
+        var nodes = [];
+        this.walkTree(function (node) {
+            if (node.isKind(kind)) {
+                nodes.push(node);
+            }
+        });
+        return nodes;
+    };
+    AbstractNode.prototype.walkTree = function (func, data) {
+        var e_5, _a;
+        func(this, data);
+        try {
+            for (var _b = __values(this.childNodes), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var child = _c.value;
+                if (child) {
+                    child.walkTree(func, data);
+                }
+            }
+        }
+        catch (e_5_1) { e_5 = { error: e_5_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_5) throw e_5.error; }
+        }
+        return data;
+    };
+    AbstractNode.prototype.toString = function () {
+        return this.kind + '(' + this.childNodes.join(',') + ')';
+    };
+    return AbstractNode;
+}());
+exports.AbstractNode = AbstractNode;
+var AbstractEmptyNode = (function (_super) {
+    __extends(AbstractEmptyNode, _super);
+    function AbstractEmptyNode() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    AbstractEmptyNode.prototype.setChildren = function (_children) {
+    };
+    AbstractEmptyNode.prototype.appendChild = function (child) {
+        return child;
+    };
+    AbstractEmptyNode.prototype.replaceChild = function (_newChild, oldChild) {
+        return oldChild;
+    };
+    AbstractEmptyNode.prototype.childIndex = function (_node) {
+        return null;
+    };
+    AbstractEmptyNode.prototype.walkTree = function (func, data) {
+        func(this, data);
+        return data;
+    };
+    AbstractEmptyNode.prototype.toString = function () {
+        return this.kind;
+    };
+    return AbstractEmptyNode;
+}(AbstractNode));
+exports.AbstractEmptyNode = AbstractEmptyNode;
+//# sourceMappingURL=Node.js.map

node_modules/mathjax-full/js/core/Tree/Node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Node.js","sourceRoot":"","sources":["../../../ts/core/Tree/Node.ts"],"names":[],"mappings":"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"}

node_modules/mathjax-full/js/core/Tree/NodeFactory.d.ts

@@ -0,0 +1,8 @@
+import { Node, PropertyList } from './Node.js';
+import { Factory, FactoryNodeClass, AbstractFactory } from './Factory.js';
+export interface NodeFactory<N extends Node, C extends FactoryNodeClass<N>> extends Factory<N, C> {
+    create(kind: string, properties?: PropertyList, children?: N[]): N;
+}
+export declare abstract class AbstractNodeFactory<N extends Node, C extends FactoryNodeClass<N>> extends AbstractFactory<N, C> {
+    create(kind: string, properties?: PropertyList, children?: N[]): N;
+}

node_modules/mathjax-full/js/core/Tree/NodeFactory.js

@@ -0,0 +1,33 @@
+"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 __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractNodeFactory = void 0;
+var Factory_js_1 = require("./Factory.js");
+var AbstractNodeFactory = (function (_super) {
+    __extends(AbstractNodeFactory, _super);
+    function AbstractNodeFactory() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    AbstractNodeFactory.prototype.create = function (kind, properties, children) {
+        if (properties === void 0) { properties = {}; }
+        if (children === void 0) { children = []; }
+        return this.node[kind](properties, children);
+    };
+    return AbstractNodeFactory;
+}(Factory_js_1.AbstractFactory));
+exports.AbstractNodeFactory = AbstractNodeFactory;
+//# sourceMappingURL=NodeFactory.js.map

node_modules/mathjax-full/js/core/Tree/NodeFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeFactory.js","sourceRoot":"","sources":["../../../ts/core/Tree/NodeFactory.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AAwBA,2CAAwE;AA0BxE;IAAiG,uCAAqB;IAAtH;;IAQA,CAAC;IAJQ,oCAAM,GAAb,UAAc,IAAY,EAAE,UAA6B,EAAE,QAAkB;QAAjD,2BAAA,EAAA,eAA6B;QAAE,yBAAA,EAAA,aAAkB;QAC3E,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;IAC/C,CAAC;IAEH,0BAAC;AAAD,CAAC,AARD,CAAiG,4BAAe,GAQ/G;AARqB,kDAAmB"}

node_modules/mathjax-full/js/core/Tree/Visitor.d.ts

@@ -0,0 +1,21 @@
+import { Node, NodeClass } from './Node.js';
+import { NodeFactory } from './NodeFactory.js';
+export declare type VisitorFunction = (visitor: NodeFactory<Node, NodeClass>, node: Node, ...args: any[]) => any;
+export interface Visitor {
+    visitTree(tree: Node, ...args: any[]): any;
+    visitNode(node: Node, ...args: any[]): any;
+    visitDefault(node: Node, ...args: any[]): any;
+    setNodeHandler(kind: string, handler: VisitorFunction): void;
+    removeNodeHandler(kind: string): void;
+    [property: string]: any;
+}
+export declare abstract class AbstractVisitor implements Visitor {
+    protected nodeHandlers: Map<string, VisitorFunction>;
+    protected static methodName(kind: string): string;
+    constructor(factory: NodeFactory<Node, NodeClass>);
+    visitTree(tree: Node, ...args: any[]): any;
+    visitNode(node: Node, ...args: any[]): any;
+    visitDefault(node: Node, ...args: any[]): void;
+    setNodeHandler(kind: string, handler: VisitorFunction): void;
+    removeNodeHandler(kind: string): void;
+}

node_modules/mathjax-full/js/core/Tree/Visitor.js

@@ -0,0 +1,111 @@
+"use strict";
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractVisitor = void 0;
+var Node_js_1 = require("./Node.js");
+var AbstractVisitor = (function () {
+    function AbstractVisitor(factory) {
+        var e_1, _a;
+        this.nodeHandlers = new Map();
+        try {
+            for (var _b = __values(factory.getKinds()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var kind = _c.value;
+                var method = this[AbstractVisitor.methodName(kind)];
+                if (method) {
+                    this.nodeHandlers.set(kind, method);
+                }
+            }
+        }
+        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; }
+        }
+    }
+    AbstractVisitor.methodName = function (kind) {
+        return 'visit' + (kind.charAt(0).toUpperCase() + kind.substr(1)).replace(/[^a-z0-9_]/ig, '_') + 'Node';
+    };
+    AbstractVisitor.prototype.visitTree = function (tree) {
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        return this.visitNode.apply(this, __spreadArray([tree], __read(args), false));
+    };
+    AbstractVisitor.prototype.visitNode = function (node) {
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        var handler = this.nodeHandlers.get(node.kind) || this.visitDefault;
+        return handler.call.apply(handler, __spreadArray([this, node], __read(args), false));
+    };
+    AbstractVisitor.prototype.visitDefault = function (node) {
+        var e_2, _a;
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        if (node instanceof Node_js_1.AbstractNode) {
+            try {
+                for (var _b = __values(node.childNodes), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var child = _c.value;
+                    this.visitNode.apply(this, __spreadArray([child], __read(args), false));
+                }
+            }
+            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; }
+            }
+        }
+    };
+    AbstractVisitor.prototype.setNodeHandler = function (kind, handler) {
+        this.nodeHandlers.set(kind, handler);
+    };
+    AbstractVisitor.prototype.removeNodeHandler = function (kind) {
+        this.nodeHandlers.delete(kind);
+    };
+    return AbstractVisitor;
+}());
+exports.AbstractVisitor = AbstractVisitor;
+//# sourceMappingURL=Visitor.js.map

node_modules/mathjax-full/js/core/Tree/Visitor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Visitor.js","sourceRoot":"","sources":["../../../ts/core/Tree/Visitor.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuBA,qCAAwD;AAqExD;IAwBE,yBAAY,OAAqC;;QApBvC,iBAAY,GAAiC,IAAI,GAAG,EAAE,CAAC;;YAqB/D,KAAmB,IAAA,KAAA,SAAA,OAAO,CAAC,QAAQ,EAAE,CAAA,gBAAA,4BAAE;gBAAlC,IAAM,IAAI,WAAA;gBACb,IAAI,MAAM,GAAI,IAAgB,CAAC,eAAe,CAAC,UAAU,CAAC,IAAI,CAAC,CAAoB,CAAC;gBACpF,IAAI,MAAM,EAAE;oBACV,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;iBACrC;aACF;;;;;;;;;IACH,CAAC;IAlBgB,0BAAU,GAA3B,UAA4B,IAAY;QACtC,OAAO,OAAO,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,cAAc,EAAE,GAAG,CAAC,GAAG,MAAM,CAAC;IACzG,CAAC;IAqBM,mCAAS,GAAhB,UAAiB,IAAU;QAAE,cAAc;aAAd,UAAc,EAAd,qBAAc,EAAd,IAAc;YAAd,6BAAc;;QACzC,OAAO,IAAI,CAAC,SAAS,OAAd,IAAI,iBAAW,IAAI,UAAK,IAAI,WAAE;IACvC,CAAC;IAKM,mCAAS,GAAhB,UAAiB,IAAU;QAAE,cAAc;aAAd,UAAc,EAAd,qBAAc,EAAd,IAAc;YAAd,6BAAc;;QACzC,IAAI,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,YAAY,CAAC;QACpE,OAAO,OAAO,CAAC,IAAI,OAAZ,OAAO,iBAAM,IAAI,EAAE,IAAI,UAAK,IAAI,WAAE;IAC3C,CAAC;IAKM,sCAAY,GAAnB,UAAoB,IAAU;;QAAE,cAAc;aAAd,UAAc,EAAd,qBAAc,EAAd,IAAc;YAAd,6BAAc;;QAC5C,IAAI,IAAI,YAAY,sBAAY,EAAE;;gBAChC,KAAoB,IAAA,KAAA,SAAA,IAAI,CAAC,UAAU,CAAA,gBAAA,4BAAE;oBAAhC,IAAM,KAAK,WAAA;oBACd,IAAI,CAAC,SAAS,OAAd,IAAI,iBAAW,KAAK,UAAK,IAAI,WAAE;iBAChC;;;;;;;;;SACF;IACH,CAAC;IAKM,wCAAc,GAArB,UAAsB,IAAY,EAAE,OAAwB;QAC1D,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;IACvC,CAAC;IAKM,2CAAiB,GAAxB,UAAyB,IAAY;QACnC,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IACjC,CAAC;IAEH,sBAAC;AAAD,CAAC,AAzED,IAyEC;AAzEqB,0CAAe"}

node_modules/mathjax-full/js/core/Tree/Wrapper.d.ts

@@ -0,0 +1,17 @@
+import { Node } from './Node.js';
+import { WrapperFactory } from './WrapperFactory.js';
+export interface Wrapper<N extends Node, W extends Wrapper<N, W>> {
+    node: N;
+    readonly kind: string;
+    wrap(node: N, ...args: any[]): W;
+}
+export interface WrapperClass<N extends Node, W extends Wrapper<N, W>> {
+    new (factory: WrapperFactory<N, W, WrapperClass<N, W>>, node: N, ...args: any[]): W;
+}
+export declare class AbstractWrapper<N extends Node, W extends Wrapper<N, W>> implements Wrapper<N, W> {
+    node: N;
+    protected factory: WrapperFactory<N, W, WrapperClass<N, W>>;
+    get kind(): string;
+    constructor(factory: WrapperFactory<N, W, WrapperClass<N, W>>, node: N);
+    wrap(node: N): W;
+}

node_modules/mathjax-full/js/core/Tree/Wrapper.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractWrapper = void 0;
+var AbstractWrapper = (function () {
+    function AbstractWrapper(factory, node) {
+        this.factory = factory;
+        this.node = node;
+    }
+    Object.defineProperty(AbstractWrapper.prototype, "kind", {
+        get: function () {
+            return this.node.kind;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    AbstractWrapper.prototype.wrap = function (node) {
+        return this.factory.wrap(node);
+    };
+    return AbstractWrapper;
+}());
+exports.AbstractWrapper = AbstractWrapper;
+//# sourceMappingURL=Wrapper.js.map

node_modules/mathjax-full/js/core/Tree/Wrapper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Wrapper.js","sourceRoot":"","sources":["../../../ts/core/Tree/Wrapper.ts"],"names":[],"mappings":";;;AAuEA;IAyBE,yBAAY,OAAiD,EAAE,IAAO;QACpE,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IACnB,CAAC;IAdD,sBAAI,iCAAI;aAAR;YACE,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC;QACxB,CAAC;;;OAAA;IAiBM,8BAAI,GAAX,UAAY,IAAO;QACjB,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACjC,CAAC;IAEH,sBAAC;AAAD,CAAC,AArCD,IAqCC;AArCY,0CAAe"}

node_modules/mathjax-full/js/core/Tree/WrapperFactory.d.ts

@@ -0,0 +1,9 @@
+import { Node } from './Node.js';
+import { Wrapper, WrapperClass } from './Wrapper.js';
+import { Factory, AbstractFactory } from './Factory.js';
+export interface WrapperFactory<N extends Node, W extends Wrapper<N, W>, C extends WrapperClass<N, W>> extends Factory<W, C> {
+    wrap(node: N, ...args: any[]): W;
+}
+export declare abstract class AbstractWrapperFactory<N extends Node, W extends Wrapper<N, W>, C extends WrapperClass<N, W>> extends AbstractFactory<W, C> implements WrapperFactory<N, W, C> {
+    wrap(node: N, ...args: any[]): W;
+}

node_modules/mathjax-full/js/core/Tree/WrapperFactory.js

@@ -0,0 +1,60 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractWrapperFactory = void 0;
+var Factory_js_1 = require("./Factory.js");
+var AbstractWrapperFactory = (function (_super) {
+    __extends(AbstractWrapperFactory, _super);
+    function AbstractWrapperFactory() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    AbstractWrapperFactory.prototype.wrap = function (node) {
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        return this.create.apply(this, __spreadArray([node.kind, node], __read(args), false));
+    };
+    return AbstractWrapperFactory;
+}(Factory_js_1.AbstractFactory));
+exports.AbstractWrapperFactory = AbstractWrapperFactory;
+//# sourceMappingURL=WrapperFactory.js.map

node_modules/mathjax-full/js/core/Tree/WrapperFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WrapperFactory.js","sourceRoot":"","sources":["../../../ts/core/Tree/WrapperFactory.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,2CAAsD;AA4BtD;IACQ,0CAAqB;IAD7B;;IAUA,CAAC;IAHQ,qCAAI,GAAX,UAAY,IAAO;QAAE,cAAc;aAAd,UAAc,EAAd,qBAAc,EAAd,IAAc;YAAd,6BAAc;;QACjC,OAAO,IAAI,CAAC,MAAM,OAAX,IAAI,iBAAQ,IAAI,CAAC,IAAI,EAAE,IAAI,UAAK,IAAI,WAAE;IAC/C,CAAC;IACH,6BAAC;AAAD,CAAC,AAVD,CACQ,4BAAe,GAStB;AAVqB,wDAAsB"}