├── .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, SVGWrapper, SVGWrapperClass, SVGCharOptions, SVGDelimiterData, SVGFontData> { 6 | static defaultNodes: { 7 | [kind: string]: import("../common/Wrapper.js").WrapperConstructor; 8 | }; 9 | jax: SVG; 10 | } 11 | -------------------------------------------------------------------------------- /mathjax/output/svg/WrapperFactory.js.map: -------------------------------------------------------------------------------- 1 | {"version":3,"file":"WrapperFactory.js","sourceRoot":"","sources":["../../../ts/output/svg/WrapperFactory.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AAwBA,iEAAiE;AAEjE,6CAA0C;AAW1C;IACA,qCAOC;IARD;QAAA,qEAoBC;QAFQ,SAAG,GAAiB,IAAI,CAAC;;IAElC,CAAC;IAPe,8BAAY,GAAG,yBAAW,CAAC;IAO3C,wBAAC;CAAA,AApBD,CACA,wCAAoB,GAmBnB;AApBY,8CAAiB"} -------------------------------------------------------------------------------- /mathjax/output/svg/Wrappers.d.ts: -------------------------------------------------------------------------------- 1 | import { WrapperConstructor } from '../common/Wrapper.js'; 2 | export declare const SVGWrappers: { 3 | [kind: string]: WrapperConstructor; 4 | }; 5 | -------------------------------------------------------------------------------- /mathjax/output/svg/Wrappers/TeXAtom.d.ts: -------------------------------------------------------------------------------- 1 | import { SVGConstructor } from '../Wrapper.js'; 2 | declare const SVGTeXAtom_base: import("../../common/Wrappers/TeXAtom.js").TeXAtomConstructor & SVGConstructor; 3 | export declare class SVGTeXAtom extends SVGTeXAtom_base { 4 | static kind: string; 5 | toSVG(parent: N): void; 6 | } 7 | export {}; 8 | -------------------------------------------------------------------------------- /mathjax/output/svg/Wrappers/TextNode.d.ts: -------------------------------------------------------------------------------- 1 | import { SVGConstructor } from '../Wrapper.js'; 2 | import { StyleList } from '../../../util/StyleList.js'; 3 | declare const SVGTextNode_base: import("../../common/Wrappers/TextNode.js").TextNodeConstructor & SVGConstructor; 4 | export declare class SVGTextNode extends SVGTextNode_base { 5 | static kind: string; 6 | static styles: StyleList; 7 | toSVG(parent: N): void; 8 | } 9 | export {}; 10 | -------------------------------------------------------------------------------- /mathjax/output/svg/Wrappers/math.d.ts: -------------------------------------------------------------------------------- 1 | import { SVGConstructor } from '../Wrapper.js'; 2 | import { StyleList } from '../../../util/StyleList.js'; 3 | declare const SVGmath_base: import("../../common/Wrappers/math.js").MathConstructor & SVGConstructor; 4 | export declare class SVGmath extends SVGmath_base { 5 | static kind: string; 6 | static styles: StyleList; 7 | toSVG(parent: N): void; 8 | protected handleDisplay(): void; 9 | protected handleSpeech(): void; 10 | protected getTitleID(): string; 11 | setChildPWidths(recompute: boolean, w?: number, _clear?: boolean): boolean; 12 | } 13 | export {}; 14 | -------------------------------------------------------------------------------- /mathjax/output/svg/Wrappers/merror.d.ts: -------------------------------------------------------------------------------- 1 | import { SVGWrapper } from '../Wrapper.js'; 2 | import { StyleList } from '../../../util/StyleList.js'; 3 | export declare class SVGmerror extends SVGWrapper { 4 | static kind: string; 5 | static styles: StyleList; 6 | toSVG(parent: N): void; 7 | } 8 | -------------------------------------------------------------------------------- /mathjax/output/svg/Wrappers/mfenced.d.ts: -------------------------------------------------------------------------------- 1 | import { SVGWrapper, SVGConstructor } from '../Wrapper.js'; 2 | import { SVGinferredMrow } from './mrow.js'; 3 | declare const SVGmfenced_base: import("../../common/Wrappers/mfenced.js").MfencedConstructor & SVGConstructor; 4 | export declare class SVGmfenced extends SVGmfenced_base { 5 | static kind: string; 6 | mrow: SVGinferredMrow; 7 | toSVG(parent: N): void; 8 | protected setChildrenParent(parent: SVGWrapper): void; 9 | } 10 | export {}; 11 | -------------------------------------------------------------------------------- /mathjax/output/svg/Wrappers/mfenced.js.map: -------------------------------------------------------------------------------- 1 | {"version":3,"file":"mfenced.js","sourceRoot":"","sources":["../../../../ts/output/svg/Wrappers/mfenced.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuBA,4CAAyD;AACzD,+DAAoE;AACpE,wEAAqE;AAWrE;IAAyC,8BAA6D;IAAtG;;IA+BA,CAAC;IAhBQ,0BAAK,GAAZ,UAAa,MAAS;QACpB,IAAM,GAAG,GAAG,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC;QACzC,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAClC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QACrB,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;IAC/B,CAAC;IAKS,sCAAiB,GAA3B,UAA4B,MAA2B;;;YACrD,KAAoB,IAAA,KAAA,SAAA,IAAI,CAAC,UAAU,CAAA,gBAAA,4BAAE;gBAAhC,IAAM,KAAK,WAAA;gBACd,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC;aACvB;;;;;;;;;IACH,CAAC;IAxBa,eAAI,GAAG,uBAAU,CAAC,SAAS,CAAC,IAAI,CAAC;IA0BjD,iBAAC;CAAA,AA/BD,CAAyC,IAAA,+BAAkB,EAAgC,uBAAU,CAAC,GA+BrG;AA/BY,gCAAU"} -------------------------------------------------------------------------------- /mathjax/output/svg/Wrappers/mfrac.d.ts: -------------------------------------------------------------------------------- 1 | import { SVGConstructor } from '../Wrapper.js'; 2 | import { SVGmo } from './mo.js'; 3 | declare const SVGmfrac_base: import("../../common/Wrappers/mfrac.js").MfracConstructor & SVGConstructor; 4 | export declare class SVGmfrac extends SVGmfrac_base { 5 | static kind: string; 6 | bevel: SVGmo; 7 | toSVG(parent: N): void; 8 | protected makeFraction(display: boolean, t: number): void; 9 | protected makeAtop(display: boolean): void; 10 | protected makeBevelled(display: boolean): void; 11 | } 12 | export {}; 13 | -------------------------------------------------------------------------------- /mathjax/output/svg/Wrappers/mglyph.d.ts: -------------------------------------------------------------------------------- 1 | import { SVGConstructor } from '../Wrapper.js'; 2 | declare const SVGmglyph_base: import("../../common/Wrappers/mglyph.js").MglyphConstructor & SVGConstructor; 3 | export declare class SVGmglyph extends SVGmglyph_base { 4 | static kind: string; 5 | toSVG(parent: N): void; 6 | } 7 | export {}; 8 | -------------------------------------------------------------------------------- /mathjax/output/svg/Wrappers/mi.d.ts: -------------------------------------------------------------------------------- 1 | import { SVGConstructor } from '../Wrapper.js'; 2 | declare const SVGmi_base: import("../../common/Wrappers/mi.js").MiConstructor & SVGConstructor; 3 | export declare class SVGmi extends SVGmi_base { 4 | static kind: string; 5 | } 6 | export {}; 7 | -------------------------------------------------------------------------------- /mathjax/output/svg/Wrappers/mi.js.map: -------------------------------------------------------------------------------- 1 | {"version":3,"file":"mi.js","sourceRoot":"","sources":["../../../../ts/output/svg/Wrappers/mi.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AAuBA,4CAAyD;AACzD,qDAA0D;AAC1D,8DAA2D;AAW3D;IACA,yBAAwD;IADxD;;IAQA,CAAC;IAFe,UAAI,GAAG,aAAK,CAAC,SAAS,CAAC,IAAI,CAAC;IAE5C,YAAC;CAAA,AARD,CACA,IAAA,qBAAa,EAAgC,uBAAU,CAAC,GAOvD;AARY,sBAAK"} -------------------------------------------------------------------------------- /mathjax/output/svg/Wrappers/mmultiscripts.d.ts: -------------------------------------------------------------------------------- 1 | import { SVGWrapper, Constructor } from '../Wrapper.js'; 2 | import { SVGmsubsup } from './msubsup.js'; 3 | export declare type AlignFunction = (w: number, W: number) => number; 4 | export declare function AlignX(align: string): AlignFunction; 5 | declare const SVGmmultiscripts_base: import("../../common/Wrappers/mmultiscripts.js").MmultiscriptsConstructor> & Constructor>; 6 | export declare class SVGmmultiscripts extends SVGmmultiscripts_base { 7 | static kind: string; 8 | toSVG(parent: N): void; 9 | protected addScripts(x: number, u: number, v: number, i: number, n: number, align: string): number; 10 | } 11 | export {}; 12 | -------------------------------------------------------------------------------- /mathjax/output/svg/Wrappers/mn.d.ts: -------------------------------------------------------------------------------- 1 | import { SVGConstructor } from '../Wrapper.js'; 2 | declare const SVGmn_base: import("../../common/Wrappers/mn.js").MnConstructor & SVGConstructor; 3 | export declare class SVGmn extends SVGmn_base { 4 | static kind: string; 5 | } 6 | export {}; 7 | -------------------------------------------------------------------------------- /mathjax/output/svg/Wrappers/mn.js.map: -------------------------------------------------------------------------------- 1 | {"version":3,"file":"mn.js","sourceRoot":"","sources":["../../../../ts/output/svg/Wrappers/mn.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AAuBA,4CAAyD;AACzD,qDAA0D;AAC1D,8DAA2D;AAW3D;IACA,yBAAwD;IADxD;;IAQA,CAAC;IAFe,UAAI,GAAG,aAAK,CAAC,SAAS,CAAC,IAAI,CAAC;IAE5C,YAAC;CAAA,AARD,CACA,IAAA,qBAAa,EAAgC,uBAAU,CAAC,GAOvD;AARY,sBAAK"} -------------------------------------------------------------------------------- /mathjax/output/svg/Wrappers/mpadded.d.ts: -------------------------------------------------------------------------------- 1 | import { SVGConstructor } from '../Wrapper.js'; 2 | declare const SVGmpadded_base: import("../../common/Wrappers/mpadded.js").MpaddedConstructor & SVGConstructor; 3 | export declare class SVGmpadded extends SVGmpadded_base { 4 | static kind: string; 5 | toSVG(parent: N): void; 6 | } 7 | export {}; 8 | -------------------------------------------------------------------------------- /mathjax/output/svg/Wrappers/mphantom.d.ts: -------------------------------------------------------------------------------- 1 | import { SVGWrapper } from '../Wrapper.js'; 2 | export declare class SVGmphantom extends SVGWrapper { 3 | static kind: string; 4 | toSVG(parent: N): void; 5 | } 6 | -------------------------------------------------------------------------------- /mathjax/output/svg/Wrappers/mphantom.js.map: -------------------------------------------------------------------------------- 1 | {"version":3,"file":"mphantom.js","sourceRoot":"","sources":["../../../../ts/output/svg/Wrappers/mphantom.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AAuBA,4CAAyC;AACzC,0EAAuE;AAUvE;IAA0C,+BAAmB;IAA7D;;IAcA,CAAC;IAJQ,2BAAK,GAAZ,UAAa,MAAS;QACpB,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC;IAC/B,CAAC;IAPa,gBAAI,GAAG,yBAAW,CAAC,SAAS,CAAC,IAAI,CAAC;IASlD,kBAAC;CAAA,AAdD,CAA0C,uBAAU,GAcnD;AAdY,kCAAW"} -------------------------------------------------------------------------------- /mathjax/output/svg/Wrappers/mroot.d.ts: -------------------------------------------------------------------------------- 1 | import { SVGWrapper, Constructor } from '../Wrapper.js'; 2 | import { SVGmsqrt } from './msqrt.js'; 3 | import { BBox } from '../../../util/BBox.js'; 4 | declare const SVGmroot_base: import("../../common/Wrappers/mroot.js").MrootConstructor & Constructor>; 5 | export declare class SVGmroot extends SVGmroot_base { 6 | static kind: string; 7 | protected addRoot(ROOT: N, root: SVGWrapper, sbox: BBox, H: number): void; 8 | } 9 | export {}; 10 | -------------------------------------------------------------------------------- /mathjax/output/svg/Wrappers/mroot.js.map: -------------------------------------------------------------------------------- 1 | {"version":3,"file":"mroot.js","sourceRoot":"","sources":["../../../../ts/output/svg/Wrappers/mroot.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,uCAAoC;AACpC,2DAAgE;AAEhE,oEAAiE;AAUjE;IAAuC,4BAAgE;IAAvG;;IAkBA,CAAC;IARW,0BAAO,GAAjB,UAAkB,IAAO,EAAE,IAAyB,EAAE,IAAU,EAAE,CAAS;QACzE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QACX,IAAA,KAAA,OAAa,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,CAAC,CAAC,IAAA,EAAvC,CAAC,QAAA,EAAE,CAAC,QAAA,EAAE,EAAE,QAA+B,CAAC;QAC/C,IAAM,IAAI,GAAG,IAAI,CAAC,YAAY,EAAE,CAAC;QACjC,IAAI,CAAC,KAAK,CAAC,EAAE,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;QAChC,IAAI,CAAC,EAAE,GAAG,CAAC,CAAC;IACd,CAAC;IAXa,aAAI,GAAG,mBAAQ,CAAC,SAAS,CAAC,IAAI,CAAC;IAa/C,eAAC;CAAA,AAlBD,CAAuC,IAAA,2BAAgB,EAAuC,mBAAQ,CAAC,GAkBtG;AAlBY,4BAAQ"} -------------------------------------------------------------------------------- /mathjax/output/svg/Wrappers/mrow.d.ts: -------------------------------------------------------------------------------- 1 | import { SVGConstructor, Constructor } from '../Wrapper.js'; 2 | declare const SVGmrow_base: import("../../common/Wrappers/mrow.js").MrowConstructor & SVGConstructor; 3 | export declare class SVGmrow extends SVGmrow_base { 4 | static kind: string; 5 | toSVG(parent: N): void; 6 | } 7 | declare const SVGinferredMrow_base: import("../../common/Wrappers/mrow.js").InferredMrowConstructor & Constructor>; 8 | export declare class SVGinferredMrow extends SVGinferredMrow_base { 9 | static kind: string; 10 | } 11 | export {}; 12 | -------------------------------------------------------------------------------- /mathjax/output/svg/Wrappers/mrow.js.map: -------------------------------------------------------------------------------- 1 | {"version":3,"file":"mrow.js","sourceRoot":"","sources":["../../../../ts/output/svg/Wrappers/mrow.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AAuBA,4CAAsE;AACtE,yDAA8D;AAC9D,yDAAsE;AACtE,kEAAgF;AAWhF;IACA,2BAA0D;IAD1D;;IAiBA,CAAC;IANQ,uBAAK,GAAZ,UAAa,MAAS;QACpB,IAAM,GAAG,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC,CAAC;QAC5F,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;IAExB,CAAC;IATa,YAAI,GAAG,iBAAO,CAAC,SAAS,CAAC,IAAI,CAAC;IAW9C,cAAC;CAAA,AAjBD,CACA,IAAA,yBAAe,EAAgC,uBAAU,CAAC,GAgBzD;AAjBY,0BAAO;AA4BpB;IACA,mCAAqE;IADrE;;IAQA,CAAC;IAFe,oBAAI,GAAG,yBAAe,CAAC,SAAS,CAAC,IAAI,CAAC;IAEtD,sBAAC;CAAA,AARD,CACA,IAAA,iCAAuB,EAAsC,OAAO,CAAC,GAOpE;AARY,0CAAe"} -------------------------------------------------------------------------------- /mathjax/output/svg/Wrappers/ms.d.ts: -------------------------------------------------------------------------------- 1 | import { SVGConstructor } from '../Wrapper.js'; 2 | declare const SVGms_base: import("../../common/Wrappers/ms.js").MsConstructor & SVGConstructor; 3 | export declare class SVGms extends SVGms_base { 4 | static kind: string; 5 | } 6 | export {}; 7 | -------------------------------------------------------------------------------- /mathjax/output/svg/Wrappers/ms.js.map: -------------------------------------------------------------------------------- 1 | {"version":3,"file":"ms.js","sourceRoot":"","sources":["../../../../ts/output/svg/Wrappers/ms.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AAuBA,4CAAyD;AACzD,qDAA0D;AAC1D,8DAA2D;AAW3D;IACA,yBAAwD;IADxD;;IAQA,CAAC;IAFe,UAAI,GAAG,aAAK,CAAC,SAAS,CAAC,IAAI,CAAC;IAE5C,YAAC;CAAA,AARD,CACA,IAAA,qBAAa,EAAgC,uBAAU,CAAC,GAOvD;AARY,sBAAK"} -------------------------------------------------------------------------------- /mathjax/output/svg/Wrappers/mspace.d.ts: -------------------------------------------------------------------------------- 1 | import { SVGConstructor } from '../Wrapper.js'; 2 | declare const SVGmspace_base: import("../../common/Wrappers/mspace.js").MspaceConstructor & SVGConstructor; 3 | export declare class SVGmspace extends SVGmspace_base { 4 | static kind: string; 5 | } 6 | export {}; 7 | -------------------------------------------------------------------------------- /mathjax/output/svg/Wrappers/mspace.js.map: -------------------------------------------------------------------------------- 1 | {"version":3,"file":"mspace.js","sourceRoot":"","sources":["../../../../ts/output/svg/Wrappers/mspace.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AAuBA,4CAAyD;AACzD,6DAAkE;AAClE,sEAAmE;AAWnE;IACA,6BAA4D;IAD5D;;IAQA,CAAC;IAFe,cAAI,GAAG,qBAAS,CAAC,SAAS,CAAC,IAAI,CAAC;IAEhD,gBAAC;CAAA,AARD,CACA,IAAA,6BAAiB,EAAgC,uBAAU,CAAC,GAO3D;AARY,8BAAS"} -------------------------------------------------------------------------------- /mathjax/output/svg/Wrappers/msqrt.d.ts: -------------------------------------------------------------------------------- 1 | import { SVGWrapper, SVGConstructor } from '../Wrapper.js'; 2 | import { BBox } from '../../../util/BBox.js'; 3 | declare const SVGmsqrt_base: import("../../common/Wrappers/msqrt.js").MsqrtConstructor & SVGConstructor; 4 | export declare class SVGmsqrt extends SVGmsqrt_base { 5 | static kind: string; 6 | dx: number; 7 | toSVG(parent: N): void; 8 | protected addRoot(_ROOT: N, _root: SVGWrapper, _sbox: BBox, _H: number): void; 9 | } 10 | export {}; 11 | -------------------------------------------------------------------------------- /mathjax/output/svg/Wrappers/mtd.d.ts: -------------------------------------------------------------------------------- 1 | import { SVGConstructor } from '../Wrapper.js'; 2 | declare const SVGmtd_base: import("../../common/Wrappers/mtd.js").MtdConstructor & SVGConstructor; 3 | export declare class SVGmtd extends SVGmtd_base { 4 | static kind: string; 5 | placeCell(x: number, y: number, W: number, H: number, D: number): [number, number]; 6 | placeColor(x: number, y: number, W: number, H: number): void; 7 | } 8 | export {}; 9 | -------------------------------------------------------------------------------- /mathjax/output/svg/Wrappers/mtext.d.ts: -------------------------------------------------------------------------------- 1 | import { SVGConstructor } from '../Wrapper.js'; 2 | declare const SVGmtext_base: import("../../common/Wrappers/mtext.js").MtextConstructor & SVGConstructor; 3 | export declare class SVGmtext extends SVGmtext_base { 4 | static kind: string; 5 | } 6 | export {}; 7 | -------------------------------------------------------------------------------- /mathjax/output/svg/Wrappers/mtext.js.map: -------------------------------------------------------------------------------- 1 | {"version":3,"file":"mtext.js","sourceRoot":"","sources":["../../../../ts/output/svg/Wrappers/mtext.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AAuBA,4CAAyD;AACzD,2DAAgE;AAChE,oEAAiE;AAWjE;IACA,4BAA2D;IAD3D;;IAQA,CAAC;IAFe,aAAI,GAAG,mBAAQ,CAAC,SAAS,CAAC,IAAI,CAAC;IAE/C,eAAC;CAAA,AARD,CACA,IAAA,2BAAgB,EAAgC,uBAAU,CAAC,GAO1D;AARY,4BAAQ"} -------------------------------------------------------------------------------- /mathjax/output/svg/Wrappers/scriptbase.d.ts: -------------------------------------------------------------------------------- 1 | import { SVGWrapper, SVGConstructor } from '../Wrapper.js'; 2 | declare const SVGscriptbase_base: import("../../common/Wrappers/scriptbase.js").ScriptbaseConstructor> & SVGConstructor; 3 | export declare class SVGscriptbase extends SVGscriptbase_base { 4 | static kind: string; 5 | toSVG(parent: N): void; 6 | } 7 | export {}; 8 | -------------------------------------------------------------------------------- /mathjax/output/svg/Wrappers/scriptbase.js.map: -------------------------------------------------------------------------------- 1 | {"version":3,"file":"scriptbase.js","sourceRoot":"","sources":["../../../../ts/output/svg/Wrappers/scriptbase.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,4CAAyD;AACzD,qEAA0E;AAY1E;IACA,iCAA2F;IAD3F;;IAuBA,CAAC;IATQ,6BAAK,GAAZ,UAAa,MAAS;QACpB,IAAM,GAAG,GAAG,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC;QACzC,IAAM,CAAC,GAAG,IAAI,CAAC,YAAY,EAAE,CAAC;QACxB,IAAA,KAAA,OAAS,IAAI,CAAC,SAAS,EAAE,IAAA,EAAxB,CAAC,QAAA,EAAE,CAAC,QAAoB,CAAC;QAChC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAC1B,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAC5B,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC;IACnC,CAAC;IAfa,kBAAI,GAAG,YAAY,CAAC;IAiBpC,oBAAC;CAAA,AAvBD,CACA,IAAA,qCAAqB,EAA2D,uBAAU,CAAC,GAsB1F;AAvBY,sCAAa"} -------------------------------------------------------------------------------- /mathjax/output/svg/fonts/tex.d.ts: -------------------------------------------------------------------------------- 1 | import { SVGFontData, SVGCharOptions, SVGVariantData, SVGDelimiterData, DelimiterMap, CharMapMap } from '../FontData.js'; 2 | import { OptionList } from '../../../util/Options.js'; 3 | declare const TeXFont_base: import("../FontData.js").FontDataClass & typeof SVGFontData; 4 | export declare class TeXFont extends TeXFont_base { 5 | protected static defaultDelimiters: DelimiterMap; 6 | protected static defaultChars: CharMapMap; 7 | protected static variantCacheIds: { 8 | [name: string]: string; 9 | }; 10 | constructor(options?: OptionList); 11 | } 12 | export {}; 13 | -------------------------------------------------------------------------------- /mathjax/output/svg/fonts/tex/bold-italic.d.ts: -------------------------------------------------------------------------------- 1 | import { SVGCharMap } from '../../FontData.js'; 2 | export declare const boldItalic: SVGCharMap; 3 | -------------------------------------------------------------------------------- /mathjax/output/svg/fonts/tex/bold-italic.js.map: -------------------------------------------------------------------------------- 1 | {"version":3,"file":"bold-italic.js","sourceRoot":"","sources":["../../../../../ts/output/svg/fonts/tex/bold-italic.ts"],"names":[],"mappings":";;;AAgBA,iDAAuD;AACvD,2EAA4E;AAE/D,QAAA,UAAU,GAAe,IAAA,sBAAQ,EAAC,2BAAI,EAAE;IACjD,IAAI,EAAE,mLAAmL;IACzL,KAAK,EAAE,qZAAqZ;IAC5Z,KAAK,EAAE,0aAA0a;IACjb,MAAM,EAAE,mLAAmL;IAC3L,MAAM,EAAE,6NAA6N;IACrO,MAAM,EAAE,mLAAmL;CAC9L,EAAC,EACD,CAAC,CAAC"} -------------------------------------------------------------------------------- /mathjax/output/svg/fonts/tex/bold.d.ts: -------------------------------------------------------------------------------- 1 | import { SVGCharMap } from '../../FontData.js'; 2 | export declare const bold: SVGCharMap; 3 | -------------------------------------------------------------------------------- /mathjax/output/svg/fonts/tex/double-struck.d.ts: -------------------------------------------------------------------------------- 1 | export { doubleStruck } from '../../../common/fonts/tex/double-struck.js'; 2 | -------------------------------------------------------------------------------- /mathjax/output/svg/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/svg/fonts/tex/double-struck.js.map: -------------------------------------------------------------------------------- 1 | {"version":3,"file":"double-struck.js","sourceRoot":"","sources":["../../../../../ts/output/svg/fonts/tex/double-struck.ts"],"names":[],"mappings":";;;AAgBA,+EAAwE;AAAhE,gHAAA,YAAY,OAAA"} -------------------------------------------------------------------------------- /mathjax/output/svg/fonts/tex/fraktur-bold.d.ts: -------------------------------------------------------------------------------- 1 | import { SVGCharMap } from '../../FontData.js'; 2 | export declare const frakturBold: SVGCharMap; 3 | -------------------------------------------------------------------------------- /mathjax/output/svg/fonts/tex/fraktur.d.ts: -------------------------------------------------------------------------------- 1 | import { SVGCharMap } from '../../FontData.js'; 2 | export declare const fraktur: SVGCharMap; 3 | -------------------------------------------------------------------------------- /mathjax/output/svg/fonts/tex/italic.d.ts: -------------------------------------------------------------------------------- 1 | import { SVGCharMap } from '../../FontData.js'; 2 | export declare const italic: SVGCharMap; 3 | -------------------------------------------------------------------------------- /mathjax/output/svg/fonts/tex/largeop.d.ts: -------------------------------------------------------------------------------- 1 | import { SVGCharMap } from '../../FontData.js'; 2 | export declare const largeop: SVGCharMap; 3 | -------------------------------------------------------------------------------- /mathjax/output/svg/fonts/tex/monospace.d.ts: -------------------------------------------------------------------------------- 1 | import { SVGCharMap } from '../../FontData.js'; 2 | export declare const monospace: SVGCharMap; 3 | -------------------------------------------------------------------------------- /mathjax/output/svg/fonts/tex/normal.d.ts: -------------------------------------------------------------------------------- 1 | import { SVGCharMap } from '../../FontData.js'; 2 | export declare const normal: SVGCharMap; 3 | -------------------------------------------------------------------------------- /mathjax/output/svg/fonts/tex/sans-serif-bold-italic.d.ts: -------------------------------------------------------------------------------- 1 | import { SVGCharMap } from '../../FontData.js'; 2 | export declare const sansSerifBoldItalic: SVGCharMap; 3 | -------------------------------------------------------------------------------- /mathjax/output/svg/fonts/tex/sans-serif-bold-italic.js.map: -------------------------------------------------------------------------------- 1 | {"version":3,"file":"sans-serif-bold-italic.js","sourceRoot":"","sources":["../../../../../ts/output/svg/fonts/tex/sans-serif-bold-italic.ts"],"names":[],"mappings":";;;AAgBA,iDAAuD;AACvD,iGAAgG;AAEnF,QAAA,mBAAmB,GAAe,IAAA,sBAAQ,EAAC,+CAAI,EAAE;IAC1D,KAAK,EAAE,0GAA0G;IACjH,KAAK,EAAE,8RAA8R;CACxS,EAAC,EACD,CAAC,CAAC"} -------------------------------------------------------------------------------- /mathjax/output/svg/fonts/tex/sans-serif-bold.d.ts: -------------------------------------------------------------------------------- 1 | import { SVGCharMap } from '../../FontData.js'; 2 | export declare const sansSerifBold: SVGCharMap; 3 | -------------------------------------------------------------------------------- /mathjax/output/svg/fonts/tex/sans-serif-italic.d.ts: -------------------------------------------------------------------------------- 1 | import { SVGCharMap } from '../../FontData.js'; 2 | export declare const sansSerifItalic: SVGCharMap; 3 | -------------------------------------------------------------------------------- /mathjax/output/svg/fonts/tex/sans-serif.d.ts: -------------------------------------------------------------------------------- 1 | import { SVGCharMap } from '../../FontData.js'; 2 | export declare const sansSerif: SVGCharMap; 3 | -------------------------------------------------------------------------------- /mathjax/output/svg/fonts/tex/script-bold.d.ts: -------------------------------------------------------------------------------- 1 | export { scriptBold } from '../../../common/fonts/tex/script-bold.js'; 2 | -------------------------------------------------------------------------------- /mathjax/output/svg/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/svg/fonts/tex/script-bold.js.map: -------------------------------------------------------------------------------- 1 | {"version":3,"file":"script-bold.js","sourceRoot":"","sources":["../../../../../ts/output/svg/fonts/tex/script-bold.ts"],"names":[],"mappings":";;;AAgBA,2EAAoE;AAA5D,4GAAA,UAAU,OAAA"} -------------------------------------------------------------------------------- /mathjax/output/svg/fonts/tex/script.d.ts: -------------------------------------------------------------------------------- 1 | export { script } from '../../../common/fonts/tex/script.js'; 2 | -------------------------------------------------------------------------------- /mathjax/output/svg/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/svg/fonts/tex/script.js.map: -------------------------------------------------------------------------------- 1 | {"version":3,"file":"script.js","sourceRoot":"","sources":["../../../../../ts/output/svg/fonts/tex/script.ts"],"names":[],"mappings":";;;AAgBA,iEAA2D;AAAnD,mGAAA,MAAM,OAAA"} -------------------------------------------------------------------------------- /mathjax/output/svg/fonts/tex/smallop.d.ts: -------------------------------------------------------------------------------- 1 | import { SVGCharMap } from '../../FontData.js'; 2 | export declare const smallop: SVGCharMap; 3 | -------------------------------------------------------------------------------- /mathjax/output/svg/fonts/tex/tex-calligraphic-bold.d.ts: -------------------------------------------------------------------------------- 1 | import { SVGCharMap } from '../../FontData.js'; 2 | export declare const texCalligraphicBold: SVGCharMap; 3 | -------------------------------------------------------------------------------- /mathjax/output/svg/fonts/tex/tex-calligraphic.d.ts: -------------------------------------------------------------------------------- 1 | import { SVGCharMap } from '../../FontData.js'; 2 | export declare const texCalligraphic: SVGCharMap; 3 | -------------------------------------------------------------------------------- /mathjax/output/svg/fonts/tex/tex-mathit.d.ts: -------------------------------------------------------------------------------- 1 | import { SVGCharMap } from '../../FontData.js'; 2 | export declare const texMathit: SVGCharMap; 3 | -------------------------------------------------------------------------------- /mathjax/output/svg/fonts/tex/tex-oldstyle-bold.d.ts: -------------------------------------------------------------------------------- 1 | import { SVGCharMap } from '../../FontData.js'; 2 | export declare const texOldstyleBold: SVGCharMap; 3 | -------------------------------------------------------------------------------- /mathjax/output/svg/fonts/tex/tex-oldstyle.d.ts: -------------------------------------------------------------------------------- 1 | import { SVGCharMap } from '../../FontData.js'; 2 | export declare const texOldstyle: SVGCharMap; 3 | -------------------------------------------------------------------------------- /mathjax/output/svg/fonts/tex/tex-size3.d.ts: -------------------------------------------------------------------------------- 1 | import { SVGCharMap } from '../../FontData.js'; 2 | export declare const texSize3: SVGCharMap; 3 | -------------------------------------------------------------------------------- /mathjax/output/svg/fonts/tex/tex-size4.d.ts: -------------------------------------------------------------------------------- 1 | import { SVGCharMap } from '../../FontData.js'; 2 | export declare const texSize4: SVGCharMap; 3 | -------------------------------------------------------------------------------- /mathjax/output/svg/fonts/tex/tex-variant.d.ts: -------------------------------------------------------------------------------- 1 | import { SVGCharMap } from '../../FontData.js'; 2 | export declare const texVariant: SVGCharMap; 3 | -------------------------------------------------------------------------------- /mathjax/ui/menu/MmlVisitor.d.ts: -------------------------------------------------------------------------------- 1 | import { MathItem } from '../../core/MathItem.js'; 2 | import { MmlNode } from '../../core/MmlTree/MmlNode.js'; 3 | import { SerializedMmlVisitor } from '../../core/MmlTree/SerializedMmlVisitor.js'; 4 | import { OptionList } from '../../util/Options.js'; 5 | export declare class MmlVisitor extends SerializedMmlVisitor { 6 | options: OptionList; 7 | mathItem: MathItem; 8 | visitTree(node: MmlNode, math?: MathItem, options?: OptionList): any; 9 | visitTeXAtomNode(node: MmlNode, space: string): any; 10 | visitMathNode(node: MmlNode, space: string): string; 11 | } 12 | -------------------------------------------------------------------------------- /mathjax/ui/menu/SelectableInfo.d.ts: -------------------------------------------------------------------------------- 1 | import { Info } from 'mj-context-menu/js/info.js'; 2 | export declare class SelectableInfo extends Info { 3 | addEvents(element: HTMLElement): void; 4 | selectAll(): void; 5 | copyToClipboard(): void; 6 | generateHtml(): void; 7 | } 8 | -------------------------------------------------------------------------------- /mathjax/ui/safe/SafeHandler.d.ts: -------------------------------------------------------------------------------- 1 | import { MathDocument, MathDocumentConstructor } from '../../core/MathDocument.js'; 2 | import { Handler } from '../../core/Handler.js'; 3 | import { Safe } from './safe.js'; 4 | export declare type Constructor = new (...args: any[]) => T; 5 | export interface SafeMathDocument extends MathDocument { 6 | safe: Safe; 7 | } 8 | export declare function SafeMathDocumentMixin>>(BaseDocument: B): Constructor> & B; 9 | export declare function SafeHandler(handler: Handler): Handler; 10 | -------------------------------------------------------------------------------- /mathjax/ui/safe/SafeMethods.d.ts: -------------------------------------------------------------------------------- 1 | import { FilterFunction } from './safe.js'; 2 | export declare const SafeMethods: { 3 | [name: string]: FilterFunction; 4 | }; 5 | -------------------------------------------------------------------------------- /mathjax/util/AsyncLoad.d.ts: -------------------------------------------------------------------------------- 1 | export declare function asyncLoad(name: string): Promise; 2 | -------------------------------------------------------------------------------- /mathjax/util/AsyncLoad.js.map: -------------------------------------------------------------------------------- 1 | {"version":3,"file":"AsyncLoad.js","sourceRoot":"","sources":["../../ts/util/AsyncLoad.ts"],"names":[],"mappings":";;;AAuBA,4CAAsC;AAQtC,SAAgB,SAAS,CAAC,IAAY;IACpC,IAAI,CAAC,oBAAO,CAAC,SAAS,EAAE;QACtB,OAAO,OAAO,CAAC,MAAM,CAAC,sBAAe,IAAI,qCAAkC,CAAC,CAAC;KAC9E;IACD,OAAO,IAAI,OAAO,CAAC,UAAC,EAAE,EAAE,IAAI;QAC1B,IAAM,MAAM,GAAG,oBAAO,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;QACvC,IAAI,MAAM,YAAY,OAAO,EAAE;YAC7B,MAAM,CAAC,IAAI,CAAC,UAAC,KAAU,IAAK,OAAA,EAAE,CAAC,KAAK,CAAC,EAAT,CAAS,CAAC,CAAC,KAAK,CAAC,UAAC,GAAU,IAAK,OAAA,IAAI,CAAC,GAAG,CAAC,EAAT,CAAS,CAAC,CAAC;SACzE;aAAM;YACL,EAAE,CAAC,MAAM,CAAC,CAAC;SACZ;IACH,CAAC,CAAC,CAAC;AACL,CAAC;AAZD,8BAYC"} -------------------------------------------------------------------------------- /mathjax/util/BBox.d.ts: -------------------------------------------------------------------------------- 1 | export declare type BBoxData = { 2 | w?: number; 3 | h?: number; 4 | d?: number; 5 | }; 6 | export declare class BBox { 7 | static fullWidth: string; 8 | static StyleAdjust: [string, string, number?][]; 9 | w: number; 10 | h: number; 11 | d: number; 12 | scale: number; 13 | rscale: number; 14 | L: number; 15 | R: number; 16 | pwidth: string; 17 | ic: number; 18 | sk: number; 19 | dx: number; 20 | static zero(): BBox; 21 | static empty(): BBox; 22 | constructor(def?: BBoxData); 23 | empty(): BBox; 24 | clean(): void; 25 | rescale(scale: number): void; 26 | combine(cbox: BBox, x?: number, y?: number): void; 27 | append(cbox: BBox): void; 28 | updateFrom(cbox: BBox): void; 29 | } 30 | -------------------------------------------------------------------------------- /mathjax/util/BitField.d.ts: -------------------------------------------------------------------------------- 1 | export declare class BitField { 2 | protected static MAXBIT: number; 3 | protected static next: number; 4 | protected static names: Map; 5 | protected bits: number; 6 | static allocate(...names: string[]): void; 7 | static has(name: string): boolean; 8 | set(name: string): void; 9 | clear(name: string): void; 10 | isSet(name: string): boolean; 11 | reset(): void; 12 | protected getBit(name: string): number; 13 | } 14 | export declare function BitFieldClass(...names: string[]): typeof BitField; 15 | -------------------------------------------------------------------------------- /mathjax/util/Entities.d.ts: -------------------------------------------------------------------------------- 1 | import { OptionList } from './Options.js'; 2 | export declare type EntityList = { 3 | [name: string]: string; 4 | }; 5 | export declare const options: OptionList; 6 | export declare const entities: EntityList; 7 | export declare function add(additions: EntityList, file: string): void; 8 | export declare function remove(entity: string): void; 9 | export declare function translate(text: string): string; 10 | export declare function numeric(entity: string): string; 11 | -------------------------------------------------------------------------------- /mathjax/util/FunctionList.d.ts: -------------------------------------------------------------------------------- 1 | import { PrioritizedList, PrioritizedListItem } from './PrioritizedList.js'; 2 | export interface FunctionListItem extends PrioritizedListItem { 3 | } 4 | export declare class FunctionList extends PrioritizedList { 5 | execute(...data: any[]): boolean; 6 | asyncExecute(...data: any[]): Promise; 7 | } 8 | -------------------------------------------------------------------------------- /mathjax/util/PrioritizedList.d.ts: -------------------------------------------------------------------------------- 1 | export interface PrioritizedListItem { 2 | priority: number; 3 | item: DataClass; 4 | } 5 | export declare class PrioritizedList { 6 | static DEFAULTPRIORITY: number; 7 | protected items: PrioritizedListItem[]; 8 | constructor(); 9 | [Symbol.iterator](): Iterator>; 10 | add(item: DataClass, priority?: number): DataClass; 11 | remove(item: DataClass): void; 12 | } 13 | -------------------------------------------------------------------------------- /mathjax/util/Retries.d.ts: -------------------------------------------------------------------------------- 1 | export interface RetryError extends Error { 2 | retry: Promise; 3 | } 4 | export declare function handleRetriesFor(code: Function): Promise; 5 | export declare function retryAfter(promise: Promise): void; 6 | -------------------------------------------------------------------------------- /mathjax/util/StyleList.d.ts: -------------------------------------------------------------------------------- 1 | export declare type StyleData = { 2 | [property: string]: string | number; 3 | }; 4 | export declare type StyleList = { 5 | [selector: string]: StyleData; 6 | }; 7 | export declare class CssStyles { 8 | protected styles: StyleList; 9 | get cssText(): string; 10 | constructor(styles?: StyleList); 11 | addStyles(styles: StyleList): void; 12 | removeStyles(...selectors: string[]): void; 13 | clear(): void; 14 | getStyleString(): string; 15 | getStyleRules(): string[]; 16 | getStyleDefString(styles: StyleData): string; 17 | } 18 | -------------------------------------------------------------------------------- /mathjax/util/asyncLoad/node.d.ts: -------------------------------------------------------------------------------- 1 | export {}; 2 | -------------------------------------------------------------------------------- /mathjax/util/asyncLoad/node.js.map: -------------------------------------------------------------------------------- 1 | {"version":3,"file":"node.js","sourceRoot":"","sources":["../../../ts/util/asyncLoad/node.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAuBA,+CAAyC;AACzC,yCAA6B;AAK7B,IAAM,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC;AAEnD,IAAI,CAAC,oBAAO,CAAC,SAAS,IAAI,OAAO,OAAO,KAAK,WAAW,EAAE;IACxD,oBAAO,CAAC,SAAS,GAAG,UAAC,IAAY;QAC/B,OAAO,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;IAC3E,CAAC,CAAC;CACH"} -------------------------------------------------------------------------------- /mathjax/util/asyncLoad/system.d.ts: -------------------------------------------------------------------------------- 1 | export declare function setBaseURL(URL: string): void; 2 | -------------------------------------------------------------------------------- /mathjax/util/asyncLoad/system.js: -------------------------------------------------------------------------------- 1 | "use strict"; 2 | Object.defineProperty(exports, "__esModule", { value: true }); 3 | exports.setBaseURL = void 0; 4 | var mathjax_js_1 = require("../../mathjax.js"); 5 | var root = 'file://' + __dirname.replace(/\/\/[^\/]*$/, '/'); 6 | if (!mathjax_js_1.mathjax.asyncLoad && typeof System !== 'undefined' && System.import) { 7 | mathjax_js_1.mathjax.asyncLoad = function (name) { 8 | return System.import(name, root); 9 | }; 10 | } 11 | function setBaseURL(URL) { 12 | root = URL; 13 | if (!root.match(/\/$/)) { 14 | root += '/'; 15 | } 16 | } 17 | exports.setBaseURL = setBaseURL; 18 | //# sourceMappingURL=system.js.map -------------------------------------------------------------------------------- /mathjax/util/asyncLoad/system.js.map: -------------------------------------------------------------------------------- 1 | {"version":3,"file":"system.js","sourceRoot":"","sources":["../../../ts/util/asyncLoad/system.ts"],"names":[],"mappings":";;;AAuBA,+CAAyC;AAKzC,IAAI,IAAI,GAAG,SAAS,GAAG,SAAS,CAAC,OAAO,CAAC,aAAa,EAAE,GAAG,CAAC,CAAC;AAE7D,IAAI,CAAC,oBAAO,CAAC,SAAS,IAAI,OAAO,MAAM,KAAK,WAAW,IAAI,MAAM,CAAC,MAAM,EAAE;IACxE,oBAAO,CAAC,SAAS,GAAG,UAAC,IAAY;QAC/B,OAAO,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IACnC,CAAC,CAAC;CACH;AAKD,SAAgB,UAAU,CAAC,GAAW;IACpC,IAAI,GAAG,GAAG,CAAC;IACX,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE;QACtB,IAAI,IAAI,GAAG,CAAC;KACb;AACH,CAAC;AALD,gCAKC"} -------------------------------------------------------------------------------- /mathjax/util/entities/a.d.ts: -------------------------------------------------------------------------------- 1 | export {}; 2 | -------------------------------------------------------------------------------- /mathjax/util/entities/all.d.ts: -------------------------------------------------------------------------------- 1 | import './a.js'; 2 | import './b.js'; 3 | import './c.js'; 4 | import './d.js'; 5 | import './e.js'; 6 | import './f.js'; 7 | import './g.js'; 8 | import './h.js'; 9 | import './i.js'; 10 | import './j.js'; 11 | import './k.js'; 12 | import './l.js'; 13 | import './m.js'; 14 | import './n.js'; 15 | import './o.js'; 16 | import './p.js'; 17 | import './q.js'; 18 | import './r.js'; 19 | import './s.js'; 20 | import './t.js'; 21 | import './u.js'; 22 | import './v.js'; 23 | import './w.js'; 24 | import './x.js'; 25 | import './y.js'; 26 | import './z.js'; 27 | import './fr.js'; 28 | import './opf.js'; 29 | import './scr.js'; 30 | -------------------------------------------------------------------------------- /mathjax/util/entities/all.js.map: -------------------------------------------------------------------------------- 1 | {"version":3,"file":"all.js","sourceRoot":"","sources":["../../../ts/util/entities/all.ts"],"names":[],"mappings":";;AAuBA,kBAAgB;AAChB,kBAAgB;AAChB,kBAAgB;AAChB,kBAAgB;AAChB,kBAAgB;AAChB,kBAAgB;AAChB,kBAAgB;AAChB,kBAAgB;AAChB,kBAAgB;AAChB,kBAAgB;AAChB,kBAAgB;AAChB,kBAAgB;AAChB,kBAAgB;AAChB,kBAAgB;AAChB,kBAAgB;AAChB,kBAAgB;AAChB,kBAAgB;AAChB,kBAAgB;AAChB,kBAAgB;AAChB,kBAAgB;AAChB,kBAAgB;AAChB,kBAAgB;AAChB,kBAAgB;AAChB,kBAAgB;AAChB,kBAAgB;AAChB,kBAAgB;AAEhB,mBAAiB;AACjB,oBAAkB;AAClB,oBAAkB"} -------------------------------------------------------------------------------- /mathjax/util/entities/b.d.ts: -------------------------------------------------------------------------------- 1 | export {}; 2 | -------------------------------------------------------------------------------- /mathjax/util/entities/c.d.ts: -------------------------------------------------------------------------------- 1 | export {}; 2 | -------------------------------------------------------------------------------- /mathjax/util/entities/d.d.ts: -------------------------------------------------------------------------------- 1 | export {}; 2 | -------------------------------------------------------------------------------- /mathjax/util/entities/e.d.ts: -------------------------------------------------------------------------------- 1 | export {}; 2 | -------------------------------------------------------------------------------- /mathjax/util/entities/f.d.ts: -------------------------------------------------------------------------------- 1 | export {}; 2 | -------------------------------------------------------------------------------- /mathjax/util/entities/fr.d.ts: -------------------------------------------------------------------------------- 1 | export {}; 2 | -------------------------------------------------------------------------------- /mathjax/util/entities/g.d.ts: -------------------------------------------------------------------------------- 1 | export {}; 2 | -------------------------------------------------------------------------------- /mathjax/util/entities/h.d.ts: -------------------------------------------------------------------------------- 1 | export {}; 2 | -------------------------------------------------------------------------------- /mathjax/util/entities/h.js.map: -------------------------------------------------------------------------------- 1 | {"version":3,"file":"h.js","sourceRoot":"","sources":["../../../ts/util/entities/h.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAiBA,uDAA2C;AAE3C,QAAQ,CAAC,GAAG,CAAC;IACT,MAAM,EAAE,QAAQ;IAChB,KAAK,EAAE,QAAQ;IACf,YAAY,EAAE,QAAQ;IACtB,cAAc,EAAE,QAAQ;IACxB,MAAM,EAAE,QAAQ;IAChB,IAAI,EAAE,QAAQ;IACd,MAAM,EAAE,QAAQ;IAChB,IAAI,EAAE,QAAQ;IACd,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,QAAQ;IAChB,IAAI,EAAE,QAAQ;IACd,OAAO,EAAE,QAAQ;IACjB,KAAK,EAAE,QAAQ;IACf,MAAM,EAAE,QAAQ;IAChB,SAAS,EAAE,QAAQ;IACnB,MAAM,EAAE,QAAQ;IAChB,QAAQ,EAAE,QAAQ;IAClB,QAAQ,EAAE,QAAQ;IAClB,KAAK,EAAE,QAAQ;IACf,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,QAAQ;CACnB,EAAE,GAAG,CAAC,CAAC"} -------------------------------------------------------------------------------- /mathjax/util/entities/i.d.ts: -------------------------------------------------------------------------------- 1 | export {}; 2 | -------------------------------------------------------------------------------- /mathjax/util/entities/j.d.ts: -------------------------------------------------------------------------------- 1 | export {}; 2 | -------------------------------------------------------------------------------- /mathjax/util/entities/j.js.map: -------------------------------------------------------------------------------- 1 | {"version":3,"file":"j.js","sourceRoot":"","sources":["../../../ts/util/entities/j.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAiBA,uDAA2C;AAE3C,QAAQ,CAAC,GAAG,CAAC;IACT,KAAK,EAAE,QAAQ;IACf,GAAG,EAAE,QAAQ;IACb,MAAM,EAAE,QAAQ;IAChB,KAAK,EAAE,QAAQ;IACf,KAAK,EAAE,QAAQ;IACf,GAAG,EAAE,QAAQ;IACb,MAAM,EAAE,QAAQ;IAChB,KAAK,EAAE,QAAQ;CAClB,EAAE,GAAG,CAAC,CAAC"} -------------------------------------------------------------------------------- /mathjax/util/entities/k.d.ts: -------------------------------------------------------------------------------- 1 | export {}; 2 | -------------------------------------------------------------------------------- /mathjax/util/entities/k.js.map: -------------------------------------------------------------------------------- 1 | {"version":3,"file":"k.js","sourceRoot":"","sources":["../../../ts/util/entities/k.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAiBA,uDAA2C;AAE3C,QAAQ,CAAC,GAAG,CAAC;IACT,IAAI,EAAE,QAAQ;IACd,IAAI,EAAE,QAAQ;IACd,KAAK,EAAE,QAAQ;IACf,MAAM,EAAE,QAAQ;IAChB,GAAG,EAAE,QAAQ;IACb,MAAM,EAAE,QAAQ;IAChB,GAAG,EAAE,QAAQ;IACb,MAAM,EAAE,QAAQ;IAChB,IAAI,EAAE,QAAQ;IACd,IAAI,EAAE,QAAQ;CACjB,EAAE,GAAG,CAAC,CAAC"} -------------------------------------------------------------------------------- /mathjax/util/entities/l.d.ts: -------------------------------------------------------------------------------- 1 | export {}; 2 | -------------------------------------------------------------------------------- /mathjax/util/entities/m.d.ts: -------------------------------------------------------------------------------- 1 | export {}; 2 | -------------------------------------------------------------------------------- /mathjax/util/entities/n.d.ts: -------------------------------------------------------------------------------- 1 | export {}; 2 | -------------------------------------------------------------------------------- /mathjax/util/entities/o.d.ts: -------------------------------------------------------------------------------- 1 | export {}; 2 | -------------------------------------------------------------------------------- /mathjax/util/entities/opf.d.ts: -------------------------------------------------------------------------------- 1 | export {}; 2 | -------------------------------------------------------------------------------- /mathjax/util/entities/p.d.ts: -------------------------------------------------------------------------------- 1 | export {}; 2 | -------------------------------------------------------------------------------- /mathjax/util/entities/q.d.ts: -------------------------------------------------------------------------------- 1 | export {}; 2 | -------------------------------------------------------------------------------- /mathjax/util/entities/q.js.map: -------------------------------------------------------------------------------- 1 | {"version":3,"file":"q.js","sourceRoot":"","sources":["../../../ts/util/entities/q.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAiBA,uDAA2C;AAE3C,QAAQ,CAAC,GAAG,CAAC;IACT,IAAI,EAAE,QAAQ;IACd,IAAI,EAAE,QAAQ;IACd,MAAM,EAAE,QAAQ;IAChB,WAAW,EAAE,QAAQ;IACrB,OAAO,EAAE,QAAQ;IACjB,KAAK,EAAE,QAAQ;IACf,OAAO,EAAE,QAAQ;CACpB,EAAE,GAAG,CAAC,CAAC"} -------------------------------------------------------------------------------- /mathjax/util/entities/r.d.ts: -------------------------------------------------------------------------------- 1 | export {}; 2 | -------------------------------------------------------------------------------- /mathjax/util/entities/s.d.ts: -------------------------------------------------------------------------------- 1 | export {}; 2 | -------------------------------------------------------------------------------- /mathjax/util/entities/scr.d.ts: -------------------------------------------------------------------------------- 1 | export {}; 2 | -------------------------------------------------------------------------------- /mathjax/util/entities/t.d.ts: -------------------------------------------------------------------------------- 1 | export {}; 2 | -------------------------------------------------------------------------------- /mathjax/util/entities/u.d.ts: -------------------------------------------------------------------------------- 1 | export {}; 2 | -------------------------------------------------------------------------------- /mathjax/util/entities/v.d.ts: -------------------------------------------------------------------------------- 1 | export {}; 2 | -------------------------------------------------------------------------------- /mathjax/util/entities/w.d.ts: -------------------------------------------------------------------------------- 1 | export {}; 2 | -------------------------------------------------------------------------------- /mathjax/util/entities/w.js.map: -------------------------------------------------------------------------------- 1 | {"version":3,"file":"w.js","sourceRoot":"","sources":["../../../ts/util/entities/w.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAiBA,uDAA2C;AAE3C,QAAQ,CAAC,GAAG,CAAC;IACT,KAAK,EAAE,QAAQ;IACf,KAAK,EAAE,QAAQ;IACf,MAAM,EAAE,QAAQ;IAChB,KAAK,EAAE,QAAQ;IACf,MAAM,EAAE,QAAQ;IAChB,EAAE,EAAE,QAAQ;IACZ,EAAE,EAAE,QAAQ;IACZ,MAAM,EAAE,QAAQ;CACnB,EAAE,GAAG,CAAC,CAAC"} -------------------------------------------------------------------------------- /mathjax/util/entities/x.d.ts: -------------------------------------------------------------------------------- 1 | export {}; 2 | -------------------------------------------------------------------------------- /mathjax/util/entities/x.js.map: -------------------------------------------------------------------------------- 1 | {"version":3,"file":"x.js","sourceRoot":"","sources":["../../../ts/util/entities/x.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAiBA,uDAA2C;AAE3C,QAAQ,CAAC,GAAG,CAAC;IACT,IAAI,EAAE,QAAQ;IACd,KAAK,EAAE,QAAQ;IACf,IAAI,EAAE,QAAQ;IACd,KAAK,EAAE,QAAQ;IACf,KAAK,EAAE,QAAQ;IACf,KAAK,EAAE,QAAQ;IACf,KAAK,EAAE,QAAQ;IACf,KAAK,EAAE,QAAQ;IACf,IAAI,EAAE,QAAQ;IACd,IAAI,EAAE,QAAQ;IACd,KAAK,EAAE,QAAQ;IACf,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,QAAQ;IAChB,KAAK,EAAE,QAAQ;IACf,KAAK,EAAE,QAAQ;IACf,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,QAAQ;IAChB,KAAK,EAAE,QAAQ;IACf,IAAI,EAAE,QAAQ;IACd,MAAM,EAAE,QAAQ;CACnB,EAAE,GAAG,CAAC,CAAC"} -------------------------------------------------------------------------------- /mathjax/util/entities/y.d.ts: -------------------------------------------------------------------------------- 1 | export {}; 2 | -------------------------------------------------------------------------------- /mathjax/util/entities/y.js.map: -------------------------------------------------------------------------------- 1 | {"version":3,"file":"y.js","sourceRoot":"","sources":["../../../ts/util/entities/y.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAiBA,uDAA2C;AAE3C,QAAQ,CAAC,GAAG,CAAC;IACT,IAAI,EAAE,QAAQ;IACd,IAAI,EAAE,QAAQ;IACd,IAAI,EAAE,QAAQ;IACd,MAAM,EAAE,QAAQ;IAChB,KAAK,EAAE,QAAQ;IACf,GAAG,EAAE,QAAQ;IACb,IAAI,EAAE,QAAQ;IACd,MAAM,EAAE,QAAQ;IAChB,IAAI,EAAE,QAAQ;IACd,KAAK,EAAE,QAAQ;IACf,GAAG,EAAE,QAAQ;IACb,IAAI,EAAE,QAAQ;IACd,IAAI,EAAE,QAAQ;IACd,IAAI,EAAE,QAAQ;CACjB,EAAE,GAAG,CAAC,CAAC"} -------------------------------------------------------------------------------- /mathjax/util/entities/z.d.ts: -------------------------------------------------------------------------------- 1 | export {}; 2 | -------------------------------------------------------------------------------- /mathjax/util/entities/z.js.map: -------------------------------------------------------------------------------- 1 | {"version":3,"file":"z.js","sourceRoot":"","sources":["../../../ts/util/entities/z.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAiBA,uDAA2C;AAE3C,QAAQ,CAAC,GAAG,CAAC;IACT,IAAI,EAAE,QAAQ;IACd,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,QAAQ;IAChB,GAAG,EAAE,QAAQ;IACb,IAAI,EAAE,QAAQ;IACd,cAAc,EAAE,QAAQ;IACxB,IAAI,EAAE,QAAQ;IACd,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,QAAQ;IAChB,GAAG,EAAE,QAAQ;IACb,IAAI,EAAE,QAAQ;IACd,MAAM,EAAE,QAAQ;IAChB,IAAI,EAAE,QAAQ;IACd,GAAG,EAAE,QAAQ;IACb,IAAI,EAAE,QAAQ;CACjB,EAAE,GAAG,CAAC,CAAC"} -------------------------------------------------------------------------------- /mathjax/util/lengths.d.ts: -------------------------------------------------------------------------------- 1 | export declare const BIGDIMEN = 1000000; 2 | export declare const UNITS: { 3 | [unit: string]: number; 4 | }; 5 | export declare const RELUNITS: { 6 | [unit: string]: number; 7 | }; 8 | export declare const MATHSPACE: { 9 | [name: string]: number; 10 | }; 11 | export declare function length2em(length: string | number, size?: number, scale?: number, em?: number): number; 12 | export declare function percent(m: number): string; 13 | export declare function em(m: number): string; 14 | export declare function emRounded(m: number, em?: number): string; 15 | export declare function px(m: number, M?: number, em?: number): string; 16 | -------------------------------------------------------------------------------- /mathjax/util/numeric.d.ts: -------------------------------------------------------------------------------- 1 | export declare function sum(A: number[]): number; 2 | export declare function max(A: number[]): number; 3 | -------------------------------------------------------------------------------- /mathjax/util/numeric.js: -------------------------------------------------------------------------------- 1 | "use strict"; 2 | Object.defineProperty(exports, "__esModule", { value: true }); 3 | exports.max = exports.sum = void 0; 4 | function sum(A) { 5 | return A.reduce(function (a, b) { return a + b; }, 0); 6 | } 7 | exports.sum = sum; 8 | function max(A) { 9 | return A.reduce(function (a, b) { return Math.max(a, b); }, 0); 10 | } 11 | exports.max = max; 12 | //# sourceMappingURL=numeric.js.map -------------------------------------------------------------------------------- /mathjax/util/numeric.js.map: -------------------------------------------------------------------------------- 1 | {"version":3,"file":"numeric.js","sourceRoot":"","sources":["../../ts/util/numeric.ts"],"names":[],"mappings":";;;AA2BA,SAAgB,GAAG,CAAC,CAAW;IAC7B,OAAO,CAAC,CAAC,MAAM,CAAC,UAAC,CAAC,EAAE,CAAC,IAAK,OAAA,CAAC,GAAG,CAAC,EAAL,CAAK,EAAE,CAAC,CAAC,CAAC;AACtC,CAAC;AAFD,kBAEC;AAMD,SAAgB,GAAG,CAAC,CAAW;IAC7B,OAAO,CAAC,CAAC,MAAM,CAAC,UAAC,CAAC,EAAE,CAAC,IAAK,OAAA,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,EAAd,CAAc,EAAE,CAAC,CAAC,CAAC;AAC/C,CAAC;AAFD,kBAEC"} -------------------------------------------------------------------------------- /mathjax/util/string.d.ts: -------------------------------------------------------------------------------- 1 | export declare function sortLength(a: string, b: string): number; 2 | export declare function quotePattern(text: string): string; 3 | export declare function unicodeChars(text: string): number[]; 4 | export declare function unicodeString(data: number[]): string; 5 | export declare function isPercent(x: string): boolean; 6 | export declare function split(x: string): string[]; 7 | --------------------------------------------------------------------------------