first commit

node_modules/mathjax-full/components/bin/build

@@ -0,0 +1,347 @@
+#! /usr/bin/env node
+
+/*************************************************************
+ *
+ *  Copyright (c) 2018 The MathJax Consortium
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/**
+ * @fileoverview  Builds the lib directory for a component
+ *
+ * @author dpvc@mathjax.org (Davide Cervone)
+ */
+
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * The amount of space for each level of indentation
+ */
+const INDENT = '  ';
+
+/**
+ * The pattern to use when looking for explort commands to process
+ */
+const EXPORTPATTERN = /(^export(?:\s+default)?(?:\s+abstract)?\s+[^ {*}]+\s+[a-zA-Z0-9_.$]+)/m;
+
+const EXPORT_IGNORE = ['type', 'interface'];
+const EXPORT_PROCESS = ['let', 'const', 'var', 'function', 'class', 'namespace'];
+
+/**
+ * The relative path to the MathJax directory
+ */
+const mjPath = path.relative(process.cwd(), path.resolve(__dirname, '..', '..', 'js'));
+const mjGlobal = path.join('..', mjPath, 'components', 'global.js');
+
+/**
+ * Read the configuration for the component
+ */
+const config = JSON.parse(fs.readFileSync(process.argv[2] || 'build.json'));
+
+function getType() {
+  const component = config.component || 'part';
+  if (component.match(/\/(svg|chtml|common)\/fonts\//)) return RegExp.$1 + '-font';
+  if (component.match(/\/(mathml|tex)\/.+\//)) return RegExp.$1 + '-extension';
+  if (component.match(/^(.+)\//)) return RegExp.$1;
+  return component;
+}
+
+/**
+ * Extract the configuration values
+ */
+const COMPONENT = path.basename(config.component || 'part');                // name of the component
+const ID = config.id || config.component || 'part';                         // the ID of the component
+const TARGETS = config.targets || [];                                       // the files to include in the component
+const EXCLUDE = new Map((config.exclude || []).map(name => [name, true]));  // files to exclude from the component
+const EXCLUDESUBDIRS = config.excludeSubdirs === 'true';                    // exclude subdirectories or not
+const JS = config.js || config.mathjax || mjPath;                           // path to the compiled .js files
+const LIB = config.lib || './lib';                                          // path to the lib directory to create
+const TS = config.ts || JS.replace(/js$/, 'ts');                            // path to the .ts files
+const GLOBAL = config.global || mjGlobal;                                   // path to the global.js file
+const VERSION = config.version || mjGlobal.replace(/global/, 'version');    // path to the version.js file
+const TYPE = config.type || getType();                                      // the module type
+
+/**
+ * The list of files that need to be added to the lib directory
+ */
+let PACKAGE = [];
+
+/**
+ * Process an array of files/directories to be included in the component
+ *
+ * @param {string} base    The root directory for the .ts files
+ * @param {string} dir     The relative path within the root for the files to process
+ * @param {string[]} list  An array of file/directory names to process
+ * @param {boolean} top    True if this is the initial list of files
+ */
+function processList(base, dir, list, top = true) {
+  for (const item of list) {
+    const file = path.join(dir, item);
+    if (!EXCLUDE.has(file)) {
+      const stat = fs.statSync(path.resolve(base, file));
+      if (stat.isDirectory()) {
+        if (top || !EXCLUDESUBDIRS) {
+          processDir(base, file);
+        }
+      } else if (file.match(/\.ts$/)) {
+        processFile(base, file);
+      }
+    }
+  }
+}
+
+/**
+ * Process the contents of the directory
+ *
+ * @param {string} base    The root directory for the .ts files
+ * @param {string} dir     The relative path within the root for the directory to process
+ */
+function processDir(base, dir) {
+  const root = path.resolve(base, dir);
+  processList(base, dir, fs.readdirSync(root), false);
+}
+
+/**
+ * Process the contents of a .ts file
+ *
+ * Look for export commands within the file, and determine the objects
+ *   that they reference, then produce the library file that defines
+ *   them, and add the file to the package list.
+ *
+ * @param {string} base    The root directory for the .ts files
+ * @param {string} name    The path of the file relative to the base
+ */
+function processFile(base, name) {
+  console.info('  ' + name);
+  const file = fs.readFileSync(path.resolve(base, name)).toString();
+  const parts = file.split(EXPORTPATTERN);
+  const objects = processParts(parts);
+  const lines = processLines(name, objects);
+  makeFile(name, lines);
+  if (objects.length) {
+    PACKAGE.push(name);
+  }
+}
+
+/**
+ * Process the export lines to record the ones that need to be added to the
+ *   library file.
+ *
+ * @param {string[]} parts       The file broken into export lines and the text between them
+ * @return {string[]}            An array of names of exported objects
+ */
+function processParts(parts) {
+  const objects = [];
+  for (let i = 1; i < parts.length; i += 2) {
+    const words = parts[i].split(/\s+/);
+    const type = words[words.length - 2];
+    const name = words[words.length - 1];
+
+    if (words[1] === 'default' || type === 'default') {
+      objects.push('default');
+    } else if (EXPORT_PROCESS.indexOf(type) >= 0) {
+      objects.push(name);
+    } else if (EXPORT_IGNORE.indexOf(type) < 0) {
+      console.info("    Can't process '" + parts[i] + "'");
+    }
+  }
+  return objects;
+}
+
+/**
+ * Create the lines of the lib file using the object names from the file.
+ *
+ * @param {string} name       The path of the file relative to the root .ts directory
+ * @param {string[]} objects  Array of names of the object exported by the file
+ * @return {string[]}         Array of lines for the contents of the library file
+ */
+function processLines(file, objects) {
+  if (objects.length === 0) return [];
+  const dir = path.dirname(file).replace(/^\.$/, '');
+  const dots = dir.replace(/[^\/]+/g, '..') || '.';
+  const relative = path.join(dots, '..', JS, dir, path.basename(file)).replace(/\.ts$/, '.js');
+  const name = path.parse(file).name;
+  const lines = [
+    '"use strict";',
+    `Object.defineProperty(exports, '__esModule', {value: true});`
+  ];
+  let source = ((dir.replace(/\//g, '.') + '.' + name).replace(/^\./, '')
+                + (exists(path.resolve(JS, file.replace(/\.ts$/, ''))) ? '_ts' : ''))
+      .replace(/\.[^.]*/g, (x) => (x.substr(1).match(/[^a-zA-Z_]/) ? '[\'' + x.substr(1) + '\']' : x));
+  for (const id of objects) {
+    lines.push(`exports.${id} = MathJax._.${source}.${id};`);
+  }
+  return lines;
+}
+
+/**
+ * @param {string} file     Path to a file
+ * @return {boolean}        True if the file exists, false if not
+ */
+function exists(file) {
+  if (!fs.existsSync(file)) return false;
+  //
+  // For case-insensitive file systems (like Mac OS),
+  //   check that the file names match exactly
+  //
+  const [dir, name] = [path.dirname(file), path.basename(file)];
+  return fs.readdirSync(dir).indexOf(name) >= 0;
+}
+
+/**
+ * Recursively make any needed directories
+ *
+ * @param {string} dir   The directory relative to the library directory
+ */
+function makeDir(dir) {
+  const fulldir = path.resolve(LIB, dir);
+  if (fs.existsSync(fulldir)) return;
+  makeDir(path.dirname(fulldir));
+  fs.mkdirSync(fulldir);
+}
+
+/**
+ * Make a file in the library directory from the given lines of javascript
+ *
+ * @param {string} file     The name of the file relative to the root .ts directory
+ * @param {string[]} lines  The contents of the file to create
+ */
+function makeFile(file, lines) {
+  if (!lines.length) return;
+  const [dir, name] = [path.dirname(file), path.basename(file)];
+  makeDir(dir);
+  fs.writeFileSync(path.resolve(LIB, dir, name.replace(/\.ts$/, '.js')), lines.join('\n') + '\n');
+}
+
+/**
+ * Make the library file that adds all the exported objects into the MathJax global object
+ */
+function processGlobal() {
+  console.info('  ' + COMPONENT + '.ts');
+  const lines = [
+    `import {combineWithMathJax} from '${GLOBAL}';`,
+    `import {VERSION} from '${VERSION}';`,
+    '',
+  ];
+  const packages = [];
+  PACKAGE = PACKAGE.sort(sortDir);
+  while (PACKAGE.length) {
+    const dir = path.dirname(PACKAGE[0]).split(path.sep)[0];
+    packages.push(processPackage(lines, INDENT, dir));
+  }
+  const name = (ID.match(/[^a-zA-Z0-9_]/) ? `"${ID}"` : ID);
+  lines.push(
+    '',
+    'if (MathJax.loader) {',
+      INDENT + `MathJax.loader.checkVersion('${ID}', VERSION, '${TYPE}');`,
+    '}',
+    '',
+    `combineWithMathJax({_: {`,
+      INDENT + packages.join(',\n' + INDENT),
+    '}});'
+  );
+  fs.writeFileSync(path.join(LIB, COMPONENT + '.js'), lines.join('\n') + '\n');
+}
+
+/**
+ * Sort file paths alphabetically
+ */
+function sortDir(a, b) {
+  const A = a.replace(/\//g, '|');          // Replace directory separator by one that is after the alphnumerics
+  const B = b.replace(/\//g, '|');
+  return (A === B ? 0 : A < B ? -1 : 1);
+}
+
+let importCount = 0;
+/**
+ * Recursively process packages, collecting them into groups by subdirectory, properly indented
+ *
+ * @param {string[]} lines   The array where lines of code defining the packages are to be stored
+ * @param {string} space     The current level of indentation
+ * @param {string} dir       The subdirectory currently being processed
+ * @return {string}          The string to use to load all the objects from the given directory
+ */
+function processPackage(lines, space, dir) {
+  const packages = [];
+  //
+  //  Loop through the lines that are in the current directory
+  //
+  while (PACKAGE.length && (PACKAGE[0].substr(0, dir.length) === dir || dir === '.')) {
+    //
+    // If the current package is in this directory (not a subdirectory)
+    //   Get the location of transpiled mathjax file
+    //   Get the name to use for the data from that file
+    //   Create an entry for the file in the MathJax global that loads the reuired component
+    // Otherwise (its in a subdirectory)
+    //   Get the subdirectory name
+    //   Process the subdirectory using an additional indentation
+    //
+    if (path.dirname(PACKAGE[0]) === dir) {
+      const file = PACKAGE.shift();
+      const name = path.basename(file);
+      const relativefile = path.join('..', JS, dir, name).replace(/\.ts$/, '.js');
+      const component = 'module' + (++importCount);
+      lines.push(`import * as ${component} from '${relativefile}';`);
+      let property = name.replace(/\.ts$/, '');
+      if (property !== name && exists(path.resolve(JS, file.replace(/\.ts$/, '')))) {
+        property += '_ts';
+      }
+      if (property.match(/[^a-zA-Z0-9_]/)) {
+        property = `"${property}"`;
+      }
+      packages.push(`${property}: ${component}`);
+    } else {
+      let subdir = path.dirname(PACKAGE[0]);
+      while (path.dirname(subdir) !== dir && subdir !== '.') {
+        subdir = path.dirname(subdir);
+      }
+      packages.push(processPackage(lines, space + (dir === '.' ? '' : INDENT), subdir));
+    }
+  }
+  //
+  // Create the string defining the object that loads all the needed files into the proper places
+  //
+  if (dir === '.') return packages.join(',\n    ');
+  return path.basename(dir) + ': {\n' + INDENT + space + packages.join(',\n' + INDENT + space) + '\n' + space + '}';
+}
+
+/**
+ * @param {string} dir   The path to the directory tree to be removed (recursively)
+ */
+function rmDir(dir) {
+  if (!dir) return;
+  if (fs.existsSync(dir)) {
+    for (const name of fs.readdirSync(dir)) {
+      const file = path.join(dir, name);
+      if (fs.lstatSync(file).isDirectory()) {
+        rmDir(file);
+      } else {
+        fs.unlinkSync(file);
+      }
+    }
+    fs.rmdirSync(dir);
+  }
+}
+
+//
+// Remove the existing lib directory contents, if any.
+// Load all the target files from the MathJax .ts directory.
+// Create the file that loads all the target objects into the MathJax global object.
+//
+rmDir(LIB);
+console.info("Processing:");
+processList(TS, '', TARGETS);
+processGlobal();

node_modules/mathjax-full/components/bin/copy

@@ -0,0 +1,78 @@
+#! /usr/bin/env node
+
+/*************************************************************
+ *
+ *  Copyright (c) 2018 The MathJax Consortium
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/**
+ * @fileoverview  Copies specified files to the distribution directory
+ *
+ * @author dpvc@mathjax.org (Davide Cervone)
+ */
+
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * The amount of space for each level of indentation
+ */
+const INDENT = '  ';
+
+/**
+ * The configuration data for the copy operation
+ */
+const config = JSON.parse(fs.readFileSync(process.argv[2] || 'copy.json'));
+
+/**
+ * Get the directory for node modules (either the parent of the MathJax directory,
+ * or the MathJax node_modules directory, if it exists).
+ */
+const parent = path.resolve(__dirname, '..', '..');
+const nodeDir = (dir => (fs.existsSync(dir) ? dir : path.resolve(parent, '..')))(path.join(parent, 'node_modules'));
+
+/**
+ * Copy a file or directory tree
+ *
+ * @param {string} from     The directory to copy from
+ * @param {string} to       The directory to copy to
+ * @param {string} name     The name of the file or directory to copy
+ * @param {string} space    The indentation for output
+ */
+function copyFile(from, to, name, space) {
+  !fs.existsSync(to) && fs.mkdirSync(to, {recursive: true});
+  const copy = path.resolve(from, name);
+  const dest = path.resolve(to, name);
+  if (fs.lstatSync(copy).isDirectory()) {
+    console.info(space + name + '/');
+    for (const file of fs.readdirSync(copy)) {
+      copyFile(copy, dest, file, space + INDENT);
+    }
+  } else {
+    console.info(space + name);
+    fs.copyFileSync(copy, dest);
+  }
+}
+
+/**
+ * Copy the given files
+ */
+const wd = process.cwd();
+const to = path.resolve(wd, config.to);
+const from = path.resolve(wd, config.from.replace(/\[node\]/, nodeDir));
+for (const name of config.copy) {
+  copyFile(from, to, name, '');
+}

node_modules/mathjax-full/components/bin/makeAll

@@ -0,0 +1,168 @@
+#! /usr/bin/env node
+
+/*************************************************************
+ *
+ *  Copyright (c) 2018 The MathJax Consortium
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/**
+ * @fileoverview  Processes all the build and webpack files in a directory
+ *                  or collection of directories
+ *
+ * @author dpvc@mathjax.org (Davide Cervone)
+ */
+
+
+const fs = require('fs');
+const path = require('path');
+const {execSync} = require('child_process');
+
+const options = {
+  recursive: true
+};
+
+/**
+ * Get the directories to process and check for options
+ */
+const dirs = process.argv.slice(2);
+
+if (dirs[0] === '--no-subdirs') {
+  dirs.shift();
+  options.recursive = false;
+}
+
+if (dirs.length === 0) {
+  dirs.push('.');
+}
+
+/**
+ * The commads to runb the bin/build scripts
+ *  (on Unix, could be done without the 'node ' prefix, but
+ *   for Windows, these are needed.)
+ */
+const build = `node '${path.join(__dirname, 'build')}'`;
+const copy = `node '${path.join(__dirname, 'copy')}'`;
+const pack = `node '${path.join(__dirname, 'pack')}'`;
+
+/**
+ * Regular expression for the components directory
+ */
+const compRE = new RegExp(path.dirname(__dirname).replace(/([\\.{}[\]()?*^$])/g, '\\$1'));
+const dirRE = new RegExp(process.cwd().replace(/([\\.{}[\]()?*^$])/g, '\\$1'));
+
+/**
+ * Process the contents of an array of directories
+ *
+ * @param {string} dirs   The directories to process
+ */
+function processList(dirs) {
+  for (const dir of dirs) {
+    const fulldir = path.resolve(dir);
+    processDir(fulldir, buildLib);
+    processDir(fulldir, webpackLib);
+    processDir(fulldir, copyLib);
+  }
+}
+
+/**
+ * Run an action (build or webpack) on a directory and its subdirectories
+ *
+ * @param {string} dir        The directory to process
+ * @param {Function} action   The action to take
+ */
+function processDir(dir, action) {
+  action(dir);
+  if (options.recursive) {
+    processSubdirs(dir, action);
+  }
+}
+
+/**
+ * Look for subdirectories and process them
+ *
+ * @param {string} dir        The directory whose subdirectories are to be processed
+ * @param {Function} action   The action to take
+ */
+function processSubdirs(dir, action) {
+  for (const name of fs.readdirSync(dir)) {
+    const file = path.join(dir, name);
+    if (fs.lstatSync(file).isDirectory()) {
+      processDir(file, action);
+    }
+  }
+}
+
+/**
+ * Run bin/build if there is a configuration file for it
+ *
+ * @param {string} dir   The directory to check
+ */
+function buildLib(dir) {
+  const file = path.join(dir, 'build.json');
+  if (!fs.existsSync(file)) return;
+  console.info('Building ' + dir.replace(compRE, '').replace(dirRE, '.'));
+  const wd = process.cwd();
+  try {
+    process.chdir(dir);
+    const result = execSync(build);
+    console.info('    ' + String(result).replace(/\n/g, '\n    '));
+  } catch (err) {
+    console.info('    ' + err.message);
+  }
+  process.chdir(wd);
+}
+
+/**
+ * Run webpack if there is a configuration file for it
+ *
+ * @param {string} dir   The directory to check
+ */
+function webpackLib(dir) {
+  const file = path.join(dir, 'webpack.config.js');
+  if (!fs.existsSync(file)) return;
+  console.info('Webpacking ' + dir.replace(compRE, '').replace(dirRE, '.'));
+  const wd = process.cwd();
+  try {
+    process.chdir(dir);
+    const result = execSync(pack);
+    console.info('    ' + String(result).replace(/\n/g, '\n    '));
+  } catch (err) {
+    console.info('    ' + err.message);
+  }
+  process.chdir(wd);
+}
+
+/**
+ * Copy the designated files if there is a configurtion file for it
+ *
+ * @param {string} dir   The directory to check
+ */
+function copyLib(dir) {
+  const file = path.join(dir, 'copy.json');
+  if (!fs.existsSync(file)) return;
+  console.info('Copying ' + dir.replace(compRE, ''));
+  try {
+    process.chdir(dir);
+    const result = execSync(copy);
+    console.info('    ' + String(result).replace(/\n/g, '\n    '));
+  } catch (err) {
+    console.info('    ' + err.message);
+  }
+}
+
+/**
+ * Process all the specified directories
+ */
+processList(dirs);

node_modules/mathjax-full/components/bin/pack

@@ -0,0 +1,132 @@
+#! /usr/bin/env node
+
+
+/*************************************************************
+ *
+ *  Copyright (c) 2018 The MathJax Consortium
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/**
+ * @fileoverview  webpack the component in the current directory
+ *
+ * @author dpvc@mathjax.org (Davide Cervone)
+ */
+
+
+const fs = require('fs');
+const path = require('path');
+const {spawn} = require('child_process');
+
+/**
+ * @param {string} name    The file name to turn into a Regular expression
+ * @return {RegExp}        The regular expression for the name,
+ */
+function fileRegExp(name) {
+  return new RegExp(name.replace(/([\\.{}[\]()?*^$])/g, '\\$1'), 'g');
+}
+
+/**
+ * @param {Object}    The file or asset data whose size is to be returned
+ * @return {string}   The string giving the size in KB
+ */
+function fileSize(file) {
+  return ' (' + (file.size / 1024).toFixed(2).replace(/\.?0+$/, '') + ' KB)';
+}
+
+/**
+ * Regular expressions for the components directory and the MathJax .js location
+ */
+const compRE = fileRegExp(path.dirname(__dirname));
+const rootRE = fileRegExp(path.join(path.dirname(path.dirname(__dirname)), 'js'));
+const nodeRE = fileRegExp(path.join(path.dirname(path.dirname(__dirname)), 'node_modules'));
+
+/**
+ * @return {JSON}   The parsed JSON from webpack
+ */
+async function readJSON() {
+  return new Promise((ok, fail) => {
+    const buffer = [];
+    const child = spawn('npx', ['webpack', '--json']);
+    child.stdout.on('data', (data) => buffer.push(String(data)));
+    child.stdout.on('close', (code) => {
+      const json = JSON.parse(buffer.join(''));
+      if (json.errors && json.errors.length) {
+        fail(json.errors[0].message);
+      }
+      ok(json);
+    });
+  });
+}
+
+/**
+ * Run webpack if there is a configuration file for it
+ *
+ * @param {string} dir   The directory to pack
+ */
+async function webpackLib(dir) {
+  try {
+    process.chdir(dir);
+    const dirRE = fileRegExp(path.resolve(dir));
+
+    //
+    // Get js directory from the webpack.config.js file
+    //
+    const jsdir = require(path.resolve(dir, 'webpack.config.js')).plugins[0].definitions.__JSDIR__;
+    const jsRE = fileRegExp(jsdir);
+    const libRE = fileRegExp(path.resolve(jsdir, '..', 'components'));
+
+    //
+    // Get the json from webpack and print the asset name and size
+    //
+    const json = await readJSON();
+    for (const asset of json.assets) {
+      console.log(asset.name + fileSize(asset));
+    }
+    //
+    // Sort the modules and print their names and sizes
+    //
+    const modules = json.modules;
+    for (const module of modules) {
+      module.name = path.resolve(dir, module.name)
+        .replace(/ \+ \d+ modules/, '')
+        .replace(dirRE, '.');
+    }
+    const list = [];
+    for (const module of modules) {
+      if (module.moduleType.match(/javascript/)) {
+        let name = module.name
+            .replace(compRE, '[components]')
+            .replace(rootRE, '[mathjax]')
+            .replace(nodeRE, '[node]')
+            .replace(jsRE,   '[js]')
+            .replace(libRE,  '[lib]');
+        if (name.charAt(0) !== '.' && name.charAt(0) !== '[') {
+          name = path.relative(dir, name);
+        }
+        list.push('  ' + name + fileSize(module));
+      }
+    }
+    console.log(
+      list
+        .filter(a => a.slice(2, 4) === './').sort()
+        .concat(list.filter(a => a.slice(2, 4) !== './').sort())
+        .join('\n')
+    );
+  } catch (err) {
+    console.error(err);
+  }
+}
+
+webpackLib(process.argv[2] || '.');

node_modules/mathjax-full/components/bin/version

@@ -0,0 +1,60 @@
+#! /usr/bin/env node
+
+/*************************************************************
+ *
+ *  Copyright (c) 2022 The MathJax Consortium
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/**
+ * @fileoverview  Creates the version.ts file from the package version number
+ *
+ * @author dpvc@mathjax.org (Davide Cervone)
+ */
+
+
+const fs = require('fs');
+const path = require('path');
+
+const package = path.resolve(__dirname, '..', '..', 'package.json');
+const version = require(package).version;
+
+const lines = `/*************************************************************
+ *
+ *  Copyright (c) 2022 The MathJax Consortium
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/**
+ * @fileoverview  The version of MathJax (used to tell what version a component
+ *                was compiled against).
+ *
+ * @author dpvc@mathjax.org (Davide Cervone)
+ */
+
+export const VERSION = '${version}';
+`;
+
+fs.writeFileSync(path.resolve(__dirname, '..', '..', 'ts', 'components', 'version.ts'), lines);

node_modules/mathjax-full/components/src/a11y/assistive-mml/assistive-mml.js

@@ -0,0 +1,7 @@
+import './lib/assistive-mml.js';
+
+import {AssistiveMmlHandler} from '../../../../js/a11y/assistive-mml.js';
+
+if (MathJax.startup) {
+  MathJax.startup.extendHandler(handler => AssistiveMmlHandler(handler));
+}

node_modules/mathjax-full/components/src/a11y/assistive-mml/build.json

@@ -0,0 +1,5 @@
+{
+  "component": "a11y/assistive-mml",
+  "targets": ["a11y/assistive-mml.ts"]
+}
+

node_modules/mathjax-full/components/src/a11y/assistive-mml/lib/a11y/assistive-mml.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.LimitedMmlVisitor = MathJax._.a11y['assistive-mml'].LimitedMmlVisitor;
+exports.AssistiveMmlMathItemMixin = MathJax._.a11y['assistive-mml'].AssistiveMmlMathItemMixin;
+exports.AssistiveMmlMathDocumentMixin = MathJax._.a11y['assistive-mml'].AssistiveMmlMathDocumentMixin;
+exports.AssistiveMmlHandler = MathJax._.a11y['assistive-mml'].AssistiveMmlHandler;

node_modules/mathjax-full/components/src/a11y/assistive-mml/lib/assistive-mml.js

@@ -0,0 +1,14 @@
+import {combineWithMathJax} from '../../../../../js/components/global.js';
+import {VERSION} from '../../../../../js/components/version.js';
+
+import * as module1 from '../../../../../js/a11y/assistive-mml.js';
+
+if (MathJax.loader) {
+  MathJax.loader.checkVersion('a11y/assistive-mml', VERSION, 'a11y');
+}
+
+combineWithMathJax({_: {
+  a11y: {
+    "assistive-mml": module1
+  }
+}});

node_modules/mathjax-full/components/src/a11y/assistive-mml/webpack.config.js

@@ -0,0 +1,11 @@
+const PACKAGE = require('../../../webpack.common.js');
+
+module.exports = PACKAGE(
+  'a11y/assistive-mml',               // the package to build
+  '../../../../js',                   // location of the MathJax js library
+  [                                   // packages to link to
+    'components/src/input/mml/lib',
+    'components/src/core/lib'
+  ],
+  __dirname                           // our directory
+);

node_modules/mathjax-full/components/src/a11y/complexity/build.json

@@ -0,0 +1,8 @@
+{
+  "component": "a11y/complexity",
+  "targets": [
+    "a11y/complexity.ts",
+    "a11y/complexity",
+    "a11y/semantic-enrich.ts"
+  ]
+}

node_modules/mathjax-full/components/src/a11y/complexity/complexity.js

@@ -0,0 +1,9 @@
+import './lib/complexity.js';
+
+import {combineDefaults} from '../../../../js/components/global.js';
+import {ComplexityHandler} from '../../../../js/a11y/complexity.js';
+
+if (MathJax.startup) {
+  MathJax.startup.extendHandler(handler => ComplexityHandler(handler));
+  combineDefaults(MathJax.config, 'options', MathJax.config['a11y/complexity'] || {});
+}

node_modules/mathjax-full/components/src/a11y/complexity/lib/a11y/complexity.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.ComplexityMathItemMixin = MathJax._.a11y.complexity_ts.ComplexityMathItemMixin;
+exports.ComplexityMathDocumentMixin = MathJax._.a11y.complexity_ts.ComplexityMathDocumentMixin;
+exports.ComplexityHandler = MathJax._.a11y.complexity_ts.ComplexityHandler;

node_modules/mathjax-full/components/src/a11y/complexity/lib/a11y/complexity/collapse.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.Collapse = MathJax._.a11y.complexity.collapse.Collapse;

node_modules/mathjax-full/components/src/a11y/complexity/lib/a11y/complexity/visitor.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.ComplexityVisitor = MathJax._.a11y.complexity.visitor.ComplexityVisitor;

node_modules/mathjax-full/components/src/a11y/complexity/lib/a11y/semantic-enrich.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.EnrichedMathItemMixin = MathJax._.a11y['semantic-enrich'].EnrichedMathItemMixin;
+exports.EnrichedMathDocumentMixin = MathJax._.a11y['semantic-enrich'].EnrichedMathDocumentMixin;
+exports.EnrichHandler = MathJax._.a11y['semantic-enrich'].EnrichHandler;

node_modules/mathjax-full/components/src/a11y/complexity/lib/complexity.js

@@ -0,0 +1,22 @@
+import {combineWithMathJax} from '../../../../../js/components/global.js';
+import {VERSION} from '../../../../../js/components/version.js';
+
+import * as module1 from '../../../../../js/a11y/complexity.js';
+import * as module2 from '../../../../../js/a11y/complexity/collapse.js';
+import * as module3 from '../../../../../js/a11y/complexity/visitor.js';
+import * as module4 from '../../../../../js/a11y/semantic-enrich.js';
+
+if (MathJax.loader) {
+  MathJax.loader.checkVersion('a11y/complexity', VERSION, 'a11y');
+}
+
+combineWithMathJax({_: {
+  a11y: {
+    complexity_ts: module1,
+    complexity: {
+      collapse: module2,
+      visitor: module3
+    },
+    "semantic-enrich": module4
+  }
+}});

node_modules/mathjax-full/components/src/a11y/complexity/webpack.config.js

@@ -0,0 +1,12 @@
+const PACKAGE = require('../../../webpack.common.js');
+
+module.exports = PACKAGE(
+  'a11y/complexity',                  // the package to build
+  '../../../../js',                   // location of the MathJax js library
+  [                                   // packages to link to
+    'components/src/a11y/semantic-enrich/lib',
+    'components/src/input/mml/lib',
+    'components/src/core/lib'
+  ],
+  __dirname                           // our directory
+);

node_modules/mathjax-full/components/src/a11y/explorer/build.json

@@ -0,0 +1,4 @@
+{
+  "component": "a11y/explorer",
+  "targets": ["a11y/explorer.ts", "a11y/explorer"]
+}

node_modules/mathjax-full/components/src/a11y/explorer/explorer.js

@@ -0,0 +1,8 @@
+import './lib/explorer.js';
+
+import {combineDefaults} from '../../../../js/components/global.js';
+import {ExplorerHandler} from '../../../../js/a11y/explorer.js';
+
+if (MathJax.startup) {
+  MathJax.startup.extendHandler(handler => ExplorerHandler(handler));
+}

node_modules/mathjax-full/components/src/a11y/explorer/lib/a11y/explorer.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.ExplorerMathItemMixin = MathJax._.a11y.explorer_ts.ExplorerMathItemMixin;
+exports.ExplorerMathDocumentMixin = MathJax._.a11y.explorer_ts.ExplorerMathDocumentMixin;
+exports.ExplorerHandler = MathJax._.a11y.explorer_ts.ExplorerHandler;
+exports.setA11yOptions = MathJax._.a11y.explorer_ts.setA11yOptions;
+exports.setA11yOption = MathJax._.a11y.explorer_ts.setA11yOption;

node_modules/mathjax-full/components/src/a11y/explorer/lib/a11y/explorer/Explorer.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.AbstractExplorer = MathJax._.a11y.explorer.Explorer.AbstractExplorer;

node_modules/mathjax-full/components/src/a11y/explorer/lib/a11y/explorer/KeyExplorer.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.AbstractKeyExplorer = MathJax._.a11y.explorer.KeyExplorer.AbstractKeyExplorer;
+exports.SpeechExplorer = MathJax._.a11y.explorer.KeyExplorer.SpeechExplorer;
+exports.Magnifier = MathJax._.a11y.explorer.KeyExplorer.Magnifier;

node_modules/mathjax-full/components/src/a11y/explorer/lib/a11y/explorer/MouseExplorer.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.AbstractMouseExplorer = MathJax._.a11y.explorer.MouseExplorer.AbstractMouseExplorer;
+exports.Hoverer = MathJax._.a11y.explorer.MouseExplorer.Hoverer;
+exports.ValueHoverer = MathJax._.a11y.explorer.MouseExplorer.ValueHoverer;
+exports.ContentHoverer = MathJax._.a11y.explorer.MouseExplorer.ContentHoverer;
+exports.FlameHoverer = MathJax._.a11y.explorer.MouseExplorer.FlameHoverer;

node_modules/mathjax-full/components/src/a11y/explorer/lib/a11y/explorer/Region.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.AbstractRegion = MathJax._.a11y.explorer.Region.AbstractRegion;
+exports.DummyRegion = MathJax._.a11y.explorer.Region.DummyRegion;
+exports.StringRegion = MathJax._.a11y.explorer.Region.StringRegion;
+exports.ToolTip = MathJax._.a11y.explorer.Region.ToolTip;
+exports.LiveRegion = MathJax._.a11y.explorer.Region.LiveRegion;
+exports.HoverRegion = MathJax._.a11y.explorer.Region.HoverRegion;

node_modules/mathjax-full/components/src/a11y/explorer/lib/a11y/explorer/TreeExplorer.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.AbstractTreeExplorer = MathJax._.a11y.explorer.TreeExplorer.AbstractTreeExplorer;
+exports.FlameColorer = MathJax._.a11y.explorer.TreeExplorer.FlameColorer;
+exports.TreeColorer = MathJax._.a11y.explorer.TreeExplorer.TreeColorer;

node_modules/mathjax-full/components/src/a11y/explorer/lib/explorer.js

@@ -0,0 +1,26 @@
+import {combineWithMathJax} from '../../../../../js/components/global.js';
+import {VERSION} from '../../../../../js/components/version.js';
+
+import * as module1 from '../../../../../js/a11y/explorer.js';
+import * as module2 from '../../../../../js/a11y/explorer/Explorer.js';
+import * as module3 from '../../../../../js/a11y/explorer/KeyExplorer.js';
+import * as module4 from '../../../../../js/a11y/explorer/MouseExplorer.js';
+import * as module5 from '../../../../../js/a11y/explorer/Region.js';
+import * as module6 from '../../../../../js/a11y/explorer/TreeExplorer.js';
+
+if (MathJax.loader) {
+  MathJax.loader.checkVersion('a11y/explorer', VERSION, 'a11y');
+}
+
+combineWithMathJax({_: {
+  a11y: {
+    explorer_ts: module1,
+    explorer: {
+      Explorer: module2,
+      KeyExplorer: module3,
+      MouseExplorer: module4,
+      Region: module5,
+      TreeExplorer: module6
+    }
+  }
+}});

node_modules/mathjax-full/components/src/a11y/explorer/webpack.config.js

@@ -0,0 +1,14 @@
+const PACKAGE = require('../../../webpack.common.js');
+
+module.exports = PACKAGE(
+  'a11y/explorer',                    // the package to build
+  '../../../../js',                   // location of the MathJax js library
+  [                                   // packages to link to
+    'components/src/ui/menu/lib',
+    'components/src/a11y/semantic-enrich/lib',
+    'components/src/a11y/sre/lib',
+    'components/src/input/mml/lib',
+    'components/src/core/lib'
+  ],
+  __dirname                           // our directory
+);

node_modules/mathjax-full/components/src/a11y/semantic-enrich/build.json

@@ -0,0 +1,5 @@
+{
+  "component": "a11y/semantic-enrich",
+  "targets": ["a11y/semantic-enrich.ts"]
+}
+

node_modules/mathjax-full/components/src/a11y/semantic-enrich/lib/a11y/semantic-enrich.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.EnrichedMathItemMixin = MathJax._.a11y['semantic-enrich'].EnrichedMathItemMixin;
+exports.EnrichedMathDocumentMixin = MathJax._.a11y['semantic-enrich'].EnrichedMathDocumentMixin;
+exports.EnrichHandler = MathJax._.a11y['semantic-enrich'].EnrichHandler;

node_modules/mathjax-full/components/src/a11y/semantic-enrich/lib/semantic-enrich.js

@@ -0,0 +1,14 @@
+import {combineWithMathJax} from '../../../../../js/components/global.js';
+import {VERSION} from '../../../../../js/components/version.js';
+
+import * as module1 from '../../../../../js/a11y/semantic-enrich.js';
+
+if (MathJax.loader) {
+  MathJax.loader.checkVersion('a11y/semantic-enrich', VERSION, 'a11y');
+}
+
+combineWithMathJax({_: {
+  a11y: {
+    "semantic-enrich": module1
+  }
+}});

node_modules/mathjax-full/components/src/a11y/semantic-enrich/semantic-enrich.js

@@ -0,0 +1,14 @@
+import './lib/semantic-enrich.js';
+
+import {combineDefaults} from '../../../../js/components/global.js';
+import Sre from '../../../../js/a11y/sre.js';
+import {EnrichHandler} from '../../../../js/a11y/semantic-enrich.js';
+import {MathML} from '../../../../js/input/mathml.js';
+
+if (MathJax.loader) {
+  combineDefaults(MathJax.config.loader, 'a11y/semantic-enrich', {checkReady: () => Sre.sreReady()});
+}
+
+if (MathJax.startup) {
+  MathJax.startup.extendHandler(handler => EnrichHandler(handler, new MathML()));
+}

node_modules/mathjax-full/components/src/a11y/semantic-enrich/webpack.config.js

@@ -0,0 +1,12 @@
+const PACKAGE = require('../../../webpack.common.js');
+
+module.exports = PACKAGE(
+  'a11y/semantic-enrich',             // the package to build
+  '../../../../js',                   // location of the MathJax js library
+  [                                   // packages to link to
+    'components/src/input/mml/lib',
+    'components/src/core/lib',
+    'components/src/a11y/sre/lib'
+  ],
+  __dirname                           // our directory
+);

node_modules/mathjax-full/components/src/a11y/sre/build.json

@@ -0,0 +1,5 @@
+{
+  "component": "a11y/sre",
+  "targets": ["a11y/sre.ts"]
+}
+

node_modules/mathjax-full/components/src/a11y/sre/lib/a11y/sre.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.Sre = MathJax._.a11y.sre.Sre;
+exports.sreReady = MathJax._.a11y.sre.sreReady;
+exports.default = MathJax._.a11y.sre.default;

node_modules/mathjax-full/components/src/a11y/sre/lib/sre.js

@@ -0,0 +1,14 @@
+import {combineWithMathJax} from '../../../../../js/components/global.js';
+import {VERSION} from '../../../../../js/components/version.js';
+
+import * as module1 from '../../../../../js/a11y/sre.js';
+
+if (MathJax.loader) {
+  MathJax.loader.checkVersion('a11y/sre', VERSION, 'a11y');
+}
+
+combineWithMathJax({_: {
+  a11y: {
+    sre: module1
+  }
+}});

node_modules/mathjax-full/components/src/a11y/sre/sre.js

@@ -0,0 +1,9 @@
+import './lib/sre.js';
+import './sre_config.js';
+import Sre from '../../../../js/a11y/sre.js';
+
+if (MathJax.startup) {
+  ((typeof window !== 'undefined') ? window : global).
+    SREfeature.custom = (loc) => Sre.preloadLocales(loc);
+}
+

node_modules/mathjax-full/components/src/a11y/sre/sre_config.js

@@ -0,0 +1,19 @@
+import {combineDefaults} from '../../../../js/components/global.js';
+import {Package} from '../../../../js/components/package.js';
+
+// This sets up the correct link to the mathmaps files.
+if (MathJax.startup) {
+
+  let path = Package.resolvePath('[sre]', false);
+
+  if (typeof window !== 'undefined') {
+    window.SREfeature = {json: path};
+  } else {
+    // In Node get the absolute path to the mathmaps directory.
+    try {
+      path = MathJax.config.loader.require.resolve(
+        path + '/base.json').replace(/\/base\.json$/, '');
+    } catch(_err) { }
+    global.SREfeature = {json: path};
+  }
+}

node_modules/mathjax-full/components/src/a11y/sre/webpack.config.js

@@ -0,0 +1,12 @@
+const PACKAGE = require('../../../webpack.common.js');
+
+module.exports = PACKAGE(
+  'a11y/sre',                         // the package to build
+  '../../../../js',                   // location of the MathJax js library
+  [                                   // packages to link to
+    'components/src/input/mml/lib',
+    'components/src/core/lib',
+    'components/src/startup/lib'
+  ],
+  __dirname                           // our directory
+);

node_modules/mathjax-full/components/src/adaptors/liteDOM/build.json

@@ -0,0 +1,5 @@
+{
+  "component": "adaptors/liteDOM",
+  "targets": ["adaptors/liteAdaptor.ts", "adaptors/lite"]
+}
+

node_modules/mathjax-full/components/src/adaptors/liteDOM/lib/adaptors/lite/Document.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.LiteDocument = MathJax._.adaptors.lite.Document.LiteDocument;

node_modules/mathjax-full/components/src/adaptors/liteDOM/lib/adaptors/lite/Element.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.LiteElement = MathJax._.adaptors.lite.Element.LiteElement;

node_modules/mathjax-full/components/src/adaptors/liteDOM/lib/adaptors/lite/List.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.LiteList = MathJax._.adaptors.lite.List.LiteList;

node_modules/mathjax-full/components/src/adaptors/liteDOM/lib/adaptors/lite/Parser.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.PATTERNS = MathJax._.adaptors.lite.Parser.PATTERNS;
+exports.LiteParser = MathJax._.adaptors.lite.Parser.LiteParser;

node_modules/mathjax-full/components/src/adaptors/liteDOM/lib/adaptors/lite/Text.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.LiteText = MathJax._.adaptors.lite.Text.LiteText;
+exports.LiteComment = MathJax._.adaptors.lite.Text.LiteComment;

node_modules/mathjax-full/components/src/adaptors/liteDOM/lib/adaptors/lite/Window.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.LiteWindow = MathJax._.adaptors.lite.Window.LiteWindow;

node_modules/mathjax-full/components/src/adaptors/liteDOM/lib/adaptors/liteAdaptor.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.LiteBase = MathJax._.adaptors.liteAdaptor.LiteBase;
+exports.LiteAdaptor = MathJax._.adaptors.liteAdaptor.LiteAdaptor;
+exports.liteAdaptor = MathJax._.adaptors.liteAdaptor.liteAdaptor;

node_modules/mathjax-full/components/src/adaptors/liteDOM/lib/liteDOM.js

@@ -0,0 +1,28 @@
+import {combineWithMathJax} from '../../../../../js/components/global.js';
+import {VERSION} from '../../../../../js/components/version.js';
+
+import * as module1 from '../../../../../js/adaptors/liteAdaptor.js';
+import * as module2 from '../../../../../js/adaptors/lite/Document.js';
+import * as module3 from '../../../../../js/adaptors/lite/Element.js';
+import * as module4 from '../../../../../js/adaptors/lite/List.js';
+import * as module5 from '../../../../../js/adaptors/lite/Parser.js';
+import * as module6 from '../../../../../js/adaptors/lite/Text.js';
+import * as module7 from '../../../../../js/adaptors/lite/Window.js';
+
+if (MathJax.loader) {
+  MathJax.loader.checkVersion('adaptors/liteDOM', VERSION, 'adaptors');
+}
+
+combineWithMathJax({_: {
+  adaptors: {
+    liteAdaptor: module1,
+    lite: {
+      Document: module2,
+      Element: module3,
+      List: module4,
+      Parser: module5,
+      Text: module6,
+      Window: module7
+    }
+  }
+}});

node_modules/mathjax-full/components/src/adaptors/liteDOM/liteDOM.js

@@ -0,0 +1,8 @@
+import './lib/liteDOM.js';
+
+import {liteAdaptor} from '../../../../js/adaptors/liteAdaptor.js';
+
+if (MathJax.startup) {
+  MathJax.startup.registerConstructor('liteAdaptor', liteAdaptor);
+  MathJax.startup.useAdaptor('liteAdaptor', true);
+}

node_modules/mathjax-full/components/src/adaptors/liteDOM/webpack.config.js

@@ -0,0 +1,8 @@
+const PACKAGE = require('../../../webpack.common.js');
+
+module.exports = PACKAGE(
+  'adaptors/liteDOM',                 // the package to build
+  '../../../../js',                   // location of the MathJax js library
+  ['components/src/core/lib'],        // packages to link to
+  __dirname                           // our directory
+);

node_modules/mathjax-full/components/src/core/build.json

@@ -0,0 +1,20 @@
+{
+  "component": "core",
+  
+  "targets": [
+    "mathjax.ts",
+    "core", "util", "handlers",
+    "adaptors/HTMLAdaptor.ts",
+    "adaptors/browserAdaptor.ts",
+    "components/global.ts"
+  ],
+
+  "exclude": [
+    "core/MmlTree/JsonMmlVisitor.ts",
+    "core/MmlTree/LegacyMmlVisitor.ts",
+    "core/MmlTree/TestMmlVisitor.ts",
+    "util/asyncLoad",
+    "util/entities"
+  ]
+}
+

node_modules/mathjax-full/components/src/core/core.js

@@ -0,0 +1,14 @@
+import './lib/core.js';
+
+import {HTMLHandler} from '../../../js/handlers/html/HTMLHandler.js';
+import {browserAdaptor} from '../../../js/adaptors/browserAdaptor.js';
+
+if (MathJax.startup) {
+  MathJax.startup.registerConstructor('HTMLHandler', HTMLHandler);
+  MathJax.startup.registerConstructor('browserAdaptor', browserAdaptor);
+  MathJax.startup.useHandler('HTMLHandler');
+  MathJax.startup.useAdaptor('browserAdaptor');
+}
+if (MathJax.loader) {
+  MathJax._.mathjax.mathjax.asyncLoad = (name => MathJax.loader.load(name));
+}

node_modules/mathjax-full/components/src/core/lib/adaptors/HTMLAdaptor.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.HTMLAdaptor = MathJax._.adaptors.HTMLAdaptor.HTMLAdaptor;

node_modules/mathjax-full/components/src/core/lib/adaptors/browserAdaptor.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.browserAdaptor = MathJax._.adaptors.browserAdaptor.browserAdaptor;

node_modules/mathjax-full/components/src/core/lib/components/global.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.isObject = MathJax._.components.global.isObject;
+exports.combineConfig = MathJax._.components.global.combineConfig;
+exports.combineDefaults = MathJax._.components.global.combineDefaults;
+exports.combineWithMathJax = MathJax._.components.global.combineWithMathJax;
+exports.MathJax = MathJax._.components.global.MathJax;

node_modules/mathjax-full/components/src/core/lib/core.js

@@ -0,0 +1,182 @@
+import {combineWithMathJax} from '../../../../js/components/global.js';
+import {VERSION} from '../../../../js/components/version.js';
+
+import * as module1 from '../../../../js/adaptors/HTMLAdaptor.js';
+import * as module2 from '../../../../js/adaptors/browserAdaptor.js';
+import * as module3 from '../../../../js/components/global.js';
+import * as module4 from '../../../../js/core/DOMAdaptor.js';
+import * as module5 from '../../../../js/core/FindMath.js';
+import * as module6 from '../../../../js/core/Handler.js';
+import * as module7 from '../../../../js/core/HandlerList.js';
+import * as module8 from '../../../../js/core/InputJax.js';
+import * as module9 from '../../../../js/core/MathDocument.js';
+import * as module10 from '../../../../js/core/MathItem.js';
+import * as module11 from '../../../../js/core/MathList.js';
+import * as module12 from '../../../../js/core/MmlTree/Attributes.js';
+import * as module13 from '../../../../js/core/MmlTree/MML.js';
+import * as module14 from '../../../../js/core/MmlTree/MathMLVisitor.js';
+import * as module15 from '../../../../js/core/MmlTree/MmlFactory.js';
+import * as module16 from '../../../../js/core/MmlTree/MmlNode.js';
+import * as module17 from '../../../../js/core/MmlTree/MmlNodes/TeXAtom.js';
+import * as module18 from '../../../../js/core/MmlTree/MmlNodes/maction.js';
+import * as module19 from '../../../../js/core/MmlTree/MmlNodes/maligngroup.js';
+import * as module20 from '../../../../js/core/MmlTree/MmlNodes/malignmark.js';
+import * as module21 from '../../../../js/core/MmlTree/MmlNodes/math.js';
+import * as module22 from '../../../../js/core/MmlTree/MmlNodes/mathchoice.js';
+import * as module23 from '../../../../js/core/MmlTree/MmlNodes/menclose.js';
+import * as module24 from '../../../../js/core/MmlTree/MmlNodes/merror.js';
+import * as module25 from '../../../../js/core/MmlTree/MmlNodes/mfenced.js';
+import * as module26 from '../../../../js/core/MmlTree/MmlNodes/mfrac.js';
+import * as module27 from '../../../../js/core/MmlTree/MmlNodes/mglyph.js';
+import * as module28 from '../../../../js/core/MmlTree/MmlNodes/mi.js';
+import * as module29 from '../../../../js/core/MmlTree/MmlNodes/mmultiscripts.js';
+import * as module30 from '../../../../js/core/MmlTree/MmlNodes/mn.js';
+import * as module31 from '../../../../js/core/MmlTree/MmlNodes/mo.js';
+import * as module32 from '../../../../js/core/MmlTree/MmlNodes/mpadded.js';
+import * as module33 from '../../../../js/core/MmlTree/MmlNodes/mphantom.js';
+import * as module34 from '../../../../js/core/MmlTree/MmlNodes/mroot.js';
+import * as module35 from '../../../../js/core/MmlTree/MmlNodes/mrow.js';
+import * as module36 from '../../../../js/core/MmlTree/MmlNodes/ms.js';
+import * as module37 from '../../../../js/core/MmlTree/MmlNodes/mspace.js';
+import * as module38 from '../../../../js/core/MmlTree/MmlNodes/msqrt.js';
+import * as module39 from '../../../../js/core/MmlTree/MmlNodes/mstyle.js';
+import * as module40 from '../../../../js/core/MmlTree/MmlNodes/msubsup.js';
+import * as module41 from '../../../../js/core/MmlTree/MmlNodes/mtable.js';
+import * as module42 from '../../../../js/core/MmlTree/MmlNodes/mtd.js';
+import * as module43 from '../../../../js/core/MmlTree/MmlNodes/mtext.js';
+import * as module44 from '../../../../js/core/MmlTree/MmlNodes/mtr.js';
+import * as module45 from '../../../../js/core/MmlTree/MmlNodes/munderover.js';
+import * as module46 from '../../../../js/core/MmlTree/MmlNodes/semantics.js';
+import * as module47 from '../../../../js/core/MmlTree/MmlVisitor.js';
+import * as module48 from '../../../../js/core/MmlTree/OperatorDictionary.js';
+import * as module49 from '../../../../js/core/MmlTree/SerializedMmlVisitor.js';
+import * as module50 from '../../../../js/core/OutputJax.js';
+import * as module51 from '../../../../js/core/Tree/Factory.js';
+import * as module52 from '../../../../js/core/Tree/Node.js';
+import * as module53 from '../../../../js/core/Tree/NodeFactory.js';
+import * as module54 from '../../../../js/core/Tree/Visitor.js';
+import * as module55 from '../../../../js/core/Tree/Wrapper.js';
+import * as module56 from '../../../../js/core/Tree/WrapperFactory.js';
+import * as module57 from '../../../../js/handlers/html.js';
+import * as module58 from '../../../../js/handlers/html/HTMLDocument.js';
+import * as module59 from '../../../../js/handlers/html/HTMLDomStrings.js';
+import * as module60 from '../../../../js/handlers/html/HTMLHandler.js';
+import * as module61 from '../../../../js/handlers/html/HTMLMathItem.js';
+import * as module62 from '../../../../js/handlers/html/HTMLMathList.js';
+import * as module63 from '../../../../js/mathjax.js';
+import * as module64 from '../../../../js/util/AsyncLoad.js';
+import * as module65 from '../../../../js/util/BBox.js';
+import * as module66 from '../../../../js/util/BitField.js';
+import * as module67 from '../../../../js/util/Entities.js';
+import * as module68 from '../../../../js/util/FunctionList.js';
+import * as module69 from '../../../../js/util/LinkedList.js';
+import * as module70 from '../../../../js/util/Options.js';
+import * as module71 from '../../../../js/util/PrioritizedList.js';
+import * as module72 from '../../../../js/util/Retries.js';
+import * as module73 from '../../../../js/util/StyleList.js';
+import * as module74 from '../../../../js/util/Styles.js';
+import * as module75 from '../../../../js/util/lengths.js';
+import * as module76 from '../../../../js/util/numeric.js';
+import * as module77 from '../../../../js/util/string.js';
+
+if (MathJax.loader) {
+  MathJax.loader.checkVersion('core', VERSION, 'core');
+}
+
+combineWithMathJax({_: {
+  adaptors: {
+    HTMLAdaptor: module1,
+    browserAdaptor: module2
+  },
+  components: {
+    global: module3
+  },
+  core: {
+    DOMAdaptor: module4,
+    FindMath: module5,
+    Handler: module6,
+    HandlerList: module7,
+    InputJax: module8,
+    MathDocument: module9,
+    MathItem: module10,
+    MathList: module11,
+    MmlTree: {
+      Attributes: module12,
+      MML: module13,
+      MathMLVisitor: module14,
+      MmlFactory: module15,
+      MmlNode: module16,
+      MmlNodes: {
+        TeXAtom: module17,
+        maction: module18,
+        maligngroup: module19,
+        malignmark: module20,
+        math: module21,
+        mathchoice: module22,
+        menclose: module23,
+        merror: module24,
+        mfenced: module25,
+        mfrac: module26,
+        mglyph: module27,
+        mi: module28,
+        mmultiscripts: module29,
+        mn: module30,
+        mo: module31,
+        mpadded: module32,
+        mphantom: module33,
+        mroot: module34,
+        mrow: module35,
+        ms: module36,
+        mspace: module37,
+        msqrt: module38,
+        mstyle: module39,
+        msubsup: module40,
+        mtable: module41,
+        mtd: module42,
+        mtext: module43,
+        mtr: module44,
+        munderover: module45,
+        semantics: module46
+      },
+      MmlVisitor: module47,
+      OperatorDictionary: module48,
+      SerializedMmlVisitor: module49
+    },
+    OutputJax: module50,
+    Tree: {
+      Factory: module51,
+      Node: module52,
+      NodeFactory: module53,
+      Visitor: module54,
+      Wrapper: module55,
+      WrapperFactory: module56
+    }
+  },
+  handlers: {
+    html_ts: module57,
+    html: {
+      HTMLDocument: module58,
+      HTMLDomStrings: module59,
+      HTMLHandler: module60,
+      HTMLMathItem: module61,
+      HTMLMathList: module62
+    }
+  },
+  mathjax: module63,
+    util: {
+    AsyncLoad: module64,
+    BBox: module65,
+    BitField: module66,
+    Entities: module67,
+    FunctionList: module68,
+    LinkedList: module69,
+    Options: module70,
+    PrioritizedList: module71,
+    Retries: module72,
+    StyleList: module73,
+    Styles: module74,
+    lengths: module75,
+    numeric: module76,
+    string: module77
+  }
+}});

node_modules/mathjax-full/components/src/core/lib/core/DOMAdaptor.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.AbstractDOMAdaptor = MathJax._.core.DOMAdaptor.AbstractDOMAdaptor;

node_modules/mathjax-full/components/src/core/lib/core/FindMath.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.AbstractFindMath = MathJax._.core.FindMath.AbstractFindMath;

node_modules/mathjax-full/components/src/core/lib/core/Handler.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.AbstractHandler = MathJax._.core.Handler.AbstractHandler;

node_modules/mathjax-full/components/src/core/lib/core/HandlerList.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.HandlerList = MathJax._.core.HandlerList.HandlerList;

node_modules/mathjax-full/components/src/core/lib/core/InputJax.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.AbstractInputJax = MathJax._.core.InputJax.AbstractInputJax;

node_modules/mathjax-full/components/src/core/lib/core/MathDocument.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.RenderList = MathJax._.core.MathDocument.RenderList;
+exports.resetOptions = MathJax._.core.MathDocument.resetOptions;
+exports.resetAllOptions = MathJax._.core.MathDocument.resetAllOptions;
+exports.AbstractMathDocument = MathJax._.core.MathDocument.AbstractMathDocument;

node_modules/mathjax-full/components/src/core/lib/core/MathItem.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.protoItem = MathJax._.core.MathItem.protoItem;
+exports.AbstractMathItem = MathJax._.core.MathItem.AbstractMathItem;
+exports.STATE = MathJax._.core.MathItem.STATE;
+exports.newState = MathJax._.core.MathItem.newState;

node_modules/mathjax-full/components/src/core/lib/core/MathList.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.AbstractMathList = MathJax._.core.MathList.AbstractMathList;

node_modules/mathjax-full/components/src/core/lib/core/MmlTree/Attributes.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.INHERIT = MathJax._.core.MmlTree.Attributes.INHERIT;
+exports.Attributes = MathJax._.core.MmlTree.Attributes.Attributes;

node_modules/mathjax-full/components/src/core/lib/core/MmlTree/MML.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.MML = MathJax._.core.MmlTree.MML.MML;

node_modules/mathjax-full/components/src/core/lib/core/MmlTree/MathMLVisitor.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.MathMLVisitor = MathJax._.core.MmlTree.MathMLVisitor.MathMLVisitor;

node_modules/mathjax-full/components/src/core/lib/core/MmlTree/MmlFactory.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.MmlFactory = MathJax._.core.MmlTree.MmlFactory.MmlFactory;

node_modules/mathjax-full/components/src/core/lib/core/MmlTree/MmlNode.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.TEXCLASS = MathJax._.core.MmlTree.MmlNode.TEXCLASS;
+exports.TEXCLASSNAMES = MathJax._.core.MmlTree.MmlNode.TEXCLASSNAMES;
+exports.indentAttributes = MathJax._.core.MmlTree.MmlNode.indentAttributes;
+exports.AbstractMmlNode = MathJax._.core.MmlTree.MmlNode.AbstractMmlNode;
+exports.AbstractMmlTokenNode = MathJax._.core.MmlTree.MmlNode.AbstractMmlTokenNode;
+exports.AbstractMmlLayoutNode = MathJax._.core.MmlTree.MmlNode.AbstractMmlLayoutNode;
+exports.AbstractMmlBaseNode = MathJax._.core.MmlTree.MmlNode.AbstractMmlBaseNode;
+exports.AbstractMmlEmptyNode = MathJax._.core.MmlTree.MmlNode.AbstractMmlEmptyNode;
+exports.TextNode = MathJax._.core.MmlTree.MmlNode.TextNode;
+exports.XMLNode = MathJax._.core.MmlTree.MmlNode.XMLNode;

node_modules/mathjax-full/components/src/core/lib/core/MmlTree/MmlNodes/TeXAtom.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.TeXAtom = MathJax._.core.MmlTree.MmlNodes.TeXAtom.TeXAtom;

node_modules/mathjax-full/components/src/core/lib/core/MmlTree/MmlNodes/maction.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.MmlMaction = MathJax._.core.MmlTree.MmlNodes.maction.MmlMaction;

node_modules/mathjax-full/components/src/core/lib/core/MmlTree/MmlNodes/maligngroup.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.MmlMaligngroup = MathJax._.core.MmlTree.MmlNodes.maligngroup.MmlMaligngroup;

node_modules/mathjax-full/components/src/core/lib/core/MmlTree/MmlNodes/malignmark.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.MmlMalignmark = MathJax._.core.MmlTree.MmlNodes.malignmark.MmlMalignmark;

node_modules/mathjax-full/components/src/core/lib/core/MmlTree/MmlNodes/math.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.MmlMath = MathJax._.core.MmlTree.MmlNodes.math.MmlMath;

node_modules/mathjax-full/components/src/core/lib/core/MmlTree/MmlNodes/mathchoice.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.MathChoice = MathJax._.core.MmlTree.MmlNodes.mathchoice.MathChoice;

node_modules/mathjax-full/components/src/core/lib/core/MmlTree/MmlNodes/menclose.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.MmlMenclose = MathJax._.core.MmlTree.MmlNodes.menclose.MmlMenclose;

node_modules/mathjax-full/components/src/core/lib/core/MmlTree/MmlNodes/merror.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.MmlMerror = MathJax._.core.MmlTree.MmlNodes.merror.MmlMerror;

node_modules/mathjax-full/components/src/core/lib/core/MmlTree/MmlNodes/mfenced.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.MmlMfenced = MathJax._.core.MmlTree.MmlNodes.mfenced.MmlMfenced;

node_modules/mathjax-full/components/src/core/lib/core/MmlTree/MmlNodes/mfrac.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.MmlMfrac = MathJax._.core.MmlTree.MmlNodes.mfrac.MmlMfrac;

node_modules/mathjax-full/components/src/core/lib/core/MmlTree/MmlNodes/mglyph.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.MmlMglyph = MathJax._.core.MmlTree.MmlNodes.mglyph.MmlMglyph;

node_modules/mathjax-full/components/src/core/lib/core/MmlTree/MmlNodes/mi.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.MmlMi = MathJax._.core.MmlTree.MmlNodes.mi.MmlMi;

node_modules/mathjax-full/components/src/core/lib/core/MmlTree/MmlNodes/mmultiscripts.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.MmlMmultiscripts = MathJax._.core.MmlTree.MmlNodes.mmultiscripts.MmlMmultiscripts;
+exports.MmlMprescripts = MathJax._.core.MmlTree.MmlNodes.mmultiscripts.MmlMprescripts;
+exports.MmlNone = MathJax._.core.MmlTree.MmlNodes.mmultiscripts.MmlNone;

node_modules/mathjax-full/components/src/core/lib/core/MmlTree/MmlNodes/mn.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.MmlMn = MathJax._.core.MmlTree.MmlNodes.mn.MmlMn;

node_modules/mathjax-full/components/src/core/lib/core/MmlTree/MmlNodes/mo.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.MmlMo = MathJax._.core.MmlTree.MmlNodes.mo.MmlMo;

node_modules/mathjax-full/components/src/core/lib/core/MmlTree/MmlNodes/mpadded.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.MmlMpadded = MathJax._.core.MmlTree.MmlNodes.mpadded.MmlMpadded;

node_modules/mathjax-full/components/src/core/lib/core/MmlTree/MmlNodes/mphantom.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.MmlMphantom = MathJax._.core.MmlTree.MmlNodes.mphantom.MmlMphantom;

node_modules/mathjax-full/components/src/core/lib/core/MmlTree/MmlNodes/mroot.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.MmlMroot = MathJax._.core.MmlTree.MmlNodes.mroot.MmlMroot;

node_modules/mathjax-full/components/src/core/lib/core/MmlTree/MmlNodes/mrow.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.MmlMrow = MathJax._.core.MmlTree.MmlNodes.mrow.MmlMrow;
+exports.MmlInferredMrow = MathJax._.core.MmlTree.MmlNodes.mrow.MmlInferredMrow;

node_modules/mathjax-full/components/src/core/lib/core/MmlTree/MmlNodes/ms.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.MmlMs = MathJax._.core.MmlTree.MmlNodes.ms.MmlMs;

node_modules/mathjax-full/components/src/core/lib/core/MmlTree/MmlNodes/mspace.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.MmlMspace = MathJax._.core.MmlTree.MmlNodes.mspace.MmlMspace;

node_modules/mathjax-full/components/src/core/lib/core/MmlTree/MmlNodes/msqrt.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.MmlMsqrt = MathJax._.core.MmlTree.MmlNodes.msqrt.MmlMsqrt;

node_modules/mathjax-full/components/src/core/lib/core/MmlTree/MmlNodes/mstyle.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.MmlMstyle = MathJax._.core.MmlTree.MmlNodes.mstyle.MmlMstyle;

node_modules/mathjax-full/components/src/core/lib/core/MmlTree/MmlNodes/msubsup.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.MmlMsubsup = MathJax._.core.MmlTree.MmlNodes.msubsup.MmlMsubsup;
+exports.MmlMsub = MathJax._.core.MmlTree.MmlNodes.msubsup.MmlMsub;
+exports.MmlMsup = MathJax._.core.MmlTree.MmlNodes.msubsup.MmlMsup;

node_modules/mathjax-full/components/src/core/lib/core/MmlTree/MmlNodes/mtable.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.MmlMtable = MathJax._.core.MmlTree.MmlNodes.mtable.MmlMtable;

node_modules/mathjax-full/components/src/core/lib/core/MmlTree/MmlNodes/mtd.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.MmlMtd = MathJax._.core.MmlTree.MmlNodes.mtd.MmlMtd;

node_modules/mathjax-full/components/src/core/lib/core/MmlTree/MmlNodes/mtext.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.MmlMtext = MathJax._.core.MmlTree.MmlNodes.mtext.MmlMtext;

node_modules/mathjax-full/components/src/core/lib/core/MmlTree/MmlNodes/mtr.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.MmlMtr = MathJax._.core.MmlTree.MmlNodes.mtr.MmlMtr;
+exports.MmlMlabeledtr = MathJax._.core.MmlTree.MmlNodes.mtr.MmlMlabeledtr;

node_modules/mathjax-full/components/src/core/lib/core/MmlTree/MmlNodes/munderover.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.MmlMunderover = MathJax._.core.MmlTree.MmlNodes.munderover.MmlMunderover;
+exports.MmlMunder = MathJax._.core.MmlTree.MmlNodes.munderover.MmlMunder;
+exports.MmlMover = MathJax._.core.MmlTree.MmlNodes.munderover.MmlMover;

node_modules/mathjax-full/components/src/core/lib/core/MmlTree/MmlNodes/semantics.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.MmlSemantics = MathJax._.core.MmlTree.MmlNodes.semantics.MmlSemantics;
+exports.MmlAnnotationXML = MathJax._.core.MmlTree.MmlNodes.semantics.MmlAnnotationXML;
+exports.MmlAnnotation = MathJax._.core.MmlTree.MmlNodes.semantics.MmlAnnotation;

node_modules/mathjax-full/components/src/core/lib/core/MmlTree/MmlVisitor.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.MmlVisitor = MathJax._.core.MmlTree.MmlVisitor.MmlVisitor;