├── .gitignore
├── HTMLStyles.js
├── HTMLUtils.js
├── LICENSE
├── README.md
├── export.png
├── index.d.ts
├── index.js
├── mathjax
├── a11y
│ ├── assistive-mml.d.ts
│ ├── assistive-mml.js
│ ├── assistive-mml.js.map
│ ├── complexity.d.ts
│ ├── complexity.js
│ ├── complexity.js.map
│ ├── complexity
│ │ ├── collapse.d.ts
│ │ ├── collapse.js
│ │ ├── collapse.js.map
│ │ ├── visitor.d.ts
│ │ ├── visitor.js
│ │ └── visitor.js.map
│ ├── explorer.d.ts
│ ├── explorer.js
│ ├── explorer.js.map
│ ├── explorer
│ │ ├── Explorer.d.ts
│ │ ├── Explorer.js
│ │ ├── Explorer.js.map
│ │ ├── KeyExplorer.d.ts
│ │ ├── KeyExplorer.js
│ │ ├── KeyExplorer.js.map
│ │ ├── MouseExplorer.d.ts
│ │ ├── MouseExplorer.js
│ │ ├── MouseExplorer.js.map
│ │ ├── Region.d.ts
│ │ ├── Region.js
│ │ ├── Region.js.map
│ │ ├── TreeExplorer.d.ts
│ │ ├── TreeExplorer.js
│ │ └── TreeExplorer.js.map
│ ├── mathmaps.d.ts
│ ├── mathmaps.js
│ ├── mathmaps.js.map
│ ├── semantic-enrich.d.ts
│ ├── semantic-enrich.js
│ ├── semantic-enrich.js.map
│ ├── sre.d.ts
│ ├── sre.js
│ └── sre.js.map
├── adaptors
│ ├── HTMLAdaptor.d.ts
│ ├── HTMLAdaptor.js
│ ├── HTMLAdaptor.js.map
│ ├── NodeMixin.d.ts
│ ├── NodeMixin.js
│ ├── NodeMixin.js.map
│ ├── browserAdaptor.d.ts
│ ├── browserAdaptor.js
│ ├── browserAdaptor.js.map
│ ├── chooseAdaptor.d.ts
│ ├── chooseAdaptor.js
│ ├── chooseAdaptor.js.map
│ ├── jsdomAdaptor.d.ts
│ ├── jsdomAdaptor.js
│ ├── jsdomAdaptor.js.map
│ ├── linkedomAdaptor.d.ts
│ ├── linkedomAdaptor.js
│ ├── linkedomAdaptor.js.map
│ ├── lite
│ │ ├── Document.d.ts
│ │ ├── Document.js
│ │ ├── Document.js.map
│ │ ├── Element.d.ts
│ │ ├── Element.js
│ │ ├── Element.js.map
│ │ ├── List.d.ts
│ │ ├── List.js
│ │ ├── List.js.map
│ │ ├── Parser.d.ts
│ │ ├── Parser.js
│ │ ├── Parser.js.map
│ │ ├── Text.d.ts
│ │ ├── Text.js
│ │ ├── Text.js.map
│ │ ├── Window.d.ts
│ │ ├── Window.js
│ │ └── Window.js.map
│ ├── liteAdaptor.d.ts
│ ├── liteAdaptor.js
│ └── liteAdaptor.js.map
├── components
│ ├── global.d.ts
│ ├── global.js
│ ├── global.js.map
│ ├── latest.d.ts
│ ├── latest.js
│ ├── latest.js.map
│ ├── loader.d.ts
│ ├── loader.js
│ ├── loader.js.map
│ ├── package.d.ts
│ ├── package.js
│ ├── package.js.map
│ ├── startup.d.ts
│ ├── startup.js
│ ├── startup.js.map
│ ├── version.d.ts
│ ├── version.js
│ └── version.js.map
├── core
│ ├── DOMAdaptor.d.ts
│ ├── DOMAdaptor.js
│ ├── DOMAdaptor.js.map
│ ├── FindMath.d.ts
│ ├── FindMath.js
│ ├── FindMath.js.map
│ ├── Handler.d.ts
│ ├── Handler.js
│ ├── Handler.js.map
│ ├── HandlerList.d.ts
│ ├── HandlerList.js
│ ├── HandlerList.js.map
│ ├── InputJax.d.ts
│ ├── InputJax.js
│ ├── InputJax.js.map
│ ├── MathDocument.d.ts
│ ├── MathDocument.js
│ ├── MathDocument.js.map
│ ├── MathItem.d.ts
│ ├── MathItem.js
│ ├── MathItem.js.map
│ ├── MathList.d.ts
│ ├── MathList.js
│ ├── MathList.js.map
│ ├── MmlTree
│ │ ├── Attributes.d.ts
│ │ ├── Attributes.js
│ │ ├── Attributes.js.map
│ │ ├── JsonMmlVisitor.d.ts
│ │ ├── JsonMmlVisitor.js
│ │ ├── JsonMmlVisitor.js.map
│ │ ├── LegacyMmlVisitor.d.ts
│ │ ├── LegacyMmlVisitor.js
│ │ ├── LegacyMmlVisitor.js.map
│ │ ├── MML.d.ts
│ │ ├── MML.js
│ │ ├── MML.js.map
│ │ ├── MathMLVisitor.d.ts
│ │ ├── MathMLVisitor.js
│ │ ├── MathMLVisitor.js.map
│ │ ├── MmlFactory.d.ts
│ │ ├── MmlFactory.js
│ │ ├── MmlFactory.js.map
│ │ ├── MmlNode.d.ts
│ │ ├── MmlNode.js
│ │ ├── MmlNode.js.map
│ │ ├── MmlNodes
│ │ │ ├── TeXAtom.d.ts
│ │ │ ├── TeXAtom.js
│ │ │ ├── TeXAtom.js.map
│ │ │ ├── maction.d.ts
│ │ │ ├── maction.js
│ │ │ ├── maction.js.map
│ │ │ ├── maligngroup.d.ts
│ │ │ ├── maligngroup.js
│ │ │ ├── maligngroup.js.map
│ │ │ ├── malignmark.d.ts
│ │ │ ├── malignmark.js
│ │ │ ├── malignmark.js.map
│ │ │ ├── math.d.ts
│ │ │ ├── math.js
│ │ │ ├── math.js.map
│ │ │ ├── mathchoice.d.ts
│ │ │ ├── mathchoice.js
│ │ │ ├── mathchoice.js.map
│ │ │ ├── menclose.d.ts
│ │ │ ├── menclose.js
│ │ │ ├── menclose.js.map
│ │ │ ├── merror.d.ts
│ │ │ ├── merror.js
│ │ │ ├── merror.js.map
│ │ │ ├── mfenced.d.ts
│ │ │ ├── mfenced.js
│ │ │ ├── mfenced.js.map
│ │ │ ├── mfrac.d.ts
│ │ │ ├── mfrac.js
│ │ │ ├── mfrac.js.map
│ │ │ ├── mglyph.d.ts
│ │ │ ├── mglyph.js
│ │ │ ├── mglyph.js.map
│ │ │ ├── mi.d.ts
│ │ │ ├── mi.js
│ │ │ ├── mi.js.map
│ │ │ ├── mmultiscripts.d.ts
│ │ │ ├── mmultiscripts.js
│ │ │ ├── mmultiscripts.js.map
│ │ │ ├── mn.d.ts
│ │ │ ├── mn.js
│ │ │ ├── mn.js.map
│ │ │ ├── mo.d.ts
│ │ │ ├── mo.js
│ │ │ ├── mo.js.map
│ │ │ ├── mpadded.d.ts
│ │ │ ├── mpadded.js
│ │ │ ├── mpadded.js.map
│ │ │ ├── mphantom.d.ts
│ │ │ ├── mphantom.js
│ │ │ ├── mphantom.js.map
│ │ │ ├── mroot.d.ts
│ │ │ ├── mroot.js
│ │ │ ├── mroot.js.map
│ │ │ ├── mrow.d.ts
│ │ │ ├── mrow.js
│ │ │ ├── mrow.js.map
│ │ │ ├── ms.d.ts
│ │ │ ├── ms.js
│ │ │ ├── ms.js.map
│ │ │ ├── mspace.d.ts
│ │ │ ├── mspace.js
│ │ │ ├── mspace.js.map
│ │ │ ├── msqrt.d.ts
│ │ │ ├── msqrt.js
│ │ │ ├── msqrt.js.map
│ │ │ ├── mstyle.d.ts
│ │ │ ├── mstyle.js
│ │ │ ├── mstyle.js.map
│ │ │ ├── msubsup.d.ts
│ │ │ ├── msubsup.js
│ │ │ ├── msubsup.js.map
│ │ │ ├── mtable.d.ts
│ │ │ ├── mtable.js
│ │ │ ├── mtable.js.map
│ │ │ ├── mtd.d.ts
│ │ │ ├── mtd.js
│ │ │ ├── mtd.js.map
│ │ │ ├── mtext.d.ts
│ │ │ ├── mtext.js
│ │ │ ├── mtext.js.map
│ │ │ ├── mtr.d.ts
│ │ │ ├── mtr.js
│ │ │ ├── mtr.js.map
│ │ │ ├── munderover.d.ts
│ │ │ ├── munderover.js
│ │ │ ├── munderover.js.map
│ │ │ ├── semantics.d.ts
│ │ │ ├── semantics.js
│ │ │ └── semantics.js.map
│ │ ├── MmlVisitor.d.ts
│ │ ├── MmlVisitor.js
│ │ ├── MmlVisitor.js.map
│ │ ├── OperatorDictionary.d.ts
│ │ ├── OperatorDictionary.js
│ │ ├── OperatorDictionary.js.map
│ │ ├── SerializedMmlVisitor.d.ts
│ │ ├── SerializedMmlVisitor.js
│ │ ├── SerializedMmlVisitor.js.map
│ │ ├── TestMmlVisitor.d.ts
│ │ ├── TestMmlVisitor.js
│ │ └── TestMmlVisitor.js.map
│ ├── OutputJax.d.ts
│ ├── OutputJax.js
│ ├── OutputJax.js.map
│ └── Tree
│ │ ├── Factory.d.ts
│ │ ├── Factory.js
│ │ ├── Factory.js.map
│ │ ├── Node.d.ts
│ │ ├── Node.js
│ │ ├── Node.js.map
│ │ ├── NodeFactory.d.ts
│ │ ├── NodeFactory.js
│ │ ├── NodeFactory.js.map
│ │ ├── Visitor.d.ts
│ │ ├── Visitor.js
│ │ ├── Visitor.js.map
│ │ ├── Wrapper.d.ts
│ │ ├── Wrapper.js
│ │ ├── Wrapper.js.map
│ │ ├── WrapperFactory.d.ts
│ │ ├── WrapperFactory.js
│ │ └── WrapperFactory.js.map
├── handlers
│ ├── html.d.ts
│ ├── html.js
│ ├── html.js.map
│ └── html
│ │ ├── HTMLDocument.d.ts
│ │ ├── HTMLDocument.js
│ │ ├── HTMLDocument.js.map
│ │ ├── HTMLDomStrings.d.ts
│ │ ├── HTMLDomStrings.js
│ │ ├── HTMLDomStrings.js.map
│ │ ├── HTMLHandler.d.ts
│ │ ├── HTMLHandler.js
│ │ ├── HTMLHandler.js.map
│ │ ├── HTMLMathItem.d.ts
│ │ ├── HTMLMathItem.js
│ │ ├── HTMLMathItem.js.map
│ │ ├── HTMLMathList.d.ts
│ │ ├── HTMLMathList.js
│ │ └── HTMLMathList.js.map
├── input
│ ├── asciimath.d.ts
│ ├── asciimath.js
│ ├── asciimath.js.map
│ ├── asciimath
│ │ ├── FindAsciiMath.d.ts
│ │ ├── FindAsciiMath.js
│ │ ├── FindAsciiMath.js.map
│ │ └── mathjax2
│ │ │ ├── input
│ │ │ ├── AsciiMath.d.ts
│ │ │ └── AsciiMath.js
│ │ │ └── legacy
│ │ │ ├── MathJax.js
│ │ │ └── jax
│ │ │ ├── element
│ │ │ ├── JSON.js
│ │ │ ├── MmlNode.js
│ │ │ └── mml
│ │ │ │ ├── jax.js
│ │ │ │ └── optable
│ │ │ │ ├── Arrows.js
│ │ │ │ ├── BasicLatin.js
│ │ │ │ ├── CombDiacritMarks.js
│ │ │ │ ├── CombDiactForSymbols.js
│ │ │ │ ├── Dingbats.js
│ │ │ │ ├── GeneralPunctuation.js
│ │ │ │ ├── GeometricShapes.js
│ │ │ │ ├── GreekAndCoptic.js
│ │ │ │ ├── Latin1Supplement.js
│ │ │ │ ├── LetterlikeSymbols.js
│ │ │ │ ├── MathOperators.js
│ │ │ │ ├── MiscMathSymbolsA.js
│ │ │ │ ├── MiscMathSymbolsB.js
│ │ │ │ ├── MiscSymbolsAndArrows.js
│ │ │ │ ├── MiscTechnical.js
│ │ │ │ ├── SpacingModLetters.js
│ │ │ │ ├── SuppMathOperators.js
│ │ │ │ ├── SupplementalArrowsA.js
│ │ │ │ └── SupplementalArrowsB.js
│ │ │ └── input
│ │ │ └── AsciiMath
│ │ │ ├── config.js
│ │ │ └── jax.js
│ ├── mathml.d.ts
│ ├── mathml.js
│ ├── mathml.js.map
│ ├── mathml
│ │ ├── FindMathML.d.ts
│ │ ├── FindMathML.js
│ │ ├── FindMathML.js.map
│ │ ├── MathMLCompile.d.ts
│ │ ├── MathMLCompile.js
│ │ ├── MathMLCompile.js.map
│ │ └── mml3
│ │ │ ├── mml3-node.d.ts
│ │ │ ├── mml3-node.js
│ │ │ ├── mml3-node.js.map
│ │ │ ├── mml3.d.ts
│ │ │ ├── mml3.js
│ │ │ ├── mml3.js.map
│ │ │ └── mml3.sef.json
│ ├── tex.d.ts
│ ├── tex.js
│ ├── tex.js.map
│ └── tex
│ │ ├── AllPackages.d.ts
│ │ ├── AllPackages.js
│ │ ├── AllPackages.js.map
│ │ ├── Configuration.d.ts
│ │ ├── Configuration.js
│ │ ├── Configuration.js.map
│ │ ├── FilterUtil.d.ts
│ │ ├── FilterUtil.js
│ │ ├── FilterUtil.js.map
│ │ ├── FindTeX.d.ts
│ │ ├── FindTeX.js
│ │ ├── FindTeX.js.map
│ │ ├── MapHandler.d.ts
│ │ ├── MapHandler.js
│ │ ├── MapHandler.js.map
│ │ ├── NodeFactory.d.ts
│ │ ├── NodeFactory.js
│ │ ├── NodeFactory.js.map
│ │ ├── NodeUtil.d.ts
│ │ ├── NodeUtil.js
│ │ ├── NodeUtil.js.map
│ │ ├── ParseMethods.d.ts
│ │ ├── ParseMethods.js
│ │ ├── ParseMethods.js.map
│ │ ├── ParseOptions.d.ts
│ │ ├── ParseOptions.js
│ │ ├── ParseOptions.js.map
│ │ ├── ParseUtil.d.ts
│ │ ├── ParseUtil.js
│ │ ├── ParseUtil.js.map
│ │ ├── Stack.d.ts
│ │ ├── Stack.js
│ │ ├── Stack.js.map
│ │ ├── StackItem.d.ts
│ │ ├── StackItem.js
│ │ ├── StackItem.js.map
│ │ ├── StackItemFactory.d.ts
│ │ ├── StackItemFactory.js
│ │ ├── StackItemFactory.js.map
│ │ ├── Symbol.d.ts
│ │ ├── Symbol.js
│ │ ├── Symbol.js.map
│ │ ├── SymbolMap.d.ts
│ │ ├── SymbolMap.js
│ │ ├── SymbolMap.js.map
│ │ ├── Tags.d.ts
│ │ ├── Tags.js
│ │ ├── Tags.js.map
│ │ ├── TexConstants.d.ts
│ │ ├── TexConstants.js
│ │ ├── TexConstants.js.map
│ │ ├── TexError.d.ts
│ │ ├── TexError.js
│ │ ├── TexError.js.map
│ │ ├── TexParser.d.ts
│ │ ├── TexParser.js
│ │ ├── TexParser.js.map
│ │ ├── Types.d.ts
│ │ ├── Types.js
│ │ ├── Types.js.map
│ │ ├── action
│ │ ├── ActionConfiguration.d.ts
│ │ ├── ActionConfiguration.js
│ │ └── ActionConfiguration.js.map
│ │ ├── ams
│ │ ├── AmsConfiguration.d.ts
│ │ ├── AmsConfiguration.js
│ │ ├── AmsConfiguration.js.map
│ │ ├── AmsItems.d.ts
│ │ ├── AmsItems.js
│ │ ├── AmsItems.js.map
│ │ ├── AmsMappings.d.ts
│ │ ├── AmsMappings.js
│ │ ├── AmsMappings.js.map
│ │ ├── AmsMethods.d.ts
│ │ ├── AmsMethods.js
│ │ └── AmsMethods.js.map
│ │ ├── amscd
│ │ ├── AmsCdConfiguration.d.ts
│ │ ├── AmsCdConfiguration.js
│ │ ├── AmsCdConfiguration.js.map
│ │ ├── AmsCdMappings.d.ts
│ │ ├── AmsCdMappings.js
│ │ ├── AmsCdMappings.js.map
│ │ ├── AmsCdMethods.d.ts
│ │ ├── AmsCdMethods.js
│ │ └── AmsCdMethods.js.map
│ │ ├── autoload
│ │ ├── AutoloadConfiguration.d.ts
│ │ ├── AutoloadConfiguration.js
│ │ └── AutoloadConfiguration.js.map
│ │ ├── base
│ │ ├── BaseConfiguration.d.ts
│ │ ├── BaseConfiguration.js
│ │ ├── BaseConfiguration.js.map
│ │ ├── BaseItems.d.ts
│ │ ├── BaseItems.js
│ │ ├── BaseItems.js.map
│ │ ├── BaseMappings.d.ts
│ │ ├── BaseMappings.js
│ │ ├── BaseMappings.js.map
│ │ ├── BaseMethods.d.ts
│ │ ├── BaseMethods.js
│ │ └── BaseMethods.js.map
│ │ ├── bbox
│ │ ├── BboxConfiguration.d.ts
│ │ ├── BboxConfiguration.js
│ │ └── BboxConfiguration.js.map
│ │ ├── boldsymbol
│ │ ├── BoldsymbolConfiguration.d.ts
│ │ ├── BoldsymbolConfiguration.js
│ │ └── BoldsymbolConfiguration.js.map
│ │ ├── braket
│ │ ├── BraketConfiguration.d.ts
│ │ ├── BraketConfiguration.js
│ │ ├── BraketConfiguration.js.map
│ │ ├── BraketItems.d.ts
│ │ ├── BraketItems.js
│ │ ├── BraketItems.js.map
│ │ ├── BraketMappings.d.ts
│ │ ├── BraketMappings.js
│ │ ├── BraketMappings.js.map
│ │ ├── BraketMethods.d.ts
│ │ ├── BraketMethods.js
│ │ └── BraketMethods.js.map
│ │ ├── bussproofs
│ │ ├── BussproofsConfiguration.d.ts
│ │ ├── BussproofsConfiguration.js
│ │ ├── BussproofsConfiguration.js.map
│ │ ├── BussproofsItems.d.ts
│ │ ├── BussproofsItems.js
│ │ ├── BussproofsItems.js.map
│ │ ├── BussproofsMappings.d.ts
│ │ ├── BussproofsMappings.js
│ │ ├── BussproofsMappings.js.map
│ │ ├── BussproofsMethods.d.ts
│ │ ├── BussproofsMethods.js
│ │ ├── BussproofsMethods.js.map
│ │ ├── BussproofsUtil.d.ts
│ │ ├── BussproofsUtil.js
│ │ └── BussproofsUtil.js.map
│ │ ├── cancel
│ │ ├── CancelConfiguration.d.ts
│ │ ├── CancelConfiguration.js
│ │ └── CancelConfiguration.js.map
│ │ ├── cases
│ │ ├── CasesConfiguration.d.ts
│ │ ├── CasesConfiguration.js
│ │ └── CasesConfiguration.js.map
│ │ ├── centernot
│ │ ├── CenternotConfiguration.d.ts
│ │ ├── CenternotConfiguration.js
│ │ └── CenternotConfiguration.js.map
│ │ ├── color
│ │ ├── ColorConfiguration.d.ts
│ │ ├── ColorConfiguration.js
│ │ ├── ColorConfiguration.js.map
│ │ ├── ColorConstants.d.ts
│ │ ├── ColorConstants.js
│ │ ├── ColorConstants.js.map
│ │ ├── ColorMethods.d.ts
│ │ ├── ColorMethods.js
│ │ ├── ColorMethods.js.map
│ │ ├── ColorUtil.d.ts
│ │ ├── ColorUtil.js
│ │ └── ColorUtil.js.map
│ │ ├── colortbl
│ │ ├── ColortblConfiguration.d.ts
│ │ ├── ColortblConfiguration.js
│ │ └── ColortblConfiguration.js.map
│ │ ├── colorv2
│ │ ├── ColorV2Configuration.d.ts
│ │ ├── ColorV2Configuration.js
│ │ └── ColorV2Configuration.js.map
│ │ ├── configmacros
│ │ ├── ConfigMacrosConfiguration.d.ts
│ │ ├── ConfigMacrosConfiguration.js
│ │ └── ConfigMacrosConfiguration.js.map
│ │ ├── empheq
│ │ ├── EmpheqConfiguration.d.ts
│ │ ├── EmpheqConfiguration.js
│ │ ├── EmpheqConfiguration.js.map
│ │ ├── EmpheqUtil.d.ts
│ │ ├── EmpheqUtil.js
│ │ └── EmpheqUtil.js.map
│ │ ├── enclose
│ │ ├── EncloseConfiguration.d.ts
│ │ ├── EncloseConfiguration.js
│ │ └── EncloseConfiguration.js.map
│ │ ├── extpfeil
│ │ ├── ExtpfeilConfiguration.d.ts
│ │ ├── ExtpfeilConfiguration.js
│ │ └── ExtpfeilConfiguration.js.map
│ │ ├── gensymb
│ │ ├── GensymbConfiguration.d.ts
│ │ ├── GensymbConfiguration.js
│ │ └── GensymbConfiguration.js.map
│ │ ├── html
│ │ ├── HtmlConfiguration.d.ts
│ │ ├── HtmlConfiguration.js
│ │ ├── HtmlConfiguration.js.map
│ │ ├── HtmlMethods.d.ts
│ │ ├── HtmlMethods.js
│ │ └── HtmlMethods.js.map
│ │ ├── mathtools
│ │ ├── MathtoolsConfiguration.d.ts
│ │ ├── MathtoolsConfiguration.js
│ │ ├── MathtoolsConfiguration.js.map
│ │ ├── MathtoolsItems.d.ts
│ │ ├── MathtoolsItems.js
│ │ ├── MathtoolsItems.js.map
│ │ ├── MathtoolsMappings.d.ts
│ │ ├── MathtoolsMappings.js
│ │ ├── MathtoolsMappings.js.map
│ │ ├── MathtoolsMethods.d.ts
│ │ ├── MathtoolsMethods.js
│ │ ├── MathtoolsMethods.js.map
│ │ ├── MathtoolsTags.d.ts
│ │ ├── MathtoolsTags.js
│ │ ├── MathtoolsTags.js.map
│ │ ├── MathtoolsUtil.d.ts
│ │ ├── MathtoolsUtil.js
│ │ └── MathtoolsUtil.js.map
│ │ ├── mhchem
│ │ ├── MhchemConfiguration.d.ts
│ │ ├── MhchemConfiguration.js
│ │ └── MhchemConfiguration.js.map
│ │ ├── newcommand
│ │ ├── NewcommandConfiguration.d.ts
│ │ ├── NewcommandConfiguration.js
│ │ ├── NewcommandConfiguration.js.map
│ │ ├── NewcommandItems.d.ts
│ │ ├── NewcommandItems.js
│ │ ├── NewcommandItems.js.map
│ │ ├── NewcommandMappings.d.ts
│ │ ├── NewcommandMappings.js
│ │ ├── NewcommandMappings.js.map
│ │ ├── NewcommandMethods.d.ts
│ │ ├── NewcommandMethods.js
│ │ ├── NewcommandMethods.js.map
│ │ ├── NewcommandUtil.d.ts
│ │ ├── NewcommandUtil.js
│ │ └── NewcommandUtil.js.map
│ │ ├── noerrors
│ │ ├── NoErrorsConfiguration.d.ts
│ │ ├── NoErrorsConfiguration.js
│ │ └── NoErrorsConfiguration.js.map
│ │ ├── noundefined
│ │ ├── NoUndefinedConfiguration.d.ts
│ │ ├── NoUndefinedConfiguration.js
│ │ └── NoUndefinedConfiguration.js.map
│ │ ├── physics
│ │ ├── PhysicsConfiguration.d.ts
│ │ ├── PhysicsConfiguration.js
│ │ ├── PhysicsConfiguration.js.map
│ │ ├── PhysicsItems.d.ts
│ │ ├── PhysicsItems.js
│ │ ├── PhysicsItems.js.map
│ │ ├── PhysicsMappings.d.ts
│ │ ├── PhysicsMappings.js
│ │ ├── PhysicsMappings.js.map
│ │ ├── PhysicsMethods.d.ts
│ │ ├── PhysicsMethods.js
│ │ └── PhysicsMethods.js.map
│ │ ├── require
│ │ ├── RequireConfiguration.d.ts
│ │ ├── RequireConfiguration.js
│ │ └── RequireConfiguration.js.map
│ │ ├── setoptions
│ │ ├── SetOptionsConfiguration.d.ts
│ │ ├── SetOptionsConfiguration.js
│ │ └── SetOptionsConfiguration.js.map
│ │ ├── tagformat
│ │ ├── TagFormatConfiguration.d.ts
│ │ ├── TagFormatConfiguration.js
│ │ └── TagFormatConfiguration.js.map
│ │ ├── textcomp
│ │ ├── TextcompConfiguration.d.ts
│ │ ├── TextcompConfiguration.js
│ │ ├── TextcompConfiguration.js.map
│ │ ├── TextcompMappings.d.ts
│ │ ├── TextcompMappings.js
│ │ └── TextcompMappings.js.map
│ │ ├── textmacros
│ │ ├── TextMacrosConfiguration.d.ts
│ │ ├── TextMacrosConfiguration.js
│ │ ├── TextMacrosConfiguration.js.map
│ │ ├── TextMacrosMappings.d.ts
│ │ ├── TextMacrosMappings.js
│ │ ├── TextMacrosMappings.js.map
│ │ ├── TextMacrosMethods.d.ts
│ │ ├── TextMacrosMethods.js
│ │ ├── TextMacrosMethods.js.map
│ │ ├── TextParser.d.ts
│ │ ├── TextParser.js
│ │ └── TextParser.js.map
│ │ ├── unicode
│ │ ├── UnicodeConfiguration.d.ts
│ │ ├── UnicodeConfiguration.js
│ │ └── UnicodeConfiguration.js.map
│ │ ├── upgreek
│ │ ├── UpgreekConfiguration.d.ts
│ │ ├── UpgreekConfiguration.js
│ │ └── UpgreekConfiguration.js.map
│ │ └── verb
│ │ ├── VerbConfiguration.d.ts
│ │ ├── VerbConfiguration.js
│ │ └── VerbConfiguration.js.map
├── mathjax.d.ts
├── mathjax.js
├── output
│ ├── chtml.d.ts
│ ├── chtml.js
│ ├── chtml.js.map
│ ├── chtml
│ │ ├── FontData.d.ts
│ │ ├── FontData.js
│ │ ├── FontData.js.map
│ │ ├── Notation.d.ts
│ │ ├── Notation.js
│ │ ├── Notation.js.map
│ │ ├── Usage.d.ts
│ │ ├── Usage.js
│ │ ├── Usage.js.map
│ │ ├── Wrapper.d.ts
│ │ ├── Wrapper.js
│ │ ├── Wrapper.js.map
│ │ ├── WrapperFactory.d.ts
│ │ ├── WrapperFactory.js
│ │ ├── WrapperFactory.js.map
│ │ ├── Wrappers.d.ts
│ │ ├── Wrappers.js
│ │ ├── Wrappers.js.map
│ │ ├── Wrappers
│ │ │ ├── TeXAtom.d.ts
│ │ │ ├── TeXAtom.js
│ │ │ ├── TeXAtom.js.map
│ │ │ ├── TextNode.d.ts
│ │ │ ├── TextNode.js
│ │ │ ├── TextNode.js.map
│ │ │ ├── maction.d.ts
│ │ │ ├── maction.js
│ │ │ ├── maction.js.map
│ │ │ ├── math.d.ts
│ │ │ ├── math.js
│ │ │ ├── math.js.map
│ │ │ ├── menclose.d.ts
│ │ │ ├── menclose.js
│ │ │ ├── menclose.js.map
│ │ │ ├── mfenced.d.ts
│ │ │ ├── mfenced.js
│ │ │ ├── mfenced.js.map
│ │ │ ├── mfrac.d.ts
│ │ │ ├── mfrac.js
│ │ │ ├── mfrac.js.map
│ │ │ ├── mglyph.d.ts
│ │ │ ├── mglyph.js
│ │ │ ├── mglyph.js.map
│ │ │ ├── mi.d.ts
│ │ │ ├── mi.js
│ │ │ ├── mi.js.map
│ │ │ ├── mmultiscripts.d.ts
│ │ │ ├── mmultiscripts.js
│ │ │ ├── mmultiscripts.js.map
│ │ │ ├── mn.d.ts
│ │ │ ├── mn.js
│ │ │ ├── mn.js.map
│ │ │ ├── mo.d.ts
│ │ │ ├── mo.js
│ │ │ ├── mo.js.map
│ │ │ ├── mpadded.d.ts
│ │ │ ├── mpadded.js
│ │ │ ├── mpadded.js.map
│ │ │ ├── mroot.d.ts
│ │ │ ├── mroot.js
│ │ │ ├── mroot.js.map
│ │ │ ├── mrow.d.ts
│ │ │ ├── mrow.js
│ │ │ ├── mrow.js.map
│ │ │ ├── ms.d.ts
│ │ │ ├── ms.js
│ │ │ ├── ms.js.map
│ │ │ ├── mspace.d.ts
│ │ │ ├── mspace.js
│ │ │ ├── mspace.js.map
│ │ │ ├── msqrt.d.ts
│ │ │ ├── msqrt.js
│ │ │ ├── msqrt.js.map
│ │ │ ├── msubsup.d.ts
│ │ │ ├── msubsup.js
│ │ │ ├── msubsup.js.map
│ │ │ ├── mtable.d.ts
│ │ │ ├── mtable.js
│ │ │ ├── mtable.js.map
│ │ │ ├── mtd.d.ts
│ │ │ ├── mtd.js
│ │ │ ├── mtd.js.map
│ │ │ ├── mtext.d.ts
│ │ │ ├── mtext.js
│ │ │ ├── mtext.js.map
│ │ │ ├── mtr.d.ts
│ │ │ ├── mtr.js
│ │ │ ├── mtr.js.map
│ │ │ ├── munderover.d.ts
│ │ │ ├── munderover.js
│ │ │ ├── munderover.js.map
│ │ │ ├── scriptbase.d.ts
│ │ │ ├── scriptbase.js
│ │ │ ├── scriptbase.js.map
│ │ │ ├── semantics.d.ts
│ │ │ ├── semantics.js
│ │ │ └── semantics.js.map
│ │ └── fonts
│ │ │ ├── tex.d.ts
│ │ │ ├── tex.js
│ │ │ ├── tex.js.map
│ │ │ └── tex
│ │ │ ├── bold-italic.d.ts
│ │ │ ├── bold-italic.js
│ │ │ ├── bold-italic.js.map
│ │ │ ├── bold.d.ts
│ │ │ ├── bold.js
│ │ │ ├── bold.js.map
│ │ │ ├── double-struck.d.ts
│ │ │ ├── double-struck.js
│ │ │ ├── double-struck.js.map
│ │ │ ├── fraktur-bold.d.ts
│ │ │ ├── fraktur-bold.js
│ │ │ ├── fraktur-bold.js.map
│ │ │ ├── fraktur.d.ts
│ │ │ ├── fraktur.js
│ │ │ ├── fraktur.js.map
│ │ │ ├── italic.d.ts
│ │ │ ├── italic.js
│ │ │ ├── italic.js.map
│ │ │ ├── largeop.d.ts
│ │ │ ├── largeop.js
│ │ │ ├── largeop.js.map
│ │ │ ├── monospace.d.ts
│ │ │ ├── monospace.js
│ │ │ ├── monospace.js.map
│ │ │ ├── normal.d.ts
│ │ │ ├── normal.js
│ │ │ ├── normal.js.map
│ │ │ ├── sans-serif-bold-italic.d.ts
│ │ │ ├── sans-serif-bold-italic.js
│ │ │ ├── sans-serif-bold-italic.js.map
│ │ │ ├── sans-serif-bold.d.ts
│ │ │ ├── sans-serif-bold.js
│ │ │ ├── sans-serif-bold.js.map
│ │ │ ├── sans-serif-italic.d.ts
│ │ │ ├── sans-serif-italic.js
│ │ │ ├── sans-serif-italic.js.map
│ │ │ ├── sans-serif.d.ts
│ │ │ ├── sans-serif.js
│ │ │ ├── sans-serif.js.map
│ │ │ ├── script-bold.d.ts
│ │ │ ├── script-bold.js
│ │ │ ├── script-bold.js.map
│ │ │ ├── script.d.ts
│ │ │ ├── script.js
│ │ │ ├── script.js.map
│ │ │ ├── smallop.d.ts
│ │ │ ├── smallop.js
│ │ │ ├── smallop.js.map
│ │ │ ├── tex-calligraphic-bold.d.ts
│ │ │ ├── tex-calligraphic-bold.js
│ │ │ ├── tex-calligraphic-bold.js.map
│ │ │ ├── tex-calligraphic.d.ts
│ │ │ ├── tex-calligraphic.js
│ │ │ ├── tex-calligraphic.js.map
│ │ │ ├── tex-mathit.d.ts
│ │ │ ├── tex-mathit.js
│ │ │ ├── tex-mathit.js.map
│ │ │ ├── tex-oldstyle-bold.d.ts
│ │ │ ├── tex-oldstyle-bold.js
│ │ │ ├── tex-oldstyle-bold.js.map
│ │ │ ├── tex-oldstyle.d.ts
│ │ │ ├── tex-oldstyle.js
│ │ │ ├── tex-oldstyle.js.map
│ │ │ ├── tex-size3.d.ts
│ │ │ ├── tex-size3.js
│ │ │ ├── tex-size3.js.map
│ │ │ ├── tex-size4.d.ts
│ │ │ ├── tex-size4.js
│ │ │ ├── tex-size4.js.map
│ │ │ ├── tex-variant.d.ts
│ │ │ ├── tex-variant.js
│ │ │ └── tex-variant.js.map
│ ├── common
│ │ ├── FontData.d.ts
│ │ ├── FontData.js
│ │ ├── FontData.js.map
│ │ ├── Notation.d.ts
│ │ ├── Notation.js
│ │ ├── Notation.js.map
│ │ ├── OutputJax.d.ts
│ │ ├── OutputJax.js
│ │ ├── OutputJax.js.map
│ │ ├── Wrapper.d.ts
│ │ ├── Wrapper.js
│ │ ├── Wrapper.js.map
│ │ ├── WrapperFactory.d.ts
│ │ ├── WrapperFactory.js
│ │ ├── WrapperFactory.js.map
│ │ ├── Wrappers
│ │ │ ├── TeXAtom.d.ts
│ │ │ ├── TeXAtom.js
│ │ │ ├── TeXAtom.js.map
│ │ │ ├── TextNode.d.ts
│ │ │ ├── TextNode.js
│ │ │ ├── TextNode.js.map
│ │ │ ├── maction.d.ts
│ │ │ ├── maction.js
│ │ │ ├── maction.js.map
│ │ │ ├── math.d.ts
│ │ │ ├── math.js
│ │ │ ├── math.js.map
│ │ │ ├── menclose.d.ts
│ │ │ ├── menclose.js
│ │ │ ├── menclose.js.map
│ │ │ ├── mfenced.d.ts
│ │ │ ├── mfenced.js
│ │ │ ├── mfenced.js.map
│ │ │ ├── mfrac.d.ts
│ │ │ ├── mfrac.js
│ │ │ ├── mfrac.js.map
│ │ │ ├── mglyph.d.ts
│ │ │ ├── mglyph.js
│ │ │ ├── mglyph.js.map
│ │ │ ├── mi.d.ts
│ │ │ ├── mi.js
│ │ │ ├── mi.js.map
│ │ │ ├── mmultiscripts.d.ts
│ │ │ ├── mmultiscripts.js
│ │ │ ├── mmultiscripts.js.map
│ │ │ ├── mn.d.ts
│ │ │ ├── mn.js
│ │ │ ├── mn.js.map
│ │ │ ├── mo.d.ts
│ │ │ ├── mo.js
│ │ │ ├── mo.js.map
│ │ │ ├── mpadded.d.ts
│ │ │ ├── mpadded.js
│ │ │ ├── mpadded.js.map
│ │ │ ├── mroot.d.ts
│ │ │ ├── mroot.js
│ │ │ ├── mroot.js.map
│ │ │ ├── mrow.d.ts
│ │ │ ├── mrow.js
│ │ │ ├── mrow.js.map
│ │ │ ├── ms.d.ts
│ │ │ ├── ms.js
│ │ │ ├── ms.js.map
│ │ │ ├── mspace.d.ts
│ │ │ ├── mspace.js
│ │ │ ├── mspace.js.map
│ │ │ ├── msqrt.d.ts
│ │ │ ├── msqrt.js
│ │ │ ├── msqrt.js.map
│ │ │ ├── msubsup.d.ts
│ │ │ ├── msubsup.js
│ │ │ ├── msubsup.js.map
│ │ │ ├── mtable.d.ts
│ │ │ ├── mtable.js
│ │ │ ├── mtable.js.map
│ │ │ ├── mtd.d.ts
│ │ │ ├── mtd.js
│ │ │ ├── mtd.js.map
│ │ │ ├── mtext.d.ts
│ │ │ ├── mtext.js
│ │ │ ├── mtext.js.map
│ │ │ ├── mtr.d.ts
│ │ │ ├── mtr.js
│ │ │ ├── mtr.js.map
│ │ │ ├── munderover.d.ts
│ │ │ ├── munderover.js
│ │ │ ├── munderover.js.map
│ │ │ ├── scriptbase.d.ts
│ │ │ ├── scriptbase.js
│ │ │ ├── scriptbase.js.map
│ │ │ ├── semantics.d.ts
│ │ │ ├── semantics.js
│ │ │ └── semantics.js.map
│ │ └── fonts
│ │ │ ├── tex.d.ts
│ │ │ ├── tex.js
│ │ │ ├── tex.js.map
│ │ │ └── tex
│ │ │ ├── bold-italic.d.ts
│ │ │ ├── bold-italic.js
│ │ │ ├── bold-italic.js.map
│ │ │ ├── bold.d.ts
│ │ │ ├── bold.js
│ │ │ ├── bold.js.map
│ │ │ ├── delimiters.d.ts
│ │ │ ├── delimiters.js
│ │ │ ├── delimiters.js.map
│ │ │ ├── double-struck.d.ts
│ │ │ ├── double-struck.js
│ │ │ ├── double-struck.js.map
│ │ │ ├── fraktur-bold.d.ts
│ │ │ ├── fraktur-bold.js
│ │ │ ├── fraktur-bold.js.map
│ │ │ ├── fraktur.d.ts
│ │ │ ├── fraktur.js
│ │ │ ├── fraktur.js.map
│ │ │ ├── italic.d.ts
│ │ │ ├── italic.js
│ │ │ ├── italic.js.map
│ │ │ ├── largeop.d.ts
│ │ │ ├── largeop.js
│ │ │ ├── largeop.js.map
│ │ │ ├── monospace.d.ts
│ │ │ ├── monospace.js
│ │ │ ├── monospace.js.map
│ │ │ ├── normal.d.ts
│ │ │ ├── normal.js
│ │ │ ├── normal.js.map
│ │ │ ├── sans-serif-bold-italic.d.ts
│ │ │ ├── sans-serif-bold-italic.js
│ │ │ ├── sans-serif-bold-italic.js.map
│ │ │ ├── sans-serif-bold.d.ts
│ │ │ ├── sans-serif-bold.js
│ │ │ ├── sans-serif-bold.js.map
│ │ │ ├── sans-serif-italic.d.ts
│ │ │ ├── sans-serif-italic.js
│ │ │ ├── sans-serif-italic.js.map
│ │ │ ├── sans-serif.d.ts
│ │ │ ├── sans-serif.js
│ │ │ ├── sans-serif.js.map
│ │ │ ├── script-bold.d.ts
│ │ │ ├── script-bold.js
│ │ │ ├── script-bold.js.map
│ │ │ ├── script.d.ts
│ │ │ ├── script.js
│ │ │ ├── script.js.map
│ │ │ ├── smallop.d.ts
│ │ │ ├── smallop.js
│ │ │ ├── smallop.js.map
│ │ │ ├── tex-calligraphic-bold.d.ts
│ │ │ ├── tex-calligraphic-bold.js
│ │ │ ├── tex-calligraphic-bold.js.map
│ │ │ ├── tex-calligraphic.d.ts
│ │ │ ├── tex-calligraphic.js
│ │ │ ├── tex-calligraphic.js.map
│ │ │ ├── tex-mathit.d.ts
│ │ │ ├── tex-mathit.js
│ │ │ ├── tex-mathit.js.map
│ │ │ ├── tex-oldstyle-bold.d.ts
│ │ │ ├── tex-oldstyle-bold.js
│ │ │ ├── tex-oldstyle-bold.js.map
│ │ │ ├── tex-oldstyle.d.ts
│ │ │ ├── tex-oldstyle.js
│ │ │ ├── tex-oldstyle.js.map
│ │ │ ├── tex-size3.d.ts
│ │ │ ├── tex-size3.js
│ │ │ ├── tex-size3.js.map
│ │ │ ├── tex-size4.d.ts
│ │ │ ├── tex-size4.js
│ │ │ ├── tex-size4.js.map
│ │ │ ├── tex-variant.d.ts
│ │ │ ├── tex-variant.js
│ │ │ └── tex-variant.js.map
│ ├── svg.d.ts
│ ├── svg.js
│ ├── svg.js.map
│ └── svg
│ │ ├── FontCache.d.ts
│ │ ├── FontCache.js
│ │ ├── FontCache.js.map
│ │ ├── FontData.d.ts
│ │ ├── FontData.js
│ │ ├── FontData.js.map
│ │ ├── Notation.d.ts
│ │ ├── Notation.js
│ │ ├── Notation.js.map
│ │ ├── Wrapper.d.ts
│ │ ├── Wrapper.js
│ │ ├── Wrapper.js.map
│ │ ├── WrapperFactory.d.ts
│ │ ├── WrapperFactory.js
│ │ ├── WrapperFactory.js.map
│ │ ├── Wrappers.d.ts
│ │ ├── Wrappers.js
│ │ ├── Wrappers.js.map
│ │ ├── Wrappers
│ │ ├── TeXAtom.d.ts
│ │ ├── TeXAtom.js
│ │ ├── TeXAtom.js.map
│ │ ├── TextNode.d.ts
│ │ ├── TextNode.js
│ │ ├── TextNode.js.map
│ │ ├── maction.d.ts
│ │ ├── maction.js
│ │ ├── maction.js.map
│ │ ├── math.d.ts
│ │ ├── math.js
│ │ ├── math.js.map
│ │ ├── menclose.d.ts
│ │ ├── menclose.js
│ │ ├── menclose.js.map
│ │ ├── merror.d.ts
│ │ ├── merror.js
│ │ ├── merror.js.map
│ │ ├── mfenced.d.ts
│ │ ├── mfenced.js
│ │ ├── mfenced.js.map
│ │ ├── mfrac.d.ts
│ │ ├── mfrac.js
│ │ ├── mfrac.js.map
│ │ ├── mglyph.d.ts
│ │ ├── mglyph.js
│ │ ├── mglyph.js.map
│ │ ├── mi.d.ts
│ │ ├── mi.js
│ │ ├── mi.js.map
│ │ ├── mmultiscripts.d.ts
│ │ ├── mmultiscripts.js
│ │ ├── mmultiscripts.js.map
│ │ ├── mn.d.ts
│ │ ├── mn.js
│ │ ├── mn.js.map
│ │ ├── mo.d.ts
│ │ ├── mo.js
│ │ ├── mo.js.map
│ │ ├── mpadded.d.ts
│ │ ├── mpadded.js
│ │ ├── mpadded.js.map
│ │ ├── mphantom.d.ts
│ │ ├── mphantom.js
│ │ ├── mphantom.js.map
│ │ ├── mroot.d.ts
│ │ ├── mroot.js
│ │ ├── mroot.js.map
│ │ ├── mrow.d.ts
│ │ ├── mrow.js
│ │ ├── mrow.js.map
│ │ ├── ms.d.ts
│ │ ├── ms.js
│ │ ├── ms.js.map
│ │ ├── mspace.d.ts
│ │ ├── mspace.js
│ │ ├── mspace.js.map
│ │ ├── msqrt.d.ts
│ │ ├── msqrt.js
│ │ ├── msqrt.js.map
│ │ ├── msubsup.d.ts
│ │ ├── msubsup.js
│ │ ├── msubsup.js.map
│ │ ├── mtable.d.ts
│ │ ├── mtable.js
│ │ ├── mtable.js.map
│ │ ├── mtd.d.ts
│ │ ├── mtd.js
│ │ ├── mtd.js.map
│ │ ├── mtext.d.ts
│ │ ├── mtext.js
│ │ ├── mtext.js.map
│ │ ├── mtr.d.ts
│ │ ├── mtr.js
│ │ ├── mtr.js.map
│ │ ├── munderover.d.ts
│ │ ├── munderover.js
│ │ ├── munderover.js.map
│ │ ├── scriptbase.d.ts
│ │ ├── scriptbase.js
│ │ ├── scriptbase.js.map
│ │ ├── semantics.d.ts
│ │ ├── semantics.js
│ │ └── semantics.js.map
│ │ └── fonts
│ │ ├── tex.d.ts
│ │ ├── tex.js
│ │ ├── tex.js.map
│ │ └── tex
│ │ ├── bold-italic.d.ts
│ │ ├── bold-italic.js
│ │ ├── bold-italic.js.map
│ │ ├── bold.d.ts
│ │ ├── bold.js
│ │ ├── bold.js.map
│ │ ├── double-struck.d.ts
│ │ ├── double-struck.js
│ │ ├── double-struck.js.map
│ │ ├── fraktur-bold.d.ts
│ │ ├── fraktur-bold.js
│ │ ├── fraktur-bold.js.map
│ │ ├── fraktur.d.ts
│ │ ├── fraktur.js
│ │ ├── fraktur.js.map
│ │ ├── italic.d.ts
│ │ ├── italic.js
│ │ ├── italic.js.map
│ │ ├── largeop.d.ts
│ │ ├── largeop.js
│ │ ├── largeop.js.map
│ │ ├── monospace.d.ts
│ │ ├── monospace.js
│ │ ├── monospace.js.map
│ │ ├── normal.d.ts
│ │ ├── normal.js
│ │ ├── normal.js.map
│ │ ├── sans-serif-bold-italic.d.ts
│ │ ├── sans-serif-bold-italic.js
│ │ ├── sans-serif-bold-italic.js.map
│ │ ├── sans-serif-bold.d.ts
│ │ ├── sans-serif-bold.js
│ │ ├── sans-serif-bold.js.map
│ │ ├── sans-serif-italic.d.ts
│ │ ├── sans-serif-italic.js
│ │ ├── sans-serif-italic.js.map
│ │ ├── sans-serif.d.ts
│ │ ├── sans-serif.js
│ │ ├── sans-serif.js.map
│ │ ├── script-bold.d.ts
│ │ ├── script-bold.js
│ │ ├── script-bold.js.map
│ │ ├── script.d.ts
│ │ ├── script.js
│ │ ├── script.js.map
│ │ ├── smallop.d.ts
│ │ ├── smallop.js
│ │ ├── smallop.js.map
│ │ ├── tex-calligraphic-bold.d.ts
│ │ ├── tex-calligraphic-bold.js
│ │ ├── tex-calligraphic-bold.js.map
│ │ ├── tex-calligraphic.d.ts
│ │ ├── tex-calligraphic.js
│ │ ├── tex-calligraphic.js.map
│ │ ├── tex-mathit.d.ts
│ │ ├── tex-mathit.js
│ │ ├── tex-mathit.js.map
│ │ ├── tex-oldstyle-bold.d.ts
│ │ ├── tex-oldstyle-bold.js
│ │ ├── tex-oldstyle-bold.js.map
│ │ ├── tex-oldstyle.d.ts
│ │ ├── tex-oldstyle.js
│ │ ├── tex-oldstyle.js.map
│ │ ├── tex-size3.d.ts
│ │ ├── tex-size3.js
│ │ ├── tex-size3.js.map
│ │ ├── tex-size4.d.ts
│ │ ├── tex-size4.js
│ │ ├── tex-size4.js.map
│ │ ├── tex-variant.d.ts
│ │ ├── tex-variant.js
│ │ └── tex-variant.js.map
├── ui
│ ├── lazy
│ │ ├── LazyHandler.d.ts
│ │ ├── LazyHandler.js
│ │ └── LazyHandler.js.map
│ ├── menu
│ │ ├── MJContextMenu.d.ts
│ │ ├── MJContextMenu.js
│ │ ├── MJContextMenu.js.map
│ │ ├── Menu.d.ts
│ │ ├── Menu.js
│ │ ├── Menu.js.map
│ │ ├── MenuHandler.d.ts
│ │ ├── MenuHandler.js
│ │ ├── MenuHandler.js.map
│ │ ├── MmlVisitor.d.ts
│ │ ├── MmlVisitor.js
│ │ ├── MmlVisitor.js.map
│ │ ├── SelectableInfo.d.ts
│ │ ├── SelectableInfo.js
│ │ └── SelectableInfo.js.map
│ └── safe
│ │ ├── SafeHandler.d.ts
│ │ ├── SafeHandler.js
│ │ ├── SafeHandler.js.map
│ │ ├── SafeMethods.d.ts
│ │ ├── SafeMethods.js
│ │ ├── SafeMethods.js.map
│ │ ├── safe.d.ts
│ │ ├── safe.js
│ │ └── safe.js.map
└── util
│ ├── AsyncLoad.d.ts
│ ├── AsyncLoad.js
│ ├── AsyncLoad.js.map
│ ├── BBox.d.ts
│ ├── BBox.js
│ ├── BBox.js.map
│ ├── BitField.d.ts
│ ├── BitField.js
│ ├── BitField.js.map
│ ├── Entities.d.ts
│ ├── Entities.js
│ ├── Entities.js.map
│ ├── FunctionList.d.ts
│ ├── FunctionList.js
│ ├── FunctionList.js.map
│ ├── LinkedList.d.ts
│ ├── LinkedList.js
│ ├── LinkedList.js.map
│ ├── Options.d.ts
│ ├── Options.js
│ ├── Options.js.map
│ ├── PrioritizedList.d.ts
│ ├── PrioritizedList.js
│ ├── PrioritizedList.js.map
│ ├── Retries.d.ts
│ ├── Retries.js
│ ├── Retries.js.map
│ ├── StyleList.d.ts
│ ├── StyleList.js
│ ├── StyleList.js.map
│ ├── Styles.d.ts
│ ├── Styles.js
│ ├── Styles.js.map
│ ├── asyncLoad
│ ├── node.d.ts
│ ├── node.js
│ ├── node.js.map
│ ├── system.d.ts
│ ├── system.js
│ └── system.js.map
│ ├── entities
│ ├── a.d.ts
│ ├── a.js
│ ├── a.js.map
│ ├── all.d.ts
│ ├── all.js
│ ├── all.js.map
│ ├── b.d.ts
│ ├── b.js
│ ├── b.js.map
│ ├── c.d.ts
│ ├── c.js
│ ├── c.js.map
│ ├── d.d.ts
│ ├── d.js
│ ├── d.js.map
│ ├── e.d.ts
│ ├── e.js
│ ├── e.js.map
│ ├── f.d.ts
│ ├── f.js
│ ├── f.js.map
│ ├── fr.d.ts
│ ├── fr.js
│ ├── fr.js.map
│ ├── g.d.ts
│ ├── g.js
│ ├── g.js.map
│ ├── h.d.ts
│ ├── h.js
│ ├── h.js.map
│ ├── i.d.ts
│ ├── i.js
│ ├── i.js.map
│ ├── j.d.ts
│ ├── j.js
│ ├── j.js.map
│ ├── k.d.ts
│ ├── k.js
│ ├── k.js.map
│ ├── l.d.ts
│ ├── l.js
│ ├── l.js.map
│ ├── m.d.ts
│ ├── m.js
│ ├── m.js.map
│ ├── n.d.ts
│ ├── n.js
│ ├── n.js.map
│ ├── o.d.ts
│ ├── o.js
│ ├── o.js.map
│ ├── opf.d.ts
│ ├── opf.js
│ ├── opf.js.map
│ ├── p.d.ts
│ ├── p.js
│ ├── p.js.map
│ ├── q.d.ts
│ ├── q.js
│ ├── q.js.map
│ ├── r.d.ts
│ ├── r.js
│ ├── r.js.map
│ ├── s.d.ts
│ ├── s.js
│ ├── s.js.map
│ ├── scr.d.ts
│ ├── scr.js
│ ├── scr.js.map
│ ├── t.d.ts
│ ├── t.js
│ ├── t.js.map
│ ├── u.d.ts
│ ├── u.js
│ ├── u.js.map
│ ├── v.d.ts
│ ├── v.js
│ ├── v.js.map
│ ├── w.d.ts
│ ├── w.js
│ ├── w.js.map
│ ├── x.d.ts
│ ├── x.js
│ ├── x.js.map
│ ├── y.d.ts
│ ├── y.js
│ ├── y.js.map
│ ├── z.d.ts
│ ├── z.js
│ └── z.js.map
│ ├── lengths.d.ts
│ ├── lengths.js
│ ├── lengths.js.map
│ ├── numeric.d.ts
│ ├── numeric.js
│ ├── numeric.js.map
│ ├── string.d.ts
│ ├── string.js
│ └── string.js.map
├── package-lock.json
└── package.json
/export.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/webyonet/react-native-mathjax-html-to-svg/48dbe3acdd4cfcdaa1a6ae4b57e1c1729dfc7ac3/export.png
--------------------------------------------------------------------------------
/index.d.ts:
--------------------------------------------------------------------------------
1 | declare module 'react-native-mathjax-html-to-svg' {
2 | import {TextStyle, ViewStyle} from 'react-native';
3 | import {ReactNode} from 'react';
4 |
5 | type Props = {
6 | fontSize?: number,
7 | color?: string,
8 | fontCache?: boolean,
9 | style?: ViewStyle,
10 | textStyle?: TextStyle,
11 | children?: ReactNode,
12 | };
13 |
14 | export function MathJaxSvg(props: Props) ;
15 | }
16 |
--------------------------------------------------------------------------------
/mathjax/a11y/mathmaps.d.ts:
--------------------------------------------------------------------------------
1 | declare const MathMaps: Map;
4 | export default MathMaps;
5 |
--------------------------------------------------------------------------------
/mathjax/a11y/mathmaps.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | Object.defineProperty(exports, "__esModule", { value: true });
3 | var MathMaps = new Map();
4 | exports.default = MathMaps;
5 | //# sourceMappingURL=mathmaps.js.map
--------------------------------------------------------------------------------
/mathjax/a11y/mathmaps.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"mathmaps.js","sourceRoot":"","sources":["../../ts/a11y/mathmaps.ts"],"names":[],"mappings":";;AAwBA,IAAM,QAAQ,GAAuC,IAAI,GAAG,EAAE,CAAC;AAE/D,kBAAe,QAAQ,CAAC"}
--------------------------------------------------------------------------------
/mathjax/adaptors/NodeMixin.d.ts:
--------------------------------------------------------------------------------
1 | import { DOMAdaptor } from '../core/DOMAdaptor.js';
2 | import { OptionList } from '../util/Options.js';
3 | export declare type Constructor = (new (...args: any[]) => T);
4 | export declare type AdaptorConstructor = Constructor>;
5 | export declare const NodeMixinOptions: OptionList;
6 | export declare function NodeMixin>(Base: A, options?: typeof NodeMixinOptions): A;
7 |
--------------------------------------------------------------------------------
/mathjax/adaptors/browserAdaptor.d.ts:
--------------------------------------------------------------------------------
1 | import { HTMLAdaptor } from './HTMLAdaptor.js';
2 | declare global {
3 | interface Window {
4 | Document: typeof Document;
5 | DOMParser: typeof DOMParser;
6 | XMLSerializer: typeof XMLSerializer;
7 | HTMLElement: typeof HTMLElement;
8 | HTMLCollection: typeof HTMLCollection;
9 | NodeList: typeof NodeList;
10 | DocumentFragment: typeof DocumentFragment;
11 | }
12 | }
13 | export declare function browserAdaptor(): HTMLAdaptor;
14 |
--------------------------------------------------------------------------------
/mathjax/adaptors/browserAdaptor.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | Object.defineProperty(exports, "__esModule", { value: true });
3 | exports.browserAdaptor = void 0;
4 | var HTMLAdaptor_js_1 = require("./HTMLAdaptor.js");
5 | function browserAdaptor() {
6 | return new HTMLAdaptor_js_1.HTMLAdaptor(window);
7 | }
8 | exports.browserAdaptor = browserAdaptor;
9 | //# sourceMappingURL=browserAdaptor.js.map
--------------------------------------------------------------------------------
/mathjax/adaptors/browserAdaptor.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"browserAdaptor.js","sourceRoot":"","sources":["../../ts/adaptors/browserAdaptor.ts"],"names":[],"mappings":";;;AAuBA,mDAA6C;AAsB7C,SAAgB,cAAc;IAC5B,OAAO,IAAI,4BAAW,CAA8B,MAAM,CAAC,CAAC;AAC9D,CAAC;AAFD,wCAEC"}
--------------------------------------------------------------------------------
/mathjax/adaptors/chooseAdaptor.d.ts:
--------------------------------------------------------------------------------
1 | import { liteAdaptor } from './liteAdaptor.js';
2 | import { browserAdaptor } from './browserAdaptor.js';
3 | export declare const chooseAdaptor: typeof browserAdaptor | typeof liteAdaptor;
4 |
--------------------------------------------------------------------------------
/mathjax/adaptors/chooseAdaptor.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | Object.defineProperty(exports, "__esModule", { value: true });
3 | exports.chooseAdaptor = void 0;
4 | var liteAdaptor_js_1 = require("./liteAdaptor.js");
5 | var browserAdaptor_js_1 = require("./browserAdaptor.js");
6 | var choose;
7 | try {
8 | document;
9 | choose = browserAdaptor_js_1.browserAdaptor;
10 | }
11 | catch (e) {
12 | choose = liteAdaptor_js_1.liteAdaptor;
13 | }
14 | exports.chooseAdaptor = choose;
15 | //# sourceMappingURL=chooseAdaptor.js.map
--------------------------------------------------------------------------------
/mathjax/adaptors/chooseAdaptor.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"chooseAdaptor.js","sourceRoot":"","sources":["../../ts/adaptors/chooseAdaptor.ts"],"names":[],"mappings":";;;AAuBA,mDAA6C;AAC7C,yDAAmD;AAEnD,IAAI,MAAM,CAAC;AAEX,IAAI;IACF,QAAQ,CAAC;IACT,MAAM,GAAG,kCAAc,CAAC;CACzB;AAAC,OAAO,CAAC,EAAE;IACV,MAAM,GAAG,4BAAW,CAAC;CACtB;AAKY,QAAA,aAAa,GAAG,MAAM,CAAC"}
--------------------------------------------------------------------------------
/mathjax/adaptors/jsdomAdaptor.d.ts:
--------------------------------------------------------------------------------
1 | import { HTMLAdaptor } from './HTMLAdaptor.js';
2 | import { Constructor } from './NodeMixin.js';
3 | import { OptionList } from '../util/Options.js';
4 | export declare type HTMLAdaptorConstructor = Constructor>;
5 | declare const JsdomAdaptor_base: HTMLAdaptorConstructor;
6 | export declare class JsdomAdaptor extends JsdomAdaptor_base {
7 | }
8 | export declare function jsdomAdaptor(JSDOM: any, options?: OptionList): JsdomAdaptor;
9 | export {};
10 |
--------------------------------------------------------------------------------
/mathjax/adaptors/jsdomAdaptor.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"jsdomAdaptor.js","sourceRoot":"","sources":["../../ts/adaptors/jsdomAdaptor.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AAuBA,mDAA6C;AAC7C,+CAAsD;AAWtD;IAAkC,gCAA2E;IAA7G;;IAA+G,CAAC;IAAD,mBAAC;AAAD,CAAC,AAAhH,CAAkC,IAAA,wBAAS,EAAsD,4BAAW,CAAC,GAAG;AAAnG,oCAAY;AAQzB,SAAgB,YAAY,CAAC,KAAU,EAAE,OAA0B;IAA1B,wBAAA,EAAA,cAA0B;IACjE,OAAO,IAAI,YAAY,CAAC,IAAI,KAAK,EAAE,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AACvD,CAAC;AAFD,oCAEC"}
--------------------------------------------------------------------------------
/mathjax/adaptors/linkedomAdaptor.d.ts:
--------------------------------------------------------------------------------
1 | import { HTMLAdaptor } from './HTMLAdaptor.js';
2 | import { Constructor } from './NodeMixin.js';
3 | import { OptionList } from '../util/Options.js';
4 | export declare type HTMLAdaptorConstructor = Constructor>;
5 | declare const LinkedomAdaptor_base: HTMLAdaptorConstructor;
6 | export declare class LinkedomAdaptor extends LinkedomAdaptor_base {
7 | parse(text: string, format?: string): Document;
8 | serializeXML(node: HTMLElement): string;
9 | }
10 | export declare function linkedomAdaptor(parseHTML: any, options?: OptionList): LinkedomAdaptor;
11 | export {};
12 |
--------------------------------------------------------------------------------
/mathjax/adaptors/lite/Document.d.ts:
--------------------------------------------------------------------------------
1 | import { LiteElement } from './Element.js';
2 | export declare class LiteDocument {
3 | root: LiteElement;
4 | head: LiteElement;
5 | body: LiteElement;
6 | type: string;
7 | get kind(): string;
8 | constructor();
9 | }
10 |
--------------------------------------------------------------------------------
/mathjax/adaptors/lite/Document.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"Document.js","sourceRoot":"","sources":["../../../ts/adaptors/lite/Document.ts"],"names":[],"mappings":";;;AAuBA,2CAAyC;AAMzC;IA6BE;QACE,IAAI,CAAC,IAAI,GAAG,IAAI,wBAAW,CAAC,MAAM,EAAE,EAAE,EAAE;YACtC,IAAI,CAAC,IAAI,GAAG,IAAI,wBAAW,CAAC,MAAM,CAAC;YACnC,IAAI,CAAC,IAAI,GAAG,IAAI,wBAAW,CAAC,MAAM,CAAC;SACpC,CAAC,CAAC;QACH,IAAI,CAAC,IAAI,GAAG,EAAE,CAAC;IACjB,CAAC;IAbD,sBAAW,8BAAI;aAAf;YACE,OAAO,WAAW,CAAC;QACrB,CAAC;;;OAAA;IAYH,mBAAC;AAAD,CAAC,AApCD,IAoCC;AApCY,oCAAY"}
--------------------------------------------------------------------------------
/mathjax/adaptors/lite/Element.d.ts:
--------------------------------------------------------------------------------
1 | import { OptionList } from '../../util/Options.js';
2 | import { Styles } from '../../util/Styles.js';
3 | import { LiteText } from './Text.js';
4 | export declare type LiteAttributeList = OptionList;
5 | export declare type LiteNode = LiteElement | LiteText;
6 | export declare class LiteElement {
7 | kind: string;
8 | attributes: LiteAttributeList;
9 | children: LiteNode[];
10 | parent: LiteElement;
11 | styles: Styles;
12 | constructor(kind: string, attributes?: LiteAttributeList, children?: LiteNode[]);
13 | }
14 |
--------------------------------------------------------------------------------
/mathjax/adaptors/lite/Element.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"Element.js","sourceRoot":"","sources":["../../../ts/adaptors/lite/Element.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CA;IAgCE,qBAAY,IAAY,EAAE,UAAkC,EAAE,QAAyB;;QAA7D,2BAAA,EAAA,eAAkC;QAAE,yBAAA,EAAA,aAAyB;QACrF,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,UAAU,gBAAO,UAAU,CAAC,CAAC;QAClC,IAAI,CAAC,QAAQ,4BAAO,QAAQ,SAAC,CAAC;;YAC9B,KAAoB,IAAA,KAAA,SAAA,IAAI,CAAC,QAAQ,CAAA,gBAAA,4BAAE;gBAA9B,IAAM,KAAK,WAAA;gBACd,KAAK,CAAC,MAAM,GAAG,IAAI,CAAC;aACrB;;;;;;;;;QACD,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;IACrB,CAAC;IACH,kBAAC;AAAD,CAAC,AAzCD,IAyCC;AAzCY,kCAAW"}
--------------------------------------------------------------------------------
/mathjax/adaptors/lite/List.d.ts:
--------------------------------------------------------------------------------
1 | import { LiteNode } from './Element.js';
2 | export declare class LiteList {
3 | nodes: N[];
4 | constructor(children: N[]);
5 | append(node: N): void;
6 | [Symbol.iterator](): Iterator;
7 | }
8 |
--------------------------------------------------------------------------------
/mathjax/adaptors/lite/List.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"List.js","sourceRoot":"","sources":["../../../ts/adaptors/lite/List.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA;IAUE,kBAAY,QAAa;QANlB,UAAK,GAAQ,EAAE,CAAC;QAOrB,IAAI,CAAC,KAAK,4BAAO,QAAQ,SAAC,CAAC;IAC7B,CAAC;IAKM,yBAAM,GAAb,UAAc,IAAO;QACnB,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACxB,CAAC;IAKM,mBAAC,MAAM,CAAC,QAAQ,CAAC,GAAxB;QACE,IAAI,CAAC,GAAG,CAAC,CAAC;QACV,OAAO;YAIL,IAAI,EAAJ;gBACE,OAAO,CAAC,CAAC,KAAK,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;oBACzB,EAAC,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAC,CAAC,CAAC;oBAC3B,EAAC,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,KAAK,EAAC,CAAC,CAAC;YACjD,CAAC;SACF,CAAC;IACJ,CAAC;IAEH,eAAC;AAAD,CAAC,AAtCD,IAsCC;AAtCY,4BAAQ"}
--------------------------------------------------------------------------------
/mathjax/adaptors/lite/Text.d.ts:
--------------------------------------------------------------------------------
1 | import { LiteElement } from './Element.js';
2 | export declare class LiteText {
3 | value: string;
4 | parent: LiteElement;
5 | get kind(): string;
6 | constructor(text?: string);
7 | }
8 | export declare class LiteComment extends LiteText {
9 | get kind(): string;
10 | }
11 |
--------------------------------------------------------------------------------
/mathjax/adaptors/lite/Text.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"Text.js","sourceRoot":"","sources":["../../../ts/adaptors/lite/Text.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AA6BA;IAsBE,kBAAY,IAAiB;QAAjB,qBAAA,EAAA,SAAiB;QAC3B,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;IACpB,CAAC;IAVD,sBAAW,0BAAI;aAAf;YACE,OAAO,OAAO,CAAC;QACjB,CAAC;;;OAAA;IASH,eAAC;AAAD,CAAC,AAzBD,IAyBC;AAzBY,4BAAQ;AA+BrB;IAAiC,+BAAQ;IAAzC;;IAIA,CAAC;IAHC,sBAAW,6BAAI;aAAf;YACE,OAAO,UAAU,CAAC;QACpB,CAAC;;;OAAA;IACH,kBAAC;AAAD,CAAC,AAJD,CAAiC,QAAQ,GAIxC;AAJY,kCAAW"}
--------------------------------------------------------------------------------
/mathjax/adaptors/lite/Window.d.ts:
--------------------------------------------------------------------------------
1 | import { LiteElement } from './Element.js';
2 | import { LiteDocument } from './Document.js';
3 | import { LiteList } from './List.js';
4 | import { LiteParser } from './Parser.js';
5 | export declare class LiteWindow {
6 | document: LiteDocument;
7 | DOMParser: typeof LiteParser;
8 | NodeList: typeof LiteList;
9 | HTMLCollection: typeof LiteList;
10 | HTMLElement: typeof LiteElement;
11 | DocumentFragment: typeof LiteList;
12 | Document: typeof LiteDocument;
13 | constructor();
14 | }
15 |
--------------------------------------------------------------------------------
/mathjax/adaptors/lite/Window.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"Window.js","sourceRoot":"","sources":["../../../ts/adaptors/lite/Window.ts"],"names":[],"mappings":";;;AAuBA,2CAAyC;AACzC,6CAA2C;AAC3C,qCAAmC;AACnC,yCAAuC;AAMvC;IAiCE;QAzBO,cAAS,GAAsB,sBAAU,CAAC;QAI1C,aAAQ,GAAoB,kBAAQ,CAAC;QAIrC,mBAAc,GAAoB,kBAAQ,CAAC;QAI3C,gBAAW,GAAuB,wBAAW,CAAC;QAI9C,qBAAgB,GAAqB,kBAAQ,CAAC;QAI9C,aAAQ,GAAyB,0BAAY,CAAC;QAMnD,IAAI,CAAC,QAAQ,GAAG,IAAI,0BAAY,EAAE,CAAC;IACrC,CAAC;IACH,iBAAC;AAAD,CAAC,AApCD,IAoCC;AApCY,gCAAU"}
--------------------------------------------------------------------------------
/mathjax/components/global.d.ts:
--------------------------------------------------------------------------------
1 | export interface MathJaxConfig {
2 | [name: string]: any;
3 | }
4 | export interface MathJaxLibrary {
5 | [name: string]: any;
6 | }
7 | export interface MathJaxObject {
8 | version: string;
9 | _: MathJaxLibrary;
10 | config: MathJaxConfig;
11 | }
12 | export declare function isObject(x: any): boolean;
13 | export declare function combineConfig(dst: any, src: any): any;
14 | export declare function combineDefaults(dst: any, name: string, src: any): any;
15 | export declare function combineWithMathJax(config: any): MathJaxObject;
16 | export declare const MathJax: MathJaxObject;
17 |
--------------------------------------------------------------------------------
/mathjax/components/latest.d.ts:
--------------------------------------------------------------------------------
1 | export declare function loadLatest(): void;
2 |
--------------------------------------------------------------------------------
/mathjax/components/version.d.ts:
--------------------------------------------------------------------------------
1 | export declare const VERSION = "3.2.2";
2 |
--------------------------------------------------------------------------------
/mathjax/components/version.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | Object.defineProperty(exports, "__esModule", { value: true });
3 | exports.VERSION = void 0;
4 | exports.VERSION = '3.2.2';
5 | //# sourceMappingURL=version.js.map
--------------------------------------------------------------------------------
/mathjax/components/version.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"version.js","sourceRoot":"","sources":["../../ts/components/version.ts"],"names":[],"mappings":";;;AAwBa,QAAA,OAAO,GAAG,OAAO,CAAC"}
--------------------------------------------------------------------------------
/mathjax/core/FindMath.d.ts:
--------------------------------------------------------------------------------
1 | import { OptionList } from '../util/Options.js';
2 | import { ProtoItem } from './MathItem.js';
3 | export interface FindMath {
4 | findMath(node: N): ProtoItem[];
5 | findMath(strings: string[]): ProtoItem[];
6 | }
7 | export declare abstract class AbstractFindMath implements FindMath {
8 | static OPTIONS: OptionList;
9 | protected options: OptionList;
10 | constructor(options: OptionList);
11 | abstract findMath(where: N | string[]): ProtoItem[];
12 | }
13 |
--------------------------------------------------------------------------------
/mathjax/core/FindMath.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | Object.defineProperty(exports, "__esModule", { value: true });
3 | exports.AbstractFindMath = void 0;
4 | var Options_js_1 = require("../util/Options.js");
5 | var AbstractFindMath = (function () {
6 | function AbstractFindMath(options) {
7 | var CLASS = this.constructor;
8 | this.options = (0, Options_js_1.userOptions)((0, Options_js_1.defaultOptions)({}, CLASS.OPTIONS), options);
9 | }
10 | AbstractFindMath.OPTIONS = {};
11 | return AbstractFindMath;
12 | }());
13 | exports.AbstractFindMath = AbstractFindMath;
14 | //# sourceMappingURL=FindMath.js.map
--------------------------------------------------------------------------------
/mathjax/core/FindMath.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"FindMath.js","sourceRoot":"","sources":["../../ts/core/FindMath.ts"],"names":[],"mappings":";;;AAuBA,iDAA2E;AAsC3E;IAeE,0BAAY,OAAmB;QAC7B,IAAI,KAAK,GAAG,IAAI,CAAC,WAAsC,CAAC;QACxD,IAAI,CAAC,OAAO,GAAG,IAAA,wBAAW,EAAC,IAAA,2BAAc,EAAC,EAAE,EAAE,KAAK,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC,CAAC;IACzE,CAAC;IAba,wBAAO,GAAe,EAAE,CAAC;IAuBzC,uBAAC;CAAA,AA5BD,IA4BC;AA5BqB,4CAAgB"}
--------------------------------------------------------------------------------
/mathjax/core/Handler.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"Handler.js","sourceRoot":"","sources":["../../ts/core/Handler.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AAuBA,qDAA8F;AA6D9F;IAA2C,uCAA6B;IAAxE;;IAA0E,CAAC;IAAD,0BAAC;AAAD,CAAC,AAA3E,CAA2C,sCAAoB,GAAY;AAU3E;IA4BE,yBAAY,OAA4B,EAAE,QAAoB;QAApB,yBAAA,EAAA,YAAoB;QAPvD,kBAAa,GAA2D,mBAAmB,CAAC;QAQjG,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAC3B,CAAC;IAKD,sBAAW,iCAAI;aAAf;YACE,OAAQ,IAAI,CAAC,WAAsC,CAAC,IAAI,CAAC;QAC3D,CAAC;;;OAAA;IAKM,yCAAe,GAAtB,UAAuB,SAAc;QACnC,OAAO,KAAK,CAAC;IACf,CAAC;IAKM,gCAAM,GAAb,UAAc,QAAa,EAAE,OAAmB;QAC9C,OAAO,IAAI,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE,IAAI,CAAC,OAAO,EAAE,OAAO,CAA0B,CAAC;IAC1F,CAAC;IA/Ca,oBAAI,GAAW,SAAS,CAAC;IAiDzC,sBAAC;CAAA,AAtDD,IAsDC;AAtDqB,0CAAe"}
--------------------------------------------------------------------------------
/mathjax/core/HandlerList.d.ts:
--------------------------------------------------------------------------------
1 | import { PrioritizedList } from '../util/PrioritizedList.js';
2 | import { OptionList } from '../util/Options.js';
3 | import { Handler } from './Handler.js';
4 | import { MathDocument } from './MathDocument.js';
5 | export declare class HandlerList extends PrioritizedList> {
6 | register(handler: Handler): Handler;
7 | unregister(handler: Handler): void;
8 | handlesDocument(document: any): Handler;
9 | document(document: any, options?: OptionList): MathDocument;
10 | }
11 |
--------------------------------------------------------------------------------
/mathjax/core/MathList.d.ts:
--------------------------------------------------------------------------------
1 | import { LinkedList } from '../util/LinkedList.js';
2 | import { MathItem } from './MathItem.js';
3 | export interface MathList extends LinkedList> {
4 | isBefore(a: MathItem, b: MathItem): boolean;
5 | }
6 | export declare abstract class AbstractMathList extends LinkedList> implements MathList {
7 | isBefore(a: MathItem, b: MathItem): boolean;
8 | }
9 |
--------------------------------------------------------------------------------
/mathjax/core/MathList.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"MathList.js","sourceRoot":"","sources":["../../ts/core/MathList.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AAuBA,uDAAiD;AA6BjD;IACA,oCAA6B;IAD7B;;IAUA,CAAC;IAJQ,mCAAQ,GAAf,UAAgB,CAAoB,EAAE,CAAoB;QACxD,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IACvF,CAAC;IAEH,uBAAC;AAAD,CAAC,AAVD,CACA,0BAAU,GAST;AAVqB,4CAAgB"}
--------------------------------------------------------------------------------
/mathjax/core/MmlTree/LegacyMmlVisitor.d.ts:
--------------------------------------------------------------------------------
1 | import { MmlVisitor } from './MmlVisitor.js';
2 | import { MmlNode, TextNode, XMLNode } from './MmlNode.js';
3 | export declare class LegacyMmlVisitor extends MmlVisitor {
4 | visitTree(node: MmlNode): any;
5 | visitTextNode(node: TextNode, parent: any): void;
6 | visitXMLNode(node: XMLNode, parent: any): void;
7 | visitInferredMrowNode(node: MmlNode, parent: any): void;
8 | visitDefault(node: MmlNode, parent: any): void;
9 | addAttributes(node: MmlNode, mml: any): void;
10 | addProperties(node: MmlNode, mml: any): void;
11 | }
12 |
--------------------------------------------------------------------------------
/mathjax/core/MmlTree/MML.d.ts:
--------------------------------------------------------------------------------
1 | import { MmlNodeClass } from './MmlNode.js';
2 | export declare let MML: {
3 | [kind: string]: MmlNodeClass;
4 | };
5 |
--------------------------------------------------------------------------------
/mathjax/core/MmlTree/MathMLVisitor.d.ts:
--------------------------------------------------------------------------------
1 | import { MmlVisitor } from './MmlVisitor.js';
2 | import { MmlNode, TextNode, XMLNode } from './MmlNode.js';
3 | export declare class MathMLVisitor extends MmlVisitor {
4 | protected document: Document;
5 | visitTree(node: MmlNode, document: Document): Node;
6 | visitTextNode(node: TextNode, parent: Element): void;
7 | visitXMLNode(node: XMLNode, parent: Element): void;
8 | visitInferredMrowNode(node: MmlNode, parent: Element): void;
9 | visitDefault(node: MmlNode, parent: Element): void;
10 | addAttributes(node: MmlNode, mml: Element): void;
11 | }
12 |
--------------------------------------------------------------------------------
/mathjax/core/MmlTree/MmlFactory.d.ts:
--------------------------------------------------------------------------------
1 | import { AbstractNodeFactory } from '../Tree/NodeFactory.js';
2 | import { MmlNode, MmlNodeClass } from './MmlNode.js';
3 | export declare class MmlFactory extends AbstractNodeFactory {
4 | static defaultNodes: {
5 | [kind: string]: MmlNodeClass;
6 | };
7 | get MML(): Object;
8 | }
9 |
--------------------------------------------------------------------------------
/mathjax/core/MmlTree/MmlFactory.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"MmlFactory.js","sourceRoot":"","sources":["../../../ts/core/MmlTree/MmlFactory.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AAuBA,yDAA2D;AAE3D,mCAA6B;AAO7B;IAAgC,8BAA0C;IAA1E;;IAeA,CAAC;IAJC,sBAAI,2BAAG;aAAP;YACE,OAAO,IAAI,CAAC,IAAI,CAAC;QACnB,CAAC;;;OAAA;IARa,uBAAY,GAAG,YAAG,CAAC;IAUnC,iBAAC;CAAA,AAfD,CAAgC,oCAAmB,GAelD;AAfY,gCAAU"}
--------------------------------------------------------------------------------
/mathjax/core/MmlTree/MmlNodes/TeXAtom.d.ts:
--------------------------------------------------------------------------------
1 | import { MmlFactory } from '../MmlFactory.js';
2 | import { PropertyList } from '../../Tree/Node.js';
3 | import { AbstractMmlBaseNode, MmlNode } from '../MmlNode.js';
4 | export declare class TeXAtom extends AbstractMmlBaseNode {
5 | static defaults: PropertyList;
6 | protected texclass: number;
7 | get kind(): string;
8 | get arity(): number;
9 | get notParent(): boolean;
10 | constructor(factory: MmlFactory, attributes: PropertyList, children: MmlNode[]);
11 | setTeXclass(prev: MmlNode): MmlNode;
12 | adjustTeXclass(prev: MmlNode): MmlNode;
13 | }
14 |
--------------------------------------------------------------------------------
/mathjax/core/MmlTree/MmlNodes/maction.d.ts:
--------------------------------------------------------------------------------
1 | import { PropertyList } from '../../Tree/Node.js';
2 | import { MmlNode, AbstractMmlNode } from '../MmlNode.js';
3 | export declare class MmlMaction extends AbstractMmlNode {
4 | static defaults: PropertyList;
5 | get kind(): string;
6 | get arity(): number;
7 | get selected(): MmlNode;
8 | get isEmbellished(): boolean;
9 | get isSpacelike(): boolean;
10 | core(): MmlNode;
11 | coreMO(): MmlNode;
12 | protected verifyAttributes(options: PropertyList): void;
13 | setTeXclass(prev: MmlNode): MmlNode;
14 | nextToggleSelection(): void;
15 | }
16 |
--------------------------------------------------------------------------------
/mathjax/core/MmlTree/MmlNodes/maligngroup.d.ts:
--------------------------------------------------------------------------------
1 | import { PropertyList } from '../../Tree/Node.js';
2 | import { AbstractMmlLayoutNode, AttributeList } from '../MmlNode.js';
3 | export declare class MmlMaligngroup extends AbstractMmlLayoutNode {
4 | static defaults: PropertyList;
5 | get kind(): string;
6 | get isSpacelike(): boolean;
7 | protected setChildInheritedAttributes(attributes: AttributeList, display: boolean, level: number, prime: boolean): void;
8 | }
9 |
--------------------------------------------------------------------------------
/mathjax/core/MmlTree/MmlNodes/maligngroup.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"maligngroup.js","sourceRoot":"","sources":["../../../../ts/core/MmlTree/MmlNodes/maligngroup.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,4CAAmE;AACnE,kDAAyC;AAOzC;IAAoC,kCAAqB;IAAzD;;IAkCA,CAAC;IArBC,sBAAW,gCAAI;aAAf;YACE,OAAO,aAAa,CAAC;QACvB,CAAC;;;OAAA;IAMD,sBAAW,uCAAW;aAAtB;YACE,OAAO,IAAI,CAAC;QACd,CAAC;;;OAAA;IAMS,oDAA2B,GAArC,UAAsC,UAAyB,EAAE,OAAgB,EAAE,KAAa,EAAE,KAAc;QAC9G,UAAU,GAAG,IAAI,CAAC,sBAAsB,CAAC,UAAU,EAAE,IAAI,CAAC,UAAU,CAAC,gBAAgB,EAAE,CAAC,CAAC;QACzF,iBAAM,2BAA2B,YAAC,UAAU,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;IACvE,CAAC;IA3Ba,uBAAQ,yBACjB,kCAAqB,CAAC,QAAQ,KACjC,UAAU,EAAE,uBAAO,IACnB;IA0BJ,qBAAC;CAAA,AAlCD,CAAoC,kCAAqB,GAkCxD;AAlCY,wCAAc"}
--------------------------------------------------------------------------------
/mathjax/core/MmlTree/MmlNodes/malignmark.d.ts:
--------------------------------------------------------------------------------
1 | import { PropertyList } from '../../Tree/Node.js';
2 | import { AbstractMmlNode } from '../MmlNode.js';
3 | export declare class MmlMalignmark extends AbstractMmlNode {
4 | static defaults: PropertyList;
5 | get kind(): string;
6 | get arity(): number;
7 | get isSpacelike(): boolean;
8 | }
9 |
--------------------------------------------------------------------------------
/mathjax/core/MmlTree/MmlNodes/malignmark.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"malignmark.js","sourceRoot":"","sources":["../../../../ts/core/MmlTree/MmlNodes/malignmark.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,4CAA8C;AAO9C;IAAmC,iCAAe;IAAlD;;IAiCA,CAAC;IApBC,sBAAW,+BAAI;aAAf;YACE,OAAO,YAAY,CAAC;QACtB,CAAC;;;OAAA;IAMD,sBAAW,gCAAK;aAAhB;YACE,OAAO,CAAC,CAAC;QACX,CAAC;;;OAAA;IAMD,sBAAW,sCAAW;aAAtB;YACE,OAAO,IAAI,CAAC;QACd,CAAC;;;OAAA;IA1Ba,sBAAQ,yBACjB,4BAAe,CAAC,QAAQ,KAC3B,IAAI,EAAE,MAAM,IACZ;IAyBJ,oBAAC;CAAA,AAjCD,CAAmC,4BAAe,GAiCjD;AAjCY,sCAAa"}
--------------------------------------------------------------------------------
/mathjax/core/MmlTree/MmlNodes/math.d.ts:
--------------------------------------------------------------------------------
1 | import { PropertyList } from '../../Tree/Node.js';
2 | import { AbstractMmlLayoutNode, AttributeList } from '../MmlNode.js';
3 | export declare class MmlMath extends AbstractMmlLayoutNode {
4 | static defaults: PropertyList;
5 | get kind(): string;
6 | get linebreakContainer(): boolean;
7 | protected setChildInheritedAttributes(attributes: AttributeList, display: boolean, level: number, prime: boolean): void;
8 | }
9 |
--------------------------------------------------------------------------------
/mathjax/core/MmlTree/MmlNodes/mathchoice.d.ts:
--------------------------------------------------------------------------------
1 | import { PropertyList } from '../../Tree/Node.js';
2 | import { AbstractMmlBaseNode, AttributeList } from '../MmlNode.js';
3 | export declare class MathChoice extends AbstractMmlBaseNode {
4 | static defaults: PropertyList;
5 | get kind(): string;
6 | get arity(): number;
7 | get notParent(): boolean;
8 | setInheritedAttributes(attributes: AttributeList, display: boolean, level: number, prime: boolean): void;
9 | }
10 |
--------------------------------------------------------------------------------
/mathjax/core/MmlTree/MmlNodes/menclose.d.ts:
--------------------------------------------------------------------------------
1 | import { PropertyList } from '../../Tree/Node.js';
2 | import { MmlNode, AbstractMmlNode } from '../MmlNode.js';
3 | export declare class MmlMenclose extends AbstractMmlNode {
4 | static defaults: PropertyList;
5 | protected texclass: number;
6 | get kind(): string;
7 | get arity(): number;
8 | get linebreakContininer(): boolean;
9 | setTeXclass(prev: MmlNode): MmlNode;
10 | }
11 |
--------------------------------------------------------------------------------
/mathjax/core/MmlTree/MmlNodes/menclose.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"menclose.js","sourceRoot":"","sources":["../../../../ts/core/MmlTree/MmlNodes/menclose.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,4CAAiE;AAOjE;IAAiC,+BAAe;IAAhD;QAAA,qEAgDC;QAnCW,cAAQ,GAAG,qBAAQ,CAAC,GAAG,CAAC;;IAmCpC,CAAC;IA7BC,sBAAW,6BAAI;aAAf;YACE,OAAO,UAAU,CAAC;QACpB,CAAC;;;OAAA;IAMD,sBAAW,8BAAK;aAAhB;YACE,OAAO,CAAC,CAAC,CAAC;QACZ,CAAC;;;OAAA;IAMD,sBAAW,4CAAmB;aAA9B;YACE,OAAO,IAAI,CAAC;QACd,CAAC;;;OAAA;IAKM,iCAAW,GAAlB,UAAmB,IAAa;QAC9B,IAAI,GAAG,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;QAC5C,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;QACxC,OAAO,IAAI,CAAC;IACd,CAAC;IAzCa,oBAAQ,yBACjB,4BAAe,CAAC,QAAQ,KAC3B,QAAQ,EAAE,SAAS,IACnB;IAwCJ,kBAAC;CAAA,AAhDD,CAAiC,4BAAe,GAgD/C;AAhDY,kCAAW"}
--------------------------------------------------------------------------------
/mathjax/core/MmlTree/MmlNodes/merror.d.ts:
--------------------------------------------------------------------------------
1 | import { PropertyList } from '../../Tree/Node.js';
2 | import { AbstractMmlNode } from '../MmlNode.js';
3 | export declare class MmlMerror extends AbstractMmlNode {
4 | static defaults: PropertyList;
5 | protected texclass: number;
6 | get kind(): string;
7 | get arity(): number;
8 | get linebreakContainer(): boolean;
9 | }
10 |
--------------------------------------------------------------------------------
/mathjax/core/MmlTree/MmlNodes/merror.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"merror.js","sourceRoot":"","sources":["../../../../ts/core/MmlTree/MmlNodes/merror.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,4CAAwD;AAOxD;IAA+B,6BAAe;IAA9C;QAAA,qEAqCC;QAzBW,cAAQ,GAAG,qBAAQ,CAAC,GAAG,CAAC;;IAyBpC,CAAC;IApBC,sBAAW,2BAAI;aAAf;YACE,OAAO,QAAQ,CAAC;QAClB,CAAC;;;OAAA;IAMD,sBAAW,4BAAK;aAAhB;YACE,OAAO,CAAC,CAAC,CAAC;QACZ,CAAC;;;OAAA;IAMD,sBAAW,yCAAkB;aAA7B;YACE,OAAO,IAAI,CAAC;QACd,CAAC;;;OAAA;IA9Ba,kBAAQ,gBACjB,4BAAe,CAAC,QAAQ,EAC3B;IA8BJ,gBAAC;CAAA,AArCD,CAA+B,4BAAe,GAqC7C;AArCY,8BAAS"}
--------------------------------------------------------------------------------
/mathjax/core/MmlTree/MmlNodes/mfenced.d.ts:
--------------------------------------------------------------------------------
1 | import { PropertyList } from '../../Tree/Node.js';
2 | import { MmlNode, AbstractMmlNode, AttributeList } from '../MmlNode.js';
3 | export declare class MmlMfenced extends AbstractMmlNode {
4 | static defaults: PropertyList;
5 | protected texclass: number;
6 | separators: MmlNode[];
7 | open: MmlNode;
8 | close: MmlNode;
9 | get kind(): string;
10 | setTeXclass(prev: MmlNode): MmlNode;
11 | protected setChildInheritedAttributes(attributes: AttributeList, display: boolean, level: number, prime: boolean): void;
12 | protected addFakeNodes(): void;
13 | protected fakeNode(c: string, properties?: PropertyList, texClass?: number): MmlNode;
14 | }
15 |
--------------------------------------------------------------------------------
/mathjax/core/MmlTree/MmlNodes/mfrac.d.ts:
--------------------------------------------------------------------------------
1 | import { PropertyList } from '../../Tree/Node.js';
2 | import { MmlNode, AbstractMmlBaseNode, AttributeList } from '../MmlNode.js';
3 | export declare class MmlMfrac extends AbstractMmlBaseNode {
4 | static defaults: PropertyList;
5 | get kind(): string;
6 | get arity(): number;
7 | get linebreakContainer(): boolean;
8 | setTeXclass(prev: MmlNode): this;
9 | protected setChildInheritedAttributes(attributes: AttributeList, display: boolean, level: number, prime: boolean): void;
10 | }
11 |
--------------------------------------------------------------------------------
/mathjax/core/MmlTree/MmlNodes/mglyph.d.ts:
--------------------------------------------------------------------------------
1 | import { PropertyList } from '../../Tree/Node.js';
2 | import { AbstractMmlTokenNode } from '../MmlNode.js';
3 | export declare class MmlMglyph extends AbstractMmlTokenNode {
4 | static defaults: PropertyList;
5 | protected texclass: number;
6 | get kind(): string;
7 | verifyAttributes(options: PropertyList): void;
8 | }
9 |
--------------------------------------------------------------------------------
/mathjax/core/MmlTree/MmlNodes/mi.d.ts:
--------------------------------------------------------------------------------
1 | import { PropertyList } from '../../Tree/Node.js';
2 | import { AbstractMmlTokenNode, AbstractMmlNode, AttributeList } from '../MmlNode.js';
3 | export declare class MmlMi extends AbstractMmlTokenNode {
4 | static defaults: PropertyList;
5 | static operatorName: RegExp;
6 | static singleCharacter: RegExp;
7 | protected texclass: number;
8 | get kind(): string;
9 | setInheritedAttributes(attributes?: AttributeList, display?: boolean, level?: number, prime?: boolean): void;
10 | setTeXclass(prev: AbstractMmlNode): this;
11 | }
12 |
--------------------------------------------------------------------------------
/mathjax/core/MmlTree/MmlNodes/mn.d.ts:
--------------------------------------------------------------------------------
1 | import { PropertyList } from '../../Tree/Node.js';
2 | import { AbstractMmlTokenNode } from '../MmlNode.js';
3 | export declare class MmlMn extends AbstractMmlTokenNode {
4 | static defaults: PropertyList;
5 | protected texclass: number;
6 | get kind(): string;
7 | }
8 |
--------------------------------------------------------------------------------
/mathjax/core/MmlTree/MmlNodes/mn.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"mn.js","sourceRoot":"","sources":["../../../../ts/core/MmlTree/MmlNodes/mn.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,4CAA6D;AAO7D;IAA2B,yBAAoB;IAA/C;QAAA,qEAqBC;QATW,cAAQ,GAAG,qBAAQ,CAAC,GAAG,CAAC;;IASpC,CAAC;IAJC,sBAAW,uBAAI;aAAf;YACE,OAAO,IAAI,CAAC;QACd,CAAC;;;OAAA;IAda,cAAQ,gBACjB,iCAAoB,CAAC,QAAQ,EAChC;IAcJ,YAAC;CAAA,AArBD,CAA2B,iCAAoB,GAqB9C;AArBY,sBAAK"}
--------------------------------------------------------------------------------
/mathjax/core/MmlTree/MmlNodes/mpadded.d.ts:
--------------------------------------------------------------------------------
1 | import { PropertyList } from '../../Tree/Node.js';
2 | import { AbstractMmlLayoutNode } from '../MmlNode.js';
3 | export declare class MmlMpadded extends AbstractMmlLayoutNode {
4 | static defaults: PropertyList;
5 | get kind(): string;
6 | }
7 |
--------------------------------------------------------------------------------
/mathjax/core/MmlTree/MmlNodes/mpadded.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"mpadded.js","sourceRoot":"","sources":["../../../../ts/core/MmlTree/MmlNodes/mpadded.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,4CAAoD;AAOpD;IAAgC,8BAAqB;IAArD;;IAqBA,CAAC;IAJC,sBAAW,4BAAI;aAAf;YACE,OAAO,SAAS,CAAC;QACnB,CAAC;;;OAAA;IAda,mBAAQ,yBACjB,kCAAqB,CAAC,QAAQ,KACjC,KAAK,EAAE,EAAE,EACT,MAAM,EAAE,EAAE,EACV,KAAK,EAAE,EAAE,EACT,MAAM,EAAE,CAAC,EACT,OAAO,EAAE,CAAC,IACV;IASJ,iBAAC;CAAA,AArBD,CAAgC,kCAAqB,GAqBpD;AArBY,gCAAU"}
--------------------------------------------------------------------------------
/mathjax/core/MmlTree/MmlNodes/mphantom.d.ts:
--------------------------------------------------------------------------------
1 | import { PropertyList } from '../../Tree/Node.js';
2 | import { AbstractMmlLayoutNode } from '../MmlNode.js';
3 | export declare class MmlMphantom extends AbstractMmlLayoutNode {
4 | static defaults: PropertyList;
5 | protected texclass: number;
6 | get kind(): string;
7 | }
8 |
--------------------------------------------------------------------------------
/mathjax/core/MmlTree/MmlNodes/mphantom.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"mphantom.js","sourceRoot":"","sources":["../../../../ts/core/MmlTree/MmlNodes/mphantom.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,4CAA8D;AAO9D;IAAiC,+BAAqB;IAAtD;QAAA,qEAqBC;QATW,cAAQ,GAAG,qBAAQ,CAAC,GAAG,CAAC;;IASpC,CAAC;IAJC,sBAAW,6BAAI;aAAf;YACE,OAAO,UAAU,CAAC;QACpB,CAAC;;;OAAA;IAda,oBAAQ,gBACjB,kCAAqB,CAAC,QAAQ,EACjC;IAcJ,kBAAC;CAAA,AArBD,CAAiC,kCAAqB,GAqBrD;AArBY,kCAAW"}
--------------------------------------------------------------------------------
/mathjax/core/MmlTree/MmlNodes/mroot.d.ts:
--------------------------------------------------------------------------------
1 | import { PropertyList } from '../../Tree/Node.js';
2 | import { MmlNode, AbstractMmlNode, AttributeList } from '../MmlNode.js';
3 | export declare class MmlMroot extends AbstractMmlNode {
4 | static defaults: PropertyList;
5 | protected texclass: number;
6 | get kind(): string;
7 | get arity(): number;
8 | setTeXclass(prev: MmlNode): this;
9 | protected setChildInheritedAttributes(attributes: AttributeList, display: boolean, level: number, prime: boolean): void;
10 | }
11 |
--------------------------------------------------------------------------------
/mathjax/core/MmlTree/MmlNodes/ms.d.ts:
--------------------------------------------------------------------------------
1 | import { PropertyList } from '../../Tree/Node.js';
2 | import { AbstractMmlTokenNode } from '../MmlNode.js';
3 | export declare class MmlMs extends AbstractMmlTokenNode {
4 | static defaults: PropertyList;
5 | protected texclass: number;
6 | get kind(): string;
7 | }
8 |
--------------------------------------------------------------------------------
/mathjax/core/MmlTree/MmlNodes/ms.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"ms.js","sourceRoot":"","sources":["../../../../ts/core/MmlTree/MmlNodes/ms.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,4CAA6D;AAO7D;IAA2B,yBAAoB;IAA/C;QAAA,qEAuBC;QATW,cAAQ,GAAG,qBAAQ,CAAC,GAAG,CAAC;;IASpC,CAAC;IAJC,sBAAW,uBAAI;aAAf;YACE,OAAO,IAAI,CAAC;QACd,CAAC;;;OAAA;IAhBa,cAAQ,yBACjB,iCAAoB,CAAC,QAAQ,KAChC,MAAM,EAAE,GAAG,EACX,MAAM,EAAE,GAAG,IACX;IAcJ,YAAC;CAAA,AAvBD,CAA2B,iCAAoB,GAuB9C;AAvBY,sBAAK"}
--------------------------------------------------------------------------------
/mathjax/core/MmlTree/MmlNodes/mspace.d.ts:
--------------------------------------------------------------------------------
1 | import { PropertyList } from '../../Tree/Node.js';
2 | import { MmlNode, AbstractMmlTokenNode } from '../MmlNode.js';
3 | export declare class MmlMspace extends AbstractMmlTokenNode {
4 | static defaults: PropertyList;
5 | protected texclass: number;
6 | setTeXclass(prev: MmlNode): MmlNode;
7 | get kind(): string;
8 | get arity(): number;
9 | get isSpacelike(): boolean;
10 | get hasNewline(): boolean;
11 | }
12 |
--------------------------------------------------------------------------------
/mathjax/core/MmlTree/MmlNodes/msqrt.d.ts:
--------------------------------------------------------------------------------
1 | import { PropertyList } from '../../Tree/Node.js';
2 | import { MmlNode, AbstractMmlNode, AttributeList } from '../MmlNode.js';
3 | export declare class MmlMsqrt extends AbstractMmlNode {
4 | static defaults: PropertyList;
5 | protected texclass: number;
6 | get kind(): string;
7 | get arity(): number;
8 | get linebreakContainer(): boolean;
9 | setTeXclass(prev: MmlNode): this;
10 | protected setChildInheritedAttributes(attributes: AttributeList, display: boolean, level: number, _prime: boolean): void;
11 | }
12 |
--------------------------------------------------------------------------------
/mathjax/core/MmlTree/MmlNodes/mstyle.d.ts:
--------------------------------------------------------------------------------
1 | import { PropertyList } from '../../Tree/Node.js';
2 | import { AbstractMmlLayoutNode, AttributeList } from '../MmlNode.js';
3 | export declare class MmlMstyle extends AbstractMmlLayoutNode {
4 | static defaults: PropertyList;
5 | get kind(): string;
6 | get notParent(): boolean;
7 | protected setChildInheritedAttributes(attributes: AttributeList, display: boolean, level: number, prime: boolean): void;
8 | }
9 |
--------------------------------------------------------------------------------
/mathjax/core/MmlTree/MmlNodes/mtable.d.ts:
--------------------------------------------------------------------------------
1 | import { PropertyList } from '../../Tree/Node.js';
2 | import { MmlNode, AbstractMmlNode, AttributeList } from '../MmlNode.js';
3 | export declare class MmlMtable extends AbstractMmlNode {
4 | static defaults: PropertyList;
5 | properties: {
6 | useHeight: boolean;
7 | };
8 | protected texclass: number;
9 | get kind(): string;
10 | get linebreakContainer(): boolean;
11 | setInheritedAttributes(attributes: AttributeList, display: boolean, level: number, prime: boolean): void;
12 | protected setChildInheritedAttributes(attributes: AttributeList, display: boolean, level: number, _prime: boolean): void;
13 | protected verifyChildren(options: PropertyList): void;
14 | setTeXclass(prev: MmlNode): this;
15 | }
16 |
--------------------------------------------------------------------------------
/mathjax/core/MmlTree/MmlNodes/mtd.d.ts:
--------------------------------------------------------------------------------
1 | import { PropertyList } from '../../Tree/Node.js';
2 | import { AbstractMmlBaseNode, MmlNode } from '../MmlNode.js';
3 | export declare class MmlMtd extends AbstractMmlBaseNode {
4 | static defaults: PropertyList;
5 | get kind(): string;
6 | get arity(): number;
7 | get linebreakContainer(): boolean;
8 | protected verifyChildren(options: PropertyList): void;
9 | setTeXclass(prev: MmlNode): this;
10 | }
11 |
--------------------------------------------------------------------------------
/mathjax/core/MmlTree/MmlNodes/mtext.d.ts:
--------------------------------------------------------------------------------
1 | import { PropertyList } from '../../Tree/Node.js';
2 | import { AbstractMmlTokenNode } from '../MmlNode.js';
3 | export declare class MmlMtext extends AbstractMmlTokenNode {
4 | static defaults: PropertyList;
5 | protected texclass: number;
6 | get kind(): string;
7 | get isSpacelike(): boolean;
8 | }
9 |
--------------------------------------------------------------------------------
/mathjax/core/MmlTree/MmlNodes/mtext.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"mtext.js","sourceRoot":"","sources":["../../../../ts/core/MmlTree/MmlNodes/mtext.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,4CAA6D;AAO7D;IAA8B,4BAAoB;IAAlD;QAAA,qEA6BC;QAjBW,cAAQ,GAAG,qBAAQ,CAAC,GAAG,CAAC;;IAiBpC,CAAC;IAZC,sBAAW,0BAAI;aAAf;YACE,OAAO,OAAO,CAAC;QACjB,CAAC;;;OAAA;IAMD,sBAAW,iCAAW;aAAtB;YACE,OAAO,IAAI,CAAC;QACd,CAAC;;;OAAA;IAtBa,iBAAQ,gBACjB,iCAAoB,CAAC,QAAQ,EAChC;IAsBJ,eAAC;CAAA,AA7BD,CAA8B,iCAAoB,GA6BjD;AA7BY,4BAAQ"}
--------------------------------------------------------------------------------
/mathjax/core/MmlTree/MmlNodes/mtr.d.ts:
--------------------------------------------------------------------------------
1 | import { PropertyList } from '../../Tree/Node.js';
2 | import { MmlNode, AbstractMmlNode, AttributeList } from '../MmlNode.js';
3 | export declare class MmlMtr extends AbstractMmlNode {
4 | static defaults: PropertyList;
5 | get kind(): string;
6 | get linebreakContainer(): boolean;
7 | protected setChildInheritedAttributes(attributes: AttributeList, display: boolean, level: number, prime: boolean): void;
8 | protected verifyChildren(options: PropertyList): void;
9 | setTeXclass(prev: MmlNode): this;
10 | }
11 | export declare class MmlMlabeledtr extends MmlMtr {
12 | get kind(): string;
13 | get arity(): number;
14 | }
15 |
--------------------------------------------------------------------------------
/mathjax/core/MmlTree/MmlVisitor.d.ts:
--------------------------------------------------------------------------------
1 | import { TextNode, XMLNode } from './MmlNode.js';
2 | import { MmlFactory } from './MmlFactory.js';
3 | import { AbstractVisitor } from '../Tree/Visitor.js';
4 | export declare class MmlVisitor extends AbstractVisitor {
5 | constructor(factory?: MmlFactory);
6 | visitTextNode(_node: TextNode, ..._args: any[]): any;
7 | visitXMLNode(_node: XMLNode, ..._args: any[]): any;
8 | }
9 |
--------------------------------------------------------------------------------
/mathjax/core/MmlTree/MmlVisitor.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"MmlVisitor.js","sourceRoot":"","sources":["../../../ts/core/MmlTree/MmlVisitor.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AAwBA,iDAA2C;AAC3C,iDAAmD;AAQnD;IAAgC,8BAAe;IAO7C,oBAAY,OAA0B;QAA1B,wBAAA,EAAA,cAA0B;QACpC,IAAI,CAAC,OAAO,EAAE;YACZ,OAAO,GAAG,IAAI,0BAAU,EAAE,CAAC;SAC5B;eACD,kBAAM,OAAO,CAAC;IAChB,CAAC;IAYM,kCAAa,GAApB,UAAqB,KAAe;QAAE,eAAe;aAAf,UAAe,EAAf,qBAAe,EAAf,IAAe;YAAf,8BAAe;;IAAQ,CAAC;IAOvD,iCAAY,GAAnB,UAAoB,KAAc;QAAE,eAAe;aAAf,UAAe,EAAf,qBAAe,EAAf,IAAe;YAAf,8BAAe;;IAAQ,CAAC;IAE9D,iBAAC;AAAD,CAAC,AAjCD,CAAgC,4BAAe,GAiC9C;AAjCY,gCAAU"}
--------------------------------------------------------------------------------
/mathjax/core/MmlTree/TestMmlVisitor.d.ts:
--------------------------------------------------------------------------------
1 | import { SerializedMmlVisitor } from './SerializedMmlVisitor.js';
2 | import { MmlNode } from './MmlNode.js';
3 | import { PropertyList } from '../Tree/Node.js';
4 | export declare class TestMmlVisitor extends SerializedMmlVisitor {
5 | visitDefault(node: MmlNode, space: string): string;
6 | protected getAttributes(node: MmlNode): string;
7 | protected getInherited(node: MmlNode): string;
8 | protected getProperties(node: MmlNode): string;
9 | protected attributeString(attributes: PropertyList, open: string, close: string): string;
10 | }
11 |
--------------------------------------------------------------------------------
/mathjax/core/Tree/NodeFactory.d.ts:
--------------------------------------------------------------------------------
1 | import { Node, PropertyList } from './Node.js';
2 | import { Factory, FactoryNodeClass, AbstractFactory } from './Factory.js';
3 | export interface NodeFactory> extends Factory {
4 | create(kind: string, properties?: PropertyList, children?: N[]): N;
5 | }
6 | export declare abstract class AbstractNodeFactory> extends AbstractFactory {
7 | create(kind: string, properties?: PropertyList, children?: N[]): N;
8 | }
9 |
--------------------------------------------------------------------------------
/mathjax/core/Tree/NodeFactory.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"NodeFactory.js","sourceRoot":"","sources":["../../../ts/core/Tree/NodeFactory.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AAwBA,2CAAwE;AA0BxE;IAAiG,uCAAqB;IAAtH;;IAQA,CAAC;IAJQ,oCAAM,GAAb,UAAc,IAAY,EAAE,UAA6B,EAAE,QAAkB;QAAjD,2BAAA,EAAA,eAA6B;QAAE,yBAAA,EAAA,aAAkB;QAC3E,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;IAC/C,CAAC;IAEH,0BAAC;AAAD,CAAC,AARD,CAAiG,4BAAe,GAQ/G;AARqB,kDAAmB"}
--------------------------------------------------------------------------------
/mathjax/core/Tree/Wrapper.d.ts:
--------------------------------------------------------------------------------
1 | import { Node } from './Node.js';
2 | import { WrapperFactory } from './WrapperFactory.js';
3 | export interface Wrapper> {
4 | node: N;
5 | readonly kind: string;
6 | wrap(node: N, ...args: any[]): W;
7 | }
8 | export interface WrapperClass> {
9 | new (factory: WrapperFactory>, node: N, ...args: any[]): W;
10 | }
11 | export declare class AbstractWrapper> implements Wrapper {
12 | node: N;
13 | protected factory: WrapperFactory>;
14 | get kind(): string;
15 | constructor(factory: WrapperFactory>, node: N);
16 | wrap(node: N): W;
17 | }
18 |
--------------------------------------------------------------------------------
/mathjax/core/Tree/Wrapper.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | Object.defineProperty(exports, "__esModule", { value: true });
3 | exports.AbstractWrapper = void 0;
4 | var AbstractWrapper = (function () {
5 | function AbstractWrapper(factory, node) {
6 | this.factory = factory;
7 | this.node = node;
8 | }
9 | Object.defineProperty(AbstractWrapper.prototype, "kind", {
10 | get: function () {
11 | return this.node.kind;
12 | },
13 | enumerable: false,
14 | configurable: true
15 | });
16 | AbstractWrapper.prototype.wrap = function (node) {
17 | return this.factory.wrap(node);
18 | };
19 | return AbstractWrapper;
20 | }());
21 | exports.AbstractWrapper = AbstractWrapper;
22 | //# sourceMappingURL=Wrapper.js.map
--------------------------------------------------------------------------------
/mathjax/core/Tree/Wrapper.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"Wrapper.js","sourceRoot":"","sources":["../../../ts/core/Tree/Wrapper.ts"],"names":[],"mappings":";;;AAuEA;IAyBE,yBAAY,OAAiD,EAAE,IAAO;QACpE,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IACnB,CAAC;IAdD,sBAAI,iCAAI;aAAR;YACE,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC;QACxB,CAAC;;;OAAA;IAiBM,8BAAI,GAAX,UAAY,IAAO;QACjB,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACjC,CAAC;IAEH,sBAAC;AAAD,CAAC,AArCD,IAqCC;AArCY,0CAAe"}
--------------------------------------------------------------------------------
/mathjax/core/Tree/WrapperFactory.d.ts:
--------------------------------------------------------------------------------
1 | import { Node } from './Node.js';
2 | import { Wrapper, WrapperClass } from './Wrapper.js';
3 | import { Factory, AbstractFactory } from './Factory.js';
4 | export interface WrapperFactory, C extends WrapperClass> extends Factory {
5 | wrap(node: N, ...args: any[]): W;
6 | }
7 | export declare abstract class AbstractWrapperFactory, C extends WrapperClass> extends AbstractFactory implements WrapperFactory {
8 | wrap(node: N, ...args: any[]): W;
9 | }
10 |
--------------------------------------------------------------------------------
/mathjax/core/Tree/WrapperFactory.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"WrapperFactory.js","sourceRoot":"","sources":["../../../ts/core/Tree/WrapperFactory.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,2CAAsD;AA4BtD;IACQ,0CAAqB;IAD7B;;IAUA,CAAC;IAHQ,qCAAI,GAAX,UAAY,IAAO;QAAE,cAAc;aAAd,UAAc,EAAd,qBAAc,EAAd,IAAc;YAAd,6BAAc;;QACjC,OAAO,IAAI,CAAC,MAAM,OAAX,IAAI,iBAAQ,IAAI,CAAC,IAAI,EAAE,IAAI,UAAK,IAAI,WAAE;IAC/C,CAAC;IACH,6BAAC;AAAD,CAAC,AAVD,CACQ,4BAAe,GAStB;AAVqB,wDAAsB"}
--------------------------------------------------------------------------------
/mathjax/handlers/html.d.ts:
--------------------------------------------------------------------------------
1 | import { HTMLHandler } from './html/HTMLHandler.js';
2 | import { DOMAdaptor } from '../core/DOMAdaptor.js';
3 | export declare function RegisterHTMLHandler(adaptor: DOMAdaptor): HTMLHandler;
4 |
--------------------------------------------------------------------------------
/mathjax/handlers/html.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | Object.defineProperty(exports, "__esModule", { value: true });
3 | exports.RegisterHTMLHandler = void 0;
4 | var mathjax_js_1 = require("../mathjax.js");
5 | var HTMLHandler_js_1 = require("./html/HTMLHandler.js");
6 | function RegisterHTMLHandler(adaptor) {
7 | var handler = new HTMLHandler_js_1.HTMLHandler(adaptor);
8 | mathjax_js_1.mathjax.handlers.register(handler);
9 | return handler;
10 | }
11 | exports.RegisterHTMLHandler = RegisterHTMLHandler;
12 | //# sourceMappingURL=html.js.map
--------------------------------------------------------------------------------
/mathjax/handlers/html.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"html.js","sourceRoot":"","sources":["../../ts/handlers/html.ts"],"names":[],"mappings":";;;AAuBA,4CAAsC;AACtC,wDAAkD;AAalD,SAAgB,mBAAmB,CAAU,OAA4B;IACvE,IAAM,OAAO,GAAG,IAAI,4BAAW,CAAU,OAAO,CAAC,CAAC;IAClD,oBAAO,CAAC,QAAQ,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;IACnC,OAAO,OAAO,CAAC;AACjB,CAAC;AAJD,kDAIC"}
--------------------------------------------------------------------------------
/mathjax/handlers/html/HTMLHandler.d.ts:
--------------------------------------------------------------------------------
1 | import { AbstractHandler } from '../../core/Handler.js';
2 | import { MinHTMLAdaptor } from '../../adaptors/HTMLAdaptor.js';
3 | import { HTMLDocument } from './HTMLDocument.js';
4 | import { OptionList } from '../../util/Options.js';
5 | export declare class HTMLHandler extends AbstractHandler {
6 | adaptor: MinHTMLAdaptor;
7 | documentClass: typeof HTMLDocument;
8 | handlesDocument(document: any): boolean;
9 | create(document: any, options: OptionList): HTMLDocument;
10 | }
11 |
--------------------------------------------------------------------------------
/mathjax/handlers/html/HTMLMathItem.d.ts:
--------------------------------------------------------------------------------
1 | import { AbstractMathItem, Location } from '../../core/MathItem.js';
2 | import { InputJax } from '../../core/InputJax.js';
3 | import { HTMLDocument } from './HTMLDocument.js';
4 | export declare class HTMLMathItem extends AbstractMathItem {
5 | get adaptor(): import("../../core/DOMAdaptor.js").DOMAdaptor;
6 | constructor(math: string, jax: InputJax, display?: boolean, start?: Location, end?: Location);
7 | updateDocument(_html: HTMLDocument): void;
8 | updateStyleSheet(document: HTMLDocument): void;
9 | removeFromDocument(restore?: boolean): void;
10 | }
11 |
--------------------------------------------------------------------------------
/mathjax/handlers/html/HTMLMathList.d.ts:
--------------------------------------------------------------------------------
1 | import { AbstractMathList } from '../../core/MathList.js';
2 | export declare class HTMLMathList extends AbstractMathList {
3 | }
4 |
--------------------------------------------------------------------------------
/mathjax/handlers/html/HTMLMathList.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"HTMLMathList.js","sourceRoot":"","sources":["../../../ts/handlers/html/HTMLMathList.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AAuBA,sDAAwD;AAUxD;IAA2C,gCAAyB;IAApE;;IACA,CAAC;IAAD,mBAAC;AAAD,CAAC,AADD,CAA2C,8BAAgB,GAC1D;AADY,oCAAY"}
--------------------------------------------------------------------------------
/mathjax/input/asciimath.d.ts:
--------------------------------------------------------------------------------
1 | import { AbstractInputJax } from '../core/InputJax.js';
2 | import { OptionList } from '../util/Options.js';
3 | import { MathDocument } from '../core/MathDocument.js';
4 | import { MathItem } from '../core/MathItem.js';
5 | import { FindAsciiMath } from './asciimath/FindAsciiMath.js';
6 | export declare class AsciiMath extends AbstractInputJax {
7 | static NAME: string;
8 | static OPTIONS: OptionList;
9 | protected findAsciiMath: FindAsciiMath;
10 | constructor(options: OptionList);
11 | compile(math: MathItem, _document: MathDocument): any;
12 | findMath(strings: string[]): import("../core/MathItem.js").ProtoItem[];
13 | }
14 |
--------------------------------------------------------------------------------
/mathjax/input/asciimath/mathjax2/input/AsciiMath.d.ts:
--------------------------------------------------------------------------------
1 | export var LegacyAsciiMath: any;
2 |
--------------------------------------------------------------------------------
/mathjax/input/mathml/FindMathML.d.ts:
--------------------------------------------------------------------------------
1 | import { AbstractFindMath } from '../../core/FindMath.js';
2 | import { DOMAdaptor } from '../../core/DOMAdaptor.js';
3 | import { OptionList } from '../../util/Options.js';
4 | import { ProtoItem } from '../../core/MathItem.js';
5 | export declare class FindMathML extends AbstractFindMath {
6 | static OPTIONS: OptionList;
7 | adaptor: DOMAdaptor;
8 | findMath(node: N): ProtoItem[];
9 | protected findMathNodes(node: N, set: Set): void;
10 | protected findMathPrefixed(node: N, set: Set): void;
11 | protected findMathNS(node: N, set: Set): void;
12 | protected processMath(set: Set): ProtoItem[];
13 | }
14 |
--------------------------------------------------------------------------------
/mathjax/input/mathml/mml3/mml3-node.d.ts:
--------------------------------------------------------------------------------
1 | import { MathDocument } from '../../../core/MathDocument.js';
2 | export declare function createTransform(): (node: N, doc: MathDocument) => N;
3 |
--------------------------------------------------------------------------------
/mathjax/input/mathml/mml3/mml3.d.ts:
--------------------------------------------------------------------------------
1 | import { MathItem } from '../../../core/MathItem.js';
2 | import { MathDocument } from '../../../core/MathDocument.js';
3 | import { Handler } from '../../../core/Handler.js';
4 | export declare type FILTERDATA = {
5 | math: MathItem;
6 | document: MathDocument;
7 | data: N;
8 | };
9 | export declare class Mml3 {
10 | static XSLT: string;
11 | protected transform: (node: N, doc: MathDocument) => N;
12 | constructor(document: MathDocument);
13 | mmlFilter(args: FILTERDATA): void;
14 | }
15 | export declare function Mml3Handler(handler: Handler): Handler;
16 |
--------------------------------------------------------------------------------
/mathjax/input/tex/FilterUtil.d.ts:
--------------------------------------------------------------------------------
1 | import ParseOptions from './ParseOptions.js';
2 | declare namespace FilterUtil {
3 | let cleanStretchy: (arg: {
4 | math: any;
5 | data: ParseOptions;
6 | }) => void;
7 | let cleanAttributes: (arg: {
8 | data: ParseOptions;
9 | }) => void;
10 | let combineRelations: (arg: {
11 | data: ParseOptions;
12 | }) => void;
13 | let cleanSubSup: (arg: {
14 | math: any;
15 | data: ParseOptions;
16 | }) => void;
17 | let moveLimits: (arg: {
18 | data: ParseOptions;
19 | }) => void;
20 | let setInherited: (arg: {
21 | math: any;
22 | data: ParseOptions;
23 | }) => void;
24 | }
25 | export default FilterUtil;
26 |
--------------------------------------------------------------------------------
/mathjax/input/tex/ParseMethods.d.ts:
--------------------------------------------------------------------------------
1 | import { Symbol } from './Symbol.js';
2 | import TexParser from './TexParser.js';
3 | declare namespace ParseMethods {
4 | function variable(parser: TexParser, c: string): void;
5 | function digit(parser: TexParser, c: string): void;
6 | function controlSequence(parser: TexParser, _c: string): void;
7 | function mathchar0mi(parser: TexParser, mchar: Symbol): void;
8 | function mathchar0mo(parser: TexParser, mchar: Symbol): void;
9 | function mathchar7(parser: TexParser, mchar: Symbol): void;
10 | function delimiter(parser: TexParser, delim: Symbol): void;
11 | function environment(parser: TexParser, env: string, func: Function, args: any[]): void;
12 | }
13 | export default ParseMethods;
14 |
--------------------------------------------------------------------------------
/mathjax/input/tex/Stack.d.ts:
--------------------------------------------------------------------------------
1 | import { MmlNode } from '../../core/MmlTree/MmlNode.js';
2 | import { StackItem, EnvList } from './StackItem.js';
3 | import StackItemFactory from './StackItemFactory.js';
4 | export default class Stack {
5 | private _factory;
6 | private _env;
7 | global: EnvList;
8 | private stack;
9 | constructor(_factory: StackItemFactory, _env: EnvList, inner: boolean);
10 | set env(env: EnvList);
11 | get env(): EnvList;
12 | Push(...args: (StackItem | MmlNode)[]): void;
13 | Pop(): StackItem;
14 | Top(n?: number): StackItem;
15 | Prev(noPop?: boolean): MmlNode | void;
16 | toString(): string;
17 | }
18 |
--------------------------------------------------------------------------------
/mathjax/input/tex/StackItemFactory.d.ts:
--------------------------------------------------------------------------------
1 | import { StackItemClass, StackItem } from './StackItem.js';
2 | import ParseOptions from './ParseOptions.js';
3 | import { AbstractFactory } from '../../core/Tree/Factory.js';
4 | export default class StackItemFactory extends AbstractFactory {
5 | static DefaultStackItems: {
6 | [kind: string]: StackItemClass;
7 | };
8 | defaultKind: string;
9 | configuration: ParseOptions;
10 | }
11 |
--------------------------------------------------------------------------------
/mathjax/input/tex/StackItemFactory.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"StackItemFactory.js","sourceRoot":"","sources":["../../../ts/input/tex/StackItemFactory.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AAyBA,+CAAmE;AAEnE,yDAA2D;AAG3D;IAAwB,6BAAQ;IAAhC;;IAAkC,CAAC;IAAD,gBAAC;AAAD,CAAC,AAAnC,CAAwB,uBAAQ,GAAG;AASnC;IAA8C,oCAA0C;IAAxF;QAAA,qEAsBC;QATQ,iBAAW,GAAG,OAAO,CAAC;QAOtB,mBAAa,GAAiB,IAAI,CAAC;;IAE5C,CAAC;IAjBe,kCAAiB;QAC7B,GAAC,SAAS,CAAC,SAAS,CAAC,IAAI,IAAG,SAAS;YACrC;IAeJ,uBAAC;CAAA,AAtBD,CAA8C,4BAAe,GAsB5D;kBAtBoB,gBAAgB"}
--------------------------------------------------------------------------------
/mathjax/input/tex/Symbol.d.ts:
--------------------------------------------------------------------------------
1 | import { Args, Attributes, ParseMethod } from './Types.js';
2 | export declare class Symbol {
3 | private _symbol;
4 | private _char;
5 | private _attributes;
6 | constructor(_symbol: string, _char: string, _attributes: Attributes);
7 | get symbol(): string;
8 | get char(): string;
9 | get attributes(): Attributes;
10 | }
11 | export declare class Macro {
12 | private _symbol;
13 | private _func;
14 | private _args;
15 | constructor(_symbol: string, _func: ParseMethod, _args?: Args[]);
16 | get symbol(): string;
17 | get func(): ParseMethod;
18 | get args(): Args[];
19 | }
20 |
--------------------------------------------------------------------------------
/mathjax/input/tex/TexError.d.ts:
--------------------------------------------------------------------------------
1 | export default class TexError {
2 | id: string;
3 | private static pattern;
4 | message: string;
5 | private static processString;
6 | constructor(id: string, message: string, ...rest: string[]);
7 | }
8 |
--------------------------------------------------------------------------------
/mathjax/input/tex/Types.d.ts:
--------------------------------------------------------------------------------
1 | import { StackItem } from './StackItem.js';
2 | import { Symbol } from './Symbol.js';
3 | import TexParser from './TexParser.js';
4 | export declare type Args = boolean | number | string | null;
5 | export declare type Attributes = Record;
6 | export declare type Environment = Record;
7 | export declare type ParseInput = [TexParser, string];
8 | export declare type ParseResult = void | boolean | StackItem;
9 | export declare type ParseMethod = (parser: TexParser, c: string | Symbol | StackItem, ...rest: any[]) => ParseResult;
10 |
--------------------------------------------------------------------------------
/mathjax/input/tex/Types.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | Object.defineProperty(exports, "__esModule", { value: true });
3 | //# sourceMappingURL=Types.js.map
--------------------------------------------------------------------------------
/mathjax/input/tex/Types.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"Types.js","sourceRoot":"","sources":["../../../ts/input/tex/Types.ts"],"names":[],"mappings":""}
--------------------------------------------------------------------------------
/mathjax/input/tex/action/ActionConfiguration.d.ts:
--------------------------------------------------------------------------------
1 | import { Configuration } from '../Configuration.js';
2 | import { ParseMethod } from '../Types.js';
3 | export declare let ActionMethods: Record;
4 | export declare const ActionConfiguration: Configuration;
5 |
--------------------------------------------------------------------------------
/mathjax/input/tex/ams/AmsConfiguration.d.ts:
--------------------------------------------------------------------------------
1 | import { Configuration } from '../Configuration.js';
2 | import { AbstractTags } from '../Tags.js';
3 | import './AmsMappings.js';
4 | export declare class AmsTags extends AbstractTags {
5 | }
6 | export declare const AmsConfiguration: Configuration;
7 |
--------------------------------------------------------------------------------
/mathjax/input/tex/ams/AmsItems.d.ts:
--------------------------------------------------------------------------------
1 | import { ArrayItem, EqnArrayItem } from '../base/BaseItems.js';
2 | export declare class MultlineItem extends ArrayItem {
3 | constructor(factory: any, ...args: any[]);
4 | get kind(): string;
5 | EndEntry(): void;
6 | EndRow(): void;
7 | EndTable(): void;
8 | }
9 | export declare class FlalignItem extends EqnArrayItem {
10 | name: string;
11 | numbered: boolean;
12 | padded: boolean;
13 | center: boolean;
14 | get kind(): string;
15 | constructor(factory: any, name: string, numbered: boolean, padded: boolean, center: boolean);
16 | EndEntry(): void;
17 | EndRow(): void;
18 | EndTable(): void;
19 | }
20 |
--------------------------------------------------------------------------------
/mathjax/input/tex/ams/AmsMappings.d.ts:
--------------------------------------------------------------------------------
1 | export {};
2 |
--------------------------------------------------------------------------------
/mathjax/input/tex/ams/AmsMethods.d.ts:
--------------------------------------------------------------------------------
1 | import { ParseMethod } from '../Types.js';
2 | export declare const AmsMethods: Record;
3 | export declare const NEW_OPS = "ams-declare-ops";
4 |
--------------------------------------------------------------------------------
/mathjax/input/tex/amscd/AmsCdConfiguration.d.ts:
--------------------------------------------------------------------------------
1 | import { Configuration } from '../Configuration.js';
2 | import './AmsCdMappings.js';
3 | export declare const AmsCdConfiguration: Configuration;
4 |
--------------------------------------------------------------------------------
/mathjax/input/tex/amscd/AmsCdConfiguration.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | Object.defineProperty(exports, "__esModule", { value: true });
3 | exports.AmsCdConfiguration = void 0;
4 | var Configuration_js_1 = require("../Configuration.js");
5 | require("./AmsCdMappings.js");
6 | exports.AmsCdConfiguration = Configuration_js_1.Configuration.create('amscd', {
7 | handler: {
8 | character: ['amscd_special'],
9 | macro: ['amscd_macros'],
10 | environment: ['amscd_environment']
11 | },
12 | options: {
13 | amscd: {
14 | colspace: '5pt',
15 | rowspace: '5pt',
16 | harrowsize: '2.75em',
17 | varrowsize: '1.75em',
18 | hideHorizontalLabels: false
19 | }
20 | }
21 | });
22 | //# sourceMappingURL=AmsCdConfiguration.js.map
--------------------------------------------------------------------------------
/mathjax/input/tex/amscd/AmsCdConfiguration.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"AmsCdConfiguration.js","sourceRoot":"","sources":["../../../../ts/input/tex/amscd/AmsCdConfiguration.ts"],"names":[],"mappings":";;;AAwBA,wDAAkD;AAClD,8BAA4B;AAGf,QAAA,kBAAkB,GAAG,gCAAa,CAAC,MAAM,CACpD,OAAO,EAAE;IACP,OAAO,EAAE;QACP,SAAS,EAAE,CAAC,eAAe,CAAC;QAC5B,KAAK,EAAE,CAAC,cAAc,CAAC;QACvB,WAAW,EAAE,CAAC,mBAAmB,CAAC;KACnC;IACD,OAAO,EAAE;QACP,KAAK,EAAE;YACL,QAAQ,EAAE,KAAK;YACf,QAAQ,EAAE,KAAK;YACf,UAAU,EAAE,QAAQ;YACpB,UAAU,EAAE,QAAQ;YACpB,oBAAoB,EAAE,KAAK;SAC5B;KACF;CACF,CACF,CAAC"}
--------------------------------------------------------------------------------
/mathjax/input/tex/amscd/AmsCdMappings.d.ts:
--------------------------------------------------------------------------------
1 | export {};
2 |
--------------------------------------------------------------------------------
/mathjax/input/tex/amscd/AmsCdMappings.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"AmsCdMappings.js","sourceRoot":"","sources":["../../../../ts/input/tex/amscd/AmsCdMappings.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,kDAAsC;AACtC,uEAA8C;AAC9C,sEAA6C;AAG7C,IAAI,EAAE,CAAC,cAAc,CAAC,mBAAmB,EAAE,yBAAY,CAAC,WAAW,EAC7C,EAAC,EAAE,EAAE,IAAI,EAAC,EAAE,yBAAY,CAAC,CAAC;AAEhD,IAAI,EAAE,CAAC,UAAU,CAAC,cAAc,EAAE;IAChC,eAAe,EAAE,iBAAiB;IAClC,gBAAgB,EAAE,kBAAkB;CACrC,EAAE,yBAAY,CAAC,CAAC;AAEjB,IAAI,EAAE,CAAC,QAAQ,CAAC,eAAe,EAAE,EAAC,GAAG,EAAE,OAAO,EAAC,EAAE,yBAAY,CAAC,CAAC"}
--------------------------------------------------------------------------------
/mathjax/input/tex/amscd/AmsCdMethods.d.ts:
--------------------------------------------------------------------------------
1 | import { ParseMethod } from '../Types.js';
2 | declare let AmsCdMethods: Record;
3 | export default AmsCdMethods;
4 |
--------------------------------------------------------------------------------
/mathjax/input/tex/autoload/AutoloadConfiguration.d.ts:
--------------------------------------------------------------------------------
1 | import { Configuration } from '../Configuration.js';
2 | export declare const AutoloadConfiguration: Configuration;
3 |
--------------------------------------------------------------------------------
/mathjax/input/tex/base/BaseConfiguration.d.ts:
--------------------------------------------------------------------------------
1 | import { Configuration } from '../Configuration.js';
2 | import TexParser from '../TexParser.js';
3 | import { AbstractTags } from '../Tags.js';
4 | import './BaseMappings.js';
5 | export declare function Other(parser: TexParser, char: string): void;
6 | export declare class BaseTags extends AbstractTags {
7 | }
8 | export declare const BaseConfiguration: Configuration;
9 |
--------------------------------------------------------------------------------
/mathjax/input/tex/base/BaseMappings.d.ts:
--------------------------------------------------------------------------------
1 | export {};
2 |
--------------------------------------------------------------------------------
/mathjax/input/tex/base/BaseMethods.d.ts:
--------------------------------------------------------------------------------
1 | import { ParseMethod } from '../Types.js';
2 | declare let BaseMethods: Record;
3 | export default BaseMethods;
4 |
--------------------------------------------------------------------------------
/mathjax/input/tex/bbox/BboxConfiguration.d.ts:
--------------------------------------------------------------------------------
1 | import { Configuration } from '../Configuration.js';
2 | import { ParseMethod } from '../Types.js';
3 | export declare let BboxMethods: Record;
4 | export declare const BboxConfiguration: Configuration;
5 |
--------------------------------------------------------------------------------
/mathjax/input/tex/boldsymbol/BoldsymbolConfiguration.d.ts:
--------------------------------------------------------------------------------
1 | import { MmlNode } from '../../../core/MmlTree/MmlNode.js';
2 | import { Configuration } from '../Configuration.js';
3 | import { ParseMethod } from '../Types.js';
4 | import { NodeFactory } from '../NodeFactory.js';
5 | import ParseOptions from '../ParseOptions.js';
6 | export declare let BoldsymbolMethods: Record;
7 | export declare function createBoldToken(factory: NodeFactory, kind: string, def: any, text: string): MmlNode;
8 | export declare function rewriteBoldTokens(arg: {
9 | data: ParseOptions;
10 | }): void;
11 | export declare const BoldsymbolConfiguration: Configuration;
12 |
--------------------------------------------------------------------------------
/mathjax/input/tex/braket/BraketConfiguration.d.ts:
--------------------------------------------------------------------------------
1 | import { Configuration } from '../Configuration.js';
2 | import './BraketMappings.js';
3 | export declare const BraketConfiguration: Configuration;
4 |
--------------------------------------------------------------------------------
/mathjax/input/tex/braket/BraketConfiguration.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | var _a;
3 | Object.defineProperty(exports, "__esModule", { value: true });
4 | exports.BraketConfiguration = void 0;
5 | var Configuration_js_1 = require("../Configuration.js");
6 | var BraketItems_js_1 = require("./BraketItems.js");
7 | require("./BraketMappings.js");
8 | exports.BraketConfiguration = Configuration_js_1.Configuration.create('braket', {
9 | handler: {
10 | character: ['Braket-characters'],
11 | macro: ['Braket-macros']
12 | },
13 | items: (_a = {},
14 | _a[BraketItems_js_1.BraketItem.prototype.kind] = BraketItems_js_1.BraketItem,
15 | _a)
16 | });
17 | //# sourceMappingURL=BraketConfiguration.js.map
--------------------------------------------------------------------------------
/mathjax/input/tex/braket/BraketConfiguration.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"BraketConfiguration.js","sourceRoot":"","sources":["../../../../ts/input/tex/braket/BraketConfiguration.ts"],"names":[],"mappings":";;;;AAwBA,wDAAkD;AAClD,mDAA4C;AAC5C,+BAA6B;AAGhB,QAAA,mBAAmB,GAAG,gCAAa,CAAC,MAAM,CACrD,QAAQ,EAAE;IACR,OAAO,EAAE;QACP,SAAS,EAAE,CAAC,mBAAmB,CAAC;QAChC,KAAK,EAAE,CAAC,eAAe,CAAC;KACzB;IACD,KAAK;QACH,GAAC,2BAAU,CAAC,SAAS,CAAC,IAAI,IAAG,2BAAU;WACxC;CACF,CACF,CAAC"}
--------------------------------------------------------------------------------
/mathjax/input/tex/braket/BraketItems.d.ts:
--------------------------------------------------------------------------------
1 | import { CheckType, BaseItem, StackItem } from '../StackItem.js';
2 | export declare class BraketItem extends BaseItem {
3 | get kind(): string;
4 | get isOpen(): boolean;
5 | checkItem(item: StackItem): CheckType;
6 | toMml(): import("../../../core/MmlTree/MmlNode.js").MmlNode;
7 | }
8 |
--------------------------------------------------------------------------------
/mathjax/input/tex/braket/BraketMappings.d.ts:
--------------------------------------------------------------------------------
1 | export {};
2 |
--------------------------------------------------------------------------------
/mathjax/input/tex/braket/BraketMethods.d.ts:
--------------------------------------------------------------------------------
1 | import { ParseMethod } from '../Types.js';
2 | declare let BraketMethods: Record;
3 | export default BraketMethods;
4 |
--------------------------------------------------------------------------------
/mathjax/input/tex/bussproofs/BussproofsConfiguration.d.ts:
--------------------------------------------------------------------------------
1 | import { Configuration } from '../Configuration.js';
2 | import './BussproofsMappings.js';
3 | export declare const BussproofsConfiguration: Configuration;
4 |
--------------------------------------------------------------------------------
/mathjax/input/tex/bussproofs/BussproofsConfiguration.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"BussproofsConfiguration.js","sourceRoot":"","sources":["../../../../ts/input/tex/bussproofs/BussproofsConfiguration.ts"],"names":[],"mappings":";;;;AAwBA,wDAAkD;AAClD,2DAAmD;AACnD,yDAAkG;AAClG,mCAAiC;AAGpB,QAAA,uBAAuB,GAAG,gCAAa,CAAC,MAAM,CACzD,YAAY,EAAE;IACZ,OAAO,EAAE;QACP,KAAK,EAAE,CAAC,mBAAmB,CAAC;QAC5B,WAAW,EAAE,CAAC,yBAAyB,CAAC;KACzC;IACD,KAAK;QACH,GAAC,kCAAa,CAAC,SAAS,CAAC,IAAI,IAAG,kCAAa;WAC9C;IACD,aAAa,EAAE;QACb,CAAC,gCAAY,EAAE,CAAC,CAAC;KAClB;IACD,cAAc,EAAE;QACd,CAAC,iCAAa,EAAE,CAAC,CAAC;QAClB,CAAC,sCAAkB,EAAE,CAAC,CAAC;QACvB,CAAC,gCAAY,EAAE,CAAC,CAAC;KAClB;CACF,CACF,CAAC"}
--------------------------------------------------------------------------------
/mathjax/input/tex/bussproofs/BussproofsItems.d.ts:
--------------------------------------------------------------------------------
1 | import { BaseItem, CheckType, StackItem } from '../StackItem.js';
2 | import { MmlNode } from '../../../core/MmlTree/MmlNode.js';
3 | export declare class ProofTreeItem extends BaseItem {
4 | leftLabel: MmlNode[];
5 | rigthLabel: MmlNode[];
6 | private innerStack;
7 | get kind(): string;
8 | checkItem(item: StackItem): CheckType;
9 | toMml(): MmlNode;
10 | }
11 |
--------------------------------------------------------------------------------
/mathjax/input/tex/bussproofs/BussproofsMappings.d.ts:
--------------------------------------------------------------------------------
1 | export {};
2 |
--------------------------------------------------------------------------------
/mathjax/input/tex/bussproofs/BussproofsMethods.d.ts:
--------------------------------------------------------------------------------
1 | import { ParseMethod } from '../Types.js';
2 | declare let BussproofsMethods: Record;
3 | export default BussproofsMethods;
4 |
--------------------------------------------------------------------------------
/mathjax/input/tex/cancel/CancelConfiguration.d.ts:
--------------------------------------------------------------------------------
1 | import { Configuration } from '../Configuration.js';
2 | import { ParseMethod } from '../Types.js';
3 | export declare let CancelMethods: Record;
4 | export declare const CancelConfiguration: Configuration;
5 |
--------------------------------------------------------------------------------
/mathjax/input/tex/centernot/CenternotConfiguration.d.ts:
--------------------------------------------------------------------------------
1 | import { Configuration } from '../Configuration.js';
2 | import ParseOptions from '../ParseOptions.js';
3 | export declare function filterCenterOver({ data }: {
4 | data: ParseOptions;
5 | }): void;
6 | export declare const CenternotConfiguration: Configuration;
7 |
--------------------------------------------------------------------------------
/mathjax/input/tex/color/ColorConfiguration.d.ts:
--------------------------------------------------------------------------------
1 | import { Configuration } from '../Configuration.js';
2 | export declare const ColorConfiguration: Configuration;
3 |
--------------------------------------------------------------------------------
/mathjax/input/tex/color/ColorConfiguration.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"ColorConfiguration.js","sourceRoot":"","sources":["../../../../ts/input/tex/color/ColorConfiguration.ts"],"names":[],"mappings":";;;AAwBA,gDAA2C;AAC3C,wDAAuE;AACvE,qDAA+C;AAC/C,+CAA0C;AAM1C,IAAI,yBAAU,CAAC,OAAO,EAAE;IACtB,KAAK,EAAE,OAAO;IACd,SAAS,EAAE,WAAW;IACtB,WAAW,EAAE,aAAa;IAC1B,QAAQ,EAAE,UAAU;IACpB,SAAS,EAAE,WAAW;CACvB,EAAE,8BAAY,CAAC,CAAC;AAQjB,IAAM,MAAM,GAAG,UAAS,OAA4B,EAAE,GAAuB;IAC3E,GAAG,CAAC,YAAY,CAAC,WAAW,CAAC,GAAG,CAAC,OAAO,EAAE,EAAC,KAAK,EAAE,IAAI,yBAAU,EAAE,EAAC,CAAC,CAAC;AACvE,CAAC,CAAC;AAKW,QAAA,kBAAkB,GAAG,gCAAa,CAAC,MAAM,CACpD,OAAO,EAAE;IACP,OAAO,EAAE;QACP,KAAK,EAAE,CAAC,OAAO,CAAC;KACjB;IACD,OAAO,EAAE;QACP,KAAK,EAAE;YACL,OAAO,EAAE,KAAK;YACd,WAAW,EAAE,KAAK;SACnB;KACF;IACD,MAAM,EAAE,MAAM;CACf,CACF,CAAC"}
--------------------------------------------------------------------------------
/mathjax/input/tex/color/ColorConstants.d.ts:
--------------------------------------------------------------------------------
1 | export declare const COLORS: Map;
2 |
--------------------------------------------------------------------------------
/mathjax/input/tex/color/ColorMethods.d.ts:
--------------------------------------------------------------------------------
1 | import { ParseMethod } from '../Types.js';
2 | export declare const ColorMethods: Record;
3 |
--------------------------------------------------------------------------------
/mathjax/input/tex/color/ColorUtil.d.ts:
--------------------------------------------------------------------------------
1 | export declare class ColorModel {
2 | private userColors;
3 | private normalizeColor;
4 | getColor(model: string, def: string): string;
5 | private getColorByName;
6 | defineColor(model: string, name: string, def: string): void;
7 | }
8 |
--------------------------------------------------------------------------------
/mathjax/input/tex/colortbl/ColortblConfiguration.d.ts:
--------------------------------------------------------------------------------
1 | import { ArrayItem } from '../base/BaseItems.js';
2 | import { Configuration } from '../Configuration.js';
3 | import { MmlNode } from '../../../core/MmlTree/MmlNode.js';
4 | export interface ColorData {
5 | cell: string;
6 | row: string;
7 | col: string[];
8 | }
9 | export declare class ColorArrayItem extends ArrayItem {
10 | color: ColorData;
11 | hasColor: boolean;
12 | EndEntry(): void;
13 | EndRow(): void;
14 | createMml(): MmlNode;
15 | }
16 | export declare const ColortblConfiguration: Configuration;
17 |
--------------------------------------------------------------------------------
/mathjax/input/tex/colorv2/ColorV2Configuration.d.ts:
--------------------------------------------------------------------------------
1 | import { Configuration } from '../Configuration.js';
2 | import { ParseMethod } from '../Types.js';
3 | export declare const ColorV2Methods: Record;
4 | export declare const ColorConfiguration: Configuration;
5 |
--------------------------------------------------------------------------------
/mathjax/input/tex/configmacros/ConfigMacrosConfiguration.d.ts:
--------------------------------------------------------------------------------
1 | import { Configuration } from '../Configuration.js';
2 | export declare const ConfigMacrosConfiguration: Configuration;
3 |
--------------------------------------------------------------------------------
/mathjax/input/tex/empheq/EmpheqConfiguration.d.ts:
--------------------------------------------------------------------------------
1 | import { Configuration } from '../Configuration.js';
2 | import TexParser from '../TexParser.js';
3 | import { BeginItem } from '../base/BaseItems.js';
4 | import { StackItem } from '../StackItem.js';
5 | export declare class EmpheqBeginItem extends BeginItem {
6 | get kind(): string;
7 | checkItem(item: StackItem): import("../StackItem.js").CheckType;
8 | }
9 | export declare const EmpheqMethods: {
10 | Empheq(parser: TexParser, begin: EmpheqBeginItem): void;
11 | EmpheqMO(parser: TexParser, _name: string, c: string): void;
12 | EmpheqDelim(parser: TexParser, name: string): void;
13 | };
14 | export declare const EmpheqConfiguration: Configuration;
15 |
--------------------------------------------------------------------------------
/mathjax/input/tex/enclose/EncloseConfiguration.d.ts:
--------------------------------------------------------------------------------
1 | import { Configuration } from '../Configuration.js';
2 | import { ParseMethod } from '../Types.js';
3 | export declare const ENCLOSE_OPTIONS: {
4 | [key: string]: number;
5 | };
6 | export declare let EncloseMethods: Record;
7 | export declare const EncloseConfiguration: Configuration;
8 |
--------------------------------------------------------------------------------
/mathjax/input/tex/extpfeil/ExtpfeilConfiguration.d.ts:
--------------------------------------------------------------------------------
1 | import { Configuration } from '../Configuration.js';
2 | import { ParseMethod } from '../Types.js';
3 | export declare let ExtpfeilMethods: Record;
4 | export declare const ExtpfeilConfiguration: Configuration;
5 |
--------------------------------------------------------------------------------
/mathjax/input/tex/gensymb/GensymbConfiguration.d.ts:
--------------------------------------------------------------------------------
1 | import { Configuration } from '../Configuration.js';
2 | export declare const GensymbConfiguration: Configuration;
3 |
--------------------------------------------------------------------------------
/mathjax/input/tex/html/HtmlConfiguration.d.ts:
--------------------------------------------------------------------------------
1 | import { Configuration } from '../Configuration.js';
2 | export declare const HtmlConfiguration: Configuration;
3 |
--------------------------------------------------------------------------------
/mathjax/input/tex/html/HtmlConfiguration.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"HtmlConfiguration.js","sourceRoot":"","sources":["../../../../ts/input/tex/html/HtmlConfiguration.ts"],"names":[],"mappings":";;;;;;AAwBA,wDAAkD;AAClD,gDAA2C;AAC3C,oEAA2C;AAG3C,IAAI,yBAAU,CAAC,aAAa,EAAE;IAC5B,IAAI,EAAK,MAAM;IACf,OAAO,EAAE,OAAO;IAChB,KAAK,EAAI,OAAO;IAChB,KAAK,EAAI,IAAI;CACd,EAAE,wBAAW,CAAC,CAAC;AAEH,QAAA,iBAAiB,GAAG,gCAAa,CAAC,MAAM,CACnD,MAAM,EAAE,EAAC,OAAO,EAAE,EAAE,KAAK,EAAE,CAAC,aAAa,CAAC,EAAC,EAAC,CAC7C,CAAC"}
--------------------------------------------------------------------------------
/mathjax/input/tex/html/HtmlMethods.d.ts:
--------------------------------------------------------------------------------
1 | import { ParseMethod } from '../Types.js';
2 | declare let HtmlMethods: Record;
3 | export default HtmlMethods;
4 |
--------------------------------------------------------------------------------
/mathjax/input/tex/mathtools/MathtoolsConfiguration.d.ts:
--------------------------------------------------------------------------------
1 | import { Configuration } from '../Configuration.js';
2 | import ParseOptions from '../ParseOptions.js';
3 | import './MathtoolsMappings.js';
4 | export declare const PAIREDDELIMS = "mathtools-paired-delims";
5 | export declare function fixPrescripts({ data }: {
6 | data: ParseOptions;
7 | }): void;
8 | export declare const MathtoolsConfiguration: Configuration;
9 |
--------------------------------------------------------------------------------
/mathjax/input/tex/mathtools/MathtoolsItems.d.ts:
--------------------------------------------------------------------------------
1 | import { MultlineItem } from '../ams/AmsItems.js';
2 | export declare class MultlinedItem extends MultlineItem {
3 | get kind(): string;
4 | EndTable(): void;
5 | }
6 |
--------------------------------------------------------------------------------
/mathjax/input/tex/mathtools/MathtoolsMappings.d.ts:
--------------------------------------------------------------------------------
1 | export {};
2 |
--------------------------------------------------------------------------------
/mathjax/input/tex/mathtools/MathtoolsMethods.d.ts:
--------------------------------------------------------------------------------
1 | import { ParseMethod } from '../Types.js';
2 | export declare const MathtoolsMethods: Record;
3 |
--------------------------------------------------------------------------------
/mathjax/input/tex/mathtools/MathtoolsTags.d.ts:
--------------------------------------------------------------------------------
1 | import { ParserConfiguration } from '../Configuration.js';
2 | import { TeX } from '../../tex.js';
3 | import { AbstractTags } from '../Tags.js';
4 | export declare type MathtoolsTags = AbstractTags & {
5 | mtFormats: Map;
6 | mtCurrent: [string, string, string];
7 | };
8 | export declare function MathtoolsTagFormat(config: ParserConfiguration, jax: TeX): void;
9 |
--------------------------------------------------------------------------------
/mathjax/input/tex/mathtools/MathtoolsUtil.d.ts:
--------------------------------------------------------------------------------
1 | import { EqnArrayItem } from '../base/BaseItems.js';
2 | import TexParser from '../TexParser.js';
3 | import ParseOptions from '../ParseOptions.js';
4 | import { MmlNode } from '../../../core/MmlTree/MmlNode.js';
5 | export declare const MathtoolsUtil: {
6 | setDisplayLevel(mml: MmlNode, style: string): void;
7 | checkAlignment(parser: TexParser, name: string): EqnArrayItem;
8 | addPairedDelims(config: ParseOptions, cs: string, args: string[]): void;
9 | spreadLines(mtable: MmlNode, spread: string): void;
10 | plusOrMinus(name: string, n: string): string;
11 | getScript(parser: TexParser, name: string, pos: string): MmlNode;
12 | };
13 |
--------------------------------------------------------------------------------
/mathjax/input/tex/mhchem/MhchemConfiguration.d.ts:
--------------------------------------------------------------------------------
1 | import { Configuration } from '../Configuration.js';
2 | export declare const MhchemConfiguration: Configuration;
3 |
--------------------------------------------------------------------------------
/mathjax/input/tex/newcommand/NewcommandConfiguration.d.ts:
--------------------------------------------------------------------------------
1 | import { Configuration } from '../Configuration.js';
2 | import './NewcommandMappings.js';
3 | export declare const NewcommandConfiguration: Configuration;
4 |
--------------------------------------------------------------------------------
/mathjax/input/tex/newcommand/NewcommandItems.d.ts:
--------------------------------------------------------------------------------
1 | import { CheckType, BaseItem, StackItem } from '../StackItem.js';
2 | export declare class BeginEnvItem extends BaseItem {
3 | get kind(): string;
4 | get isOpen(): boolean;
5 | checkItem(item: StackItem): CheckType;
6 | }
7 |
--------------------------------------------------------------------------------
/mathjax/input/tex/newcommand/NewcommandMappings.d.ts:
--------------------------------------------------------------------------------
1 | export {};
2 |
--------------------------------------------------------------------------------
/mathjax/input/tex/newcommand/NewcommandMappings.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | var __importDefault = (this && this.__importDefault) || function (mod) {
3 | return (mod && mod.__esModule) ? mod : { "default": mod };
4 | };
5 | Object.defineProperty(exports, "__esModule", { value: true });
6 | var NewcommandMethods_js_1 = __importDefault(require("./NewcommandMethods.js"));
7 | var SymbolMap_js_1 = require("../SymbolMap.js");
8 | new SymbolMap_js_1.CommandMap('Newcommand-macros', {
9 | newcommand: 'NewCommand',
10 | renewcommand: 'NewCommand',
11 | newenvironment: 'NewEnvironment',
12 | renewenvironment: 'NewEnvironment',
13 | def: 'MacroDef',
14 | 'let': 'Let'
15 | }, NewcommandMethods_js_1.default);
16 | //# sourceMappingURL=NewcommandMappings.js.map
--------------------------------------------------------------------------------
/mathjax/input/tex/newcommand/NewcommandMappings.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"NewcommandMappings.js","sourceRoot":"","sources":["../../../../ts/input/tex/newcommand/NewcommandMappings.ts"],"names":[],"mappings":";;;;;AAwBA,gFAAuD;AACvD,gDAA2C;AAM3C,IAAI,yBAAU,CAAC,mBAAmB,EAAE;IAClC,UAAU,EAAQ,YAAY;IAC9B,YAAY,EAAM,YAAY;IAC9B,cAAc,EAAI,gBAAgB;IAClC,gBAAgB,EAAE,gBAAgB;IAClC,GAAG,EAAe,UAAU;IAC5B,KAAK,EAAa,KAAK;CACxB,EAAE,8BAAiB,CAAC,CAAC"}
--------------------------------------------------------------------------------
/mathjax/input/tex/newcommand/NewcommandMethods.d.ts:
--------------------------------------------------------------------------------
1 | import { ParseMethod } from '../Types.js';
2 | declare let NewcommandMethods: Record;
3 | export default NewcommandMethods;
4 |
--------------------------------------------------------------------------------
/mathjax/input/tex/noerrors/NoErrorsConfiguration.d.ts:
--------------------------------------------------------------------------------
1 | import { Configuration } from '../Configuration.js';
2 | export declare const NoErrorsConfiguration: Configuration;
3 |
--------------------------------------------------------------------------------
/mathjax/input/tex/noerrors/NoErrorsConfiguration.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | Object.defineProperty(exports, "__esModule", { value: true });
3 | exports.NoErrorsConfiguration = void 0;
4 | var Configuration_js_1 = require("../Configuration.js");
5 | function noErrors(factory, message, _id, expr) {
6 | var mtext = factory.create('token', 'mtext', {}, expr.replace(/\n/g, ' '));
7 | var error = factory.create('node', 'merror', [mtext], { 'data-mjx-error': message, title: message });
8 | return error;
9 | }
10 | exports.NoErrorsConfiguration = Configuration_js_1.Configuration.create('noerrors', { nodes: { 'error': noErrors } });
11 | //# sourceMappingURL=NoErrorsConfiguration.js.map
--------------------------------------------------------------------------------
/mathjax/input/tex/noerrors/NoErrorsConfiguration.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"NoErrorsConfiguration.js","sourceRoot":"","sources":["../../../../ts/input/tex/noerrors/NoErrorsConfiguration.ts"],"names":[],"mappings":";;;AAwBA,wDAAkD;AAUlD,SAAS,QAAQ,CAAC,OAAoB,EACpB,OAAe,EAAE,GAAW,EAAE,IAAY;IAC1D,IAAI,KAAK,GAAG,OAAO,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,EAAE,EAAE,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,CAAC;IAC3E,IAAI,KAAK,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,EAAE,CAAC,KAAK,CAAC,EAAE,EAAC,gBAAgB,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAC,CAAC,CAAC;IACnG,OAAO,KAAK,CAAC;AACf,CAAC;AAEY,QAAA,qBAAqB,GAAG,gCAAa,CAAC,MAAM,CACvD,UAAU,EAAE,EAAC,KAAK,EAAE,EAAC,OAAO,EAAE,QAAQ,EAAC,EAAC,CACzC,CAAC"}
--------------------------------------------------------------------------------
/mathjax/input/tex/noundefined/NoUndefinedConfiguration.d.ts:
--------------------------------------------------------------------------------
1 | import { Configuration } from '../Configuration.js';
2 | export declare const NoUndefinedConfiguration: Configuration;
3 |
--------------------------------------------------------------------------------
/mathjax/input/tex/physics/PhysicsConfiguration.d.ts:
--------------------------------------------------------------------------------
1 | import { Configuration } from '../Configuration.js';
2 | import './PhysicsMappings.js';
3 | export declare const PhysicsConfiguration: Configuration;
4 |
--------------------------------------------------------------------------------
/mathjax/input/tex/physics/PhysicsConfiguration.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"PhysicsConfiguration.js","sourceRoot":"","sources":["../../../../ts/input/tex/physics/PhysicsConfiguration.ts"],"names":[],"mappings":";;;;AAwBA,wDAAkD;AAClD,qDAA2C;AAC3C,gCAA8B;AAGjB,QAAA,oBAAoB,GAAG,gCAAa,CAAC,MAAM,CACtD,SAAS,EAAE;IACT,OAAO,EAAE;QACP,KAAK,EAAE;YACL,kCAAkC;YAClC,uBAAuB;YACvB,mBAAmB;YACnB,mBAAmB;YACnB,2BAA2B;YAC3B,4BAA4B;YAC5B,2BAA2B;YAC3B,wBAAwB;YACxB,uBAAuB;SACxB;QACD,SAAS,EAAE,CAAC,oBAAoB,CAAC;QACjC,WAAW,EAAE,CAAC,kBAAkB,CAAC;KAClC;IACD,KAAK;QACH,GAAC,0BAAQ,CAAC,SAAS,CAAC,IAAI,IAAG,0BAAQ;WACpC;IACD,OAAO,EAAE;QACP,OAAO,EAAE;YACP,UAAU,EAAE,KAAK;YACjB,QAAQ,EAAE,KAAK;SAChB;KACF;CACF,CACF,CAAC"}
--------------------------------------------------------------------------------
/mathjax/input/tex/physics/PhysicsItems.d.ts:
--------------------------------------------------------------------------------
1 | import { CheckType, BaseItem, StackItem } from '../StackItem.js';
2 | export declare class AutoOpen extends BaseItem {
3 | protected static errors: any;
4 | protected openCount: number;
5 | get kind(): string;
6 | get isOpen(): boolean;
7 | toMml(): import("../../../core/MmlTree/MmlNode.js").MmlNode;
8 | checkItem(item: StackItem): CheckType;
9 | }
10 |
--------------------------------------------------------------------------------
/mathjax/input/tex/physics/PhysicsMappings.d.ts:
--------------------------------------------------------------------------------
1 | export {};
2 |
--------------------------------------------------------------------------------
/mathjax/input/tex/physics/PhysicsMethods.d.ts:
--------------------------------------------------------------------------------
1 | import { ParseMethod } from '../Types.js';
2 | declare let PhysicsMethods: Record;
3 | export default PhysicsMethods;
4 |
--------------------------------------------------------------------------------
/mathjax/input/tex/require/RequireConfiguration.d.ts:
--------------------------------------------------------------------------------
1 | import { Configuration } from '../Configuration.js';
2 | import TexParser from '../TexParser.js';
3 | import { ParseMethod } from '../Types.js';
4 | export declare function RequireLoad(parser: TexParser, name: string): void;
5 | export declare const RequireMethods: Record;
6 | export declare const options: {
7 | require: {
8 | allow: any;
9 | defaultAllow: boolean;
10 | prefix: string;
11 | };
12 | };
13 | export declare const RequireConfiguration: Configuration;
14 |
--------------------------------------------------------------------------------
/mathjax/input/tex/setoptions/SetOptionsConfiguration.d.ts:
--------------------------------------------------------------------------------
1 | import { Configuration } from '../Configuration.js';
2 | import TexParser from '../TexParser.js';
3 | export declare const SetOptionsUtil: {
4 | filterPackage(parser: TexParser, extension: string): boolean;
5 | filterOption(parser: TexParser, extension: string, option: string): boolean;
6 | filterValue(_parser: TexParser, _extension: string, _option: string, value: string): string;
7 | };
8 | export declare const SetOptionsConfiguration: Configuration;
9 |
--------------------------------------------------------------------------------
/mathjax/input/tex/tagformat/TagFormatConfiguration.d.ts:
--------------------------------------------------------------------------------
1 | import { Configuration, ParserConfiguration } from '../Configuration.js';
2 | import { TeX } from '../../tex.js';
3 | export declare function tagformatConfig(config: ParserConfiguration, jax: TeX): void;
4 | export declare const TagFormatConfiguration: Configuration;
5 |
--------------------------------------------------------------------------------
/mathjax/input/tex/textcomp/TextcompConfiguration.d.ts:
--------------------------------------------------------------------------------
1 | import { Configuration } from '../Configuration.js';
2 | import './TextcompMappings.js';
3 | export declare const TextcompConfiguration: Configuration;
4 |
--------------------------------------------------------------------------------
/mathjax/input/tex/textcomp/TextcompConfiguration.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | Object.defineProperty(exports, "__esModule", { value: true });
3 | exports.TextcompConfiguration = void 0;
4 | var Configuration_js_1 = require("../Configuration.js");
5 | require("./TextcompMappings.js");
6 | exports.TextcompConfiguration = Configuration_js_1.Configuration.create('textcomp', {
7 | handler: { macro: ['textcomp-macros'] }
8 | });
9 | //# sourceMappingURL=TextcompConfiguration.js.map
--------------------------------------------------------------------------------
/mathjax/input/tex/textcomp/TextcompConfiguration.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"TextcompConfiguration.js","sourceRoot":"","sources":["../../../../ts/input/tex/textcomp/TextcompConfiguration.ts"],"names":[],"mappings":";;;AAwBA,wDAAkD;AAClD,iCAA+B;AAGlB,QAAA,qBAAqB,GAAG,gCAAa,CAAC,MAAM,CACvD,UAAU,EAAE;IACV,OAAO,EAAE,EAAC,KAAK,EAAE,CAAC,iBAAiB,CAAC,EAAC;CACtC,CACF,CAAC"}
--------------------------------------------------------------------------------
/mathjax/input/tex/textcomp/TextcompMappings.d.ts:
--------------------------------------------------------------------------------
1 | export {};
2 |
--------------------------------------------------------------------------------
/mathjax/input/tex/textmacros/TextMacrosConfiguration.d.ts:
--------------------------------------------------------------------------------
1 | import { Configuration } from '../Configuration.js';
2 | import './TextMacrosMappings.js';
3 | export declare const TextBaseConfiguration: Configuration;
4 | export declare const TextMacrosConfiguration: Configuration;
5 |
--------------------------------------------------------------------------------
/mathjax/input/tex/textmacros/TextMacrosMappings.d.ts:
--------------------------------------------------------------------------------
1 | export {};
2 |
--------------------------------------------------------------------------------
/mathjax/input/tex/unicode/UnicodeConfiguration.d.ts:
--------------------------------------------------------------------------------
1 | import { Configuration } from '../Configuration.js';
2 | import { ParseMethod } from '../Types.js';
3 | export declare let UnicodeMethods: Record;
4 | export declare const UnicodeConfiguration: Configuration;
5 |
--------------------------------------------------------------------------------
/mathjax/input/tex/upgreek/UpgreekConfiguration.d.ts:
--------------------------------------------------------------------------------
1 | import { Configuration } from '../Configuration.js';
2 | export declare const UpgreekConfiguration: Configuration;
3 |
--------------------------------------------------------------------------------
/mathjax/input/tex/verb/VerbConfiguration.d.ts:
--------------------------------------------------------------------------------
1 | import { Configuration } from '../Configuration.js';
2 | import { ParseMethod } from '../Types.js';
3 | export declare let VerbMethods: Record;
4 | export declare const VerbConfiguration: Configuration;
5 |
--------------------------------------------------------------------------------
/mathjax/mathjax.d.ts:
--------------------------------------------------------------------------------
1 | import { HandlerList } from './core/HandlerList.js';
2 | import { handleRetriesFor, retryAfter } from './util/Retries.js';
3 | import { OptionList } from './util/Options.js';
4 | import { MathDocument } from './core/MathDocument.js';
5 | export declare const mathjax: {
6 | version: string;
7 | handlers: HandlerList;
8 | document: (document: any, options: OptionList) => MathDocument;
9 | handleRetriesFor: typeof handleRetriesFor;
10 | retryAfter: typeof retryAfter;
11 | asyncLoad: (file: string) => any;
12 | };
13 |
--------------------------------------------------------------------------------
/mathjax/mathjax.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | Object.defineProperty(exports, "__esModule", { value: true });
3 | exports.mathjax = void 0;
4 | var version_js_1 = require("./components/version.js");
5 | var HandlerList_js_1 = require("./core/HandlerList.js");
6 | var Retries_js_1 = require("./util/Retries.js");
7 | exports.mathjax = {
8 | version: version_js_1.VERSION,
9 | handlers: new HandlerList_js_1.HandlerList(),
10 | document: function (document, options) {
11 | return exports.mathjax.handlers.document(document, options);
12 | },
13 | handleRetriesFor: Retries_js_1.handleRetriesFor,
14 | retryAfter: Retries_js_1.retryAfter,
15 | asyncLoad: null,
16 | };
17 | //# sourceMappingURL=mathjax.js.map
--------------------------------------------------------------------------------
/mathjax/output/chtml/Usage.d.ts:
--------------------------------------------------------------------------------
1 | export declare class Usage {
2 | protected used: Set;
3 | protected needsUpdate: T[];
4 | add(item: T): void;
5 | has(item: T): boolean;
6 | clear(): void;
7 | update(): T[];
8 | }
9 |
--------------------------------------------------------------------------------
/mathjax/output/chtml/WrapperFactory.d.ts:
--------------------------------------------------------------------------------
1 | import { CHTML } from '../chtml.js';
2 | import { CommonWrapperFactory } from '../common/WrapperFactory.js';
3 | import { CHTMLWrapper, CHTMLWrapperClass } from './Wrapper.js';
4 | import { CHTMLCharOptions, CHTMLDelimiterData, CHTMLFontData } from './FontData.js';
5 | export declare class CHTMLWrapperFactory extends CommonWrapperFactory, CHTMLWrapper, CHTMLWrapperClass, CHTMLCharOptions, CHTMLDelimiterData, CHTMLFontData> {
6 | static defaultNodes: {
7 | [kind: string]: import("../common/Wrapper.js").WrapperConstructor;
8 | };
9 | jax: CHTML;
10 | }
11 |
--------------------------------------------------------------------------------
/mathjax/output/chtml/WrapperFactory.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"WrapperFactory.js","sourceRoot":"","sources":["../../../ts/output/chtml/WrapperFactory.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AAwBA,iEAAiE;AAEjE,6CAA4C;AAW5C;IACA,uCAOC;IARD;;IAoBA,CAAC;IAPe,gCAAY,GAAG,2BAAa,CAAC;IAO7C,0BAAC;CAAA,AApBD,CACA,wCAAoB,GAmBnB;AApBY,kDAAmB"}
--------------------------------------------------------------------------------
/mathjax/output/chtml/Wrappers.d.ts:
--------------------------------------------------------------------------------
1 | import { WrapperConstructor } from '../common/Wrapper.js';
2 | export declare const CHTMLWrappers: {
3 | [kind: string]: WrapperConstructor;
4 | };
5 |
--------------------------------------------------------------------------------
/mathjax/output/chtml/Wrappers/TeXAtom.d.ts:
--------------------------------------------------------------------------------
1 | import { CHTMLConstructor } from '../Wrapper.js';
2 | declare const CHTMLTeXAtom_base: import("../../common/Wrappers/TeXAtom.js").TeXAtomConstructor & CHTMLConstructor;
3 | export declare class CHTMLTeXAtom extends CHTMLTeXAtom_base {
4 | static kind: string;
5 | toCHTML(parent: N): void;
6 | }
7 | export {};
8 |
--------------------------------------------------------------------------------
/mathjax/output/chtml/Wrappers/TextNode.d.ts:
--------------------------------------------------------------------------------
1 | import { CHTMLConstructor } from '../Wrapper.js';
2 | import { StyleList } from '../../../util/StyleList.js';
3 | declare const CHTMLTextNode_base: import("../../common/Wrappers/TextNode.js").TextNodeConstructor & CHTMLConstructor;
4 | export declare class CHTMLTextNode extends CHTMLTextNode_base {
5 | static kind: string;
6 | static autoStyle: boolean;
7 | static styles: StyleList;
8 | toCHTML(parent: N): void;
9 | }
10 | export {};
11 |
--------------------------------------------------------------------------------
/mathjax/output/chtml/Wrappers/math.d.ts:
--------------------------------------------------------------------------------
1 | import { CHTMLConstructor } from '../Wrapper.js';
2 | import { StyleList } from '../../../util/StyleList.js';
3 | declare const CHTMLmath_base: import("../../common/Wrappers/math.js").MathConstructor & CHTMLConstructor;
4 | export declare class CHTMLmath extends CHTMLmath_base {
5 | static kind: string;
6 | static styles: StyleList;
7 | toCHTML(parent: N): void;
8 | protected handleDisplay(parent: N): void;
9 | protected handleInline(parent: N): void;
10 | setChildPWidths(recompute: boolean, w?: number, clear?: boolean): boolean;
11 | }
12 | export {};
13 |
--------------------------------------------------------------------------------
/mathjax/output/chtml/Wrappers/mfenced.d.ts:
--------------------------------------------------------------------------------
1 | import { CHTMLConstructor } from '../Wrapper.js';
2 | declare const CHTMLmfenced_base: import("../../common/Wrappers/mfenced.js").MfencedConstructor & CHTMLConstructor;
3 | export declare class CHTMLmfenced extends CHTMLmfenced_base {
4 | static kind: string;
5 | toCHTML(parent: N): void;
6 | }
7 | export {};
8 |
--------------------------------------------------------------------------------
/mathjax/output/chtml/Wrappers/mfenced.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"mfenced.js","sourceRoot":"","sources":["../../../../ts/output/chtml/Wrappers/mfenced.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AAuBA,4CAA6D;AAC7D,+DAAoE;AACpE,wEAAqE;AAWrE;IAA2C,gCAAiE;IAA5G;;IAeA,CAAC;IALQ,8BAAO,GAAd,UAAe,MAAS;QACtB,IAAM,KAAK,GAAG,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAC;QAC5C,IAAI,CAAC,IAAmC,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;IAC3D,CAAC;IARa,iBAAI,GAAG,uBAAU,CAAC,SAAS,CAAC,IAAI,CAAC;IAUjD,mBAAC;CAAA,AAfD,CAA2C,IAAA,+BAAkB,EAAkC,yBAAY,CAAC,GAe3G;AAfY,oCAAY"}
--------------------------------------------------------------------------------
/mathjax/output/chtml/Wrappers/mfrac.d.ts:
--------------------------------------------------------------------------------
1 | import { CHTMLConstructor } from '../Wrapper.js';
2 | import { CHTMLmo } from './mo.js';
3 | import { StyleList } from '../../../util/StyleList.js';
4 | declare const CHTMLmfrac_base: import("../../common/Wrappers/mfrac.js").MfracConstructor & CHTMLConstructor;
5 | export declare class CHTMLmfrac extends CHTMLmfrac_base {
6 | static kind: string;
7 | static styles: StyleList;
8 | bevel: CHTMLmo;
9 | toCHTML(parent: N): void;
10 | protected makeFraction(display: boolean, t: number): void;
11 | protected makeAtop(display: boolean): void;
12 | protected makeBevelled(display: boolean): void;
13 | }
14 | export {};
15 |
--------------------------------------------------------------------------------
/mathjax/output/chtml/Wrappers/mglyph.d.ts:
--------------------------------------------------------------------------------
1 | import { CHTMLConstructor } from '../Wrapper.js';
2 | import { StyleList } from '../../../util/StyleList.js';
3 | declare const CHTMLmglyph_base: import("../../common/Wrappers/mglyph.js").MglyphConstructor & CHTMLConstructor;
4 | export declare class CHTMLmglyph extends CHTMLmglyph_base {
5 | static kind: string;
6 | static styles: StyleList;
7 | toCHTML(parent: N): void;
8 | }
9 | export {};
10 |
--------------------------------------------------------------------------------
/mathjax/output/chtml/Wrappers/mi.d.ts:
--------------------------------------------------------------------------------
1 | import { CHTMLConstructor } from '../Wrapper.js';
2 | declare const CHTMLmi_base: import("../../common/Wrappers/mi.js").MiConstructor & CHTMLConstructor;
3 | export declare class CHTMLmi extends CHTMLmi_base {
4 | static kind: string;
5 | }
6 | export {};
7 |
--------------------------------------------------------------------------------
/mathjax/output/chtml/Wrappers/mi.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"mi.js","sourceRoot":"","sources":["../../../../ts/output/chtml/Wrappers/mi.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AAuBA,4CAA6D;AAC7D,qDAA0D;AAC1D,8DAA2D;AAW3D;IACA,2BAA4D;IAD5D;;IAQA,CAAC;IAFe,YAAI,GAAG,aAAK,CAAC,SAAS,CAAC,IAAI,CAAC;IAE5C,cAAC;CAAA,AARD,CACA,IAAA,qBAAa,EAAkC,yBAAY,CAAC,GAO3D;AARY,0BAAO"}
--------------------------------------------------------------------------------
/mathjax/output/chtml/Wrappers/mmultiscripts.d.ts:
--------------------------------------------------------------------------------
1 | import { CHTMLWrapper, Constructor } from '../Wrapper.js';
2 | import { CHTMLmsubsup } from './msubsup.js';
3 | import { BBox } from '../../../util/BBox.js';
4 | import { StyleList } from '../../../util/StyleList.js';
5 | declare const CHTMLmmultiscripts_base: import("../../common/Wrappers/mmultiscripts.js").MmultiscriptsConstructor> & Constructor>;
6 | export declare class CHTMLmmultiscripts extends CHTMLmmultiscripts_base {
7 | static kind: string;
8 | static styles: StyleList;
9 | toCHTML(parent: N): void;
10 | protected addScripts(u: number, v: number, isPre: boolean, sub: BBox, sup: BBox, i: number, n: number): N;
11 | }
12 | export {};
13 |
--------------------------------------------------------------------------------
/mathjax/output/chtml/Wrappers/mn.d.ts:
--------------------------------------------------------------------------------
1 | import { CHTMLConstructor } from '../Wrapper.js';
2 | declare const CHTMLmn_base: import("../../common/Wrappers/mn.js").MnConstructor & CHTMLConstructor;
3 | export declare class CHTMLmn extends CHTMLmn_base {
4 | static kind: string;
5 | }
6 | export {};
7 |
--------------------------------------------------------------------------------
/mathjax/output/chtml/Wrappers/mn.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"mn.js","sourceRoot":"","sources":["../../../../ts/output/chtml/Wrappers/mn.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AAuBA,4CAA6D;AAC7D,qDAA0D;AAC1D,8DAA2D;AAW3D;IACA,2BAA4D;IAD5D;;IAQA,CAAC;IAFe,YAAI,GAAG,aAAK,CAAC,SAAS,CAAC,IAAI,CAAC;IAE5C,cAAC;CAAA,AARD,CACA,IAAA,qBAAa,EAAkC,yBAAY,CAAC,GAO3D;AARY,0BAAO"}
--------------------------------------------------------------------------------
/mathjax/output/chtml/Wrappers/mo.d.ts:
--------------------------------------------------------------------------------
1 | import { CHTMLConstructor } from '../Wrapper.js';
2 | import { StyleList } from '../../../util/StyleList.js';
3 | declare const CHTMLmo_base: import("../../common/Wrappers/mo.js").MoConstructor & CHTMLConstructor;
4 | export declare class CHTMLmo extends CHTMLmo_base {
5 | static kind: string;
6 | static styles: StyleList;
7 | toCHTML(parent: N): void;
8 | protected stretchHTML(chtml: N): void;
9 | }
10 | export {};
11 |
--------------------------------------------------------------------------------
/mathjax/output/chtml/Wrappers/mpadded.d.ts:
--------------------------------------------------------------------------------
1 | import { CHTMLConstructor } from '../Wrapper.js';
2 | import { StyleList } from '../../../util/StyleList.js';
3 | declare const CHTMLmpadded_base: import("../../common/Wrappers/mpadded.js").MpaddedConstructor & CHTMLConstructor;
4 | export declare class CHTMLmpadded extends CHTMLmpadded_base {
5 | static kind: string;
6 | static styles: StyleList;
7 | toCHTML(parent: N): void;
8 | }
9 | export {};
10 |
--------------------------------------------------------------------------------
/mathjax/output/chtml/Wrappers/mroot.d.ts:
--------------------------------------------------------------------------------
1 | import { CHTMLWrapper } from '../Wrapper.js';
2 | import { MrootConstructor } from '../../common/Wrappers/mroot.js';
3 | import { BBox } from '../../../util/BBox.js';
4 | declare const CHTMLmroot_base: MrootConstructor;
5 | export declare class CHTMLmroot extends CHTMLmroot_base {
6 | static kind: string;
7 | protected addRoot(ROOT: N, root: CHTMLWrapper, sbox: BBox, H: number): void;
8 | }
9 | export {};
10 |
--------------------------------------------------------------------------------
/mathjax/output/chtml/Wrappers/mrow.d.ts:
--------------------------------------------------------------------------------
1 | import { CHTMLConstructor, Constructor } from '../Wrapper.js';
2 | declare const CHTMLmrow_base: import("../../common/Wrappers/mrow.js").MrowConstructor & CHTMLConstructor;
3 | export declare class CHTMLmrow extends CHTMLmrow_base {
4 | static kind: string;
5 | toCHTML(parent: N): void;
6 | }
7 | declare const CHTMLinferredMrow_base: import("../../common/Wrappers/mrow.js").InferredMrowConstructor & Constructor>;
8 | export declare class CHTMLinferredMrow extends CHTMLinferredMrow_base {
9 | static kind: string;
10 | }
11 | export {};
12 |
--------------------------------------------------------------------------------
/mathjax/output/chtml/Wrappers/ms.d.ts:
--------------------------------------------------------------------------------
1 | import { CHTMLConstructor } from '../Wrapper.js';
2 | declare const CHTMLms_base: import("../../common/Wrappers/ms.js").MsConstructor & CHTMLConstructor;
3 | export declare class CHTMLms extends CHTMLms_base {
4 | static kind: string;
5 | }
6 | export {};
7 |
--------------------------------------------------------------------------------
/mathjax/output/chtml/Wrappers/ms.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"ms.js","sourceRoot":"","sources":["../../../../ts/output/chtml/Wrappers/ms.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AAuBA,4CAA6D;AAC7D,qDAA0D;AAC1D,8DAA2D;AAW3D;IACA,2BAA4D;IAD5D;;IAQA,CAAC;IAFe,YAAI,GAAG,aAAK,CAAC,SAAS,CAAC,IAAI,CAAC;IAE5C,cAAC;CAAA,AARD,CACA,IAAA,qBAAa,EAAkC,yBAAY,CAAC,GAO3D;AARY,0BAAO"}
--------------------------------------------------------------------------------
/mathjax/output/chtml/Wrappers/mspace.d.ts:
--------------------------------------------------------------------------------
1 | import { CHTMLConstructor } from '../Wrapper.js';
2 | declare const CHTMLmspace_base: import("../../common/Wrappers/mspace.js").MspaceConstructor & CHTMLConstructor;
3 | export declare class CHTMLmspace extends CHTMLmspace_base {
4 | static kind: string;
5 | toCHTML(parent: N): void;
6 | }
7 | export {};
8 |
--------------------------------------------------------------------------------
/mathjax/output/chtml/Wrappers/msqrt.d.ts:
--------------------------------------------------------------------------------
1 | import { CHTMLWrapper, CHTMLConstructor } from '../Wrapper.js';
2 | import { BBox } from '../../../util/BBox.js';
3 | import { StyleList } from '../../../util/StyleList.js';
4 | declare const CHTMLmsqrt_base: import("../../common/Wrappers/msqrt.js").MsqrtConstructor & CHTMLConstructor;
5 | export declare class CHTMLmsqrt extends CHTMLmsqrt_base {
6 | static kind: string;
7 | static styles: StyleList;
8 | toCHTML(parent: N): void;
9 | protected addRoot(_ROOT: N, _root: CHTMLWrapper, _sbox: BBox, _H: number): void;
10 | }
11 | export {};
12 |
--------------------------------------------------------------------------------
/mathjax/output/chtml/Wrappers/mtd.d.ts:
--------------------------------------------------------------------------------
1 | import { CHTMLConstructor } from '../Wrapper.js';
2 | import { StyleList } from '../../../util/StyleList.js';
3 | declare const CHTMLmtd_base: import("../../common/Wrappers/mtd.js").MtdConstructor & CHTMLConstructor;
4 | export declare class CHTMLmtd extends CHTMLmtd_base {
5 | static kind: string;
6 | static styles: StyleList;
7 | toCHTML(parent: N): void;
8 | }
9 | export {};
10 |
--------------------------------------------------------------------------------
/mathjax/output/chtml/Wrappers/mtext.d.ts:
--------------------------------------------------------------------------------
1 | import { CHTMLConstructor } from '../Wrapper.js';
2 | declare const CHTMLmtext_base: import("../../common/Wrappers/mtext.js").MtextConstructor & CHTMLConstructor;
3 | export declare class CHTMLmtext extends CHTMLmtext_base {
4 | static kind: string;
5 | }
6 | export {};
7 |
--------------------------------------------------------------------------------
/mathjax/output/chtml/Wrappers/mtext.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"mtext.js","sourceRoot":"","sources":["../../../../ts/output/chtml/Wrappers/mtext.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AAuBA,4CAA6D;AAC7D,2DAAgE;AAChE,oEAAiE;AAWjE;IACA,8BAA+D;IAD/D;;IAQA,CAAC;IAFe,eAAI,GAAG,mBAAQ,CAAC,SAAS,CAAC,IAAI,CAAC;IAE/C,iBAAC;CAAA,AARD,CACA,IAAA,2BAAgB,EAAkC,yBAAY,CAAC,GAO9D;AARY,gCAAU"}
--------------------------------------------------------------------------------
/mathjax/output/chtml/Wrappers/scriptbase.d.ts:
--------------------------------------------------------------------------------
1 | import { CHTMLWrapper, CHTMLConstructor } from '../Wrapper.js';
2 | import { BBox } from '../../../util/BBox.js';
3 | declare const CHTMLscriptbase_base: import("../../common/Wrappers/scriptbase.js").ScriptbaseConstructor> & CHTMLConstructor;
4 | export declare class CHTMLscriptbase extends CHTMLscriptbase_base {
5 | static kind: string;
6 | toCHTML(parent: N): void;
7 | protected setDeltaW(nodes: N[], dx: number[]): void;
8 | protected adjustOverDepth(over: N, overbox: BBox): void;
9 | protected adjustUnderDepth(under: N, underbox: BBox): void;
10 | protected adjustBaseHeight(base: N, basebox: BBox): void;
11 | }
12 | export {};
13 |
--------------------------------------------------------------------------------
/mathjax/output/chtml/fonts/tex/bold-italic.d.ts:
--------------------------------------------------------------------------------
1 | import { CHTMLCharMap } from '../../FontData.js';
2 | export declare const boldItalic: CHTMLCharMap;
3 |
--------------------------------------------------------------------------------
/mathjax/output/chtml/fonts/tex/bold-italic.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | Object.defineProperty(exports, "__esModule", { value: true });
3 | exports.boldItalic = void 0;
4 | var FontData_js_1 = require("../../FontData.js");
5 | var bold_italic_js_1 = require("../../../common/fonts/tex/bold-italic.js");
6 | exports.boldItalic = (0, FontData_js_1.AddCSS)(bold_italic_js_1.boldItalic, {
7 | 0x131: { f: 'B' },
8 | 0x237: { f: 'B' },
9 | 0x2044: { c: '/' },
10 | 0x2206: { c: '\\394' },
11 | 0x29F8: { c: '/' },
12 | });
13 | //# sourceMappingURL=bold-italic.js.map
--------------------------------------------------------------------------------
/mathjax/output/chtml/fonts/tex/bold-italic.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"bold-italic.js","sourceRoot":"","sources":["../../../../../ts/output/chtml/fonts/tex/bold-italic.ts"],"names":[],"mappings":";;;AAgBA,iDAAuD;AACvD,2EAA4E;AAE/D,QAAA,UAAU,GAAiB,IAAA,oBAAM,EAAC,2BAAI,EAAE;IACjD,KAAK,EAAE,EAAC,CAAC,EAAE,GAAG,EAAC;IACf,KAAK,EAAE,EAAC,CAAC,EAAE,GAAG,EAAC;IACf,MAAM,EAAE,EAAC,CAAC,EAAE,GAAG,EAAC;IAChB,MAAM,EAAE,EAAC,CAAC,EAAE,OAAO,EAAC;IACpB,MAAM,EAAE,EAAC,CAAC,EAAE,GAAG,EAAC;CACnB,CAAC,CAAC"}
--------------------------------------------------------------------------------
/mathjax/output/chtml/fonts/tex/bold.d.ts:
--------------------------------------------------------------------------------
1 | import { CHTMLCharMap } from '../../FontData.js';
2 | export declare const bold: CHTMLCharMap;
3 |
--------------------------------------------------------------------------------
/mathjax/output/chtml/fonts/tex/double-struck.d.ts:
--------------------------------------------------------------------------------
1 | export { doubleStruck } from '../../../common/fonts/tex/double-struck.js';
2 |
--------------------------------------------------------------------------------
/mathjax/output/chtml/fonts/tex/double-struck.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | Object.defineProperty(exports, "__esModule", { value: true });
3 | exports.doubleStruck = void 0;
4 | var double_struck_js_1 = require("../../../common/fonts/tex/double-struck.js");
5 | Object.defineProperty(exports, "doubleStruck", { enumerable: true, get: function () { return double_struck_js_1.doubleStruck; } });
6 | //# sourceMappingURL=double-struck.js.map
--------------------------------------------------------------------------------
/mathjax/output/chtml/fonts/tex/double-struck.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"double-struck.js","sourceRoot":"","sources":["../../../../../ts/output/chtml/fonts/tex/double-struck.ts"],"names":[],"mappings":";;;AAgBA,+EAAwE;AAAhE,gHAAA,YAAY,OAAA"}
--------------------------------------------------------------------------------
/mathjax/output/chtml/fonts/tex/fraktur-bold.d.ts:
--------------------------------------------------------------------------------
1 | import { CHTMLCharMap } from '../../FontData.js';
2 | export declare const frakturBold: CHTMLCharMap;
3 |
--------------------------------------------------------------------------------
/mathjax/output/chtml/fonts/tex/fraktur-bold.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | Object.defineProperty(exports, "__esModule", { value: true });
3 | exports.frakturBold = void 0;
4 | var FontData_js_1 = require("../../FontData.js");
5 | var fraktur_bold_js_1 = require("../../../common/fonts/tex/fraktur-bold.js");
6 | exports.frakturBold = (0, FontData_js_1.AddCSS)(fraktur_bold_js_1.frakturBold, {
7 | 0x2044: { c: '/' },
8 | });
9 | //# sourceMappingURL=fraktur-bold.js.map
--------------------------------------------------------------------------------
/mathjax/output/chtml/fonts/tex/fraktur-bold.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"fraktur-bold.js","sourceRoot":"","sources":["../../../../../ts/output/chtml/fonts/tex/fraktur-bold.ts"],"names":[],"mappings":";;;AAgBA,iDAAuD;AACvD,6EAA8E;AAEjE,QAAA,WAAW,GAAiB,IAAA,oBAAM,EAAC,6BAAI,EAAE;IAClD,MAAM,EAAE,EAAC,CAAC,EAAE,GAAG,EAAC;CACnB,CAAC,CAAC"}
--------------------------------------------------------------------------------
/mathjax/output/chtml/fonts/tex/fraktur.d.ts:
--------------------------------------------------------------------------------
1 | import { CHTMLCharMap } from '../../FontData.js';
2 | export declare const fraktur: CHTMLCharMap;
3 |
--------------------------------------------------------------------------------
/mathjax/output/chtml/fonts/tex/fraktur.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | Object.defineProperty(exports, "__esModule", { value: true });
3 | exports.fraktur = void 0;
4 | var FontData_js_1 = require("../../FontData.js");
5 | var fraktur_js_1 = require("../../../common/fonts/tex/fraktur.js");
6 | exports.fraktur = (0, FontData_js_1.AddCSS)(fraktur_js_1.fraktur, {
7 | 0x2044: { c: '/' },
8 | });
9 | //# sourceMappingURL=fraktur.js.map
--------------------------------------------------------------------------------
/mathjax/output/chtml/fonts/tex/fraktur.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"fraktur.js","sourceRoot":"","sources":["../../../../../ts/output/chtml/fonts/tex/fraktur.ts"],"names":[],"mappings":";;;AAgBA,iDAAuD;AACvD,mEAAqE;AAExD,QAAA,OAAO,GAAiB,IAAA,oBAAM,EAAC,oBAAI,EAAE;IAC9C,MAAM,EAAE,EAAC,CAAC,EAAE,GAAG,EAAC;CACnB,CAAC,CAAC"}
--------------------------------------------------------------------------------
/mathjax/output/chtml/fonts/tex/italic.d.ts:
--------------------------------------------------------------------------------
1 | import { CHTMLCharMap } from '../../FontData.js';
2 | export declare const italic: CHTMLCharMap;
3 |
--------------------------------------------------------------------------------
/mathjax/output/chtml/fonts/tex/italic.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | Object.defineProperty(exports, "__esModule", { value: true });
3 | exports.italic = void 0;
4 | var FontData_js_1 = require("../../FontData.js");
5 | var italic_js_1 = require("../../../common/fonts/tex/italic.js");
6 | exports.italic = (0, FontData_js_1.AddCSS)(italic_js_1.italic, {
7 | 0x2F: { f: 'I' },
8 | 0x3DD: { c: '\\E008', f: 'A' },
9 | 0x2015: { c: '\\2014' },
10 | 0x2017: { c: '_' },
11 | 0x2044: { c: '/', f: 'I' },
12 | 0x2206: { c: '\\394', f: 'I' },
13 | 0x29F8: { c: '/', f: 'I' },
14 | });
15 | //# sourceMappingURL=italic.js.map
--------------------------------------------------------------------------------
/mathjax/output/chtml/fonts/tex/italic.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"italic.js","sourceRoot":"","sources":["../../../../../ts/output/chtml/fonts/tex/italic.ts"],"names":[],"mappings":";;;AAgBA,iDAAuD;AACvD,iEAAmE;AAEtD,QAAA,MAAM,GAAiB,IAAA,oBAAM,EAAC,kBAAI,EAAE;IAC7C,IAAI,EAAE,EAAC,CAAC,EAAE,GAAG,EAAC;IACd,KAAK,EAAE,EAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,GAAG,EAAC;IAC5B,MAAM,EAAE,EAAC,CAAC,EAAE,QAAQ,EAAC;IACrB,MAAM,EAAE,EAAC,CAAC,EAAE,GAAG,EAAC;IAChB,MAAM,EAAE,EAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAC;IACxB,MAAM,EAAE,EAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,GAAG,EAAC;IAC5B,MAAM,EAAE,EAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAC;CAC3B,CAAC,CAAC"}
--------------------------------------------------------------------------------
/mathjax/output/chtml/fonts/tex/largeop.d.ts:
--------------------------------------------------------------------------------
1 | import { CHTMLCharMap } from '../../FontData.js';
2 | export declare const largeop: CHTMLCharMap;
3 |
--------------------------------------------------------------------------------
/mathjax/output/chtml/fonts/tex/monospace.d.ts:
--------------------------------------------------------------------------------
1 | import { CHTMLCharMap } from '../../FontData.js';
2 | export declare const monospace: CHTMLCharMap;
3 |
--------------------------------------------------------------------------------
/mathjax/output/chtml/fonts/tex/normal.d.ts:
--------------------------------------------------------------------------------
1 | import { CHTMLCharMap } from '../../FontData.js';
2 | export declare const normal: CHTMLCharMap;
3 |
--------------------------------------------------------------------------------
/mathjax/output/chtml/fonts/tex/sans-serif-bold-italic.d.ts:
--------------------------------------------------------------------------------
1 | import { CHTMLCharMap } from '../../FontData.js';
2 | export declare const sansSerifBoldItalic: CHTMLCharMap;
3 |
--------------------------------------------------------------------------------
/mathjax/output/chtml/fonts/tex/sans-serif-bold-italic.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | Object.defineProperty(exports, "__esModule", { value: true });
3 | exports.sansSerifBoldItalic = void 0;
4 | var FontData_js_1 = require("../../FontData.js");
5 | var sans_serif_bold_italic_js_1 = require("../../../common/fonts/tex/sans-serif-bold-italic.js");
6 | exports.sansSerifBoldItalic = (0, FontData_js_1.AddCSS)(sans_serif_bold_italic_js_1.sansSerifBoldItalic, {
7 | 0x131: { f: 'SSB' },
8 | 0x237: { f: 'SSB' },
9 | });
10 | //# sourceMappingURL=sans-serif-bold-italic.js.map
--------------------------------------------------------------------------------
/mathjax/output/chtml/fonts/tex/sans-serif-bold-italic.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"sans-serif-bold-italic.js","sourceRoot":"","sources":["../../../../../ts/output/chtml/fonts/tex/sans-serif-bold-italic.ts"],"names":[],"mappings":";;;AAgBA,iDAAuD;AACvD,iGAAgG;AAEnF,QAAA,mBAAmB,GAAiB,IAAA,oBAAM,EAAC,+CAAI,EAAE;IAC1D,KAAK,EAAE,EAAC,CAAC,EAAE,KAAK,EAAC;IACjB,KAAK,EAAE,EAAC,CAAC,EAAE,KAAK,EAAC;CACpB,CAAC,CAAC"}
--------------------------------------------------------------------------------
/mathjax/output/chtml/fonts/tex/sans-serif-bold.d.ts:
--------------------------------------------------------------------------------
1 | import { CHTMLCharMap } from '../../FontData.js';
2 | export declare const sansSerifBold: CHTMLCharMap;
3 |
--------------------------------------------------------------------------------
/mathjax/output/chtml/fonts/tex/sans-serif-bold.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | Object.defineProperty(exports, "__esModule", { value: true });
3 | exports.sansSerifBold = void 0;
4 | var FontData_js_1 = require("../../FontData.js");
5 | var sans_serif_bold_js_1 = require("../../../common/fonts/tex/sans-serif-bold.js");
6 | exports.sansSerifBold = (0, FontData_js_1.AddCSS)(sans_serif_bold_js_1.sansSerifBold, {
7 | 0x2015: { c: '\\2014' },
8 | 0x2017: { c: '_' },
9 | 0x2044: { c: '/' },
10 | 0x2206: { c: '\\394' },
11 | });
12 | //# sourceMappingURL=sans-serif-bold.js.map
--------------------------------------------------------------------------------
/mathjax/output/chtml/fonts/tex/sans-serif-bold.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"sans-serif-bold.js","sourceRoot":"","sources":["../../../../../ts/output/chtml/fonts/tex/sans-serif-bold.ts"],"names":[],"mappings":";;;AAgBA,iDAAuD;AACvD,mFAAmF;AAEtE,QAAA,aAAa,GAAiB,IAAA,oBAAM,EAAC,kCAAI,EAAE;IACpD,MAAM,EAAE,EAAC,CAAC,EAAE,QAAQ,EAAC;IACrB,MAAM,EAAE,EAAC,CAAC,EAAE,GAAG,EAAC;IAChB,MAAM,EAAE,EAAC,CAAC,EAAE,GAAG,EAAC;IAChB,MAAM,EAAE,EAAC,CAAC,EAAE,OAAO,EAAC;CACvB,CAAC,CAAC"}
--------------------------------------------------------------------------------
/mathjax/output/chtml/fonts/tex/sans-serif-italic.d.ts:
--------------------------------------------------------------------------------
1 | import { CHTMLCharMap } from '../../FontData.js';
2 | export declare const sansSerifItalic: CHTMLCharMap;
3 |
--------------------------------------------------------------------------------
/mathjax/output/chtml/fonts/tex/sans-serif.d.ts:
--------------------------------------------------------------------------------
1 | import { CHTMLCharMap } from '../../FontData.js';
2 | export declare const sansSerif: CHTMLCharMap;
3 |
--------------------------------------------------------------------------------
/mathjax/output/chtml/fonts/tex/script-bold.d.ts:
--------------------------------------------------------------------------------
1 | export { scriptBold } from '../../../common/fonts/tex/script-bold.js';
2 |
--------------------------------------------------------------------------------
/mathjax/output/chtml/fonts/tex/script-bold.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | Object.defineProperty(exports, "__esModule", { value: true });
3 | exports.scriptBold = void 0;
4 | var script_bold_js_1 = require("../../../common/fonts/tex/script-bold.js");
5 | Object.defineProperty(exports, "scriptBold", { enumerable: true, get: function () { return script_bold_js_1.scriptBold; } });
6 | //# sourceMappingURL=script-bold.js.map
--------------------------------------------------------------------------------
/mathjax/output/chtml/fonts/tex/script-bold.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"script-bold.js","sourceRoot":"","sources":["../../../../../ts/output/chtml/fonts/tex/script-bold.ts"],"names":[],"mappings":";;;AAgBA,2EAAoE;AAA5D,4GAAA,UAAU,OAAA"}
--------------------------------------------------------------------------------
/mathjax/output/chtml/fonts/tex/script.d.ts:
--------------------------------------------------------------------------------
1 | export { script } from '../../../common/fonts/tex/script.js';
2 |
--------------------------------------------------------------------------------
/mathjax/output/chtml/fonts/tex/script.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | Object.defineProperty(exports, "__esModule", { value: true });
3 | exports.script = void 0;
4 | var script_js_1 = require("../../../common/fonts/tex/script.js");
5 | Object.defineProperty(exports, "script", { enumerable: true, get: function () { return script_js_1.script; } });
6 | //# sourceMappingURL=script.js.map
--------------------------------------------------------------------------------
/mathjax/output/chtml/fonts/tex/script.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"script.js","sourceRoot":"","sources":["../../../../../ts/output/chtml/fonts/tex/script.ts"],"names":[],"mappings":";;;AAgBA,iEAA2D;AAAnD,mGAAA,MAAM,OAAA"}
--------------------------------------------------------------------------------
/mathjax/output/chtml/fonts/tex/smallop.d.ts:
--------------------------------------------------------------------------------
1 | import { CHTMLCharMap } from '../../FontData.js';
2 | export declare const smallop: CHTMLCharMap;
3 |
--------------------------------------------------------------------------------
/mathjax/output/chtml/fonts/tex/smallop.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | Object.defineProperty(exports, "__esModule", { value: true });
3 | exports.smallop = void 0;
4 | var FontData_js_1 = require("../../FontData.js");
5 | var smallop_js_1 = require("../../../common/fonts/tex/smallop.js");
6 | exports.smallop = (0, FontData_js_1.AddCSS)(smallop_js_1.smallop, {
7 | 0x2044: { c: '/' },
8 | 0x2329: { c: '\\27E8' },
9 | 0x232A: { c: '\\27E9' },
10 | 0x2758: { c: '\\2223' },
11 | 0x2A0C: { c: '\\222C\\222C' },
12 | 0x3008: { c: '\\27E8' },
13 | 0x3009: { c: '\\27E9' },
14 | });
15 | //# sourceMappingURL=smallop.js.map
--------------------------------------------------------------------------------
/mathjax/output/chtml/fonts/tex/smallop.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"smallop.js","sourceRoot":"","sources":["../../../../../ts/output/chtml/fonts/tex/smallop.ts"],"names":[],"mappings":";;;AAgBA,iDAAuD;AACvD,mEAAqE;AAExD,QAAA,OAAO,GAAiB,IAAA,oBAAM,EAAC,oBAAI,EAAE;IAC9C,MAAM,EAAE,EAAC,CAAC,EAAE,GAAG,EAAC;IAChB,MAAM,EAAE,EAAC,CAAC,EAAE,QAAQ,EAAC;IACrB,MAAM,EAAE,EAAC,CAAC,EAAE,QAAQ,EAAC;IACrB,MAAM,EAAE,EAAC,CAAC,EAAE,QAAQ,EAAC;IACrB,MAAM,EAAE,EAAC,CAAC,EAAE,cAAc,EAAC;IAC3B,MAAM,EAAE,EAAC,CAAC,EAAE,QAAQ,EAAC;IACrB,MAAM,EAAE,EAAC,CAAC,EAAE,QAAQ,EAAC;CACxB,CAAC,CAAC"}
--------------------------------------------------------------------------------
/mathjax/output/chtml/fonts/tex/tex-calligraphic-bold.d.ts:
--------------------------------------------------------------------------------
1 | import { CHTMLCharMap } from '../../FontData.js';
2 | export declare const texCalligraphicBold: CHTMLCharMap;
3 |
--------------------------------------------------------------------------------
/mathjax/output/chtml/fonts/tex/tex-calligraphic-bold.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | Object.defineProperty(exports, "__esModule", { value: true });
3 | exports.texCalligraphicBold = void 0;
4 | var FontData_js_1 = require("../../FontData.js");
5 | var tex_calligraphic_bold_js_1 = require("../../../common/fonts/tex/tex-calligraphic-bold.js");
6 | exports.texCalligraphicBold = (0, FontData_js_1.AddCSS)(tex_calligraphic_bold_js_1.texCalligraphicBold, {
7 | 0x131: { f: 'B' },
8 | 0x237: { f: 'B' },
9 | });
10 | //# sourceMappingURL=tex-calligraphic-bold.js.map
--------------------------------------------------------------------------------
/mathjax/output/chtml/fonts/tex/tex-calligraphic-bold.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"tex-calligraphic-bold.js","sourceRoot":"","sources":["../../../../../ts/output/chtml/fonts/tex/tex-calligraphic-bold.ts"],"names":[],"mappings":";;;AAgBA,iDAAuD;AACvD,+FAA+F;AAElF,QAAA,mBAAmB,GAAiB,IAAA,oBAAM,EAAC,8CAAI,EAAE;IAC1D,KAAK,EAAE,EAAC,CAAC,EAAE,GAAG,EAAC;IACf,KAAK,EAAE,EAAC,CAAC,EAAE,GAAG,EAAC;CAClB,CAAC,CAAC"}
--------------------------------------------------------------------------------
/mathjax/output/chtml/fonts/tex/tex-calligraphic.d.ts:
--------------------------------------------------------------------------------
1 | export { texCalligraphic } from '../../../common/fonts/tex/tex-calligraphic.js';
2 |
--------------------------------------------------------------------------------
/mathjax/output/chtml/fonts/tex/tex-calligraphic.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | Object.defineProperty(exports, "__esModule", { value: true });
3 | exports.texCalligraphic = void 0;
4 | var tex_calligraphic_js_1 = require("../../../common/fonts/tex/tex-calligraphic.js");
5 | Object.defineProperty(exports, "texCalligraphic", { enumerable: true, get: function () { return tex_calligraphic_js_1.texCalligraphic; } });
6 | //# sourceMappingURL=tex-calligraphic.js.map
--------------------------------------------------------------------------------
/mathjax/output/chtml/fonts/tex/tex-calligraphic.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"tex-calligraphic.js","sourceRoot":"","sources":["../../../../../ts/output/chtml/fonts/tex/tex-calligraphic.ts"],"names":[],"mappings":";;;AAgBA,qFAA8E;AAAtE,sHAAA,eAAe,OAAA"}
--------------------------------------------------------------------------------
/mathjax/output/chtml/fonts/tex/tex-mathit.d.ts:
--------------------------------------------------------------------------------
1 | export { texMathit } from '../../../common/fonts/tex/tex-mathit.js';
2 |
--------------------------------------------------------------------------------
/mathjax/output/chtml/fonts/tex/tex-mathit.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | Object.defineProperty(exports, "__esModule", { value: true });
3 | exports.texMathit = void 0;
4 | var tex_mathit_js_1 = require("../../../common/fonts/tex/tex-mathit.js");
5 | Object.defineProperty(exports, "texMathit", { enumerable: true, get: function () { return tex_mathit_js_1.texMathit; } });
6 | //# sourceMappingURL=tex-mathit.js.map
--------------------------------------------------------------------------------
/mathjax/output/chtml/fonts/tex/tex-mathit.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"tex-mathit.js","sourceRoot":"","sources":["../../../../../ts/output/chtml/fonts/tex/tex-mathit.ts"],"names":[],"mappings":";;;AAgBA,yEAAkE;AAA1D,0GAAA,SAAS,OAAA"}
--------------------------------------------------------------------------------
/mathjax/output/chtml/fonts/tex/tex-oldstyle-bold.d.ts:
--------------------------------------------------------------------------------
1 | export { texOldstyleBold } from '../../../common/fonts/tex/tex-oldstyle-bold.js';
2 |
--------------------------------------------------------------------------------
/mathjax/output/chtml/fonts/tex/tex-oldstyle-bold.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | Object.defineProperty(exports, "__esModule", { value: true });
3 | exports.texOldstyleBold = void 0;
4 | var tex_oldstyle_bold_js_1 = require("../../../common/fonts/tex/tex-oldstyle-bold.js");
5 | Object.defineProperty(exports, "texOldstyleBold", { enumerable: true, get: function () { return tex_oldstyle_bold_js_1.texOldstyleBold; } });
6 | //# sourceMappingURL=tex-oldstyle-bold.js.map
--------------------------------------------------------------------------------
/mathjax/output/chtml/fonts/tex/tex-oldstyle-bold.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"tex-oldstyle-bold.js","sourceRoot":"","sources":["../../../../../ts/output/chtml/fonts/tex/tex-oldstyle-bold.ts"],"names":[],"mappings":";;;AAgBA,uFAA+E;AAAvE,uHAAA,eAAe,OAAA"}
--------------------------------------------------------------------------------
/mathjax/output/chtml/fonts/tex/tex-oldstyle.d.ts:
--------------------------------------------------------------------------------
1 | export { texOldstyle } from '../../../common/fonts/tex/tex-oldstyle.js';
2 |
--------------------------------------------------------------------------------
/mathjax/output/chtml/fonts/tex/tex-oldstyle.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | Object.defineProperty(exports, "__esModule", { value: true });
3 | exports.texOldstyle = void 0;
4 | var tex_oldstyle_js_1 = require("../../../common/fonts/tex/tex-oldstyle.js");
5 | Object.defineProperty(exports, "texOldstyle", { enumerable: true, get: function () { return tex_oldstyle_js_1.texOldstyle; } });
6 | //# sourceMappingURL=tex-oldstyle.js.map
--------------------------------------------------------------------------------
/mathjax/output/chtml/fonts/tex/tex-oldstyle.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"tex-oldstyle.js","sourceRoot":"","sources":["../../../../../ts/output/chtml/fonts/tex/tex-oldstyle.ts"],"names":[],"mappings":";;;AAgBA,6EAAsE;AAA9D,8GAAA,WAAW,OAAA"}
--------------------------------------------------------------------------------
/mathjax/output/chtml/fonts/tex/tex-size3.d.ts:
--------------------------------------------------------------------------------
1 | import { CHTMLCharMap } from '../../FontData.js';
2 | export declare const texSize3: CHTMLCharMap;
3 |
--------------------------------------------------------------------------------
/mathjax/output/chtml/fonts/tex/tex-size3.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | Object.defineProperty(exports, "__esModule", { value: true });
3 | exports.texSize3 = void 0;
4 | var FontData_js_1 = require("../../FontData.js");
5 | var tex_size3_js_1 = require("../../../common/fonts/tex/tex-size3.js");
6 | exports.texSize3 = (0, FontData_js_1.AddCSS)(tex_size3_js_1.texSize3, {
7 | 0x2044: { c: '/' },
8 | 0x2329: { c: '\\27E8' },
9 | 0x232A: { c: '\\27E9' },
10 | 0x3008: { c: '\\27E8' },
11 | 0x3009: { c: '\\27E9' },
12 | });
13 | //# sourceMappingURL=tex-size3.js.map
--------------------------------------------------------------------------------
/mathjax/output/chtml/fonts/tex/tex-size3.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"tex-size3.js","sourceRoot":"","sources":["../../../../../ts/output/chtml/fonts/tex/tex-size3.ts"],"names":[],"mappings":";;;AAgBA,iDAAuD;AACvD,uEAAwE;AAE3D,QAAA,QAAQ,GAAiB,IAAA,oBAAM,EAAC,uBAAI,EAAE;IAC/C,MAAM,EAAE,EAAC,CAAC,EAAE,GAAG,EAAC;IAChB,MAAM,EAAE,EAAC,CAAC,EAAE,QAAQ,EAAC;IACrB,MAAM,EAAE,EAAC,CAAC,EAAE,QAAQ,EAAC;IACrB,MAAM,EAAE,EAAC,CAAC,EAAE,QAAQ,EAAC;IACrB,MAAM,EAAE,EAAC,CAAC,EAAE,QAAQ,EAAC;CACxB,CAAC,CAAC"}
--------------------------------------------------------------------------------
/mathjax/output/chtml/fonts/tex/tex-size4.d.ts:
--------------------------------------------------------------------------------
1 | import { CHTMLCharMap } from '../../FontData.js';
2 | export declare const texSize4: CHTMLCharMap;
3 |
--------------------------------------------------------------------------------
/mathjax/output/chtml/fonts/tex/tex-size4.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | Object.defineProperty(exports, "__esModule", { value: true });
3 | exports.texSize4 = void 0;
4 | var FontData_js_1 = require("../../FontData.js");
5 | var tex_size4_js_1 = require("../../../common/fonts/tex/tex-size4.js");
6 | exports.texSize4 = (0, FontData_js_1.AddCSS)(tex_size4_js_1.texSize4, {
7 | 0x2044: { c: '/' },
8 | 0x2329: { c: '\\27E8' },
9 | 0x232A: { c: '\\27E9' },
10 | 0x3008: { c: '\\27E8' },
11 | 0x3009: { c: '\\27E9' },
12 | 0xE155: { c: '\\E153\\E152' },
13 | 0xE156: { c: '\\E151\\E150' },
14 | });
15 | //# sourceMappingURL=tex-size4.js.map
--------------------------------------------------------------------------------
/mathjax/output/chtml/fonts/tex/tex-size4.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"tex-size4.js","sourceRoot":"","sources":["../../../../../ts/output/chtml/fonts/tex/tex-size4.ts"],"names":[],"mappings":";;;AAgBA,iDAAuD;AACvD,uEAAwE;AAE3D,QAAA,QAAQ,GAAiB,IAAA,oBAAM,EAAC,uBAAI,EAAE;IAC/C,MAAM,EAAE,EAAC,CAAC,EAAE,GAAG,EAAC;IAChB,MAAM,EAAE,EAAC,CAAC,EAAE,QAAQ,EAAC;IACrB,MAAM,EAAE,EAAC,CAAC,EAAE,QAAQ,EAAC;IACrB,MAAM,EAAE,EAAC,CAAC,EAAE,QAAQ,EAAC;IACrB,MAAM,EAAE,EAAC,CAAC,EAAE,QAAQ,EAAC;IACrB,MAAM,EAAE,EAAC,CAAC,EAAE,cAAc,EAAC;IAC3B,MAAM,EAAE,EAAC,CAAC,EAAE,cAAc,EAAC;CAC9B,CAAC,CAAC"}
--------------------------------------------------------------------------------
/mathjax/output/chtml/fonts/tex/tex-variant.d.ts:
--------------------------------------------------------------------------------
1 | import { CHTMLCharMap } from '../../FontData.js';
2 | export declare const texVariant: CHTMLCharMap;
3 |
--------------------------------------------------------------------------------
/mathjax/output/common/WrapperFactory.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"WrapperFactory.js","sourceRoot":"","sources":["../../../ts/output/common/WrapperFactory.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AAwBA,uEAAyE;AAezE;IAOU,wCAAqC;IAP/C;QAAA,qEA2BC;QATQ,SAAG,GAAM,IAAI,CAAC;;IASvB,CAAC;IAJC,sBAAI,0CAAQ;aAAZ;YACE,OAAO,IAAI,CAAC,IAAI,CAAC;QACnB,CAAC;;;OAAA;IAZa,iCAAY,GAAuE,EAAE,CAAC;IActG,2BAAC;CAAA,AA3BD,CAOU,0CAAsB,GAoB/B;AA3BY,oDAAoB"}
--------------------------------------------------------------------------------
/mathjax/output/common/Wrappers/TeXAtom.d.ts:
--------------------------------------------------------------------------------
1 | import { AnyWrapper, WrapperConstructor, Constructor } from '../Wrapper.js';
2 | export interface CommonTeXAtom extends AnyWrapper {
3 | }
4 | export declare type TeXAtomConstructor = Constructor;
5 | export declare function CommonTeXAtomMixin(Base: T): TeXAtomConstructor & T;
6 |
--------------------------------------------------------------------------------
/mathjax/output/common/Wrappers/TextNode.d.ts:
--------------------------------------------------------------------------------
1 | import { AnyWrapper, WrapperConstructor, Constructor } from '../Wrapper.js';
2 | export interface CommonTextNode extends AnyWrapper {
3 | remappedText(text: string, variant: string): number[];
4 | }
5 | export declare type TextNodeConstructor = Constructor;
6 | export declare function CommonTextNodeMixin(Base: T): TextNodeConstructor & T;
7 |
--------------------------------------------------------------------------------
/mathjax/output/common/Wrappers/math.d.ts:
--------------------------------------------------------------------------------
1 | import { AnyWrapper, WrapperConstructor, Constructor } from '../Wrapper.js';
2 | export interface CommonMath extends AnyWrapper {
3 | }
4 | export declare type MathConstructor = Constructor;
5 | export declare function CommonMathMixin(Base: T): MathConstructor & T;
6 |
--------------------------------------------------------------------------------
/mathjax/output/common/Wrappers/math.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"math.js","sourceRoot":"","sources":["../../../../ts/output/common/Wrappers/math.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AA2CA,SAAgB,eAAe,CAA+B,IAAO;IAEnE;QAAqB,2BAAI;QAAlB;;QASP,CAAC;QAJQ,8BAAY,GAAnB,UAAoB,EAAU;YAC5B,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;QAC3F,CAAC;QAEH,cAAC;IAAD,CAAC,AATM,CAAc,IAAI,GASvB;AAEJ,CAAC;AAbD,0CAaC"}
--------------------------------------------------------------------------------
/mathjax/output/common/Wrappers/mfenced.d.ts:
--------------------------------------------------------------------------------
1 | import { AnyWrapper, WrapperConstructor, Constructor } from '../Wrapper.js';
2 | import { CommonInferredMrow } from './mrow.js';
3 | import { MmlNode } from '../../../core/MmlTree/MmlNode.js';
4 | export interface CommonMfenced extends AnyWrapper {
5 | mrow: CommonInferredMrow;
6 | createMrow(): void;
7 | addMrowChildren(): void;
8 | addMo(node: MmlNode): void;
9 | }
10 | export declare type MfencedConstructor = Constructor;
11 | export declare function CommonMfencedMixin(Base: T): MfencedConstructor & T;
12 |
--------------------------------------------------------------------------------
/mathjax/output/common/Wrappers/mglyph.d.ts:
--------------------------------------------------------------------------------
1 | import { AnyWrapper, WrapperConstructor, Constructor } from '../Wrapper.js';
2 | import { CommonTextNode } from './TextNode.js';
3 | export interface CommonMglyph extends AnyWrapper {
4 | width: number;
5 | height: number;
6 | valign: number;
7 | charWrapper: CommonTextNode;
8 | getParameters(): void;
9 | }
10 | export declare type MglyphConstructor = Constructor;
11 | export declare function CommonMglyphMixin(Base: T): MglyphConstructor & T;
12 |
--------------------------------------------------------------------------------
/mathjax/output/common/Wrappers/mi.d.ts:
--------------------------------------------------------------------------------
1 | import { AnyWrapper, WrapperConstructor, Constructor } from '../Wrapper.js';
2 | export interface CommonMi extends AnyWrapper {
3 | }
4 | export declare type MiConstructor = Constructor;
5 | export declare function CommonMiMixin(Base: T): MiConstructor & T;
6 |
--------------------------------------------------------------------------------
/mathjax/output/common/Wrappers/mi.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"mi.js","sourceRoot":"","sources":["../../../../ts/output/common/Wrappers/mi.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AA4CA,SAAgB,aAAa,CAA+B,IAAO;IAEjE;QAAqB,2BAAI;QAAlB;;QASP,CAAC;QAJQ,6BAAW,GAAlB,UAAmB,IAAU,EAAE,UAA2B;YAA3B,2BAAA,EAAA,kBAA2B;YACxD,iBAAM,WAAW,YAAC,IAAI,CAAC,CAAC;YACxB,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;QACxB,CAAC;QACH,cAAC;IAAD,CAAC,AATM,CAAc,IAAI,GASvB;AAEJ,CAAC;AAbD,sCAaC"}
--------------------------------------------------------------------------------
/mathjax/output/common/Wrappers/mn.d.ts:
--------------------------------------------------------------------------------
1 | import { AnyWrapper, WrapperConstructor, Constructor } from '../Wrapper.js';
2 | export interface CommonMn extends AnyWrapper {
3 | }
4 | export declare type MnConstructor = Constructor;
5 | export declare function CommonMnMixin(Base: T): MnConstructor & T;
6 |
--------------------------------------------------------------------------------
/mathjax/output/common/Wrappers/mn.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"mn.js","sourceRoot":"","sources":["../../../../ts/output/common/Wrappers/mn.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AA2CA,SAAgB,aAAa,CAA+B,IAAO;IAEjE;QAAqB,2BAAI;QAAlB;;QAsBP,CAAC;QAjBQ,4BAAU,GAAjB,UAAkB,KAAe;YAI/B,IAAI,KAAK,CAAC,MAAM,EAAE;gBAChB,IAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;gBACvD,IAAI,IAAI,EAAE;oBACR,IAAM,CAAC,GAAG,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;oBAChD,IAAI,CAAC,CAAC,MAAM,KAAK,CAAC,EAAE;wBAClB,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;qBACjB;yBAAM;wBACL,KAAK,GAAG,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;qBAClC;iBACF;aACF;YACD,OAAO,KAAK,CAAC;QACf,CAAC;QACH,cAAC;IAAD,CAAC,AAtBM,CAAc,IAAI,GAsBvB;AAEJ,CAAC;AA1BD,sCA0BC"}
--------------------------------------------------------------------------------
/mathjax/output/common/Wrappers/mpadded.d.ts:
--------------------------------------------------------------------------------
1 | import { AnyWrapper, WrapperConstructor, Constructor } from '../Wrapper.js';
2 | import { BBox } from '../../../util/BBox.js';
3 | import { Property } from '../../../core/Tree/Node.js';
4 | export interface CommonMpadded extends AnyWrapper {
5 | getDimens(): number[];
6 | dimen(length: Property, bbox: BBox, d?: string, m?: number): number;
7 | }
8 | export declare type MpaddedConstructor = Constructor;
9 | export declare function CommonMpaddedMixin(Base: T): MpaddedConstructor & T;
10 |
--------------------------------------------------------------------------------
/mathjax/output/common/Wrappers/mroot.d.ts:
--------------------------------------------------------------------------------
1 | import { Constructor } from '../../common/Wrapper.js';
2 | import { CommonMsqrt, MsqrtConstructor } from './msqrt.js';
3 | export interface CommonMroot extends CommonMsqrt {
4 | }
5 | export declare type MrootConstructor = Constructor;
6 | export declare function CommonMrootMixin(Base: T): MrootConstructor & T;
7 |
--------------------------------------------------------------------------------
/mathjax/output/common/Wrappers/mrow.d.ts:
--------------------------------------------------------------------------------
1 | import { AnyWrapper, WrapperConstructor, Constructor } from '../Wrapper.js';
2 | export interface CommonMrow extends AnyWrapper {
3 | stretchChildren(): void;
4 | }
5 | export declare type MrowConstructor = Constructor;
6 | export declare function CommonMrowMixin(Base: T): MrowConstructor & T;
7 | export interface CommonInferredMrow extends CommonMrow {
8 | }
9 | export declare type InferredMrowConstructor = Constructor;
10 | export declare function CommonInferredMrowMixin(Base: T): InferredMrowConstructor & T;
11 |
--------------------------------------------------------------------------------
/mathjax/output/common/Wrappers/ms.d.ts:
--------------------------------------------------------------------------------
1 | import { AnyWrapper, WrapperConstructor, Constructor } from '../Wrapper.js';
2 | export interface CommonMs extends AnyWrapper {
3 | createText(text: string): AnyWrapper;
4 | }
5 | export declare type MsConstructor = Constructor;
6 | export declare function CommonMsMixin(Base: T): MsConstructor & T;
7 |
--------------------------------------------------------------------------------
/mathjax/output/common/Wrappers/mspace.d.ts:
--------------------------------------------------------------------------------
1 | import { AnyWrapper, WrapperConstructor, Constructor } from '../Wrapper.js';
2 | export interface CommonMspace extends AnyWrapper {
3 | }
4 | export declare type MspaceConstructor = Constructor;
5 | export declare function CommonMspaceMixin(Base: T): MspaceConstructor & T;
6 |
--------------------------------------------------------------------------------
/mathjax/output/common/Wrappers/mspace.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"mspace.js","sourceRoot":"","sources":["../../../../ts/output/common/Wrappers/mspace.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AA4CA,SAAgB,iBAAiB,CAA+B,IAAO;IAErE;QAAqB,2BAAI;QAAlB;;QAoBP,CAAC;QAfQ,6BAAW,GAAlB,UAAmB,IAAU,EAAE,UAA2B;YAA3B,2BAAA,EAAA,kBAA2B;YACxD,IAAM,UAAU,GAAG,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC;YACxC,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,CAAC;YACpD,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC;YACrD,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,CAAC;QACtD,CAAC;QAOM,+BAAa,GAApB;QACA,CAAC;QAEH,cAAC;IAAD,CAAC,AApBM,CAAc,IAAI,GAoBvB;AAEJ,CAAC;AAxBD,8CAwBC"}
--------------------------------------------------------------------------------
/mathjax/output/common/Wrappers/msqrt.d.ts:
--------------------------------------------------------------------------------
1 | import { AnyWrapper, WrapperConstructor, Constructor } from '../Wrapper.js';
2 | import { BBox } from '../../../util/BBox.js';
3 | export interface CommonMsqrt extends AnyWrapper {
4 | readonly base: number;
5 | readonly surd: number;
6 | readonly root: number;
7 | surdH: number;
8 | combineRootBBox(bbox: BBox, sbox: BBox, H: number): void;
9 | getPQ(sbox: BBox): number[];
10 | getRootDimens(sbox: BBox, H: Number): number[];
11 | }
12 | export declare type MsqrtConstructor = Constructor;
13 | export declare function CommonMsqrtMixin(Base: T): MsqrtConstructor & T;
14 |
--------------------------------------------------------------------------------
/mathjax/output/common/Wrappers/mtd.d.ts:
--------------------------------------------------------------------------------
1 | import { AnyWrapper, WrapperConstructor, Constructor } from '../Wrapper.js';
2 | export interface CommonMtd extends AnyWrapper {
3 | }
4 | export declare type MtdConstructor = Constructor;
5 | export declare function CommonMtdMixin(Base: T): MtdConstructor & T;
6 |
--------------------------------------------------------------------------------
/mathjax/output/common/Wrappers/mtext.d.ts:
--------------------------------------------------------------------------------
1 | import { AnyWrapper, WrapperConstructor, Constructor } from '../Wrapper.js';
2 | export interface CommonMtext extends AnyWrapper {
3 | }
4 | export declare type MtextConstructor = Constructor;
5 | export declare function CommonMtextMixin(Base: T): MtextConstructor & T;
6 |
--------------------------------------------------------------------------------
/mathjax/output/common/Wrappers/semantics.d.ts:
--------------------------------------------------------------------------------
1 | import { AnyWrapper, WrapperConstructor, Constructor } from '../Wrapper.js';
2 | export interface CommonSemantics extends AnyWrapper {
3 | }
4 | export declare type SemanticsConstructor = Constructor;
5 | export declare function CommonSemanticsMixin(Base: T): SemanticsConstructor & T;
6 |
--------------------------------------------------------------------------------
/mathjax/output/common/Wrappers/semantics.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"semantics.js","sourceRoot":"","sources":["../../../../ts/output/common/Wrappers/semantics.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AA4CA,SAAgB,oBAAoB,CAA+B,IAAO;IAExE;QAAqB,2BAAI;QAAlB;;QAaP,CAAC;QARQ,6BAAW,GAAlB,UAAmB,IAAU,EAAE,UAA2B;YAA3B,2BAAA,EAAA,kBAA2B;YACxD,IAAI,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE;gBACpB,IAAA,KAAY,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,OAAO,EAAE,EAAvC,CAAC,OAAA,EAAE,CAAC,OAAA,EAAE,CAAC,OAAgC,CAAC;gBAC/C,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;gBACX,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;gBACX,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;aACZ;QACH,CAAC;QACH,cAAC;IAAD,CAAC,AAbM,CAAc,IAAI,GAavB;AAEJ,CAAC;AAjBD,oDAiBC"}
--------------------------------------------------------------------------------
/mathjax/output/common/fonts/tex.d.ts:
--------------------------------------------------------------------------------
1 | import { FontDataClass, CharOptions, VariantData, DelimiterData } from '../FontData.js';
2 | export declare function CommonTeXFontMixin, D extends DelimiterData, B extends FontDataClass>(Base: B): FontDataClass & B;
3 |
--------------------------------------------------------------------------------
/mathjax/output/common/fonts/tex/bold-italic.d.ts:
--------------------------------------------------------------------------------
1 | import { CharMap, CharOptions } from '../../FontData.js';
2 | export declare const boldItalic: CharMap;
3 |
--------------------------------------------------------------------------------
/mathjax/output/common/fonts/tex/bold-italic.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | Object.defineProperty(exports, "__esModule", { value: true });
3 | exports.boldItalic = void 0;
4 | exports.boldItalic = {
5 | 0x2F: [.711, .21, .894],
6 | 0x131: [.452, .008, .394, { sk: .0319 }],
7 | 0x237: [.451, .201, .439, { sk: .0958 }],
8 | 0x2044: [.711, .21, .894],
9 | 0x2206: [.711, 0, .958, { sk: .192 }],
10 | 0x29F8: [.711, .21, .894],
11 | };
12 | //# sourceMappingURL=bold-italic.js.map
--------------------------------------------------------------------------------
/mathjax/output/common/fonts/tex/bold-italic.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"bold-italic.js","sourceRoot":"","sources":["../../../../../ts/output/common/fonts/tex/bold-italic.ts"],"names":[],"mappings":";;;AAmBa,QAAA,UAAU,GAAyB;IAC5C,IAAI,EAAE,CAAC,IAAI,EAAE,GAAG,EAAE,IAAI,CAAC;IACvB,KAAK,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,EAAC,EAAE,EAAE,KAAK,EAAC,CAAC;IACtC,KAAK,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,EAAC,EAAE,EAAE,KAAK,EAAC,CAAC;IACtC,MAAM,EAAE,CAAC,IAAI,EAAE,GAAG,EAAE,IAAI,CAAC;IACzB,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,EAAC,EAAE,EAAE,IAAI,EAAC,CAAC;IACnC,MAAM,EAAE,CAAC,IAAI,EAAE,GAAG,EAAE,IAAI,CAAC;CAC5B,CAAC"}
--------------------------------------------------------------------------------
/mathjax/output/common/fonts/tex/bold.d.ts:
--------------------------------------------------------------------------------
1 | import { CharMap, CharOptions } from '../../FontData.js';
2 | export declare const bold: CharMap;
3 |
--------------------------------------------------------------------------------
/mathjax/output/common/fonts/tex/delimiters.d.ts:
--------------------------------------------------------------------------------
1 | import { DelimiterMap, DelimiterData } from '../../FontData.js';
2 | export declare const HDW1: number[];
3 | export declare const HDW2: number[];
4 | export declare const HDW3: number[];
5 | export declare const VSIZES: number[];
6 | export declare const delimiters: DelimiterMap;
7 |
--------------------------------------------------------------------------------
/mathjax/output/common/fonts/tex/double-struck.d.ts:
--------------------------------------------------------------------------------
1 | import { CharMap, CharOptions } from '../../FontData.js';
2 | export declare const doubleStruck: CharMap;
3 |
--------------------------------------------------------------------------------
/mathjax/output/common/fonts/tex/double-struck.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | Object.defineProperty(exports, "__esModule", { value: true });
3 | exports.doubleStruck = void 0;
4 | exports.doubleStruck = {};
5 | //# sourceMappingURL=double-struck.js.map
--------------------------------------------------------------------------------
/mathjax/output/common/fonts/tex/double-struck.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"double-struck.js","sourceRoot":"","sources":["../../../../../ts/output/common/fonts/tex/double-struck.ts"],"names":[],"mappings":";;;AAmBa,QAAA,YAAY,GAAyB,EACjD,CAAC"}
--------------------------------------------------------------------------------
/mathjax/output/common/fonts/tex/fraktur-bold.d.ts:
--------------------------------------------------------------------------------
1 | import { CharMap, CharOptions } from '../../FontData.js';
2 | export declare const frakturBold: CharMap;
3 |
--------------------------------------------------------------------------------
/mathjax/output/common/fonts/tex/fraktur.d.ts:
--------------------------------------------------------------------------------
1 | import { CharMap, CharOptions } from '../../FontData.js';
2 | export declare const fraktur: CharMap;
3 |
--------------------------------------------------------------------------------
/mathjax/output/common/fonts/tex/italic.d.ts:
--------------------------------------------------------------------------------
1 | import { CharMap, CharOptions } from '../../FontData.js';
2 | export declare const italic: CharMap;
3 |
--------------------------------------------------------------------------------
/mathjax/output/common/fonts/tex/largeop.d.ts:
--------------------------------------------------------------------------------
1 | import { CharMap, CharOptions } from '../../FontData.js';
2 | export declare const largeop: CharMap;
3 |
--------------------------------------------------------------------------------
/mathjax/output/common/fonts/tex/monospace.d.ts:
--------------------------------------------------------------------------------
1 | import { CharMap, CharOptions } from '../../FontData.js';
2 | export declare const monospace: CharMap;
3 |
--------------------------------------------------------------------------------
/mathjax/output/common/fonts/tex/normal.d.ts:
--------------------------------------------------------------------------------
1 | import { CharMap, CharOptions } from '../../FontData.js';
2 | export declare const normal: CharMap;
3 |
--------------------------------------------------------------------------------
/mathjax/output/common/fonts/tex/sans-serif-bold-italic.d.ts:
--------------------------------------------------------------------------------
1 | import { CharMap, CharOptions } from '../../FontData.js';
2 | export declare const sansSerifBoldItalic: CharMap;
3 |
--------------------------------------------------------------------------------
/mathjax/output/common/fonts/tex/sans-serif-bold-italic.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | Object.defineProperty(exports, "__esModule", { value: true });
3 | exports.sansSerifBoldItalic = void 0;
4 | exports.sansSerifBoldItalic = {
5 | 0x131: [.458, 0, .256],
6 | 0x237: [.458, .205, .286],
7 | };
8 | //# sourceMappingURL=sans-serif-bold-italic.js.map
--------------------------------------------------------------------------------
/mathjax/output/common/fonts/tex/sans-serif-bold-italic.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"sans-serif-bold-italic.js","sourceRoot":"","sources":["../../../../../ts/output/common/fonts/tex/sans-serif-bold-italic.ts"],"names":[],"mappings":";;;AAmBa,QAAA,mBAAmB,GAAyB;IACrD,KAAK,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,IAAI,CAAC;IACtB,KAAK,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC;CAC5B,CAAC"}
--------------------------------------------------------------------------------
/mathjax/output/common/fonts/tex/sans-serif-bold.d.ts:
--------------------------------------------------------------------------------
1 | import { CharMap, CharOptions } from '../../FontData.js';
2 | export declare const sansSerifBold: CharMap;
3 |
--------------------------------------------------------------------------------
/mathjax/output/common/fonts/tex/sans-serif-italic.d.ts:
--------------------------------------------------------------------------------
1 | import { CharMap, CharOptions } from '../../FontData.js';
2 | export declare const sansSerifItalic: CharMap;
3 |
--------------------------------------------------------------------------------
/mathjax/output/common/fonts/tex/sans-serif.d.ts:
--------------------------------------------------------------------------------
1 | import { CharMap, CharOptions } from '../../FontData.js';
2 | export declare const sansSerif: CharMap;
3 |
--------------------------------------------------------------------------------
/mathjax/output/common/fonts/tex/script-bold.d.ts:
--------------------------------------------------------------------------------
1 | import { CharMap, CharOptions } from '../../FontData.js';
2 | export declare const scriptBold: CharMap;
3 |
--------------------------------------------------------------------------------
/mathjax/output/common/fonts/tex/script-bold.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | Object.defineProperty(exports, "__esModule", { value: true });
3 | exports.scriptBold = void 0;
4 | exports.scriptBold = {};
5 | //# sourceMappingURL=script-bold.js.map
--------------------------------------------------------------------------------
/mathjax/output/common/fonts/tex/script-bold.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"script-bold.js","sourceRoot":"","sources":["../../../../../ts/output/common/fonts/tex/script-bold.ts"],"names":[],"mappings":";;;AAmBa,QAAA,UAAU,GAAyB,EAC/C,CAAC"}
--------------------------------------------------------------------------------
/mathjax/output/common/fonts/tex/script.d.ts:
--------------------------------------------------------------------------------
1 | import { CharMap, CharOptions } from '../../FontData.js';
2 | export declare const script: CharMap;
3 |
--------------------------------------------------------------------------------
/mathjax/output/common/fonts/tex/script.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | Object.defineProperty(exports, "__esModule", { value: true });
3 | exports.script = void 0;
4 | exports.script = {};
5 | //# sourceMappingURL=script.js.map
--------------------------------------------------------------------------------
/mathjax/output/common/fonts/tex/script.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"script.js","sourceRoot":"","sources":["../../../../../ts/output/common/fonts/tex/script.ts"],"names":[],"mappings":";;;AAmBa,QAAA,MAAM,GAAyB,EAC3C,CAAC"}
--------------------------------------------------------------------------------
/mathjax/output/common/fonts/tex/smallop.d.ts:
--------------------------------------------------------------------------------
1 | import { CharMap, CharOptions } from '../../FontData.js';
2 | export declare const smallop: CharMap;
3 |
--------------------------------------------------------------------------------
/mathjax/output/common/fonts/tex/tex-calligraphic-bold.d.ts:
--------------------------------------------------------------------------------
1 | import { CharMap, CharOptions } from '../../FontData.js';
2 | export declare const texCalligraphicBold: CharMap;
3 |
--------------------------------------------------------------------------------
/mathjax/output/common/fonts/tex/tex-calligraphic.d.ts:
--------------------------------------------------------------------------------
1 | import { CharMap, CharOptions } from '../../FontData.js';
2 | export declare const texCalligraphic: CharMap;
3 |
--------------------------------------------------------------------------------
/mathjax/output/common/fonts/tex/tex-mathit.d.ts:
--------------------------------------------------------------------------------
1 | import { CharMap, CharOptions } from '../../FontData.js';
2 | export declare const texMathit: CharMap;
3 |
--------------------------------------------------------------------------------
/mathjax/output/common/fonts/tex/tex-oldstyle-bold.d.ts:
--------------------------------------------------------------------------------
1 | import { CharMap, CharOptions } from '../../FontData.js';
2 | export declare const texOldstyleBold: CharMap;
3 |
--------------------------------------------------------------------------------
/mathjax/output/common/fonts/tex/tex-oldstyle.d.ts:
--------------------------------------------------------------------------------
1 | import { CharMap, CharOptions } from '../../FontData.js';
2 | export declare const texOldstyle: CharMap;
3 |
--------------------------------------------------------------------------------
/mathjax/output/common/fonts/tex/tex-size3.d.ts:
--------------------------------------------------------------------------------
1 | import { CharMap, CharOptions } from '../../FontData.js';
2 | export declare const texSize3: CharMap;
3 |
--------------------------------------------------------------------------------
/mathjax/output/common/fonts/tex/tex-size4.d.ts:
--------------------------------------------------------------------------------
1 | import { CharMap, CharOptions } from '../../FontData.js';
2 | export declare const texSize4: CharMap;
3 |
--------------------------------------------------------------------------------
/mathjax/output/common/fonts/tex/tex-variant.d.ts:
--------------------------------------------------------------------------------
1 | import { CharMap, CharOptions } from '../../FontData.js';
2 | export declare const texVariant: CharMap;
3 |
--------------------------------------------------------------------------------
/mathjax/output/svg/FontCache.d.ts:
--------------------------------------------------------------------------------
1 | import { SVG } from '../svg.js';
2 | export declare class FontCache {
3 | protected jax: SVG;
4 | protected cache: Map;
5 | protected defs: N;
6 | protected localID: string;
7 | protected nextID: number;
8 | constructor(jax: SVG);
9 | cachePath(variant: string, C: string, path: string): string;
10 | clearLocalID(): void;
11 | useLocalID(id?: string): void;
12 | clearCache(): void;
13 | getCache(): N;
14 | }
15 |
--------------------------------------------------------------------------------
/mathjax/output/svg/WrapperFactory.d.ts:
--------------------------------------------------------------------------------
1 | import { SVG } from '../svg.js';
2 | import { CommonWrapperFactory } from '../common/WrapperFactory.js';
3 | import { SVGWrapper, SVGWrapperClass } from './Wrapper.js';
4 | import { SVGCharOptions, SVGDelimiterData, SVGFontData } from './FontData.js';
5 | export declare class SVGWrapperFactory extends CommonWrapperFactory