first commit

This commit is contained in:
Missdrop
2025-07-16 16:30:56 +00:00
commit 7ee33927cb
11326 changed files with 1230901 additions and 0 deletions

314
node_modules/mathjax-full/CONTRIBUTING.md generated vendored Normal file
View File

@@ -0,0 +1,314 @@
# Contributing to MathJax
You are interested in giving us a hand? That's awesome! We've put
together some brief guidelines that should help you get started
quickly and easily.
There are lots and lots of ways to get involved, this document covers:
* [reporting an issue](#reporting-an-issue)
* [bug reports](#bug-reports)
* [feature requests](#feature-requests)
* [change requests](#change-requests)
* [working on MathJax core](#working-on-mathjax-core)
* [key branches and tags](#key-branches--tags)
* [submitting pull requests](#submitting-pull-requests)
* [testing and quality assurance](#testing-and-quality-assurance)
* [writing documentation](#writing-documentation)
* [translation](#translation)
* [Conduct](#conduct)
## Reporting An Issue
If you're about to raise an issue because you think you've found a
problem with MathJax, or you'd like to make a request for a new
feature in the codebase, or any other reason, please read this first.
The [MathJax issue
tracker](https://github.com/mathjax/MathJax/issues) is the
preferred channel for [bug reports](#bug-reports), [feature
requests](#feature-requests), [change requests](#change-requests), and
[submitting pull requests](#submitting-pull-requests), but please
respect the following restrictions:
* Please **search for existing issues**. Help us keep duplicate issues
to a minimum by checking to see if someone has already reported your
problem or requested your idea.
* Please **do not** use the issue tracker for personal support
requests (use [the MathJax User Group](https://groups.google.com/forum/#!forum/mathjax-users)).
* Please **be civil**. Keep the discussion on topic and respect the
opinions of others. See also our [Conduct Guidelines](#conduct)
### Bug Reports
A bug is a *demonstrable problem* that is caused by the code in the
repository. Good bug reports are extremely helpful — thank you!
Guidelines for bug reports:
1. **Use the GitHub issue search** — check if the issue has already been
reported.
2. **Check if the issue has been fixed** — look for [closed
issues in the current
milestone](https://github.com/mathjax/MathJax/issues?q=is%3Aclosed)
or try to reproduce it using the latest `develop` branch. Please
note that you will need to
[compile MathJax and make the components](https://docs.mathjax.org/en/latest/web/hosting.html#getting-mathjax-via-git)
in order to test MathJax from the source repository.
3. **Share a live sample of the problem** — without a live page
it is usually impossible to debug problems; see also the [Bug Report
Template](#template) below.
4. **Isolate the problem** — a live sample is a starting point
but if you want to speed things up, create a [reduced test
case](https://css-tricks.com/reduced-test-cases/). Be specific
about your setup (browser, OS versions, etc). Use services like
[jsbin](http://jsbin.com), [CodePen](http://codepen.io), or
[jsFiddle](http://jsfiddle.com) to make collaboration on minimal
test cases easier for everyone.
5. **Include a screenshot/cast as a last resort** — Is your
issue about a layout or design feature or bug that is hard to reproduce
or isolate? Then please provide a screenshot or screencast. Tools
like [LICEcap](http://www.cockos.com/licecap/) or
[SauceLabs](http://www.saucelabs.com) allow you to quickly and
easily record a screencasts. If you make it an animated gif, you can
embed it directly into your GitHub issue.
6. Use the [Bug Report Template](#template) below or [click this
link](https://github.com/MathJax/MathJax/issues/new?title=Bug%3A&body=%23%23%23%20Issue%20Summary%0A%0A%23%23%23%20Steps%20to%20Reproduce%0A%0A1.%20This%20is%20the%20first%20step%0A%0AThis%20is%20a%20bug%20because...%0A%0A%23%23%23%20Technical%20details%0A%0A*%20MathJax%20Version%3A%20master%20-%20latest%20commit%3A%20%20INSERT%20COMMIT%20REF%0A*%20Client%20OS%3A%20%0A*%20Browser%3A%20%0A*%20)
to start creating a bug report with the template automatically.
A good bug report shouldn't leave others needing to request
more information from you. Be sure to include the details of your environment.
<a id="template"></a>
Template Example ([click to use](https://github.com/MathJax/MathJax/issues/new?title=Bug%3A&body=%23%23%23%20Issue%20Summary%0A%0A%23%23%23%20Steps%20to%20Reproduce%0A%0A1.%20This%20is%20the%20first%20step%0A%0AThis%20is%20a%20bug%20because...%0A%0A%23%23%23%20Technical%20details%0A%0A*%20MathJax%20Version%3A%20master%20-%20latest%20commit%3A%20%20INSERT%20COMMIT%20REF%0A*%20Client%20OS%3A%20%0A*%20Browser%3A%20%0A*%20)):
```
Short and descriptive example bug report title
### Issue Summary
A summary of the issue and the browser/OS environment in which it occurs. If
suitable, include the steps required to reproduce the bug.
### Steps to Reproduce
1. This is the first step
2. This is the second step
3. Further steps, etc.
Any other information you want to share that is relevant to the issue
being reported. Especially, why do you consider this to be a bug? What
do you expect to happen instead?
### Technical details:
* MathJax Version: 2.3 (latest commit: f3aaf3a2a3e964df2770dc4aaaa9c87ce5f47e2c)
* Client OS: Mac OS X 10.8.4
* Browser: Chrome 29.0.1547.57
```
### Feature Requests
Feature requests are welcome. Before you submit one, be sure to have:
1. **Used the GitHub search** to check that the feature hasn't already
been requested.
2. Take a moment to think about whether your idea fits with the scope
and aims of the project, or if it might better fit being a [custom
extension](https://github.com/mathjax/MathJax-third-party-extensions).
3. Remember, it's up to *you* to make a strong case to convince the
project's leaders of the merits of this feature. Please provide as
much detail and context as possible, this means explaining the use
case and why it is likely to be common.
### Change Requests
Change requests cover both architectural and functional changes to how
MathJax works. If you have an idea for a new or different dependency,
a refactor, or an improvement to a feature, etc., please be sure to:
1. **Use the GitHub search** to check that someone else didn't get there first.
2. Take a moment to think about the best way to make a case for, and
explain what you're thinking. Are you sure this shouldn't really be
a [bug report](#bug-reports) or a [feature
request](#feature-requests)? Is it really one idea or is it many?
What's the context? What problem are you solving? Why is what you
are suggesting better than what's already there?
## Working on MathJax core
You want to contribute code? We describe how below. First, note that
the MathJax source code is in the
<https://github.com/mathjax/MathJax-src> repository, not the
<https://github.com/mathjax/MathJax> repository, which contains the
packaged component files for distribution on CDNs and the [mathjax npm
package](https://www.npmjs.com/package/mathjax) (the source code is
included in the [mathjax-full npm
package](https://www.npmjs.com/package/mathjax-full)).
### Key Branches & Tags
MathJax uses several permanent branches in the [MathJax source repository](https://github.com/mathjax/MathJax-src):
- **[develop](https://github.com/mathjax/MathJax-src/tree/develop)**
is the development branch. All work on the next release happens here
so you should generally branch off `develop` if you are going to
submit a pull request. Do **NOT** use this branch for a production
site.
- **[master](https://github.com/mathjax/MathJax-src)** contains the latest
release of MathJax. This branch may be used in production. Do
**NOT** use this branch to work on MathJax's source.
These branches reflect version 3 of MathJax, which is substantially
different from the version 2 codebase. Version 2 will continue to be
maintained while web sites transition to version 3, with work being
done using the following branches in the [MathJax distribution
repository](https://github.com/mathjax/MathJax):
- **[legacy-v2-develop](https://github.com/mathjax/MathJax/tree/legacy-v2-develop)**
is the development branch for changes to the legacy version 2 code.
Any pull requests for version 2 should be branched from here. Do
**NOT** use this branch for a production site.
- **[legacy-v2](https://github.com/mathjax/MathJax/tree/legacy-v2)**
is the branch that contains any updates to version 2 following
the release of version 3. Do **NOT** use this branch to work on
MathJax's source.
In addition to these branches, MathJax uses tags to identify the
various versions. These can be checked out to obtain the specified
release; for example, `git checkout 2.7.5` would get you the files for
version 2.7.5 of MathJax.
Note that version 3 is written in Typescript, and so must be compiled
to obtain usable javascript files, and that the components need to be
built once that is done. See the
[documentation](https://docs.mathjax.org/en/latest/web/hosting.html#getting-mathjax-via-git)
for details. For version 2, the source javascript files are not
compressed until a release is made, so you should use the copies in
the `unpacked` directory during development.
### Submitting Pull Requests
Pull requests are welcome. If you're looking to submit a PR for
something that doesn't have an open issue, please consider [raising an
issue](#reporting-an-issue) that your PR can close, especially if
you're fixing a bug. This makes it more likely that there will be
enough information available for your PR to be properly tested and
merged.
##### Need Help?
If you're not completely clear on how to submit/update/*do* Pull
Requests, please check out our [source control
policies](https://github.com/mathjax/MathJax/wiki/Source-control-policies). For
more insights, check the excellent in depth [Git Workflow
guide](https://github.com/TryGhost/Ghost/wiki/Git-Workflow) from
Ghost, in particular
* [Ghost Workflow guide: commit messages](https://github.com/TryGhost/Ghost/wiki/Git-workflow#commit-messages)
### Testing and Quality Assurance
If you're
looking to get involved with the code base and don't know where to
start, checking out and testing a pull request is one of the most
useful things you could do.
These are some [excellent
instructions](https://gist.github.com/piscisaureus/3342247) on
configuring your GitHub repository to allow you to checkout pull
requests in the same way as branches.
### Writing documentation
MathJax's main documentation can be found at [docs.mathjax.org](http://docs.mathjax.org).
The source of the docs is hosted in the
[mathjax/MathJax-docs](http://github.com/mathjax/MathJax-docs) repo here on GitHub.
The documentation is generated using
[Sphinx-doc](http://sphinx-doc.org/) and hosted on [Read the
docs](http://readthedocs.org). You can clone the repo and submit pull
requests following the [pull-request](#submitting-pull-requests)
guidelines.
### Translation
If you wish to add or update translations of MathJax, please do it on
[TranslateWiki.net](https://translatewiki.net/w/i.php?title=Special:Translate&group=out-mathjax-0-all)
(and while you're there you can help other open source projects,
too).
For bug reports and other questions that don't fit on
TranslateWiki.net, head over to the
[mathjax/mathjax-i18n](https://github.com/mathjax/MathJax-i18n)
repository.
The translation files currently are for version 2, as localization
hasn't been added to version 3 yet.
## Conduct
As a NumFOCUS fiscally sponsored project, MathJax is governed by the
[NumFOCUS code of conduct](https://numfocus.org/code-of-conduct),
which we summarize as follows:
We are committed to providing a friendly, safe and welcoming
environment for all, regardless of gender, sexual orientation,
disability, ethnicity, religion, or similar personal characteristic.
Please be kind and courteous. There's no need to be mean or rude.
Respect that people have differences of opinion and that every design
or implementation choice carries a trade-off and numerous costs. There
is seldom a right answer, merely an optimal answer given a set of
values and circumstances.
Please keep unstructured critique to a minimum. If you have solid
ideas you want to experiment with, make a fork and see how it works.
We will exclude you from interaction if you insult, demean or harass
anyone. That is not welcome behaviour. We interpret the term
"harassment" as including the definition in the [Unacceptable
Behavior](https://numfocus.org/code-of-conduct#unacceptable-behavior)
section of the [NumFOCUS code of
conduct](https://numfocus.org/code-of-conduct); if you have any lack
of clarity about what might be included in that concept, please read
that definition. In particular, we don't tolerate behavior that
excludes people in socially marginalized groups.
Private harassment is also unacceptable. No matter who you are, if you
feel you have been or are being harassed or made uncomfortable by a
community member, please contact one of the channel ops or any of the
[MathJax](https://github.com/MathJax/MathJax) core team
immediately. Whether you're a regular contributor or a newcomer, we
care about making this community a safe place for you and we've got
your back.
Likewise any spamming, trolling, flaming, baiting, or other
attention-stealing behaviour is not welcome.
We also recommend that you read [discourse's
rules](http://blog.discourse.org/2013/03/the-universal-rules-of-civilized-discourse/)
for further suggestions on appropriate behavior.
## References
* We heavily borrowed from Mozilla and Ghost -- thank you!
* <https://github.com/TryGhost/Ghost/blob/master/CONTRIBUTING.md>
* <https://github.com/mozilla/rust/wiki/Note-development-policy>
* <https://github.com/jden/CONTRIBUTING.md/blob/master/CONTRIBUTING.md>
* <http://blog.discourse.org/2013/03/the-universal-rules-of-civilized-discourse/>

202
node_modules/mathjax-full/LICENSE generated vendored Normal file
View File

@@ -0,0 +1,202 @@
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright [yyyy] [name of copyright owner]
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.

183
node_modules/mathjax-full/README.md generated vendored Normal file
View File

@@ -0,0 +1,183 @@
# MathJax (Source Repository)
![GitHub release version](https://img.shields.io/github/v/release/mathjax/MathJax-src.svg?sort=semver)
![GitHub release version (v2)](https://img.shields.io/github/package-json/v/mathjax/MathJax/legacy-v2.svg?label=release-v2)
![NPM version](https://img.shields.io/npm/v/mathjax.svg?style=flat)
<a href="http://www.numfocus.org">![powered by NumFOCUS](https://img.shields.io/badge/powered%20by-NumFOCUS-orange.svg?style=flat)</a>
![jsdelivr rank](https://flat.badgen.net/jsdelivr/rank/npm/mathjax?color=green)
![jsDelivr hits (npm)](https://img.shields.io/jsdelivr/npm/hm/mathjax)
![npm monthly downloads (full)](https://img.shields.io/npm/dm/mathjax?label=npm)
![npm monthly downloads (full)](https://img.shields.io/npm/dm/mathjax-full?label=npm%20%28full%29)
![npm total downloads](https://img.shields.io/npm/dt/mathjax.svg?style=flat&label=npm%20total)
![npm total downloads](https://img.shields.io/npm/dt/mathjax-full.svg?style=flat&label=npm%20total%20%28full%29)
## Beautiful math in all browsers
MathJax is an open-source JavaScript display engine for LaTeX, MathML,
and AsciiMath notation that works in all modern browsers. It was
designed with the goal of consolidating the recent advances in web
technologies into a single, definitive, math-on-the-web platform
supporting the major browsers and operating systems. It requires no
setup on the part of the user (no plugins to download or software to
install), so the page author can write web documents that include
mathematics and be confident that users will be able to view it
naturally and easily. Simply include MathJax and some mathematics in
a web page, and MathJax does the rest.
Some of the main features of MathJax include:
- High-quality display of LaTeX, MathML, and AsciiMath notation in HTML pages
- Supported in most browsers with no plug-ins, extra fonts, or special
setup for the reader
- Easy for authors, flexible for publishers, extensible for developers
- Supports math accessibility, cut-and-paste interoperability, and other
advanced functionality
- Powerful API for integration with other web applications
See <http://www.mathjax.org/> for additional details about MathJax,
and <https://docs.mathjax.org> for the MathJax documentation.
## What's in this Repository
This repository contains the source files for MathJax, which are
written in TypeScript. These are compiled into JavaScript files and
then combined into component files for use on the web. The component
files are available from several [CDN services that host
MathJax](https://docs.mathjax.org/en/latest/web/start.html#using-mathjax-from-a-content-delivery-network-cdn),
and also from the [MathJax Component
Repository](https://github.com/mathjax/MathJax). Node applications
can use either the component files, or call the MathJax JavaScript
files directly.
## Installation and Use
### Using MathJax in web browsers
If you are loading MathJax from a CDN into a web page, there is no
need to install anything. Simply use a `script` tag that loads
MathJax from the CDN. E.g.,
``` html
<script id="MathJax-script" async src="https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js"></script>
```
See the [MathJax
documentation](https://docs.mathjax.org/en/latest/index.html#browser-components),
the [MathJax Web Demos](https://github.com/mathjax/MathJax-demos-web),
and the [MathJax Component
Repository](https://github.com/mathjax/MathJax-demos-web) for more information.
### Using MathJax Components in node applications
To use MathJax components in a node application, install the `mathjax` package:
``` bash
npm install mathjax@3
```
(we are still making updates to version 2, so you should include `@3`
since the latest chronological version may not be version 3).
Then require `mathjax` within your application:
``` javascript
require('mathjax').init({ ... }).then((MathJax) => { ... });
```
where the first `{ ... }` is a MathJax configuration, and the second
`{ ... }` is the code to run after MathJax has been loaded. E.g.
``` javascript
require('mathjax').init({
loader: {load: ['input/tex', 'output/svg']}
}).then((MathJax) => {
const svg = MathJax.tex2svg('\\frac{1}{x^2-1}', {display: true});
console.log(MathJax.startup.adaptor.outerHTML(svg));
}).catch((err) => console.log(err.message));
```
**Note:** this technique is for node-based applications only, not for
browser applications. This method sets up an alternative DOM
implementation, which you don't need in the browser, and tells MathJax
to use node's `require()` command to load external modules. This
setup will not work properly in the browser, even if you webpack it or
bundle it in other ways.
See the
[documentation](https://docs.mathjax.org/en/latest/index.html#server-nodejs)
and the [MathJax Node
Repository](https://github.com/mathjax/MathJax-demos-node) for more details.
### Using MathJax modules directly in node applications
You can use the MathJax JavaScript files (as opposed to MathJax
components) directly in node applications. This gives you the
greatest flexibility, but requires more coding. To use this approach,
install the `mathjax-full` package:
npm install mathjax-full
This will provide the following directories:
node_modules/
mathjax-full/
ts/ the MathJax source TypeScript files
js/ the compiled JavaScript files
components/ the component build tools and control files
es5/ the packages component files
You can use the components and JavaScript files directly in your node
applications (see the [MathJax node
demos](https://github.com/mathjax/MathJax-demos-node) for examples).
If you want to work from the GitHub repository directly, then do the following:
``` bash
git clone https://github.com/mathjax/MathJax-src.git mathjax-src
cd mathjax-src
npm run --silent compile
npm run --silent make-components
```
in order to compile the JavaScript files from the TypeScript source,
and build the component files from the JavaScript files.
## Code Contributions
If you are interested in contributing code to MathJax, please see the
[documentation for contributors](CONTRIBUTING.md) for details on how
to do this, and for the policies for making pull requests. In
particular, please be careful that you are working from the proper
branch in the git repository, or you may be asked to rebase your
changes when you make a pull request.
## MathJax Community
The main MathJax website is <http://www.mathjax.org>, and it includes
announcements and other important information. A [MathJax user
forum](http://groups.google.com/group/mathjax-users) for asking
questions and getting assistance is hosted at Google, and the [MathJax
bug tracker](https://github.com/mathjax/MathJax/issues) is hosted
at GitHub.
Before reporting a bug, please check that it has not already been
reported. Also, please use the bug tracker (rather than the help
forum) for reporting bugs, and use the user's forum (rather than the
bug tracker) for questions about how to use MathJax.
## MathJax Resources
* [MathJax Documentation](https://docs.mathjax.org)
* [MathJax Components](https://github.com/mathjax/MathJax)
* [MathJax Source Code](https://github.com/mathjax/MathJax-src)
* [MathJax Web Examples](https://github.com/mathjax/MathJax-demos-web)
* [MathJax Node Examples](https://github.com/mathjax/MathJax-demos-node)
* [MathJax Bug Tracker](https://github.com/mathjax/MathJax/issues)
* [MathJax Users' Group](http://groups.google.com/group/mathjax-users)

347
node_modules/mathjax-full/components/bin/build generated vendored Executable file
View File

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

78
node_modules/mathjax-full/components/bin/copy generated vendored Executable file
View File

@@ -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, '');
}

168
node_modules/mathjax-full/components/bin/makeAll generated vendored Executable file
View File

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

132
node_modules/mathjax-full/components/bin/pack generated vendored Executable file
View File

@@ -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] || '.');

60
node_modules/mathjax-full/components/bin/version generated vendored Executable file
View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

@@ -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'] || {});
}

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

@@ -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()));
}

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

14
node_modules/mathjax-full/components/src/core/core.js generated vendored Normal file
View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

Some files were not shown because too many files have changed in this diff Show More