Warning: file_get_contents(https://raw.githubusercontent.com/Den1xxx/Filemanager/master/languages/ru.json): failed to open stream: HTTP request failed! HTTP/1.1 404 Not Found
in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 88
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 215
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 216
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 217
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 218
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 219
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 220
PK ! ٥ Ù¥ math2html.pynu „[µü¤ #! /usr/bin/env python3
# math2html: convert LaTeX equations to HTML output.
#
# Copyright (C) 2009-2011 Alex Fernández, 2021 Günter Milde
#
# Released under the terms of the `2-Clause BSD license'_, in short:
# Copying and distribution of this file, with or without modification,
# are permitted in any medium without royalty provided the copyright
# notice and this notice are preserved.
# This file is offered as-is, without any warranty.
#
# .. _2-Clause BSD license: https://opensource.org/licenses/BSD-2-Clause
# Based on eLyXer: convert LyX source files to HTML output.
# http://alexfernandez.github.io/elyxer/
# Versions:
# 1.2.5 2015-02-26 eLyXer standalone formula conversion to HTML.
# 1.3 2021-06-02 Removed code for conversion of LyX files not
# required for LaTeX math.
# Support for more math commands from the AMS "math-guide".
# 2.0 2021-12-31 Drop 2.7 compatibility code.
import pathlib
import sys
import unicodedata
from docutils.utils.math import tex2unichar
__version__ = '1.3 (2021-06-02)'
class Trace:
"A tracing class"
debugmode = False
quietmode = False
showlinesmode = False
prefix = None
def debug(cls, message):
"Show a debug message"
if not Trace.debugmode or Trace.quietmode:
return
Trace.show(message, sys.stdout)
def message(cls, message):
"Show a trace message"
if Trace.quietmode:
return
if Trace.prefix and Trace.showlinesmode:
message = Trace.prefix + message
Trace.show(message, sys.stdout)
def error(cls, message):
"Show an error message"
message = '* ' + message
if Trace.prefix and Trace.showlinesmode:
message = Trace.prefix + message
Trace.show(message, sys.stderr)
def fatal(cls, message):
"Show an error message and terminate"
Trace.error('FATAL: ' + message)
exit(-1)
def show(cls, message, channel):
"Show a message out of a channel"
channel.write(message + '\n')
debug = classmethod(debug)
message = classmethod(message)
error = classmethod(error)
fatal = classmethod(fatal)
show = classmethod(show)
class ContainerConfig:
"Configuration class from elyxer.config file"
extracttext = {
'allowed': ['FormulaConstant'],
'extracted': ['AlphaCommand',
'Bracket',
'BracketCommand',
'CombiningFunction',
'EmptyCommand',
'FontFunction',
'Formula',
'FormulaNumber',
'FormulaSymbol',
'OneParamFunction',
'OversetFunction',
'RawText',
'SpacedCommand',
'SymbolFunction',
'TextFunction',
'UndersetFunction',
],
}
class EscapeConfig:
"Configuration class from elyxer.config file"
chars = {
'\n': '',
"'": '’',
'`': '‘',
}
entities = {
'&': '&',
'<': '<',
'>': '>',
}
class FormulaConfig:
"Configuration class from elyxer.config file"
alphacommands = {
'\\AmS': 'AmS',
'\\AA': 'Ã…',
'\\AE': 'Æ',
'\\DH': 'Ã',
'\\L': 'Å',
'\\O': 'Ø',
'\\OE': 'Å’',
'\\TH': 'Þ',
'\\aa': 'Ã¥',
'\\ae': 'æ',
'\\dh': 'ð',
'\\i': 'ı',
'\\j': 'È·',
'\\l': 'Å‚',
'\\o': 'ø',
'\\oe': 'Å“',
'\\ss': 'ß',
'\\th': 'þ',
}
for key, value in tex2unichar.mathalpha.items():
alphacommands['\\'+key] = value
array = {
'begin': r'\begin',
'cellseparator': '&',
'end': r'\end',
'rowseparator': r'\\',
}
bigbrackets = {'(': ['⎛', '⎜', 'âŽ'],
')': ['⎞', '⎟', '⎠'],
'[': ['⎡', '⎢', '⎣'],
']': ['⎤', '⎥', '⎦'],
'{': ['⎧', '⎪', '⎨', '⎩'],
'}': ['⎫', '⎪', '⎬', 'âŽ'],
# TODO: 2-row brackets with ⎰⎱ (\lmoustache \rmoustache)
'|': ['|'], # 007C VERTICAL LINE
# '|': ['⎮'], # 23AE INTEGRAL EXTENSION
# '|': ['⎪'], # 23AA CURLY BRACKET EXTENSION
'‖': ['‖'], # 2016 DOUBLE VERTICAL LINE
# '∥': ['∥'], # 2225 PARALLEL TO
}
bracketcommands = {
'\\left': 'span class="stretchy"',
'\\left.': '',
'\\middle': 'span class="stretchy"',
'\\right': 'span class="stretchy"',
'\\right.': '',
}
combiningfunctions = {
"\\'": '\u0301', # xÌ
'\\"': '\u0308', # ẍ
'\\^': '\u0302', # x̂
'\\`': '\u0300', # x̀
'\\~': '\u0303', # x̃
'\\c': '\u0327', # x̧
'\\r': '\u030a', # xÌŠ
'\\s': '\u0329', # x̩
'\\textcircled': '\u20dd', # xâƒ
'\\textsubring': '\u0325', # x̥
'\\v': '\u030c', # x̌
}
for key, value in tex2unichar.mathaccent.items():
combiningfunctions['\\'+key] = value
commands = {
'\\\\': '
',
'\\\n': ' ', # escaped whitespace
'\\\t': ' ', # escaped whitespace
'\\centerdot': '\u2B1D', # BLACK VERY SMALL SQUARE, mathbin
'\\colon': ': ',
'\\copyright': '©',
'\\dotminus': '∸',
'\\dots': '…',
'\\dotsb': '⋯',
'\\dotsc': '…',
'\\dotsi': '⋯',
'\\dotsm': '⋯',
'\\dotso': '…',
'\\euro': '€',
'\\guillemotleft': '«',
'\\guillemotright': '»',
'\\hbar': '\u0127', # ħ LATIN SMALL LETTER H WITH STROKE
'\\lVert': '‖',
'\\Arrowvert': '\u2016', # ‖
'\\lvert': '|',
'\\newline': '
',
'\\nobreakspace': 'Â ',
'\\nolimits': '',
'\\nonumber': '',
'\\qquad': 'â€â€',
'\\rVert': '‖',
'\\rvert': '|',
'\\textasciicircum': '^',
'\\textasciitilde': '~',
'\\textbackslash': '\\',
'\\textcopyright': '©',
'\\textdegree': '°',
'\\textellipsis': '…',
'\\textemdash': '—',
'\\textendash': '—',
'\\texteuro': '€',
'\\textgreater': '>',
'\\textless': '<',
'\\textordfeminine': 'ª',
'\\textordmasculine': 'º',
'\\textquotedblleft': '“',
'\\textquotedblright': 'â€',
'\\textquoteright': '’',
'\\textregistered': '®',
'\\textrightarrow': '→',
'\\textsection': '§',
'\\texttrademark': 'â„¢',
'\\texttwosuperior': '²',
'\\textvisiblespace': ' ',
'\\thickspace': ' ', # 5/13 em
'\\;': ' ', # 5/13 em
'\\triangle': '\u25B3', # WHITE UP-POINTING TRIANGLE, mathord
'\\triangledown': '\u25BD', # WHITE DOWN-POINTING TRIANGLE, mathord
'\\varnothing': '\u2300', # ⌀ DIAMETER SIGN
# functions
'\\Pr': 'Pr',
'\\arccos': 'arccos',
'\\arcsin': 'arcsin',
'\\arctan': 'arctan',
'\\arg': 'arg',
'\\cos': 'cos',
'\\cosh': 'cosh',
'\\cot': 'cot',
'\\coth': 'coth',
'\\csc': 'csc',
'\\deg': 'deg',
'\\det': 'det',
'\\dim': 'dim',
'\\exp': 'exp',
'\\gcd': 'gcd',
'\\hom': 'hom',
'\\injlim': 'inj lim',
'\\ker': 'ker',
'\\lg': 'lg',
'\\liminf': 'lim inf',
'\\limsup': 'lim sup',
'\\ln': 'ln',
'\\log': 'log',
'\\projlim': 'proj lim',
'\\sec': 'sec',
'\\sin': 'sin',
'\\sinh': 'sinh',
'\\tan': 'tan',
'\\tanh': 'tanh',
}
cmddict = {}
cmddict.update(tex2unichar.mathbin) # TODO: spacing around binary operators
cmddict.update(tex2unichar.mathopen)
cmddict.update(tex2unichar.mathclose)
cmddict.update(tex2unichar.mathfence)
cmddict.update(tex2unichar.mathord)
cmddict.update(tex2unichar.mathpunct)
cmddict.update(tex2unichar.space)
commands.update(('\\' + key, value) for key, value in cmddict.items())
oversetfunctions = {
# math accents (cf. combiningfunctions)
# '\\acute': '´',
'\\bar': '‒', # FIGURE DASH
# '\\breve': '˘',
# '\\check': 'ˇ',
'\\dddot': '⋯',
# '\\ddot': '··', # ¨ too high
# '\\dot': '·',
# '\\grave': '`',
# '\\hat': '^',
# '\\mathring': 'Ëš',
# '\\tilde': '~',
'\\vec': '→',
# embellishments
'\\overleftarrow': '⟵',
'\\overleftrightarrow': '⟷',
'\\overrightarrow': '⟶',
'\\widehat': '^',
'\\widetilde': '～',
}
undersetfunctions = {
'\\underleftarrow': '⟵',
'\\underleftrightarrow': '⟷',
'\\underrightarrow': '⟶',
}
endings = {
'bracket': '}',
'complex': '\\]',
'endafter': '}',
'endbefore': '\\end{',
'squarebracket': ']',
}
environments = {
'align': ['r', 'l'],
'eqnarray': ['r', 'c', 'l'],
'gathered': ['l', 'l'],
'smallmatrix': ['c', 'c'],
}
fontfunctions = {
'\\boldsymbol': 'b', '\\mathbb': 'span class="blackboard"',
'\\mathbb{A}': 'ð”¸', '\\mathbb{B}': 'ð”¹', '\\mathbb{C}': 'â„‚',
'\\mathbb{D}': 'ð”»', '\\mathbb{E}': 'ð”¼', '\\mathbb{F}': 'ð”½',
'\\mathbb{G}': 'ð”¾', '\\mathbb{H}': 'â„', '\\mathbb{J}': 'ð•',
'\\mathbb{K}': 'ð•‚', '\\mathbb{L}': 'ð•ƒ', '\\mathbb{N}': 'â„•',
'\\mathbb{O}': 'ð•†', '\\mathbb{P}': 'â„™', '\\mathbb{Q}': 'â„š',
'\\mathbb{R}': 'â„', '\\mathbb{S}': 'ð•Š', '\\mathbb{T}': 'ð•‹',
'\\mathbb{W}': 'ð•Ž', '\\mathbb{Z}': 'ℤ', '\\mathbf': 'b',
'\\mathcal': 'span class="scriptfont"',
'\\mathcal{B}': 'ℬ', '\\mathcal{E}': 'ℰ', '\\mathcal{F}':
'ℱ', '\\mathcal{H}': 'â„‹', '\\mathcal{I}': 'â„',
'\\mathcal{L}': 'ℒ', '\\mathcal{M}': 'ℳ', '\\mathcal{R}': 'ℛ',
'\\mathfrak': 'span class="fraktur"',
'\\mathfrak{C}': 'â„', '\\mathfrak{F}': 'ð”‰', '\\mathfrak{H}': 'â„Œ',
'\\mathfrak{I}': 'ℑ', '\\mathfrak{R}': 'ℜ', '\\mathfrak{Z}': 'ℨ',
'\\mathit': 'i',
'\\mathring{A}': 'Ã…', '\\mathring{U}': 'Å®',
'\\mathring{a}': 'å', '\\mathring{u}': 'ů', '\\mathring{w}': 'ẘ',
'\\mathring{y}': 'ẙ',
'\\mathrm': 'span class="mathrm"',
'\\mathscr': 'span class="mathscr"',
'\\mathscr{B}': 'ℬ', '\\mathscr{E}': 'ℰ', '\\mathscr{F}': 'ℱ',
'\\mathscr{H}': 'â„‹', '\\mathscr{I}': 'â„', '\\mathscr{L}': 'â„’',
'\\mathscr{M}': 'ℳ', '\\mathscr{R}': 'ℛ',
'\\mathsf': 'span class="mathsf"',
'\\mathtt': 'span class="mathtt"',
'\\operatorname': 'span class="mathrm"',
}
hybridfunctions = {
'\\addcontentsline': ['{$p!}{$q!}{$r!}', 'f0{}', 'ignored'],
'\\addtocontents': ['{$p!}{$q!}', 'f0{}', 'ignored'],
'\\backmatter': ['', 'f0{}', 'ignored'],
'\\binom': ['{$1}{$2}', 'f2{(}f0{f1{$1}f1{$2}}f2{)}', 'span class="binom"', 'span class="binomstack"', 'span class="bigdelimiter size2"'],
'\\boxed': ['{$1}', 'f0{$1}', 'span class="boxed"'],
'\\cfrac': ['[$p!]{$1}{$2}', 'f0{f3{(}f1{$1}f3{)/(}f2{$2}f3{)}}', 'span class="fullfraction"', 'span class="numerator align-$p"', 'span class="denominator"', 'span class="ignored"'],
'\\color': ['{$p!}{$1}', 'f0{$1}', 'span style="color: $p;"'],
'\\colorbox': ['{$p!}{$1}', 'f0{$1}', 'span class="colorbox" style="background: $p;"'],
'\\dbinom': ['{$1}{$2}', '(f0{f1{f2{$1}}f1{f2{ }}f1{f2{$2}}})', 'span class="binomial"', 'span class="binomrow"', 'span class="binomcell"'],
'\\dfrac': ['{$1}{$2}', 'f0{f3{(}f1{$1}f3{)/(}f2{$2}f3{)}}', 'span class="fullfraction"', 'span class="numerator"', 'span class="denominator"', 'span class="ignored"'],
'\\displaystyle': ['{$1}', 'f0{$1}', 'span class="displaystyle"'],
'\\fancyfoot': ['[$p!]{$q!}', 'f0{}', 'ignored'],
'\\fancyhead': ['[$p!]{$q!}', 'f0{}', 'ignored'],
'\\fbox': ['{$1}', 'f0{$1}', 'span class="fbox"'],
'\\fboxrule': ['{$p!}', 'f0{}', 'ignored'],
'\\fboxsep': ['{$p!}', 'f0{}', 'ignored'],
'\\fcolorbox': ['{$p!}{$q!}{$1}', 'f0{$1}', 'span class="boxed" style="border-color: $p; background: $q;"'],
'\\frac': ['{$1}{$2}', 'f0{f3{(}f1{$1}f3{)/(}f2{$2}f3{)}}', 'span class="fraction"', 'span class="numerator"', 'span class="denominator"', 'span class="ignored"'],
'\\framebox': ['[$p!][$q!]{$1}', 'f0{$1}', 'span class="framebox align-$q" style="width: $p;"'],
'\\frontmatter': ['', 'f0{}', 'ignored'],
'\\href': ['[$o]{$u!}{$t!}', 'f0{$t}', 'a href="$u"'],
'\\hspace': ['{$p!}', 'f0{ }', 'span class="hspace" style="width: $p;"'],
'\\leftroot': ['{$p!}', 'f0{ }', 'span class="leftroot" style="width: $p;px"'],
# TODO: convert 1 mu to 1/18 em
# '\\mspace': ['{$p!}', 'f0{ }', 'span class="hspace" style="width: $p;"'],
'\\nicefrac': ['{$1}{$2}', 'f0{f1{$1}â„f2{$2}}', 'span class="fraction"', 'sup class="numerator"', 'sub class="denominator"', 'span class="ignored"'],
'\\parbox': ['[$p!]{$w!}{$1}', 'f0{1}', 'div class="Boxed" style="width: $w;"'],
'\\raisebox': ['{$p!}{$1}', 'f0{$1.font}', 'span class="raisebox" style="vertical-align: $p;"'],
'\\renewenvironment': ['{$1!}{$2!}{$3!}', ''],
'\\rule': ['[$v!]{$w!}{$h!}', 'f0/', 'hr class="line" style="width: $w; height: $h;"'],
'\\scriptscriptstyle': ['{$1}', 'f0{$1}', 'span class="scriptscriptstyle"'],
'\\scriptstyle': ['{$1}', 'f0{$1}', 'span class="scriptstyle"'],
# TODO: increase √-size with argument (\frac in display mode, ...)
'\\sqrt': ['[$0]{$1}', 'f0{f1{$0}f2{√}f4{(}f3{$1}f4{)}}', 'span class="sqrt"', 'sup class="root"', 'span class="radical"', 'span class="root"', 'span class="ignored"'],
'\\stackrel': ['{$1}{$2}', 'f0{f1{$1}f2{$2}}', 'span class="stackrel"', 'span class="upstackrel"', 'span class="downstackrel"'],
'\\tbinom': ['{$1}{$2}', '(f0{f1{f2{$1}}f1{f2{ }}f1{f2{$2}}})', 'span class="binomial"', 'span class="binomrow"', 'span class="binomcell"'],
'\\tfrac': ['{$1}{$2}', 'f0{f3{(}f1{$1}f3{)/(}f2{$2}f3{)}}', 'span class="textfraction"', 'span class="numerator"', 'span class="denominator"', 'span class="ignored"'],
'\\textcolor': ['{$p!}{$1}', 'f0{$1}', 'span style="color: $p;"'],
'\\textstyle': ['{$1}', 'f0{$1}', 'span class="textstyle"'],
'\\thispagestyle': ['{$p!}', 'f0{}', 'ignored'],
'\\unit': ['[$0]{$1}', '$0f0{$1.font}', 'span class="unit"'],
'\\unitfrac': ['[$0]{$1}{$2}', '$0f0{f1{$1.font}â„f2{$2.font}}', 'span class="fraction"', 'sup class="unit"', 'sub class="unit"'],
'\\uproot': ['{$p!}', 'f0{ }', 'span class="uproot" style="width: $p;px"'],
'\\url': ['{$u!}', 'f0{$u}', 'a href="$u"'],
'\\vspace': ['{$p!}', 'f0{ }', 'span class="vspace" style="height: $p;"'],
}
hybridsizes = {
'\\binom': '$1+$2', '\\cfrac': '$1+$2', '\\dbinom': '$1+$2+1',
'\\dfrac': '$1+$2', '\\frac': '$1+$2', '\\tbinom': '$1+$2+1',
}
labelfunctions = {
'\\label': 'a name="#"',
}
limitcommands = {
'\\biginterleave': '⫼',
'\\inf': 'inf',
'\\lim': 'lim',
'\\max': 'max',
'\\min': 'min',
'\\sup': 'sup',
'\\ointop': '∮',
'\\bigcap': 'â‹‚',
'\\bigcup': '⋃',
'\\bigodot': '⨀',
'\\bigoplus': 'â¨',
'\\bigotimes': '⨂',
'\\bigsqcap': '⨅',
'\\bigsqcup': '⨆',
'\\biguplus': '⨄',
'\\bigvee': 'â‹',
'\\bigwedge': 'â‹€',
'\\coprod': 'âˆ',
'\\intop': '∫',
'\\prod': 'âˆ',
'\\sum': '∑',
'\\varprod': '⨉',
'\\zcmp': '⨟', '\\zhide': '⧹', '\\zpipe': '⨠', '\\zproject': '⨡',
# integrals have limits in index position with LaTeX default settings
# TODO: move to commands?
'\\int': '∫',
'\\iint': '∬',
'\\iiint': 'âˆ',
'\\iiiint': '⨌',
'\\fint': 'â¨',
'\\idotsint': '∫⋯∫',
'\\oint': '∮',
'\\oiint': '∯',
'\\oiiint': '∰',
'\\ointclockwise': '∲',
'\\ointctrclockwise': '∳',
'\\smallint': '∫',
'\\sqint': '⨖',
'\\varointclockwise': '∲',
}
modified = {
'\n': '', ' ': '', '$': '', '&': ' ', '\'': '’', '+': '\u2009+\u2009',
',': ',\u2009', '-': '\u2009−\u2009', '/': '\u2009â„\u2009', ':': ' : ', '<': '\u2009<\u2009',
'=': '\u2009=\u2009', '>': '\u2009>\u2009', '@': '', '~': '\u00a0',
}
onefunctions = {
'\\big': 'span class="bigdelimiter size1"',
'\\bigl': 'span class="bigdelimiter size1"',
'\\bigr': 'span class="bigdelimiter size1"',
'\\Big': 'span class="bigdelimiter size2"',
'\\Bigl': 'span class="bigdelimiter size2"',
'\\Bigr': 'span class="bigdelimiter size2"',
'\\bigg': 'span class="bigdelimiter size3"',
'\\biggl': 'span class="bigdelimiter size3"',
'\\biggr': 'span class="bigdelimiter size3"',
'\\Bigg': 'span class="bigdelimiter size4"',
'\\Biggl': 'span class="bigdelimiter size4"',
'\\Biggr': 'span class="bigdelimiter size4"',
# '\\bar': 'span class="bar"',
'\\begin{array}': 'span class="arraydef"',
'\\centering': 'span class="align-center"',
'\\ensuremath': 'span class="ensuremath"',
'\\hphantom': 'span class="phantom"',
'\\noindent': 'span class="noindent"',
'\\overbrace': 'span class="overbrace"',
'\\overline': 'span class="overline"',
'\\phantom': 'span class="phantom"',
'\\underbrace': 'span class="underbrace"',
'\\underline': '',
'\\vphantom': 'span class="phantom"',
}
# relations (put additional space before and after the symbol)
spacedcommands = {
# negated symbols without pre-composed Unicode character
'\\nleqq': '\u2266\u0338', # ≦̸
'\\ngeqq': '\u2267\u0338', # ≧̸
'\\nleqslant': '\u2a7d\u0338', # ⩽̸
'\\ngeqslant': '\u2a7e\u0338', # ⩾̸
'\\nsubseteqq': '\u2AC5\u0338', # ⫅̸
'\\nsupseteqq': '\u2AC6\u0338', # ⫆̸
'\\nsqsubset': '\u2276\u228F', # âŠÌ¸
# modified glyphs
'\\shortmid': '∣',
'\\shortparallel': '∥',
'\\nshortmid': '∤',
'\\nshortparallel': '∦',
'\\smallfrown': '⌢',
'\\smallsmile': '⌣',
'\\thickapprox': '≈',
'\\thicksim': '∼',
'\\varpropto': '\u221d', # ∠PROPORTIONAL TO
}
for key, value in tex2unichar.mathrel.items():
spacedcommands['\\'+key] = value
starts = {
'beginafter': '}', 'beginbefore': '\\begin{', 'bracket': '{',
'command': '\\', 'comment': '%', 'complex': '\\[', 'simple': '$',
'squarebracket': '[', 'unnumbered': '*',
}
symbolfunctions = {
'^': 'sup', '_': 'sub',
}
textfunctions = {
'\\mbox': 'span class="mbox"',
'\\text': 'span class="text"',
'\\textbf': 'span class="textbf"',
'\\textit': 'span class="textit"',
'\\textnormal': 'span class="textnormal"',
'\\textrm': 'span class="textrm"',
'\\textsc': 'span class="textsc"',
'\\textsf': 'span class="textsf"',
'\\textsl': 'span class="textsl"',
'\\texttt': 'span class="texttt"',
'\\textup': 'span class="normal"',
}
unmodified = {
'characters': ['.', '*', '€', '(', ')', '[', ']',
'·', '!', ';', '|', '§', '"', '?'],
}
class CommandLineParser:
"A parser for runtime options"
def __init__(self, options):
self.options = options
def parseoptions(self, args):
"Parse command line options"
if len(args) == 0:
return None
while len(args) > 0 and args[0].startswith('--'):
key, value = self.readoption(args)
if not key:
return 'Option ' + value + ' not recognized'
if not value:
return 'Option ' + key + ' needs a value'
setattr(self.options, key, value)
return None
def readoption(self, args):
"Read the key and value for an option"
arg = args[0][2:]
del args[0]
if '=' in arg:
key = self.readequalskey(arg, args)
else:
key = arg.replace('-', '')
if not hasattr(self.options, key):
return None, key
current = getattr(self.options, key)
if isinstance(current, bool):
return key, True
# read value
if len(args) == 0:
return key, None
if args[0].startswith('"'):
initial = args[0]
del args[0]
return key, self.readquoted(args, initial)
value = args[0].decode('utf-8')
del args[0]
if isinstance(current, list):
current.append(value)
return key, current
return key, value
def readquoted(self, args, initial):
"Read a value between quotes"
Trace.error('Oops')
value = initial[1:]
while len(args) > 0 and not args[0].endswith('"') and not args[0].startswith('--'):
Trace.error('Appending ' + args[0])
value += ' ' + args[0]
del args[0]
if len(args) == 0 or args[0].startswith('--'):
return None
value += ' ' + args[0:-1]
return value
def readequalskey(self, arg, args):
"Read a key using equals"
split = arg.split('=', 1)
key = split[0]
value = split[1]
args.insert(0, value)
return key
class Options:
"A set of runtime options"
location = None
debug = False
quiet = False
version = False
help = False
simplemath = False
showlines = True
branches = {}
def parseoptions(self, args):
"Parse command line options"
Options.location = args[0]
del args[0]
parser = CommandLineParser(Options)
result = parser.parseoptions(args)
if result:
Trace.error(result)
self.usage()
self.processoptions()
def processoptions(self):
"Process all options parsed."
if Options.help:
self.usage()
if Options.version:
self.showversion()
# set in Trace if necessary
for param in dir(Trace):
if param.endswith('mode'):
setattr(Trace, param, getattr(self, param[:-4]))
def usage(self):
"Show correct usage"
Trace.error(f'Usage: {pathlib.Path(Options.location).parent}'
' [options] "input string"')
Trace.error('Convert input string with LaTeX math to MathML')
self.showoptions()
def showoptions(self):
"Show all possible options"
Trace.error(' --help: show this online help')
Trace.error(' --quiet: disables all runtime messages')
Trace.error(' --debug: enable debugging messages (for developers)')
Trace.error(' --version: show version number and release date')
Trace.error(' --simplemath: do not generate fancy math constructions')
sys.exit()
def showversion(self):
"Return the current eLyXer version string"
Trace.error('math2html '+__version__)
sys.exit()
class Cloner:
"An object used to clone other objects."
def clone(cls, original):
"Return an exact copy of an object."
"The original object must have an empty constructor."
return cls.create(original.__class__)
def create(cls, type):
"Create an object of a given class."
clone = type.__new__(type)
clone.__init__()
return clone
clone = classmethod(clone)
create = classmethod(create)
class ContainerExtractor:
"""A class to extract certain containers.
The config parameter is a map containing three lists:
allowed, copied and extracted.
Each of the three is a list of class names for containers.
Allowed containers are included as is into the result.
Cloned containers are cloned and placed into the result.
Extracted containers are looked into.
All other containers are silently ignored.
"""
def __init__(self, config):
self.allowed = config['allowed']
self.extracted = config['extracted']
def extract(self, container):
"Extract a group of selected containers from a container."
list = []
locate = lambda c: c.__class__.__name__ in self.allowed
recursive = lambda c: c.__class__.__name__ in self.extracted
process = lambda c: self.process(c, list)
container.recursivesearch(locate, recursive, process)
return list
def process(self, container, list):
"Add allowed containers."
name = container.__class__.__name__
if name in self.allowed:
list.append(container)
else:
Trace.error('Unknown container class ' + name)
def safeclone(self, container):
"Return a new container with contents only in a safe list, recursively."
clone = Cloner.clone(container)
clone.output = container.output
clone.contents = self.extract(container)
return clone
class Parser:
"A generic parser"
def __init__(self):
self.begin = 0
self.parameters = {}
def parseheader(self, reader):
"Parse the header"
header = reader.currentline().split()
reader.nextline()
self.begin = reader.linenumber
return header
def parseparameter(self, reader):
"Parse a parameter"
split = reader.currentline().strip().split(' ', 1)
reader.nextline()
if len(split) == 0:
return
key = split[0]
if len(split) == 1:
self.parameters[key] = True
return
if '"' not in split[1]:
self.parameters[key] = split[1].strip()
return
doublesplit = split[1].split('"')
self.parameters[key] = doublesplit[1]
def parseending(self, reader, process):
"Parse until the current ending is found"
if not self.ending:
Trace.error('No ending for ' + str(self))
return
while not reader.currentline().startswith(self.ending):
process()
def parsecontainer(self, reader, contents):
container = self.factory.createcontainer(reader)
if container:
container.parent = self.parent
contents.append(container)
def __str__(self):
"Return a description"
return self.__class__.__name__ + ' (' + str(self.begin) + ')'
class LoneCommand(Parser):
"A parser for just one command line"
def parse(self, reader):
"Read nothing"
return []
class TextParser(Parser):
"A parser for a command and a bit of text"
stack = []
def __init__(self, container):
Parser.__init__(self)
self.ending = None
if container.__class__.__name__ in ContainerConfig.endings:
self.ending = ContainerConfig.endings[container.__class__.__name__]
self.endings = []
def parse(self, reader):
"Parse lines as long as they are text"
TextParser.stack.append(self.ending)
self.endings = TextParser.stack + [ContainerConfig.endings['Layout'],
ContainerConfig.endings['Inset'],
self.ending]
contents = []
while not self.isending(reader):
self.parsecontainer(reader, contents)
return contents
def isending(self, reader):
"Check if text is ending"
current = reader.currentline().split()
if len(current) == 0:
return False
if current[0] in self.endings:
if current[0] in TextParser.stack:
TextParser.stack.remove(current[0])
else:
TextParser.stack = []
return True
return False
class ExcludingParser(Parser):
"A parser that excludes the final line"
def parse(self, reader):
"Parse everything up to (and excluding) the final line"
contents = []
self.parseending(reader, lambda: self.parsecontainer(reader, contents))
return contents
class BoundedParser(ExcludingParser):
"A parser bound by a final line"
def parse(self, reader):
"Parse everything, including the final line"
contents = ExcludingParser.parse(self, reader)
# skip last line
reader.nextline()
return contents
class BoundedDummy(Parser):
"A bound parser that ignores everything"
def parse(self, reader):
"Parse the contents of the container"
self.parseending(reader, lambda: reader.nextline())
# skip last line
reader.nextline()
return []
class StringParser(Parser):
"Parses just a string"
def parseheader(self, reader):
"Do nothing, just take note"
self.begin = reader.linenumber + 1
return []
def parse(self, reader):
"Parse a single line"
contents = reader.currentline()
reader.nextline()
return contents
class ContainerOutput:
"The generic HTML output for a container."
def gethtml(self, container):
"Show an error."
Trace.error('gethtml() not implemented for ' + str(self))
def isempty(self):
"Decide if the output is empty: by default, not empty."
return False
class EmptyOutput(ContainerOutput):
def gethtml(self, container):
"Return empty HTML code."
return []
def isempty(self):
"This output is particularly empty."
return True
class FixedOutput(ContainerOutput):
"Fixed output"
def gethtml(self, container):
"Return constant HTML code"
return container.html
class ContentsOutput(ContainerOutput):
"Outputs the contents converted to HTML"
def gethtml(self, container):
"Return the HTML code"
html = []
if container.contents is None:
return html
for element in container.contents:
if not hasattr(element, 'gethtml'):
Trace.error('No html in ' + element.__class__.__name__ + ': ' + str(element))
return html
html += element.gethtml()
return html
class TaggedOutput(ContentsOutput):
"Outputs an HTML tag surrounding the contents."
tag = None
breaklines = False
empty = False
def settag(self, tag, breaklines=False, empty=False):
"Set the value for the tag and other attributes."
self.tag = tag
if breaklines:
self.breaklines = breaklines
if empty:
self.empty = empty
return self
def setbreaklines(self, breaklines):
"Set the value for breaklines."
self.breaklines = breaklines
return self
def gethtml(self, container):
"Return the HTML code."
if self.empty:
return [self.selfclosing(container)]
html = [self.open(container)]
html += ContentsOutput.gethtml(self, container)
html.append(self.close(container))
return html
def open(self, container):
"Get opening line."
if not self.checktag(container):
return ''
open = '<' + self.tag + '>'
if self.breaklines:
return open + '\n'
return open
def close(self, container):
"Get closing line."
if not self.checktag(container):
return ''
close = ''
if self.breaklines:
return '\n' + close + '\n'
return close
def selfclosing(self, container):
"Get self-closing line."
if not self.checktag(container):
return ''
selfclosing = '<' + self.tag + '/>'
if self.breaklines:
return selfclosing + '\n'
return selfclosing
def checktag(self, container):
"Check that the tag is valid."
if not self.tag:
Trace.error('No tag in ' + str(container))
return False
if self.tag == '':
return False
return True
class FilteredOutput(ContentsOutput):
"Returns the output in the contents, but filtered:"
"some strings are replaced by others."
def __init__(self):
"Initialize the filters."
self.filters = []
def addfilter(self, original, replacement):
"Add a new filter: replace the original by the replacement."
self.filters.append((original, replacement))
def gethtml(self, container):
"Return the HTML code"
result = []
html = ContentsOutput.gethtml(self, container)
for line in html:
result.append(self.filter(line))
return result
def filter(self, line):
"Filter a single line with all available filters."
for original, replacement in self.filters:
if original in line:
line = line.replace(original, replacement)
return line
class StringOutput(ContainerOutput):
"Returns a bare string as output"
def gethtml(self, container):
"Return a bare string"
return [container.string]
class Globable:
"""A bit of text which can be globbed (lumped together in bits).
Methods current(), skipcurrent(), checkfor() and isout() have to be
implemented by subclasses."""
leavepending = False
def __init__(self):
self.endinglist = EndingList()
def checkbytemark(self):
"Check for a Unicode byte mark and skip it."
if self.finished():
return
if ord(self.current()) == 0xfeff:
self.skipcurrent()
def isout(self):
"Find out if we are out of the position yet."
Trace.error('Unimplemented isout()')
return True
def current(self):
"Return the current character."
Trace.error('Unimplemented current()')
return ''
def checkfor(self, string):
"Check for the given string in the current position."
Trace.error('Unimplemented checkfor()')
return False
def finished(self):
"Find out if the current text has finished."
if self.isout():
if not self.leavepending:
self.endinglist.checkpending()
return True
return self.endinglist.checkin(self)
def skipcurrent(self):
"Return the current character and skip it."
Trace.error('Unimplemented skipcurrent()')
return ''
def glob(self, currentcheck):
"Glob a bit of text that satisfies a check on the current char."
glob = ''
while not self.finished() and currentcheck():
glob += self.skipcurrent()
return glob
def globalpha(self):
"Glob a bit of alpha text"
return self.glob(lambda: self.current().isalpha())
def globnumber(self):
"Glob a row of digits."
return self.glob(lambda: self.current().isdigit())
def isidentifier(self):
"Return if the current character is alphanumeric or _."
if self.current().isalnum() or self.current() == '_':
return True
return False
def globidentifier(self):
"Glob alphanumeric and _ symbols."
return self.glob(self.isidentifier)
def isvalue(self):
"Return if the current character is a value character:"
"not a bracket or a space."
if self.current().isspace():
return False
if self.current() in '{}()':
return False
return True
def globvalue(self):
"Glob a value: any symbols but brackets."
return self.glob(self.isvalue)
def skipspace(self):
"Skip all whitespace at current position."
return self.glob(lambda: self.current().isspace())
def globincluding(self, magicchar):
"Glob a bit of text up to (including) the magic char."
glob = self.glob(lambda: self.current() != magicchar) + magicchar
self.skip(magicchar)
return glob
def globexcluding(self, excluded):
"Glob a bit of text up until (excluding) any excluded character."
return self.glob(lambda: self.current() not in excluded)
def pushending(self, ending, optional=False):
"Push a new ending to the bottom"
self.endinglist.add(ending, optional)
def popending(self, expected=None):
"Pop the ending found at the current position"
if self.isout() and self.leavepending:
return expected
ending = self.endinglist.pop(self)
if expected and expected != ending:
Trace.error('Expected ending ' + expected + ', got ' + ending)
self.skip(ending)
return ending
def nextending(self):
"Return the next ending in the queue."
nextending = self.endinglist.findending(self)
if not nextending:
return None
return nextending.ending
class EndingList:
"A list of position endings"
def __init__(self):
self.endings = []
def add(self, ending, optional=False):
"Add a new ending to the list"
self.endings.append(PositionEnding(ending, optional))
def pickpending(self, pos):
"Pick any pending endings from a parse position."
self.endings += pos.endinglist.endings
def checkin(self, pos):
"Search for an ending"
if self.findending(pos):
return True
return False
def pop(self, pos):
"Remove the ending at the current position"
if pos.isout():
Trace.error('No ending out of bounds')
return ''
ending = self.findending(pos)
if not ending:
Trace.error('No ending at ' + pos.current())
return ''
for each in reversed(self.endings):
self.endings.remove(each)
if each == ending:
return each.ending
elif not each.optional:
Trace.error('Removed non-optional ending ' + each)
Trace.error('No endings left')
return ''
def findending(self, pos):
"Find the ending at the current position"
if len(self.endings) == 0:
return None
for index, ending in enumerate(reversed(self.endings)):
if ending.checkin(pos):
return ending
if not ending.optional:
return None
return None
def checkpending(self):
"Check if there are any pending endings"
if len(self.endings) != 0:
Trace.error('Pending ' + str(self) + ' left open')
def __str__(self):
"Printable representation"
string = 'endings ['
for ending in self.endings:
string += str(ending) + ','
if len(self.endings) > 0:
string = string[:-1]
return string + ']'
class PositionEnding:
"An ending for a parsing position"
def __init__(self, ending, optional):
self.ending = ending
self.optional = optional
def checkin(self, pos):
"Check for the ending"
return pos.checkfor(self.ending)
def __str__(self):
"Printable representation"
string = 'Ending ' + self.ending
if self.optional:
string += ' (optional)'
return string
class Position(Globable):
"""A position in a text to parse.
Including those in Globable, functions to implement by subclasses are:
skip(), identifier(), extract(), isout() and current()."""
def __init__(self):
Globable.__init__(self)
def skip(self, string):
"Skip a string"
Trace.error('Unimplemented skip()')
def identifier(self):
"Return an identifier for the current position."
Trace.error('Unimplemented identifier()')
return 'Error'
def extract(self, length):
"Extract the next string of the given length, or None if not enough text,"
"without advancing the parse position."
Trace.error('Unimplemented extract()')
return None
def checkfor(self, string):
"Check for a string at the given position."
return string == self.extract(len(string))
def checkforlower(self, string):
"Check for a string in lower case."
extracted = self.extract(len(string))
if not extracted:
return False
return string.lower() == self.extract(len(string)).lower()
def skipcurrent(self):
"Return the current character and skip it."
current = self.current()
self.skip(current)
return current
def __next__(self):
"Advance the position and return the next character."
self.skipcurrent()
return self.current()
def checkskip(self, string):
"Check for a string at the given position; if there, skip it"
if not self.checkfor(string):
return False
self.skip(string)
return True
def error(self, message):
"Show an error message and the position identifier."
Trace.error(message + ': ' + self.identifier())
class TextPosition(Position):
"A parse position based on a raw text."
def __init__(self, text):
"Create the position from some text."
Position.__init__(self)
self.pos = 0
self.text = text
self.checkbytemark()
def skip(self, string):
"Skip a string of characters."
self.pos += len(string)
def identifier(self):
"Return a sample of the remaining text."
length = 30
if self.pos + length > len(self.text):
length = len(self.text) - self.pos
return '*' + self.text[self.pos:self.pos + length] + '*'
def isout(self):
"Find out if we are out of the text yet."
return self.pos >= len(self.text)
def current(self):
"Return the current character, assuming we are not out."
return self.text[self.pos]
def extract(self, length):
"Extract the next string of the given length, or None if not enough text."
if self.pos + length > len(self.text):
return None
return self.text[self.pos : self.pos + length] # noqa: E203
class Container:
"A container for text and objects in a lyx file"
partkey = None
parent = None
begin = None
def __init__(self):
self.contents = list()
def process(self):
"Process contents"
pass
def gethtml(self):
"Get the resulting HTML"
html = self.output.gethtml(self)
if isinstance(html, str):
Trace.error('Raw string ' + html)
html = [html]
return html
def escape(self, line, replacements=EscapeConfig.entities):
"Escape a line with replacements from a map"
pieces = sorted(replacements.keys())
# do them in order
for piece in pieces:
if piece in line:
line = line.replace(piece, replacements[piece])
return line
def escapeentities(self, line):
"Escape all Unicode characters to HTML entities."
result = ''
pos = TextPosition(line)
while not pos.finished():
if ord(pos.current()) > 128:
codepoint = hex(ord(pos.current()))
if codepoint == '0xd835':
codepoint = hex(ord(next(pos)) + 0xf800)
result += '&#' + codepoint[1:] + ';'
else:
result += pos.current()
pos.skipcurrent()
return result
def searchall(self, type):
"Search for all embedded containers of a given type"
list = []
self.searchprocess(type, lambda container: list.append(container))
return list
def searchremove(self, type):
"Search for all containers of a type and remove them"
list = self.searchall(type)
for container in list:
container.parent.contents.remove(container)
return list
def searchprocess(self, type, process):
"Search for elements of a given type and process them"
self.locateprocess(lambda container: isinstance(container, type), process)
def locateprocess(self, locate, process):
"Search for all embedded containers and process them"
for container in self.contents:
container.locateprocess(locate, process)
if locate(container):
process(container)
def recursivesearch(self, locate, recursive, process):
"Perform a recursive search in the container."
for container in self.contents:
if recursive(container):
container.recursivesearch(locate, recursive, process)
if locate(container):
process(container)
def extracttext(self):
"Extract all text from allowed containers."
constants = ContainerExtractor(ContainerConfig.extracttext).extract(self)
return ''.join(constant.string for constant in constants)
def group(self, index, group, isingroup):
"Group some adjoining elements into a group"
if index >= len(self.contents):
return
if hasattr(self.contents[index], 'grouped'):
return
while index < len(self.contents) and isingroup(self.contents[index]):
self.contents[index].grouped = True
group.contents.append(self.contents[index])
self.contents.pop(index)
self.contents.insert(index, group)
def remove(self, index):
"Remove a container but leave its contents"
container = self.contents[index]
self.contents.pop(index)
while len(container.contents) > 0:
self.contents.insert(index, container.contents.pop())
def tree(self, level=0):
"Show in a tree"
Trace.debug(" " * level + str(self))
for container in self.contents:
container.tree(level + 1)
def getparameter(self, name):
"Get the value of a parameter, if present."
if name not in self.parameters:
return None
return self.parameters[name]
def getparameterlist(self, name):
"Get the value of a comma-separated parameter as a list."
paramtext = self.getparameter(name)
if not paramtext:
return []
return paramtext.split(',')
def hasemptyoutput(self):
"Check if the parent's output is empty."
current = self.parent
while current:
if current.output.isempty():
return True
current = current.parent
return False
def __str__(self):
"Get a description"
if not self.begin:
return self.__class__.__name__
return self.__class__.__name__ + '@' + str(self.begin)
class BlackBox(Container):
"A container that does not output anything"
def __init__(self):
self.parser = LoneCommand()
self.output = EmptyOutput()
self.contents = []
class StringContainer(Container):
"A container for a single string"
parsed = None
def __init__(self):
self.parser = StringParser()
self.output = StringOutput()
self.string = ''
def process(self):
"Replace special chars from the contents."
if self.parsed:
self.string = self.replacespecial(self.parsed)
self.parsed = None
def replacespecial(self, line):
"Replace all special chars from a line"
replaced = self.escape(line, EscapeConfig.entities)
replaced = self.changeline(replaced)
if ContainerConfig.string['startcommand'] in replaced and len(replaced) > 1:
# unprocessed commands
if self.begin:
message = 'Unknown command at ' + str(self.begin) + ': '
else:
message = 'Unknown command: '
Trace.error(message + replaced.strip())
return replaced
def changeline(self, line):
return self.escape(line, EscapeConfig.chars)
def extracttext(self):
"Return all text."
return self.string
def __str__(self):
"Return a printable representation."
result = 'StringContainer'
if self.begin:
result += '@' + str(self.begin)
ellipsis = '...'
if len(self.string.strip()) <= 15:
ellipsis = ''
return result + ' (' + self.string.strip()[:15] + ellipsis + ')'
class Constant(StringContainer):
"A constant string"
def __init__(self, text):
self.contents = []
self.string = text
self.output = StringOutput()
def __str__(self):
return 'Constant: ' + self.string
class DocumentParameters:
"Global parameters for the document."
displaymode = False
class FormulaParser(Parser):
"Parses a formula"
def parseheader(self, reader):
"See if the formula is inlined"
self.begin = reader.linenumber + 1
type = self.parsetype(reader)
if not type:
reader.nextline()
type = self.parsetype(reader)
if not type:
Trace.error('Unknown formula type in ' + reader.currentline().strip())
return ['unknown']
return [type]
def parsetype(self, reader):
"Get the formula type from the first line."
if reader.currentline().find(FormulaConfig.starts['simple']) >= 0:
return 'inline'
if reader.currentline().find(FormulaConfig.starts['complex']) >= 0:
return 'block'
if reader.currentline().find(FormulaConfig.starts['unnumbered']) >= 0:
return 'block'
if reader.currentline().find(FormulaConfig.starts['beginbefore']) >= 0:
return 'numbered'
return None
def parse(self, reader):
"Parse the formula until the end"
formula = self.parseformula(reader)
while not reader.currentline().startswith(self.ending):
stripped = reader.currentline().strip()
if len(stripped) > 0:
Trace.error('Unparsed formula line ' + stripped)
reader.nextline()
reader.nextline()
return formula
def parseformula(self, reader):
"Parse the formula contents"
simple = FormulaConfig.starts['simple']
if simple in reader.currentline():
rest = reader.currentline().split(simple, 1)[1]
if simple in rest:
# formula is $...$
return self.parsesingleliner(reader, simple, simple)
# formula is multiline $...$
return self.parsemultiliner(reader, simple, simple)
if FormulaConfig.starts['complex'] in reader.currentline():
# formula of the form \[...\]
return self.parsemultiliner(reader, FormulaConfig.starts['complex'],
FormulaConfig.endings['complex'])
beginbefore = FormulaConfig.starts['beginbefore']
beginafter = FormulaConfig.starts['beginafter']
if beginbefore in reader.currentline():
if reader.currentline().strip().endswith(beginafter):
current = reader.currentline().strip()
endsplit = current.split(beginbefore)[1].split(beginafter)
startpiece = beginbefore + endsplit[0] + beginafter
endbefore = FormulaConfig.endings['endbefore']
endafter = FormulaConfig.endings['endafter']
endpiece = endbefore + endsplit[0] + endafter
return startpiece + self.parsemultiliner(reader, startpiece, endpiece) + endpiece
Trace.error('Missing ' + beginafter + ' in ' + reader.currentline())
return ''
begincommand = FormulaConfig.starts['command']
beginbracket = FormulaConfig.starts['bracket']
if begincommand in reader.currentline() and beginbracket in reader.currentline():
endbracket = FormulaConfig.endings['bracket']
return self.parsemultiliner(reader, beginbracket, endbracket)
Trace.error('Formula beginning ' + reader.currentline() + ' is unknown')
return ''
def parsesingleliner(self, reader, start, ending):
"Parse a formula in one line"
line = reader.currentline().strip()
if start not in line:
Trace.error('Line ' + line + ' does not contain formula start ' + start)
return ''
if not line.endswith(ending):
Trace.error('Formula ' + line + ' does not end with ' + ending)
return ''
index = line.index(start)
rest = line[index + len(start):-len(ending)]
reader.nextline()
return rest
def parsemultiliner(self, reader, start, ending):
"Parse a formula in multiple lines"
formula = ''
line = reader.currentline()
if start not in line:
Trace.error('Line ' + line.strip() + ' does not contain formula start ' + start)
return ''
index = line.index(start)
line = line[index + len(start):].strip()
while not line.endswith(ending):
formula += line + '\n'
reader.nextline()
line = reader.currentline()
formula += line[:-len(ending)]
reader.nextline()
return formula
class FormulaBit(Container):
"A bit of a formula"
type = None
size = 1
original = ''
def __init__(self):
"The formula bit type can be 'alpha', 'number', 'font'."
self.contents = []
self.output = ContentsOutput()
def setfactory(self, factory):
"Set the internal formula factory."
self.factory = factory
return self
def add(self, bit):
"Add any kind of formula bit already processed"
self.contents.append(bit)
self.original += bit.original
bit.parent = self
def skiporiginal(self, string, pos):
"Skip a string and add it to the original formula"
self.original += string
if not pos.checkskip(string):
Trace.error('String ' + string + ' not at ' + pos.identifier())
def computesize(self):
"Compute the size of the bit as the max of the sizes of all contents."
if len(self.contents) == 0:
return 1
self.size = max(element.size for element in self.contents)
return self.size
def clone(self):
"Return a copy of itself."
return self.factory.parseformula(self.original)
def __str__(self):
"Get a string representation"
return self.__class__.__name__ + ' read in ' + self.original
class TaggedBit(FormulaBit):
"A tagged string in a formula"
def constant(self, constant, tag):
"Set the constant and the tag"
self.output = TaggedOutput().settag(tag)
self.add(FormulaConstant(constant))
return self
def complete(self, contents, tag, breaklines=False):
"Set the constant and the tag"
self.contents = contents
self.output = TaggedOutput().settag(tag, breaklines)
return self
def selfcomplete(self, tag):
"Set the self-closing tag, no contents (as in
)."
self.output = TaggedOutput().settag(tag, empty=True)
return self
class FormulaConstant(Constant):
"A constant string in a formula"
def __init__(self, string):
"Set the constant string"
Constant.__init__(self, string)
self.original = string
self.size = 1
self.type = None
def computesize(self):
"Compute the size of the constant: always 1."
return self.size
def clone(self):
"Return a copy of itself."
return FormulaConstant(self.original)
def __str__(self):
"Return a printable representation."
return 'Formula constant: ' + self.string
class RawText(FormulaBit):
"A bit of text inside a formula"
def detect(self, pos):
"Detect a bit of raw text"
return pos.current().isalpha()
def parsebit(self, pos):
"Parse alphabetic text"
alpha = pos.globalpha()
self.add(FormulaConstant(alpha))
self.type = 'alpha'
class FormulaSymbol(FormulaBit):
"A symbol inside a formula"
modified = FormulaConfig.modified
unmodified = FormulaConfig.unmodified['characters']
def detect(self, pos):
"Detect a symbol"
if pos.current() in FormulaSymbol.unmodified:
return True
if pos.current() in FormulaSymbol.modified:
return True
return False
def parsebit(self, pos):
"Parse the symbol"
if pos.current() in FormulaSymbol.unmodified:
self.addsymbol(pos.current(), pos)
return
if pos.current() in FormulaSymbol.modified:
self.addsymbol(FormulaSymbol.modified[pos.current()], pos)
return
Trace.error('Symbol ' + pos.current() + ' not found')
def addsymbol(self, symbol, pos):
"Add a symbol"
self.skiporiginal(pos.current(), pos)
self.contents.append(FormulaConstant(symbol))
class FormulaNumber(FormulaBit):
"A string of digits in a formula"
def detect(self, pos):
"Detect a digit"
return pos.current().isdigit()
def parsebit(self, pos):
"Parse a bunch of digits"
digits = pos.glob(lambda: pos.current().isdigit())
self.add(FormulaConstant(digits))
self.type = 'number'
class Comment(FormulaBit):
"A LaTeX comment: % to the end of the line."
start = FormulaConfig.starts['comment']
def detect(self, pos):
"Detect the %."
return pos.current() == self.start
def parsebit(self, pos):
"Parse to the end of the line."
self.original += pos.globincluding('\n')
class WhiteSpace(FormulaBit):
"Some white space inside a formula."
def detect(self, pos):
"Detect the white space."
return pos.current().isspace()
def parsebit(self, pos):
"Parse all whitespace."
self.original += pos.skipspace()
def __str__(self):
"Return a printable representation."
return 'Whitespace: *' + self.original + '*'
class Bracket(FormulaBit):
"A {} bracket inside a formula"
start = FormulaConfig.starts['bracket']
ending = FormulaConfig.endings['bracket']
def __init__(self):
"Create a (possibly literal) new bracket"
FormulaBit.__init__(self)
self.inner = None
def detect(self, pos):
"Detect the start of a bracket"
return pos.checkfor(self.start)
def parsebit(self, pos):
"Parse the bracket"
self.parsecomplete(pos, self.innerformula)
return self
def parsetext(self, pos):
"Parse a text bracket"
self.parsecomplete(pos, self.innertext)
return self
def parseliteral(self, pos):
"Parse a literal bracket"
self.parsecomplete(pos, self.innerliteral)
return self
def parsecomplete(self, pos, innerparser):
"Parse the start and end marks"
if not pos.checkfor(self.start):
Trace.error('Bracket should start with ' + self.start + ' at ' + pos.identifier())
return None
self.skiporiginal(self.start, pos)
pos.pushending(self.ending)
innerparser(pos)
self.original += pos.popending(self.ending)
self.computesize()
def innerformula(self, pos):
"Parse a whole formula inside the bracket"
while not pos.finished():
self.add(self.factory.parseany(pos))
def innertext(self, pos):
"Parse some text inside the bracket, following textual rules."
specialchars = list(FormulaConfig.symbolfunctions.keys())
specialchars.append(FormulaConfig.starts['command'])
specialchars.append(FormulaConfig.starts['bracket'])
specialchars.append(Comment.start)
while not pos.finished():
if pos.current() in specialchars:
self.add(self.factory.parseany(pos))
if pos.checkskip(' '):
self.original += ' '
else:
self.add(FormulaConstant(pos.skipcurrent()))
def innerliteral(self, pos):
"Parse a literal inside the bracket, which does not generate HTML."
self.literal = ''
while not pos.finished() and not pos.current() == self.ending:
if pos.current() == self.start:
self.parseliteral(pos)
else:
self.literal += pos.skipcurrent()
self.original += self.literal
class SquareBracket(Bracket):
"A [] bracket inside a formula"
start = FormulaConfig.starts['squarebracket']
ending = FormulaConfig.endings['squarebracket']
def clone(self):
"Return a new square bracket with the same contents."
bracket = SquareBracket()
bracket.contents = self.contents
return bracket
class MathsProcessor:
"A processor for a maths construction inside the FormulaProcessor."
def process(self, contents, index):
"Process an element inside a formula."
Trace.error('Unimplemented process() in ' + str(self))
def __str__(self):
"Return a printable description."
return 'Maths processor ' + self.__class__.__name__
class FormulaProcessor:
"A processor specifically for formulas."
processors = []
def process(self, bit):
"Process the contents of every formula bit, recursively."
self.processcontents(bit)
self.processinsides(bit)
self.traversewhole(bit)
def processcontents(self, bit):
"Process the contents of a formula bit."
if not isinstance(bit, FormulaBit):
return
bit.process()
for element in bit.contents:
self.processcontents(element)
def processinsides(self, bit):
"Process the insides (limits, brackets) in a formula bit."
if not isinstance(bit, FormulaBit):
return
for index, element in enumerate(bit.contents):
for processor in self.processors:
processor.process(bit.contents, index)
# continue with recursive processing
self.processinsides(element)
def traversewhole(self, formula):
"Traverse over the contents to alter variables and space units."
last = None
for bit, contents in self.traverse(formula):
if bit.type == 'alpha':
self.italicize(bit, contents)
elif bit.type == 'font' and last and last.type == 'number':
bit.contents.insert(0, FormulaConstant('\u2009'))
last = bit
def traverse(self, bit):
"Traverse a formula and yield a flattened structure of (bit, list) pairs."
for element in bit.contents:
if hasattr(element, 'type') and element.type:
yield element, bit.contents
elif isinstance(element, FormulaBit):
yield from self.traverse(element)
def italicize(self, bit, contents):
"Italicize the given bit of text."
index = contents.index(bit)
contents[index] = TaggedBit().complete([bit], 'i')
class Formula(Container):
"A LaTeX formula"
def __init__(self):
self.parser = FormulaParser()
self.output = TaggedOutput().settag('span class="formula"')
def process(self):
"Convert the formula to tags"
if self.header[0] == 'inline':
DocumentParameters.displaymode = False
else:
DocumentParameters.displaymode = True
self.output.settag('div class="formula"', True)
self.classic()
def classic(self):
"Make the contents using classic output generation with XHTML and CSS."
whole = FormulaFactory().parseformula(self.parsed)
FormulaProcessor().process(whole)
whole.parent = self
self.contents = [whole]
def parse(self, pos):
"Parse using a parse position instead of self.parser."
if pos.checkskip('$$'):
self.parsedollarblock(pos)
elif pos.checkskip('$'):
self.parsedollarinline(pos)
elif pos.checkskip('\\('):
self.parseinlineto(pos, '\\)')
elif pos.checkskip('\\['):
self.parseblockto(pos, '\\]')
else:
pos.error('Unparseable formula')
self.process()
return self
def parsedollarinline(self, pos):
"Parse a $...$ formula."
self.header = ['inline']
self.parsedollar(pos)
def parsedollarblock(self, pos):
"Parse a $$...$$ formula."
self.header = ['block']
self.parsedollar(pos)
if not pos.checkskip('$'):
pos.error('Formula should be $$...$$, but last $ is missing.')
def parsedollar(self, pos):
"Parse to the next $."
pos.pushending('$')
self.parsed = pos.globexcluding('$')
pos.popending('$')
def parseinlineto(self, pos, limit):
"Parse a \\(...\\) formula."
self.header = ['inline']
self.parseupto(pos, limit)
def parseblockto(self, pos, limit):
"Parse a \\[...\\] formula."
self.header = ['block']
self.parseupto(pos, limit)
def parseupto(self, pos, limit):
"Parse a formula that ends with the given command."
pos.pushending(limit)
self.parsed = pos.glob(lambda: True)
pos.popending(limit)
def __str__(self):
"Return a printable representation."
if self.partkey and self.partkey.number:
return 'Formula (' + self.partkey.number + ')'
return 'Unnumbered formula'
class WholeFormula(FormulaBit):
"Parse a whole formula"
def detect(self, pos):
"Not outside the formula is enough."
return not pos.finished()
def parsebit(self, pos):
"Parse with any formula bit"
while not pos.finished():
self.add(self.factory.parseany(pos))
class FormulaFactory:
"Construct bits of formula"
# bit types will be appended later
types = [FormulaSymbol, RawText, FormulaNumber, Bracket, Comment, WhiteSpace]
skippedtypes = [Comment, WhiteSpace]
defining = False
def __init__(self):
"Initialize the map of instances."
self.instances = {}
def detecttype(self, type, pos):
"Detect a bit of a given type."
if pos.finished():
return False
return self.instance(type).detect(pos)
def instance(self, type):
"Get an instance of the given type."
if type not in self.instances or not self.instances[type]:
self.instances[type] = self.create(type)
return self.instances[type]
def create(self, type):
"Create a new formula bit of the given type."
return Cloner.create(type).setfactory(self)
def clearskipped(self, pos):
"Clear any skipped types."
while not pos.finished():
if not self.skipany(pos):
return
return
def skipany(self, pos):
"Skip any skipped types."
for type in self.skippedtypes:
if self.instance(type).detect(pos):
return self.parsetype(type, pos)
return None
def parseany(self, pos):
"Parse any formula bit at the current location."
for type in self.types + self.skippedtypes:
if self.detecttype(type, pos):
return self.parsetype(type, pos)
Trace.error('Unrecognized formula at ' + pos.identifier())
return FormulaConstant(pos.skipcurrent())
def parsetype(self, type, pos):
"Parse the given type and return it."
bit = self.instance(type)
self.instances[type] = None
returnedbit = bit.parsebit(pos)
if returnedbit:
return returnedbit.setfactory(self)
return bit
def parseformula(self, formula):
"Parse a string of text that contains a whole formula."
pos = TextPosition(formula)
whole = self.create(WholeFormula)
if whole.detect(pos):
whole.parsebit(pos)
return whole
# no formula found
if not pos.finished():
Trace.error('Unknown formula at: ' + pos.identifier())
whole.add(TaggedBit().constant(formula, 'span class="unknown"'))
return whole
class FormulaCommand(FormulaBit):
"A LaTeX command inside a formula"
types = []
start = FormulaConfig.starts['command']
commandmap = None
def detect(self, pos):
"Find the current command."
return pos.checkfor(FormulaCommand.start)
def parsebit(self, pos):
"Parse the command."
command = self.extractcommand(pos)
bit = self.parsewithcommand(command, pos)
if bit:
return bit
if command.startswith('\\up') or command.startswith('\\Up'):
upgreek = self.parseupgreek(command, pos)
if upgreek:
return upgreek
if not self.factory.defining:
Trace.error('Unknown command ' + command)
self.output = TaggedOutput().settag('span class="unknown"')
self.add(FormulaConstant(command))
return None
def parsewithcommand(self, command, pos):
"Parse the command type once we have the command."
for type in FormulaCommand.types:
if command in type.commandmap:
return self.parsecommandtype(command, type, pos)
return None
def parsecommandtype(self, command, type, pos):
"Parse a given command type."
bit = self.factory.create(type)
bit.setcommand(command)
returned = bit.parsebit(pos)
if returned:
return returned
return bit
def extractcommand(self, pos):
"Extract the command from the current position."
if not pos.checkskip(FormulaCommand.start):
pos.error('Missing command start ' + FormulaCommand.start)
return
if pos.finished():
return self.emptycommand(pos)
if pos.current().isalpha():
# alpha command
command = FormulaCommand.start + pos.globalpha()
# skip mark of short command
pos.checkskip('*')
return command
# symbol command
return FormulaCommand.start + pos.skipcurrent()
def emptycommand(self, pos):
"""Check for an empty command: look for command disguised as ending.
Special case against '{ \\{ \\} }' situation."""
command = ''
if not pos.isout():
ending = pos.nextending()
if ending and pos.checkskip(ending):
command = ending
return FormulaCommand.start + command
def parseupgreek(self, command, pos):
"Parse the Greek \\up command.."
if len(command) < 4:
return None
if command.startswith('\\up'):
upcommand = '\\' + command[3:]
elif pos.checkskip('\\Up'):
upcommand = '\\' + command[3:4].upper() + command[4:]
else:
Trace.error('Impossible upgreek command: ' + command)
return
upgreek = self.parsewithcommand(upcommand, pos)
if upgreek:
upgreek.type = 'font'
return upgreek
class CommandBit(FormulaCommand):
"A formula bit that includes a command"
def setcommand(self, command):
"Set the command in the bit"
self.command = command
if self.commandmap:
self.original += command
self.translated = self.commandmap[self.command]
def parseparameter(self, pos):
"Parse a parameter at the current position"
self.factory.clearskipped(pos)
if pos.finished():
return None
parameter = self.factory.parseany(pos)
self.add(parameter)
return parameter
def parsesquare(self, pos):
"Parse a square bracket"
self.factory.clearskipped(pos)
if not self.factory.detecttype(SquareBracket, pos):
return None
bracket = self.factory.parsetype(SquareBracket, pos)
self.add(bracket)
return bracket
def parseliteral(self, pos):
"Parse a literal bracket."
self.factory.clearskipped(pos)
if not self.factory.detecttype(Bracket, pos):
if not pos.isvalue():
Trace.error('No literal parameter found at: ' + pos.identifier())
return None
return pos.globvalue()
bracket = Bracket().setfactory(self.factory)
self.add(bracket.parseliteral(pos))
return bracket.literal
def parsesquareliteral(self, pos):
"Parse a square bracket literally."
self.factory.clearskipped(pos)
if not self.factory.detecttype(SquareBracket, pos):
return None
bracket = SquareBracket().setfactory(self.factory)
self.add(bracket.parseliteral(pos))
return bracket.literal
def parsetext(self, pos):
"Parse a text parameter."
self.factory.clearskipped(pos)
if not self.factory.detecttype(Bracket, pos):
Trace.error('No text parameter for ' + self.command)
return None
bracket = Bracket().setfactory(self.factory).parsetext(pos)
self.add(bracket)
return bracket
class EmptyCommand(CommandBit):
"An empty command (without parameters)"
commandmap = FormulaConfig.commands
def parsebit(self, pos):
"Parse a command without parameters"
self.contents = [FormulaConstant(self.translated)]
class SpacedCommand(CommandBit):
"""An empty command which should have math spacing in formulas."""
commandmap = FormulaConfig.spacedcommands
def parsebit(self, pos):
"Place as contents the command translated and spaced."
# pad with MEDIUM MATHEMATICAL SPACE (4/18 em): too wide in STIX fonts :(
# self.contents = [FormulaConstant('\u205f' + self.translated + '\u205f')]
# pad with THIN SPACE (1/5 em)
self.contents = [FormulaConstant('\u2009' + self.translated + '\u2009')]
class AlphaCommand(EmptyCommand):
"""A command without parameters whose result is alphabetical."""
commandmap = FormulaConfig.alphacommands
greek_capitals = ('\\Xi', '\\Theta', '\\Pi', '\\Sigma', '\\Gamma',
'\\Lambda', '\\Phi', '\\Psi', '\\Delta',
'\\Upsilon', '\\Omega')
def parsebit(self, pos):
"Parse the command and set type to alpha"
EmptyCommand.parsebit(self, pos)
if self.command not in self.greek_capitals:
# Greek Capital letters are upright in LaTeX default math-style.
# TODO: use italic, like in MathML and "iso" math-style?
self.type = 'alpha'
class OneParamFunction(CommandBit):
"A function of one parameter"
commandmap = FormulaConfig.onefunctions
simplified = False
def parsebit(self, pos):
"Parse a function with one parameter"
self.output = TaggedOutput().settag(self.translated)
self.parseparameter(pos)
self.simplifyifpossible()
def simplifyifpossible(self):
"Try to simplify to a single character."
if self.original in self.commandmap:
self.output = FixedOutput()
self.html = [self.commandmap[self.original]]
self.simplified = True
class SymbolFunction(CommandBit):
"Find a function which is represented by a symbol (like _ or ^)"
commandmap = FormulaConfig.symbolfunctions
def detect(self, pos):
"Find the symbol"
return pos.current() in SymbolFunction.commandmap
def parsebit(self, pos):
"Parse the symbol"
self.setcommand(pos.current())
pos.skip(self.command)
self.output = TaggedOutput().settag(self.translated)
self.parseparameter(pos)
class TextFunction(CommandBit):
"A function where parameters are read as text."
commandmap = FormulaConfig.textfunctions
def parsebit(self, pos):
"Parse a text parameter"
self.output = TaggedOutput().settag(self.translated)
self.parsetext(pos)
def process(self):
"Set the type to font"
self.type = 'font'
class FontFunction(OneParamFunction):
"""A function of one parameter that changes the font."""
# TODO: keep letters italic with \boldsymbol.
commandmap = FormulaConfig.fontfunctions
def process(self):
"Simplify if possible using a single character."
self.type = 'font'
self.simplifyifpossible()
FormulaFactory.types += [FormulaCommand, SymbolFunction]
FormulaCommand.types = [
AlphaCommand, EmptyCommand, OneParamFunction, FontFunction,
TextFunction, SpacedCommand]
class BigBracket:
"A big bracket generator."
def __init__(self, size, bracket, alignment='l'):
"Set the size and symbol for the bracket."
self.size = size
self.original = bracket
self.alignment = alignment
self.pieces = None
if bracket in FormulaConfig.bigbrackets:
self.pieces = FormulaConfig.bigbrackets[bracket]
def getpiece(self, index):
"Return the nth piece for the bracket."
function = getattr(self, 'getpiece' + str(len(self.pieces)))
return function(index)
def getpiece1(self, index):
"Return the only piece for a single-piece bracket."
return self.pieces[0]
def getpiece3(self, index):
"Get the nth piece for a 3-piece bracket: parenthesis or square bracket."
if index == 0:
return self.pieces[0]
if index == self.size - 1:
return self.pieces[-1]
return self.pieces[1]
def getpiece4(self, index):
"Get the nth piece for a 4-piece bracket: curly bracket."
if index == 0:
return self.pieces[0]
if index == self.size - 1:
return self.pieces[3]
if index == (self.size - 1)/2:
return self.pieces[2]
return self.pieces[1]
def getcell(self, index):
"Get the bracket piece as an array cell."
piece = self.getpiece(index)
span = 'span class="bracket align-' + self.alignment + '"'
return TaggedBit().constant(piece, span)
def getcontents(self):
"Get the bracket as an array or as a single bracket."
if self.size == 1 or not self.pieces:
return self.getsinglebracket()
rows = []
for index in range(self.size):
cell = self.getcell(index)
rows.append(TaggedBit().complete([cell], 'span class="arrayrow"'))
return [TaggedBit().complete(rows, 'span class="array"')]
def getsinglebracket(self):
"Return the bracket as a single sign."
if self.original == '.':
return [TaggedBit().constant('', 'span class="emptydot"')]
return [TaggedBit().constant(self.original, 'span class="stretchy"')]
class FormulaEquation(CommandBit):
"A simple numbered equation."
piece = 'equation'
def parsebit(self, pos):
"Parse the array"
self.output = ContentsOutput()
self.add(self.factory.parsetype(WholeFormula, pos))
class FormulaCell(FormulaCommand):
"An array cell inside a row"
def setalignment(self, alignment):
self.alignment = alignment
self.output = TaggedOutput().settag('span class="arraycell align-'
+ alignment + '"', True)
return self
def parsebit(self, pos):
self.factory.clearskipped(pos)
if pos.finished():
return
self.add(self.factory.parsetype(WholeFormula, pos))
class FormulaRow(FormulaCommand):
"An array row inside an array"
cellseparator = FormulaConfig.array['cellseparator']
def setalignments(self, alignments):
self.alignments = alignments
self.output = TaggedOutput().settag('span class="arrayrow"', True)
return self
def parsebit(self, pos):
"Parse a whole row"
index = 0
pos.pushending(self.cellseparator, optional=True)
while not pos.finished():
cell = self.createcell(index)
cell.parsebit(pos)
self.add(cell)
index += 1
pos.checkskip(self.cellseparator)
if len(self.contents) == 0:
self.output = EmptyOutput()
def createcell(self, index):
"Create the cell that corresponds to the given index."
alignment = self.alignments[index % len(self.alignments)]
return self.factory.create(FormulaCell).setalignment(alignment)
class MultiRowFormula(CommandBit):
"A formula with multiple rows."
def parserows(self, pos):
"Parse all rows, finish when no more row ends"
self.rows = []
first = True
for row in self.iteraterows(pos):
if first:
first = False
else:
# intersparse empty rows
self.addempty()
row.parsebit(pos)
self.addrow(row)
self.size = len(self.rows)
def iteraterows(self, pos):
"Iterate over all rows, end when no more row ends"
rowseparator = FormulaConfig.array['rowseparator']
while True:
pos.pushending(rowseparator, True)
row = self.factory.create(FormulaRow)
yield row.setalignments(self.alignments)
if pos.checkfor(rowseparator):
self.original += pos.popending(rowseparator)
else:
return
def addempty(self):
"Add an empty row."
row = self.factory.create(FormulaRow).setalignments(self.alignments)
for index, originalcell in enumerate(self.rows[-1].contents):
cell = row.createcell(index)
cell.add(FormulaConstant(' '))
row.add(cell)
self.addrow(row)
def addrow(self, row):
"Add a row to the contents and to the list of rows."
self.rows.append(row)
self.add(row)
class FormulaArray(MultiRowFormula):
"An array within a formula"
piece = 'array'
def parsebit(self, pos):
"Parse the array"
self.output = TaggedOutput().settag('span class="array"', False)
self.parsealignments(pos)
self.parserows(pos)
def parsealignments(self, pos):
"Parse the different alignments"
# vertical
self.valign = 'c'
literal = self.parsesquareliteral(pos)
if literal:
self.valign = literal
# horizontal
literal = self.parseliteral(pos)
self.alignments = []
for s in literal:
self.alignments.append(s)
class FormulaMatrix(MultiRowFormula):
"A matrix (array with center alignment)."
piece = 'matrix'
def parsebit(self, pos):
"Parse the matrix, set alignments to 'c'."
self.output = TaggedOutput().settag('span class="array"', False)
self.valign = 'c'
self.alignments = ['c']
self.parserows(pos)
class FormulaCases(MultiRowFormula):
"A cases statement"
piece = 'cases'
def parsebit(self, pos):
"Parse the cases"
self.output = ContentsOutput()
self.alignments = ['l', 'l']
self.parserows(pos)
for row in self.contents:
for cell in row.contents:
cell.output.settag('span class="case align-l"', True)
cell.contents.append(FormulaConstant(' '))
array = TaggedBit().complete(self.contents, 'span class="bracketcases"', True)
brace = BigBracket(len(self.contents), '{', 'l')
self.contents = brace.getcontents() + [array]
class EquationEnvironment(MultiRowFormula):
"A \\begin{}...\\end equation environment with rows and cells."
def parsebit(self, pos):
"Parse the whole environment."
environment = self.piece.replace('*', '')
self.output = TaggedOutput().settag(
'span class="environment %s"'%environment, False)
if environment in FormulaConfig.environments:
self.alignments = FormulaConfig.environments[environment]
else:
Trace.error('Unknown equation environment ' + self.piece)
# print in red
self.output = TaggedOutput().settag('span class="unknown"')
self.add(FormulaConstant('\\begin{%s} '%environment))
self.alignments = ['l']
self.parserows(pos)
class BeginCommand(CommandBit):
"A \\begin{}...\\end command and what it entails (array, cases, aligned)"
commandmap = {FormulaConfig.array['begin']: ''}
types = [FormulaEquation, FormulaArray, FormulaCases, FormulaMatrix]
def parsebit(self, pos):
"Parse the begin command"
command = self.parseliteral(pos)
bit = self.findbit(command)
ending = FormulaConfig.array['end'] + '{' + command + '}'
pos.pushending(ending)
bit.parsebit(pos)
self.add(bit)
self.original += pos.popending(ending)
self.size = bit.size
def findbit(self, piece):
"Find the command bit corresponding to the \\begin{piece}"
for type in BeginCommand.types:
if piece.replace('*', '') == type.piece:
return self.factory.create(type)
bit = self.factory.create(EquationEnvironment)
bit.piece = piece
return bit
FormulaCommand.types += [BeginCommand]
class CombiningFunction(OneParamFunction):
commandmap = FormulaConfig.combiningfunctions
def parsebit(self, pos):
"Parse a combining function."
combining = self.translated
parameter = self.parsesingleparameter(pos)
if not parameter:
Trace.error('Missing parameter for combining function ' + self.command)
return
# Trace.message('apply %s to %r'%(self.command, parameter.extracttext()))
# parameter.tree()
if not isinstance(parameter, FormulaConstant):
try:
extractor = ContainerExtractor(ContainerConfig.extracttext)
parameter = extractor.extract(parameter)[0]
except IndexError:
Trace.error('No base character found for "%s".' % self.command)
return
# Trace.message(' basechar: %r' % parameter.string)
# Insert combining character after the first character:
if parameter.string.startswith('\u2009'):
i = 2 # skip padding by SpacedCommand and FormulaConfig.modified
else:
i = 1
parameter.string = parameter.string[:i] + combining + parameter.string[i:]
# Use pre-composed characters if possible: \not{=} -> ≠, say.
parameter.string = unicodedata.normalize('NFC', parameter.string)
def parsesingleparameter(self, pos):
"Parse a parameter, or a single letter."
self.factory.clearskipped(pos)
if pos.finished():
return None
return self.parseparameter(pos)
class OversetFunction(OneParamFunction):
"A function that decorates some bit of text with an overset."
commandmap = FormulaConfig.oversetfunctions
def parsebit(self, pos):
"Parse an overset-function"
symbol = self.translated
self.symbol = TaggedBit().constant(symbol, 'sup')
self.parameter = self.parseparameter(pos)
self.output = TaggedOutput().settag('span class="embellished"')
self.contents.insert(0, self.symbol)
self.parameter.output = TaggedOutput().settag('span class="base"')
self.simplifyifpossible()
class UndersetFunction(OneParamFunction):
"A function that decorates some bit of text with an underset."
commandmap = FormulaConfig.undersetfunctions
def parsebit(self, pos):
"Parse an underset-function"
symbol = self.translated
self.symbol = TaggedBit().constant(symbol, 'sub')
self.parameter = self.parseparameter(pos)
self.output = TaggedOutput().settag('span class="embellished"')
self.contents.insert(0, self.symbol)
self.parameter.output = TaggedOutput().settag('span class="base"')
self.simplifyifpossible()
class LimitCommand(EmptyCommand):
"A command which accepts limits above and below, in display mode."
commandmap = FormulaConfig.limitcommands
def parsebit(self, pos):
"Parse a limit command."
self.output = TaggedOutput().settag('span class="limits"')
symbol = self.translated
self.contents.append(TaggedBit().constant(symbol, 'span class="limit"'))
class LimitPreviousCommand(LimitCommand):
"A command to limit the previous command."
commandmap = None
def parsebit(self, pos):
"Do nothing."
self.output = TaggedOutput().settag('span class="limits"')
self.factory.clearskipped(pos)
def __str__(self):
"Return a printable representation."
return 'Limit previous command'
class LimitsProcessor(MathsProcessor):
"A processor for limits inside an element."
def process(self, contents, index):
"Process the limits for an element."
if Options.simplemath:
return
if self.checklimits(contents, index):
self.modifylimits(contents, index)
if self.checkscript(contents, index) and self.checkscript(contents, index + 1):
self.modifyscripts(contents, index)
def checklimits(self, contents, index):
"Check if the current position has a limits command."
# TODO: check for \limits macro
if not DocumentParameters.displaymode:
return False
if self.checkcommand(contents, index + 1, LimitPreviousCommand):
self.limitsahead(contents, index)
return False
if not isinstance(contents[index], LimitCommand):
return False
return self.checkscript(contents, index + 1)
def limitsahead(self, contents, index):
"Limit the current element based on the next."
contents[index + 1].add(contents[index].clone())
contents[index].output = EmptyOutput()
def modifylimits(self, contents, index):
"Modify a limits commands so that the limits appear above and below."
limited = contents[index]
subscript = self.getlimit(contents, index + 1)
if self.checkscript(contents, index + 1):
superscript = self.getlimit(contents, index + 1)
else:
superscript = TaggedBit().constant('\u2009', 'sup class="limit"')
# fix order if source is x^i
if subscript.command == '^':
superscript, subscript = subscript, superscript
limited.contents.append(subscript)
limited.contents.insert(0, superscript)
def getlimit(self, contents, index):
"Get the limit for a limits command."
limit = self.getscript(contents, index)
limit.output.tag = limit.output.tag.replace('script', 'limit')
return limit
def modifyscripts(self, contents, index):
"Modify the super- and subscript to appear vertically aligned."
subscript = self.getscript(contents, index)
# subscript removed so instead of index + 1 we get index again
superscript = self.getscript(contents, index)
# super-/subscript are reversed if source is x^i_j
if subscript.command == '^':
superscript, subscript = subscript, superscript
scripts = TaggedBit().complete([superscript, subscript], 'span class="scripts"')
contents.insert(index, scripts)
def checkscript(self, contents, index):
"Check if the current element is a sub- or superscript."
return self.checkcommand(contents, index, SymbolFunction)
def checkcommand(self, contents, index, type):
"Check for the given type as the current element."
if len(contents) <= index:
return False
return isinstance(contents[index], type)
def getscript(self, contents, index):
"Get the sub- or superscript."
bit = contents[index]
bit.output.tag += ' class="script"'
del contents[index]
return bit
class BracketCommand(OneParamFunction):
"A command which defines a bracket."
commandmap = FormulaConfig.bracketcommands
def parsebit(self, pos):
"Parse the bracket."
OneParamFunction.parsebit(self, pos)
def create(self, direction, character):
"Create the bracket for the given character."
self.original = character
self.command = '\\' + direction
self.contents = [FormulaConstant(character)]
return self
class BracketProcessor(MathsProcessor):
"A processor for bracket commands."
def process(self, contents, index):
"Convert the bracket using Unicode pieces, if possible."
if Options.simplemath:
return
if self.checkleft(contents, index):
return self.processleft(contents, index)
def processleft(self, contents, index):
"Process a left bracket."
rightindex = self.findright(contents, index + 1)
if not rightindex:
return
size = self.findmax(contents, index, rightindex)
self.resize(contents[index], size)
self.resize(contents[rightindex], size)
def checkleft(self, contents, index):
"Check if the command at the given index is left."
return self.checkdirection(contents[index], '\\left')
def checkright(self, contents, index):
"Check if the command at the given index is right."
return self.checkdirection(contents[index], '\\right')
def checkdirection(self, bit, command):
"Check if the given bit is the desired bracket command."
if not isinstance(bit, BracketCommand):
return False
return bit.command == command
def findright(self, contents, index):
"Find the right bracket starting at the given index, or 0."
depth = 1
while index < len(contents):
if self.checkleft(contents, index):
depth += 1
if self.checkright(contents, index):
depth -= 1
if depth == 0:
return index
index += 1
return None
def findmax(self, contents, leftindex, rightindex):
"Find the max size of the contents between the two given indices."
sliced = contents[leftindex:rightindex]
return max(element.size for element in sliced)
def resize(self, command, size):
"Resize a bracket command to the given size."
character = command.extracttext()
alignment = command.command.replace('\\', '')
bracket = BigBracket(size, character, alignment)
command.output = ContentsOutput()
command.contents = bracket.getcontents()
FormulaCommand.types += [OversetFunction, UndersetFunction,
CombiningFunction, LimitCommand, BracketCommand]
FormulaProcessor.processors += [
LimitsProcessor(), BracketProcessor(),
]
class ParameterDefinition:
"The definition of a parameter in a hybrid function."
"[] parameters are optional, {} parameters are mandatory."
"Each parameter has a one-character name, like {$1} or {$p}."
"A parameter that ends in ! like {$p!} is a literal."
"Example: [$1]{$p!} reads an optional parameter $1 and a literal mandatory parameter p."
parambrackets = [('[', ']'), ('{', '}')]
def __init__(self):
self.name = None
self.literal = False
self.optional = False
self.value = None
self.literalvalue = None
def parse(self, pos):
"Parse a parameter definition: [$0], {$x}, {$1!}..."
for (opening, closing) in ParameterDefinition.parambrackets:
if pos.checkskip(opening):
if opening == '[':
self.optional = True
if not pos.checkskip('$'):
Trace.error('Wrong parameter name, did you mean $' + pos.current() + '?')
return None
self.name = pos.skipcurrent()
if pos.checkskip('!'):
self.literal = True
if not pos.checkskip(closing):
Trace.error('Wrong parameter closing ' + pos.skipcurrent())
return None
return self
Trace.error('Wrong character in parameter template: ' + pos.skipcurrent())
return None
def read(self, pos, function):
"Read the parameter itself using the definition."
if self.literal:
if self.optional:
self.literalvalue = function.parsesquareliteral(pos)
else:
self.literalvalue = function.parseliteral(pos)
if self.literalvalue:
self.value = FormulaConstant(self.literalvalue)
elif self.optional:
self.value = function.parsesquare(pos)
else:
self.value = function.parseparameter(pos)
def __str__(self):
"Return a printable representation."
result = 'param ' + self.name
if self.value:
result += ': ' + str(self.value)
else:
result += ' (empty)'
return result
class ParameterFunction(CommandBit):
"A function with a variable number of parameters defined in a template."
"The parameters are defined as a parameter definition."
def readparams(self, readtemplate, pos):
"Read the params according to the template."
self.params = {}
for paramdef in self.paramdefs(readtemplate):
paramdef.read(pos, self)
self.params['$' + paramdef.name] = paramdef
def paramdefs(self, readtemplate):
"Read each param definition in the template"
pos = TextPosition(readtemplate)
while not pos.finished():
paramdef = ParameterDefinition().parse(pos)
if paramdef:
yield paramdef
def getparam(self, name):
"Get a parameter as parsed."
if name not in self.params:
return None
return self.params[name]
def getvalue(self, name):
"Get the value of a parameter."
return self.getparam(name).value
def getliteralvalue(self, name):
"Get the literal value of a parameter."
param = self.getparam(name)
if not param or not param.literalvalue:
return None
return param.literalvalue
class HybridFunction(ParameterFunction):
"""
A parameter function where the output is also defined using a template.
The template can use a number of functions; each function has an associated
tag.
Example: [f0{$1},span class="fbox"] defines a function f0 which corresponds
to a span of class fbox, yielding $1.
Literal parameters can be used in tags definitions:
[f0{$1},span style="color: $p;"]
yields $1, where $p is a literal parameter.
Sizes can be specified in hybridsizes, e.g. adding parameter sizes. By
default the resulting size is the max of all arguments. Sizes are used
to generate the right parameters.
A function followed by a single / is output as a self-closing XHTML tag:
[f0/,hr]
will generate
.
"""
commandmap = FormulaConfig.hybridfunctions
def parsebit(self, pos):
"Parse a function with [] and {} parameters"
readtemplate = self.translated[0]
writetemplate = self.translated[1]
self.readparams(readtemplate, pos)
self.contents = self.writeparams(writetemplate)
self.computehybridsize()
def writeparams(self, writetemplate):
"Write all params according to the template"
return self.writepos(TextPosition(writetemplate))
def writepos(self, pos):
"Write all params as read in the parse position."
result = []
while not pos.finished():
if pos.checkskip('$'):
param = self.writeparam(pos)
if param:
result.append(param)
elif pos.checkskip('f'):
function = self.writefunction(pos)
if function:
function.type = None
result.append(function)
elif pos.checkskip('('):
result.append(self.writebracket('left', '('))
elif pos.checkskip(')'):
result.append(self.writebracket('right', ')'))
else:
result.append(FormulaConstant(pos.skipcurrent()))
return result
def writeparam(self, pos):
"Write a single param of the form $0, $x..."
name = '$' + pos.skipcurrent()
if name not in self.params:
Trace.error('Unknown parameter ' + name)
return None
if not self.params[name]:
return None
if pos.checkskip('.'):
self.params[name].value.type = pos.globalpha()
return self.params[name].value
def writefunction(self, pos):
"Write a single function f0,...,fn."
tag = self.readtag(pos)
if not tag:
return None
if pos.checkskip('/'):
# self-closing XHTML tag, such as
return TaggedBit().selfcomplete(tag)
if not pos.checkskip('{'):
Trace.error('Function should be defined in {}')
return None
pos.pushending('}')
contents = self.writepos(pos)
pos.popending()
if len(contents) == 0:
return None
return TaggedBit().complete(contents, tag)
def readtag(self, pos):
"Get the tag corresponding to the given index. Does parameter substitution."
if not pos.current().isdigit():
Trace.error('Function should be f0,...,f9: f' + pos.current())
return None
index = int(pos.skipcurrent())
if 2 + index > len(self.translated):
Trace.error('Function f' + str(index) + ' is not defined')
return None
tag = self.translated[2 + index]
if '$' not in tag:
return tag
for variable in self.params:
if variable in tag:
param = self.params[variable]
if not param.literal:
Trace.error('Parameters in tag ' + tag + ' should be literal: {' + variable + '!}')
continue
if param.literalvalue:
value = param.literalvalue
else:
value = ''
tag = tag.replace(variable, value)
return tag
def writebracket(self, direction, character):
"Return a new bracket looking at the given direction."
return self.factory.create(BracketCommand).create(direction, character)
def computehybridsize(self):
"Compute the size of the hybrid function."
if self.command not in HybridSize.configsizes:
self.computesize()
return
self.size = HybridSize().getsize(self)
# set the size in all elements at first level
for element in self.contents:
element.size = self.size
class HybridSize:
"The size associated with a hybrid function."
configsizes = FormulaConfig.hybridsizes
def getsize(self, function):
"Read the size for a function and parse it."
sizestring = self.configsizes[function.command]
for name in function.params:
if name in sizestring:
size = function.params[name].value.computesize()
sizestring = sizestring.replace(name, str(size))
if '$' in sizestring:
Trace.error('Unconverted variable in hybrid size: ' + sizestring)
return 1
return eval(sizestring)
FormulaCommand.types += [HybridFunction]
def math2html(formula):
"Convert some TeX math to HTML."
factory = FormulaFactory()
whole = factory.parseformula(formula)
FormulaProcessor().process(whole)
whole.process()
return ''.join(whole.gethtml())
def main():
"Main function, called if invoked from the command line"
args = sys.argv
Options().parseoptions(args)
if len(args) != 1:
Trace.error('Usage: math2html.py escaped_string')
exit()
result = math2html(args[0])
Trace.message(result)
if __name__ == '__main__':
main()
PK ! ý™fIýf ýf ' __pycache__/tex2unichar.cpython-311.pycnu „[µü¤ §
¥ Þiy’ ã ó– — i d d“dd“dd“dd“dd “d
d “d d
“dd“dd“dd“dd“dd“dd“dd“d d “d d “d d!“d"d#d$d%œ¥Z i d&d'“d(d)“d*d+“d,d-“d.d/“d0d1“d2d3“d4d5“d6d7“d8d9“d:d;“dd?“d@dA“dBdC“dDdE“dFdG“i dHdI“dJdK“dLdM“dNdO“dPdQ“dRdS“dTdU“dVdW“dXdY“dZd[“d\d]“d^d_“d`da“dbdc“ddde“dfdg“dhdi“¥i djdk“dldm“dndo“dpdq“drds“dtdu“dvdw“dxdy“dzd{“d|d}“d~d“d€d“d‚dƒ“d„d…“d†d‡“dˆd‰“dŠd‹“¥dŒddŽddd‘d’d“d”d•d–d—d˜d™dšd›œ¥Zi dœd“dždŸ“d d¡“d¢d£“d¤d¥“d¦d§“d¨d©“dªd«“d¬d“d®d¯“d°d±“d²d³“d´dµ“d¶d·“d¸d¹“dºd»“d¼d½“i d¾d¿“dÀdÁ“dÂdÓdÄdÅ“dÆdÇ“dÈdÉ“dÊdË“dÌdÍ“dÎdÏ“dÐdÑ“dÒdÓ“dÔdÕ“dÖdדdØdÙ“dÚdÛ“dÜdÝ“dÞdß“¥i dàdá“dâdã“dädå“dædç“dèdé“dêdë“dìdí“dîdï“dðdñ“dòdó“dôdõ“död÷“død³“dùdú“dûdü“dýdþ“dÿd “¥i dd“dd“dd“dd“d d
“d d “d
d“dd“dd“dd“dd“dd“dd“dd “d d “d d “d!d"“¥d#d$d%d&d'd d d(d d)dúd*d+œ ¥Zd,d-d.d,d/d0d1d2d3d4d5d6d/d7œ
Zd8d9d8d:œZi d;d<“d=d>“d?d@“dAdB“dCdD“dEdF“dGdH“dIdJ“dKdL“dMdN“dOdP“dQdR“dSdT“dUdV“dWdX“dYdZ“d[d\“d]d]d^d_d`dad`dbdcdddedfdgœ ¥Zdhdidhdjdkdldmdndodpdqdrdjdsœ
Zi dtdt“dudu“dvdv“dwdw“dxdy“dzd{“d|d}“d~d“d€d“d‚dƒ“d„d…“d†d‡“dˆd‰“dŠd‹“dŒd“dŽd“dd‘“i d’d““d”d•“d–d—“d˜d™“dšd›“dœd“dždŸ“d d¡“d¢d£“d¤d¥“d¦d§“d¨d©“dªd«“d¬d“d®d¯“d°d±“d²d³“¥i d´dµ“d¶d·“d¸d¹“dºd»“d¼d½“d¾d¿“dÀdÁ“dÂdÓdÄdÅ“dÆdÇ“dÈdÉ“dÊdÊ“dËdÌ“dÍdΓdÏd‹“dÐdÑ“dÒdÓ“¥i dÔdÕ“dÖdדdØdÙ“dÚdÛ“dÜdÝ“dÞdß“dàdÝ“dádâ“dãd©“dädå“dædç“dèdé“dêdë“dìdí“dîdï“dðdñ“dòdó“¥i dôdõ“död÷“dødù“dúdû“düdý“dþdÿ“d d“dd“dd“ddÅ“dd“d d
“d d “d
d“dd“ddÅ“dd“¥i dd“dd“dd“ddŸ“dd“d d “d d¥“d d§“d d!“d"d#“d$d%“d&d©“d'd(“d)dí“d*du“d+d,“d-d.“¥i d/d0“d1d2“d3d«“d4d5“d6d7“d8d9“d:d#“d;d“d<d=“d>d?“d@dA“dBdC“dDd±“dEd,“dFdG“dHdI“dJdK“¥i dLdM“dNdO“dPd¹“dQd»“dRdS“dTdU“dVdW“dXdY“dZd[“d\d]“d^d_“d`da“dbdc“ddde“dfdg“dhdÁ“didj“¥dkdldÃddmdndodpdqdrdsdtœ ¥ZdudvdwœZdxdydzœZ d{d|d}œZ
i d~d“d€d“d‚dƒ“d„d…“d†d‡“dˆd‰“dŠd‹“dŒd“dŽd“dd‘“d’d““d”d•“d–d—“d˜d™“dšd›“dœd“dždŸ“i d d¡“d¢d“d£d¤“d¥d¦“d§d¨“d©dª“d«d¬“dd®“d¯d°“d±d²“d³d´“dµd¶“d·d¸“d¹dº“d»d¼“d½d¾“d¿dÀ“¥i dÁd“dÃdÄ“dÅdÆ“dÇdÈ“dÉdÊ“dËdÌ“dÍdΓdÏdГdÑdÒ“dÓdÔ“dÕdÖ“d×dØ“dÙdÚ“dÛdÜ“dÝdÞ“dßdà“dádâ“¥i dãdä“dådæ“dçdæ“dèdé“dêdë“dìdí“dîdï“dðdñ“dòdó“dôdõ“död÷“dødõ“dùdú“dûdü“dýdþ“dÿd…“d d“¥i dd“dd“dd“dd “d
d “d d
“dd“dd“dd“dd“dd“dd“dd“dd “d d “d d “d!d"“¥i d#d"“d$d%“d&d'“d(d)“d*d+“d,d-“d.d/“d0d/“d1d2“d3d4“d5d6“d7d8“d9d:“d;d<“d=d>“d?d@“dAd¾“¥i dBdC“dDdE“dFdG“dHdI“dJd“dKd—“dLdM“dNdO“dPdQ“dRd)“dSdT“dUdV“dWdX“dYdZ“d[d\“d]d^“d_d`“¥i dadb“dcdd“dedf“dgdh“didj“dkdl“dmdn“dodp“dqdâ“drdO“dsdt“dudv“dwdx“dydz“d{d|“d}d~“ddÀ“¥i d€d“d‚dƒ“d„d…“d†d‡“dˆd‰“dŠd‰“d‹dŒ“ddŽ“dd“d‘d’“d“d”“d•d–“d—d˜“d™dš“d›dœ“ddž“dŸd “¥i d¡dÜ“d¢d£“d¤d¥“d¦d§“d¨d©“dªd«“d¬d“d®d¯“d°d±“d²d³“d´dµ“d¶d·“d¸d¹“dºd»“d¼d½“d¾d¿“dÀdÁ“¥i dÂdÓdÄdÁ“dÅdÆ“dÇdÈ“dÉdÊ“dËdÌ“dÍdΓdÏdГdÑdÒ“dÓdÔ“dÕdÖ“d×dØ“dÙdÚ“dÛdÜ“dÝdÞ“dßdÞ“dàdá“¥i dâdã“dädå“dædç“dèdé“dêdë“dìdí“dîdï“dðdñ“dòdó“dôdõ“död÷“dødù“dúdû“düdý“dþdÿ“d d“dd“¥i ddÌ“dd“dd“d d
“d d “d
d“dd“dd“dd“dd“dd“dd“dd “d d “d d “d!d"“d#d$“¥i d%d&“d'd(“d)d*“d+d,“d-d.“d/d0“d1d2“d3d4“d5d6“d7d8“d9d:“d;d<“d=dä“d>d?“d@dA“dBdC“dDdE“¥i dFdG“dHdI“dJdK“dLdM“dNdO“dPdQ“dRdS“dTdU“dVdW“dXdY“dZd[“d\d]“d^d_“d`da“dbdc“ddde“dfdg“¥i dhdi“djdk“dldm“dndo“dpdq“drds“dtdu“dvdw“dxdy“dzd{“d|d}“d~d$“dd€“dd‚“dƒd„“d…d†“d‡dˆ“¥d‰dŠd‹dŒdd dŽddd‘dd"d’d}d“œ¥Z d”d•iZ d–d—d˜d˜d™d—dšœZ
d›S (œ Úacuteu ÌÚbaru Ì„Úbreveu ̆Úchecku ÌŒÚddddotu ⃜Údddotu ⃛Úddotu ̈Údotu ̇Úgraveu Ì€Úhatu Ì‚Úmathringu ÌŠÚnotu ̸Úoverleftrightarrowu ⃡Úoverlineu Ì…Útildeu ̃Úunderbaru ̱Úunderleftarrowu ⃮u ̲u ⃯u ⃗)Ú underlineÚunderrightarrowÚvecÚBbbku ð•œÚDeltau ΔÚGammau ΓÚImu â„‘ÚLambdau ΛÚOmegau ΩÚPhiu ΦÚPiu Î ÚPsiu ΨÚReu â„œÚSigmau ΣÚThetau ΘÚUpsilonu Î¥ÚXiu ΞÚalephu ℵÚalphau αÚbetau βÚbethu ℶÚchiu χÚdalethu ℸÚdeltau δÚdigammau ÏÚellu â„“Úepsilonu ϵÚetau ηÚethõ ðÚgammau γÚgimelu â„·Úhslashu â„Úimathu ıÚiotau ιÚjmathu È·Úkappau κÚlambdau λÚmuu μÚnuu νÚomegau ωÚphiu Ï•Úpiu Ï€Úpsiu ψÚrhou ÏÚsigmau σÚtauu Ï„Úthetau θÚupsilonu Ï…ÚvarDeltau ð›¥ÚvarGammau ð›¤Ú varLambdau ð›¬ÚvarOmegau ð›ºÚvarPhiu ð›·ÚvarPiu ð›±u ð›¹u ð›´u ð›©u ð›¶u ð›¯u εu Ï°u φu Ï–u ϱu Ï‚u Ï‘u ℘u ξu ζ)ÚvarPsiÚvarSigmaÚvarThetaÚ
varUpsilonÚvarXiÚ
varepsilonÚvarkappaÚvarphiÚvarpiÚvarrhoÚvarsigmaÚvarthetaÚwpÚxiÚzetaÚCapu â‹’ÚCircleu â—‹ÚCupu â‹“ÚLHDu â—€ÚRHDu â–¶Úamalgu ⨿Úastu ∗Úbarwedgeu ⊼Úbigcircu â—¯Úbigtriangledownu â–½Ú
bigtriangleupu â–³Ú bindnasrepmau â…‹Ú blacklozengeu ⧫Úboxastu ⧆Úboxbaru â—«Úboxboxu â§ˆÚ boxbslashu â§…Ú boxcircleu ⧇Úboxdotu ⊡Úboxminusu ⊟Úboxplusu ⊞Úboxslashu ⧄Úboxtimesu ⊠Úbulletu •Úcapu ∩Úcdotu â‹…Úcircu ∘Ú
circledastu ⊛Ú
circledbslashu â¦¸Ú circledcircu âŠšÚ circleddashu âŠÚ
circledgtru â§Ú circledlessu ⧀Úcupu ∪Úcurlyveeu â‹ŽÚ
curlywedgeu â‹Údaggeru †Úddaggeru ‡Údiamondu â‹„Údivõ ÷Ú
divideontimesu ⋇Údotplusu ∔Údoublebarwedgeu â©žÚgtrdotu â‹—Úintercalu ⊺Ú
interleaveu â«´ÚinvampÚlandu ∧Úleftthreetimesu â‹‹Úlessdotu â‹–Úloru ∨Últimesu ⋉Úmpu ∓Úodotu ⊙Úominusu ⊖Úoplusu ⊕Úoslashu ⊘Úotimesu ⊗Úpmõ ±Úrightthreetimesu â‹ŒÚrtimesu â‹ŠÚsetminusu ⧵Úslashu ∕Ú
smallsetminusu ∖Úsmalltriangledownu â–¿Úsmalltriangleleftu â—ƒÚsmalltrianglerightu â–¹Úsqcapu ⊓u ⊔u ⫽u ⋆u ⫾õ ×u ⊎u ⊻u ≀) ÚsqcupÚsslashÚstarÚ
talloblongÚtimesÚ triangleleftÚ
trianglerightÚuplusÚveeÚveebarÚwedgeÚwru ⟆u ⌟u ⟩Ú}ú]u ⌉u ⌋u ⟯u ⟧u ⦈u âŒ)
ÚRbagÚlrcornerÚrangleÚrbagÚrbraceÚrbrackÚrceilÚrfloorÚrgroupÚ rrbracketÚ
rrparenthesisÚurcornerr¬ u ‖ú|)ÚVertÚvertrº Úbigcapu â‹‚Úbigcupu ⋃Ú
biginterleaveu ⫼Úbigodotu ⨀Úbigoplusu â¨Ú bigotimesu ⨂Úbigsqcapu ⨅Úbigsqcupu ⨆Úbiguplusu ⨄Úbigveeu â‹Úbigwedgeu â‹€Úcoprodu âˆÚfatsemiu ⨟Úfintu â¨Úiiiintu ⨌Úiiintu âˆÚiintu ∬u ∫u ∰u ∯u ∮u ∳u âˆu ⨖u ∑u ∲u ⨉) ÚintÚintopÚoiiintÚoiintÚointÚointctrclockwiseÚointopÚprodÚsqintÚsumÚvarointclockwiseÚvarprodu ⟅u ⟨Ú{ú[u ⌈u ⌊u ⟮u ⟦u ⌞u ⦇u ⌜)
ÚLbagÚlangleÚlbagÚlbraceÚlbrackÚlceilÚlfloorÚlgroupÚ llbracketÚllcornerÚ
llparenthesisÚulcornerrÚ ú#ú$ú%ú&ÚACu ∿Ú
APLcommentu âÚAPLdownarrowboxu â—ÚAPLinputu âžÚAPLinvu ⌹ÚAPLleftarrowboxu â‡ÚAPLlogu âŸÚAPLrightarrowboxu âˆÚ
APLuparrowboxu âÚAriesu ♈ÚBoxu ⬜ÚCIRCLEu â—Ú
CheckedBoxu ☑ÚDiamondu â—‡Ú Diamondblacku â—†Ú
Diamonddotu âŸÚFinvu ℲÚGameu â…ÚGeminiu ♊ÚJupiteru ♃Ú
LEFTCIRCLEu â—–Ú
LEFTcircleu â—ÚLeou ♌ÚLibrau ♎ÚMarsu ♂ÚMercuryu ☿ÚNeptuneu ♆ÚPõ ¶ÚPlutou â™‡Ú RIGHTCIRCLEu â——Ú RIGHTcircleu â—‘ÚSõ §ÚSaturnu ♄ÚScorpiou â™ÚSquareu â˜ÚSunu ☉ÚTaurusu ♉ÚUranusu â™…ÚVenusu ♀ÚXBoxu ☒ÚYupu â…„Ú_Úangleu ∠Úaquariusu â™’ÚariesÚ arrowvertu âÚ backprimeu â€µÚ backslashú\Úbigstaru â˜…Ú blacksmileyu â˜»Ú blacksquareu â—¼Ú
blacktriangleu â–´Úblacktriangledownu â–¾ÚblacktriangleupÚbotu ⊥ÚboyÚ bracevertu ⎪Úcanceru â™‹Ú capricornusu ♑Úcdotsu ⋯Úcentõ Â¢Ú checkmarku ✓ÚcircledRu ⓇÚcircledSu ⓈÚclubsuitu ♣Ú
complementu âˆÚdiagdownu âŸÚdiagupu ⟋Údiameteru âŒ€Ú diamondsuitu ♢Úearthu â™Úemptysetu ∅Úexistsu ∃ÚfemaleÚflatu â™Úforallu ∀Úfourthu â—Úfrownieu ☹ÚgeminiÚgirlÚ heartsuitu ♡Úinftyu âˆžÚ invdiameteru â‰Úinvnegu âŒÚjupiterÚldotsu …Úleftmoonu ☾ÚleoÚlibraÚ
lmoustacheu ⎰Úlnotõ ¬Úlozengeu â—ŠÚmaleÚmalteseu ✠ÚmathcentÚ
mathdollarÚ mathsterlingõ £Ú
measuredangleu âˆ¡Ú medbulletu âš«Úmedcircu ⚪ÚmercuryÚmhou ℧Únablau ∇Únaturalu â™®ÚnegÚneptuneÚnexistsu âˆ„Ú notbackslashu â€Úpartialu ∂Úpiscesu ♓ÚplutoÚpoundsÚprimeu â€²Ú quarternoteu â™©Ú rightmoonu ☽Ú
rmoustacheu âŽ±Ú sagittariusu â™ÚsaturnÚscorpioÚsecondu ″Úsharpu ♯Úsmileyu â˜ºÚ spadesuitu â™ Úspddotõ ¨Úsphatú^Úsphericalangleu ∢Úsptildeú~Úsquareu â—»Úsunu ☼Úsurdu √ÚtaurusÚthirdu ‴u ⊤u ♫u ♧u ♦u ♥u ♤u â™u ⌑õ Â¥) ÚtopÚtwonotesÚuranusÚvarEarthÚ varclubsuitÚvardiamondsuitÚ varheartsuitÚ varspadesuitÚvirgoÚ wasylozengeÚyenu âžu âœ)Ú overbraceÚ wideparenu ⋱u â‹®)ÚddotsÚvdotsu ∛u ∜)zsqrt[3]zsqrt[4]ÚBotu â««ÚBumpequ ≎ÚColoneqqu â©´ÚDotequ â‰‘Ú Downarrowu â‡“Ú Leftarrowu â‡ÚLeftrightarrowu ⇔Ú
Lleftarrowu ⇚Ú
Longleftarrowu ⟸ÚLongleftrightarrowu âŸºÚ Longmapsfromu ⟽Ú
Longmapstou ⟾ÚLongrightarrowu ⟹ÚLshu ↰ÚMapsfromu ⤆ÚMapstou ⤇ÚNearrowu ⇗ÚNwarrowu ⇖ÚPerpÚ
Rightarrowu â‡’Ú Rrightarrowu ⇛ÚRshu ↱ÚSearrowu ⇘ÚSubsetu â‹ÚSupsetu â‹‘ÚSwarrowu ⇙ÚTopu ⫪ÚUparrowu â‡‘Ú Updownarrowu ⇕ÚVDashu ⊫ÚVdashu ⊩ÚVvdashu ⊪Úapprgeu ≳Úapprleu ≲Úapproxu ≈Úapproxequ ≊Úasympu â‰Ú backepsilonu âˆÚbacksimu âˆ½Ú backsimequ â‹Úbarinu ⋶Úbarleftharpoonu ⥫Úbarrightharpoonu â¥Úbecauseu ∵Úbetweenu ≬Úblacktriangleleftu â—‚Úblacktrianglerightu â–¸Úbowtieu ⋈Úbumpequ â‰Úcircequ ≗Úcirclearrowleftu ↺Úcirclearrowrightu ↻Úcolonequ ≔ÚcoloneqqÚcongu â‰…Ú correspondsu â‰™Ú curlyeqprecu â‹žÚ curlyeqsuccu â‹ŸÚcurvearrowleftu ↶Úcurvearrowrightu â†·Ú dasharrowu ⇢Ú
dashleftarrowu ⇠ÚdashrightarrowÚdashvu ⊣Údlshu ↲Údotequ â‰ÚdoteqdotÚ downarrowu ↓Údowndownarrowsu ⇊Údowndownharpoonsu ⥥Údownharpoonleftu ⇃Údownharpoonrightu â‡‚Ú downuparrowsu ⇵Údownupharpoonsu ⥯Údrshu ↳Úeqcircu ≖Úeqcolonu ≕ÚeqqcolonÚeqsimu ≂Ú
eqslantgtru âª–Ú eqslantlessu ⪕Úequivu ≡Ú
fallingdotsequ ≒Úfrownu ⌢Úgeu ≥ÚgeqÚgeqqu ≧Úgeqslantu ⩾Úgetsu â†Úggu ≫Úggcurlyu ⪼Úgggu â‹™ÚgggtrÚgnapproxu ⪊Úgnequ ⪈Úgneqqu ≩Úgnsimu â‹§Ú gtrapproxu âª†Ú gtreqlessu â‹›Ú
gtreqqlessu ⪌Úgtrlessu ≷ÚgtrsimÚhashu â‹•Ú
hookleftarrowu ↩Úhookrightarrowu ↪Úiddotsu â‹°Ú impliedbyÚimpliesÚinu ∈Úleu ≤Úleadstou â¤³Ú leftarrowÚ
leftarrowtailu ↢Úleftarrowtriangleu ⇽Úleftbarharpoonu ⥪Úleftharpoondownu ↽Ú
leftharpoonupu ↼Úleftleftarrowsu ⇇Úleftleftharpoonsu ⥢Úleftrightarrowu ↔Úleftrightarrowsu ⇆Úleftrightarrowtriangleu ⇿Úleftrightharpoonu ⥊Úleftrightharpoonsu ⇋Úleftrightsquigarrowu â†Ú leftsliceu ⪦Úleftsquigarrowu ⇜ÚleftturnÚleqÚleqqu ≦Úleqslantu ⩽Ú
lessapproxu âª…Ú lesseqgtru â‹šÚ
lesseqqgtru ⪋Úlessgtru ≶ÚlesssimÚlhdu âŠ²Ú lightningu ↯Úllu ≪Úllcurlyu ⪻Úlllu ⋘ÚlllessÚlnapproxu ⪉Úlnequ ⪇Úlneqqu ≨Úlnsimu ⋦Ú
longleftarrowu ⟵Úlongleftrightarrowu âŸ·Ú longmapsfromu ⟻Ú
longmapstou ⟼Úlongrightarrowu ⟶Ú
looparrowleftu ↫Úlooparrowrightu ↬ÚlrtimesÚmapsfromu ↤Úmapstou ↦Úmidu ∣Úmodelsu ⊧Úmultimapu âŠ¸Ú multimapbothu ⧟ÚmultimapdotbothAu ⊶ÚmultimapdotbothBu âŠ·Ú multimapinvu ⟜Ú
nLeftarrowu â‡ÚnLeftrightarrowu â‡ŽÚ nRightarrowu â‡ÚnVDashu ⊯ÚnVdashu ⊮Úncongu ≇Úneu ≠Únearrowu ↗ÚneqÚngequ ≱Úngtru ≯Úngtrlessu ≹Úniu ∋Ú
nleftarrowu ↚Únleftrightarrowu ↮Únlequ ≰Únlessu ≮Únlessgtru ≸Únmidu ∤Únotasympu â‰Únotinu ∉Únotniu ∌ÚnotownerÚnotslashu âŒ¿Ú nparallelu ∦Únprecu ⊀Únprecequ â‹ Ú nrightarrowu ↛Únsimu â‰Únsimequ â‰„Ú nsubsetequ ⊈Únsuccu âŠÚnsuccequ â‹¡Ú nsupsetequ ⊉Ú
ntriangleleftu ⋪Úntriangleleftequ ⋬Úntrianglerightu â‹«Úntrianglerightequ â‹ÚnvDashu âŠÚnvdashu ⊬Únwarrowu ↖ÚownsÚparallelu ∥Úperpu âŸ‚Ú pitchforku â‹”Úprecu ≺Ú
precapproxu âª·Ú preccurlyequ ≼Úprecequ ⪯Úpreceqqu âª³Ú precnapproxu ⪹Úprecneqqu ⪵Úprecnsimu ⋨Úprecsimu ≾Úproptou âˆÚ restrictionu ↾Úrhdu ⊳Ú
rightarrowu →Úrightarrowtailu ↣Úrightarrowtriangleu ⇾Úrightbarharpoonu ⥬Úrightharpoondownu â‡Úrightharpoonupu ⇀Úrightleftarrowsu ⇄Úrightleftharpoonu ⥋Úrightleftharpoonsu ⇌Úrightrightarrowsu ⇉Úrightrightharpoonsu ⥤Ú
rightsliceu ⪧Úrightsquigarrowu â‡Ú rightturnÚ risingdotsequ ≓Úsearrowu ↘Úsimu ∼Úsimequ ≃Úsmileu ⌣Úsqsubsetu âŠÚ
sqsubsetequ ⊑Úsqsupsetu âŠÚ
sqsupsetequ ⊒Ústrictfiu ⥼Ústrictifu ⥽Úsubsetu ⊂Úsubsetequ âŠ†Ú subseteqqu â«…Ú subsetnequ ⊊Ú
subsetneqqu â«‹Úsuccu ≻Ú
succapproxu âª¸Ú succcurlyequ ≽Úsuccequ ⪰Úsucceqqu âª´Ú succnapproxu ⪺Úsuccneqqu ⪶Úsuccnsimu â‹©Úsuccsimu ≿Úsupsetu ⊃Úsupsetequ âŠ‡Ú supseteqqu â«†Ú supsetnequ ⊋Ú
supsetneqqu â«ŒÚswarrowu â†™Ú thereforeu ∴ÚtoÚtriangleleftequ âŠ´Ú trianglequ ≜Útrianglerightequ ⊵Útwoheadleftarrowu ↞Útwoheadrightarrowu ↠u ↑u ↕u ⇅u ⥮u ↿u ⇈u ⥣u ⊨u â–µu ⊢)ÚuparrowÚ updownarrowÚ updownarrowsÚupdownharpoonsÚ
upharpoonleftÚupharpoonrightÚ
upuparrowsÚ upupharpoonsÚvDashÚ vartriangleÚvartriangleleftÚvartrianglerightÚvdashÚ
wasythereforeÚ
underbraceu âŸú u  u âŸu â€)r¨ ú,ú:ÚmedspaceÚquadÚ thinspaceN)Ú
mathaccentÚ mathalphaÚmathbinÚ mathcloseÚ mathfenceÚmathopÚmathopenÚmathordÚmathoverÚ mathpunctÚ mathradicalÚmathrelÚ mathunderÚspace© ó ú/builddir/build/BUILD/imunify360-venv-2.6.2/opt/imunify360/venv/lib/python3.11/site-packages/docutils/utils/math/tex2unichar.pyúr¿ s# ðð(Ø ˆXðà ˆ8ðð ˆXðð ˆXð ð
ˆhð ð ˆXð
ð ˆHðð
ˆ8ðð ˆXðð
ˆ8ðð ðð
ˆ8ðð ˜(ðð ð ð ˆXð ð ð!ð" hð#ð$ Ø Ø ð)ð ð €
ð.C
Ø
ˆLðC
à ˆXðC
ð ˆXðC
ð ˆ(ð C
ð
ˆhð C
ð ˆXð
C
ð
ˆ8ðC
ð ˆ(ðC
ð
ˆ8ðC
ð ˆ(ðC
ð ˆXðC
ð ˆXðC
ð ˆxðC
ð ˆ(ð C
ð ˆXð C
ð ˆXð!C
ð" ˆHð#C
ð C
ð$ ˆHð%C
ð&
ˆ8ð'C
ð(
ˆhð)C
ð* ˆXð+C
ð, ˆxð-C
ð.
ˆ8ð/C
ð0 ˆxð1C
ð2
ˆ8ð3C
ð4
ˆ6ð5C
ð6 ˆXð7C
ð8 ˆXð9C
ð:
ˆhð;C
ð< ˆXð=C
ð> ˆHð?C
ð@ ˆXðAC
ðB ˆXðCC
ðD
ˆhðEC
ð C
ð C
ðF ˆ(ðGC
ðH ˆ(ðIC
ðJ ˆXðKC
ðL
ˆ8ðMC
ðN ˆ(ðOC
ðP
ˆ8ðQC
ðR
ˆ8ðSC
ðT ˆXðUC
ðV
ˆ8ðWC
ðX ˆXðYC
ðZ ˆxð[C
ð\ ð]C
ð^ ð_C
ð` ðaC
ðb ðcC
ðd
ˆlðeC
ðf ˆ\ðgC
ð C
ðh Ø Ø Ø Ø
ØØØØ
ØØØØ
Ø
Ø ðEC
ð C
ð C
€ ðJQ Ø ˆ8ðQ à ˆhðQ ð
ˆ8ðQ ð
ˆ8ð Q ð
ˆ8ð Q ð ˆXð
Q ð
ˆ8ðQ ð ðQ ð ˆxðQ ð xðQ ð XðQ ð HðQ ð HðQ ð
ˆhð Q ð
ˆhð Q ð
ˆhð!Q ð" ð#Q ð Q ð$ ð%Q ð&
ˆhð'Q ð( ð)Q ð* ˆxð+Q ð, ð-Q ð. ð/Q ð0
ˆhð1Q ð2
ˆ8ð3Q ð4 ˆHð5Q ð6 ˆHð7Q ð8 (ð9Q ð: Xð;Q ð< 8ð=Q ð> 8ð?Q ð@ (ðAQ ðB 8ðCQ ðD
ˆ8ðEQ ð Q ð Q ðF ðGQ ðH (ðIQ ðJ
ˆhðKQ ðL ˆxðMQ ðN ˆxðOQ ðP
ˆ6ðQQ ðR XðSQ ðT ˆxðUQ ðV hðWQ ðX
ˆhðYQ ðZ ð[Q ð\ (ð]Q ð^
ˆhð_Q ð` ˆHðaQ ðb hðcQ ðd ˆxðeQ ðf
‰8ðgQ ð Q ð Q ñh
‰hðiQ ñj ‰(ðkQ ñl ‰HðmQ ñn
‰hðoQ ñp ‰XðqQ ñr
‰hðsQ ñt
‰hðuQ ñv ‰&ðwQ ñx ‘xðyQ ñz
‰hð{Q ñ| ‘ð}Q ñ~ ‰XðQ ñ@ ‘XðAQ ñB ™ðCQ ñD ™ðEQ ñF ™(ðGQ ñH ‰XðIQ ð Q ñJ ÙÙ ÙÙ
Ù Ù Ù
Ù ÙØ
Ù
ñaQ ð Q ð Q €ñh
ÙÙÙ ÙÙÙ
ÙÙÙÙ ÙÙ ñ
ð
€ ñ"
Ù Ù ñ
ð
€ ð
Ù ‰hð
á ‰hð
ñ ‘Xð
ñ ‰xð
ñ
‘ð
ñ ‘ð
ñ ‘ð
ñ ‘ð
ñ ‘ð
ñ
‰hð
ñ ‘ð
ñ
‰hð
ñ ‰xð
ñ ‰Hð
ñ
‰hð
ñ ‰Xð!
ñ" ‰Hð#
ñ$ Ù
ÙÙ
Ù Ù ÙÙ Ù
Ù Ù Ùñ;
ð
ð
ۖB
ÙÙ ÙÙÙ
ÙÙÙÙÙ ÙÙ ñ ð €ð T Ù‰ðT á‰ðT ñ ‰ðT ñ ‰ð T ñ
‰(ð T ñ ‘(ð
T ñ ‘xðT ñ ‘ðT ñ
‰hðT ñ ‘xðT ñ
‰hðT ñ ™ðT ñ ‘XðT ñ ‰Xð T ñ
‰8ð T ñ
‰hð!T ñ" ‘(ð#T ð T ñ$ ‰xð%T ñ& ‘Hð'T ñ( ‘(ð)T ñ* ‰Hð+T ñ, ‰Hð-T ñ.
‰hð/T ñ0 ‰xð1T ñ2 ‘(ð3T ñ4 ‘(ð5T ñ6
‰8ð7T ñ8 ‰Xð9T ñ: ‰Hð;T ñ< ‰xð=T ñ> ‰xð?T ñ@ ‰ðAT ñB ‰XðCT ñD ‘8ðET ð T ð T ñF ‘8ðGT ñH ‰ðIT ñJ
‰hðKT ñL ‰xðMT ñN
‰hðOT ñP
‰8ðQT ñR
‰hðST ñT
‰hðUT ñV ‰XðWT ñX ‰HðYT ñZ
‰8ð[T ñ\ ‰ð]T ñ^ ‰Xð_T ñ` ‘ðaT ñb ‰XðcT ñd ‘ðeT ñf ‘ðgT ð T ð T ñh ‘ðiT ñj ‰xðkT ñl ‘8ðmT ñn ‘8ðoT ñp ‘XðqT ñr ™ðsT ñt ‘xðuT ñv
‰8ðwT ñx
‰8ðyT ñz ‘ð{T ñ|
‰hð}T ñ~ ‘8ðT ñ@ ‰XðAT ñB ‰FðCT ñD ‘ðET ñF ‘ðGT ñH ‘ðIT ð T ð T ñJ ‘ðKT ñL ‘(ðMT ñN ‘ðOT ñP
‰hðQT ñR ‘ðST ñT ‘8ðUT ñV ‰XðWT ñX ‘ðYT ñZ
‰hð[T ñ\
‰hð]T ñ^ ‰Hð_T ñ`
‰hðaT ñb
‰hðcT ñd ‰xðeT ñf
‰hðgT ñh ‰HðiT ñj ‘ðkT ð T ð T ñl ‰XðmT ñn ‘8ðoT ñp
‰hðqT ñr ‰xðsT ñt ‰XðuT ñv ‘ðwT ñx
‰8ðyT ñz ‰Xð{T ñ| ‘(ð}T ñ~ ‰FðT ñ@ ‰xðAT ñB ‰HðCT ñD ‰xðET ñF ‘ðGT ñH ‘#ðIT ñJ ‘FðKT ñL ‘XðMT ð T ð T ñN ‘ðOT ñP ‰xðQT ñR ‰xðST ñT
‰8ðUT ñV ‰XðWT ñX ‰xðYT ñZ
‰6ð[T ñ\ ‰xð]T ñ^ ‰xð_T ñ` ‘HðaT ñb ‰xðcT ñd
‰hðeT ñf ‰XðgT ñh
‰fðiT ñj ‰XðkT ñl ‘8ðmT ñn ‘ðoT ð T ð T ñp ‘(ðqT ñr ‘8ðsT ñt
‰hðuT ñv ‰xðwT ñx
‰hðyT ñz ‰Xð{T ñ|
‰hð}T ñ~ ‘ðT ñ@
‰fðAT ñB ‰SðCT ñD ‘hðET ñF ‰sðGT ñH
‰hðIT ñJ
‰8ðKT ñL ‰HðMT ñN
‰hðOT ñP ‰XðQT ð T ñR ÙÙÙÙÙ Ù Ù Ù
ÙÙ ñgT ð T ð T €ñn Ùñ ð €ñ Ù
ñ
ð
€ ñ Ùñð € ð
_ Ù ‰8ð_ á ‰hð_ ñ ‘ð_ ñ ‰Xð _ ñ
‘ð _ ñ ‘ð
_ ñ ‘hð_ ñ ‘(ð_ ñ ‘Xð_ ñ ™(ð_ ñ ‘Hð_ ñ ‘(ð_ ñ ‘hð_ ñ
‰8ð _ ñ ‘ð _ ñ
‰hð!_ ñ" ‰xð#_ ð _ ñ$ ‰xð%_ ñ& ‰Hð'_ ñ( ‘(ð)_ ñ* ‘8ð+_ ñ,
‰8ð-_ ñ. ‰xð/_ ñ0
‰hð1_ ñ2
‰hð3_ ñ4 ‰xð5_ ñ6
‰8ð7_ ñ8 ‰xð9_ ñ: ‘8ð;_ ñ< ‰Xð=_ ñ> ‰Xð?_ ñ@
‰hðA_ ñB
‰hðC_ ñD
‰hðE_ ð _ ð _ ñF
‰hðG_ ñH ‘ðI_ ñJ ‰XðK_ ñL ‘8ðM_ ñN ‰xðO_ ñP ‘ðQ_ ñR ‰XðS_ ñT ‘hðU_ ñV ‘xðW_ ñX ‰xðY_ ñZ ‰xð[_ ñ\ ™ð]_ ñ^ ™(ð__ ñ`
‰hða_ ñb
‰hðc_ ñd
‰hðe_ ñf ‘xðg_ ð _ ð _ ñh ™ði_ ñj ‰xðk_ ñl ‘ðm_ ñn ‰Hðo_ ñp ‘8ðq_ ñr ‘8ðs_ ñt ‘8ðu_ ñv ‘hðw_ ñx ‘xðy_ ñz ‘ð{_ ñ| ‘Xð}_ ñ~ ‘hð_ ñ@ ‰XðA_ ñB ‰HðC_ ñD ‰XðE_ ñF ‘ðG_ ñH ‘ðI_ ð _ ð _ ñJ ‘hðK_ ñL ™ðM_ ñN ‘xðO_ ñP ™ðQ_ ñR ‘HðS_ ñT ‘hðU_ ñV ‰HðW_ ñX
‰hðY_ ñZ ‰xð[_ ñ\ ‘ð]_ ñ^ ‰Xð__ ñ` ‘(ða_ ñb ‘8ðc_ ñd ‰Xðe_ ñf ‘Xðg_ ñh ‰Xði_ ñj ‰(ðk_ ð _ ð _ ñl
‰8ðm_ ñn ‰Hðo_ ñp ‘ðq_ ñr ‰Hðs_ ñt ‰(ðu_ ñv ‰xðw_ ñx
‰8ðy_ ñz ‰Xð{_ ñ| ‘ð}_ ñ~ ‰Hð_ ñ@ ‰XðA_ ñB ‰XðC_ ñD ‘ðE_ ñF ‘ðG_ ñH ‘(ðI_ ñJ ‰xðK_ ñL
‰hðM_ ð _ ð _ ñN ‰HðO_ ñP ‘XðQ_ ñR ‘hðS_ ñT
‰hðU_ ñV ‘ðW_ ñX ‰xðY_ ñZ ‰(ð[_ ñ\ ‰(ð]_ ñ^ ‰xð__ ñ` ‘ða_ ñb ‘Xðc_ ñd ™ðe_ ñf ‘hðg_ ñh ‘xði_ ñj ‘Xðk_ ñl ‘hðm_ ñn ™ðo_ ð _ ð _ ñp ‘hðq_ ñr ‘xðs_ ñt ™hðu_ ñv ™ðw_ ñx ™ðy_ ñz ™8ð{_ ñ| ‘ð}_ ñ~ ‘hð_ ñ@ ‘ðA_ ñB
‰8ðC_ ñD ‰HðE_ ñF ‘ðG_ ñH ‘(ðI_ ñJ ‘ðK_ ñL ‘(ðM_ ñN ‰xðO_ ñP ‰xðQ_ ð _ ð _ ñR
‰8ðS_ ñT ‘ðU_ ñV ‰(ðW_ ñX ‰xðY_ ñZ
‰8ð[_ ñ\
‰hð]_ ñ^ ‘ð__ ñ` ‰Hða_ ñb ‰Xðc_ ñd ‰Xðe_ ñf ‘Xðg_ ñh ™(ði_ ñj ‘Hðk_ ñl ‘(ðm_ ñn ‘hðo_ ñp ‘Xðq_ ñr ‘hðs_ ð _ ð _ ñt ‰xðu_ ñv ‘ðw_ ñx
‰hðy_ ñz
‰8ð{_ ñ|
‰hð}_ ñ~ ‘ð_ ñ@ ‘HðA_ ñB ™ðC_ ñD ™ðE_ ñF ‘8ðG_ ñH ‘(ðI_ ñJ ‘xðK_ ñL ‘8ðM_ ñN
‰hðO_ ñP
‰hðQ_ ñR ‰XðS_ ñT ‰(ðU_ ð _ ð _ ñV ‰xðW_ ñX
‰8ðY_ ñZ ‰Hð[_ ñ\ ‰Hð]_ ñ^ ‘ð__ ñ` ‰(ða_ ñb ‘(ðc_ ñd ‘xðe_ ñf ‰Hðg_ ñh ‰Xði_ ñj ‘ðk_ ñl ‰Hðm_ ñn ‘ðo_ ñp ‰Xðq_ ñr ‰Xðs_ ñt ‘ðu_ ñv ‘ðw_ ð _ ð _ ñx ‘ðy_ ñz ‰Xð{_ ñ| ‰xð}_ ñ~ ‘8ð_ ñ@ ‰HðA_ ñB
‰hðC_ ñD ‘ðE_ ñF ‰XðG_ ñH ‰xðI_ ñJ ‘ðK_ ñL ‘XðM_ ñN ‘xðO_ ñP ‘hðQ_ ñR ™ðS_ ñT
‰hðU_ ñV
‰hðW_ ñX ‰xðY_ ð _ ð _ ñZ ‰Hð[_ ñ\ ‘ð]_ ñ^ ‰Hð__ ñ` ‘ða_ ñb ‰Hðc_ ñd ‘(ðe_ ñf ‘8ðg_ ñh
‰hði_ ñj ‰xðk_ ñl ‘8ðm_ ñn ‘ðo_ ñp ‘ðq_ ñr ‰xðs_ ñt
‰hðu_ ñv ‘8ðw_ ñx
‰8ðy_ ñz ‘(ð{_ ð _ ð _ ñ| ‘hð}_ ñ~ ™(ð_ ñ@ ‘xðA_ ñB ™ðC_ ñD ‘hðE_ ñF ‘xðG_ ñH ™ðI_ ñJ ™ðK_ ñL ™ðM_ ñN ™(ðO_ ñP ‘(ðQ_ ñR ‘xðS_ ñT ‘ðU_ ñV ‘HðW_ ñX ‰xðY_ ñZ
‰8ð[_ ñ\ ‰Xð]_ ð _ ð _ ñ^ ‰Xð__ ñ` ‘ða_ ñb ‘(ðc_ ñd ‘ðe_ ñf ‘(ðg_ ñh ‘ði_ ñj ‘ðk_ ñl
‰hðm_ ñn ‘ðo_ ñp ‘ðq_ ñr ‘ðs_ ñt ‘(ðu_ ñv ‰Hðw_ ñx ‘(ðy_ ñz ‘8ð{_ ñ|
‰hð}_ ñ~ ‰xð_ ð _ ð _ ñ@ ‘8ðA_ ñB ‘ðC_ ñD ‘ðE_ ñF ‰xðG_ ñH
‰hðI_ ñJ ‘ðK_ ñL ‘ðM_ ñN ‘ðO_ ñP ‘(ðQ_ ñR ‰xðS_ ñT ‘ðU_ ñV ‰(ðW_ ñX ‘hðY_ ñZ ‘ð[_ ñ\ ‘xð]_ ñ^ ™ð__ ñ` ™ða_ ð _ ñb ÙÙ Ù Ù Ù ÙÙ Ù
ÙÙ Ù Ù
Ù ñ}_ ð _ ð _ €ñD ‘(ð
€ ñ
Ù Ù ÙÙ Ùñ
ð €€r½ PK ! ‰¤™×¿ ׿ % __pycache__/math2html.cpython-311.pycnu „[µü¤ §
¥ ÞiÙ¥ ã óÈ — d dl Z d dlZd dlZd dlmZ dZ G d„ d¦ « Z G d„ d¦ « Z G d„ d ¦ « Z G d
„ d ¦ « Z G d „ d
¦ « Z
G d„ d¦ « Z G d„ d¦ « Z G d„ d¦ « Z
G d„ d¦ « Z G d„ de¦ « Z G d„ de¦ « Z G d„ de¦ « Z G d „ d e¦ « Z G d „ d e¦ « Z G d „ d!e¦ « Z G d"„ d#¦ « Z G d$„ d%e¦ « Z G d&„ d'e¦ « Z G d(„ d)e¦ « Z G d*„ d+e¦ « Z G d,„ d-e¦ « Z G d.„ d/e¦ « Z G d0„ d1¦ « Z G d2„ d3¦ « Z G d4„ d5¦ « Z G d6„ d7e ¦ « Z G d8„ d9e ¦ « Z G d:„ d;¦ « Z! G d<„ d=e!¦ « Z" G d>„ d?e!¦ « Z# G d@„ dAe#¦ « Z$ G dB„ dC¦ « Z% G dD„ dEe¦ « Z& G dF„ dGe!¦ « Z' G dH„ dIe'¦ « Z( G dJ„ dKe$¦ « Z) G dL„ dMe'¦ « Z* G dN„ dOe'¦ « Z+ G dP„ dQe'¦ « Z, G dR„ dSe'¦ « Z- G dT„ dUe'¦ « Z. G dV„ dWe'¦ « Z/ G dX„ dYe/¦ « Z0 G dZ„ d[¦ « Z1 G d\„ d]¦ « Z2 G d^„ d_e!¦ « Z3 G d`„ dae'¦ « Z4 G db„ dc¦ « Z5 G dd„ dee'¦ « Z6 G df„ dge6¦ « Z7 G dh„ die7¦ « Z8 G dj„ dke7¦ « Z9 G dl„ dme8¦ « Z: G dn„ doe7¦ « Z; G dp„ dqe7¦ « Z< G dr„ dse7¦ « Z= G dt„ due;¦ « Z>e5xj? e6ee=e9ge6_? G dv„ dw¦ « Z@ G dx„ dye7¦ « ZA G dz„ d{e6¦ « ZB G d|„ d}e6¦ « ZC G d~„ de7¦ « ZD G d€„ deD¦ « ZE G d‚„ dƒeD¦ « ZF G d„„ d…eD¦ « ZG G d†„ d‡eD¦ « ZH G dˆ„ d‰e7¦ « ZIe6xj? eIgz
c_? G dŠ„ d‹e;¦ « ZJ G dŒ„ de;¦ « ZK G dŽ„ de;¦ « ZL G d„ d‘e8¦ « ZM G d’„ d“eM¦ « ZN G d”„ d•e1¦ « ZO G d–„ d—e;¦ « ZP G d˜„ d™e1¦ « ZQe6xj? eKeLeJeMePgz
c_? e2xjR eO¦ « eQ¦ « gz
c_R G dš„ d›¦ « ZS G dœ„ de7¦ « ZT G dž„ dŸeT¦ « ZU G d „ d¡¦ « ZVe6xj? eUgz
c_? d¢„ ZWd£„ ZXeYd¤k r eX¦ « dS dS )¥é N)Ú tex2unicharz1.3 (2021-06-02)c ó® — e Zd ZdZdZdZdZdZd„ Zd„ Z d„ Z
d„ Z d„ Z e
e¦ « Z e
e ¦ « Z e
e
¦ « Z
e
e ¦ « Z e
e ¦ « Z dS ) ÚTracezA tracing classFNc ó„ — t j r t j rdS t |t j ¦ « dS )zShow a debug messageN)r Ú debugmodeÚ quietmodeÚshowÚsysÚstdout©ÚclsÚmessages ú}/builddir/build/BUILD/imunify360-venv-2.6.2/opt/imunify360/venv/lib/python3.11/site-packages/docutils/utils/math/math2html.pyÚdebugz Trace.debug+ s6 € åŒð ¥%¤/ð Ø ˆFÝ
Š
7CœJÑ'Ô'Ð'Ð'Ð'ó c óº — t j rdS t j rt j rt j |z }t |t
j ¦ « dS )zShow a trace messageN)r r ÚprefixÚ
showlinesmoder r
r r s r r z
Trace.message1 sM € å Œ?ð Ø ˆFÝ Œ<ð -EÔ /ð -Ý”l WÑ,ˆGÝ
Š
7CœJÑ'Ô'Ð'Ð'Ð'r c ó¨ — d|z }t j rt j rt j |z }t |t j ¦ « dS )zShow an error messagez* N)r r r r r
Ústderrr s r Úerrorz Trace.error9 sG € à˜‘.ˆÝ Œ<ð -EÔ /ð -Ý”l WÑ,ˆGÝ
Š
7CœJÑ'Ô'Ð'Ð'Ð'r c ó^ — t d|z ¦ « t d¦ « dS )z#Show an error message and terminatezFATAL: éÿÿÿÿN)r r Úexitr s r Úfatalz Trace.fatal@ s( € å
Š I Ñ'Ñ(Ô(Ð(Ý ˆR‰Œˆˆˆr c ó6 — | |dz ¦ « dS )z Show a message out of a channelú
N)Úwrite)r
r Úchannels r r z
Trace.showE s € à
Š
g ‘nÑ%Ô%Ð%Ð%Ð%r )Ú__name__Ú
__module__Ú __qualname__Ú__doc__r r r r r r r r r Ú classmethod© r r r r " sÀ € € € € € ØÐà€IØ€IØ€Mà
€Fð(ð (ð (ð (ð (ð (ð(ð (ð (ðð ð ð
&ð &ð &ð
ˆK˜Ñ Ô €E؈k˜'Ñ"Ô"€GØ ˆK˜Ñ Ô €EØ ˆK˜Ñ Ô €EØ ˆ;tÑ Ô €D€D€Dr r c ó" — e Zd ZdZdgg d¢dœZdS )ÚContainerConfigú+Configuration class from elyxer.config fileÚFormulaConstant)Ú AlphaCommandÚBracketÚBracketCommandÚCombiningFunctionÚ EmptyCommandÚ FontFunctionÚFormulaÚ
FormulaNumberÚ
FormulaSymbolÚOneParamFunctionÚOversetFunctionÚRawTextÚ
SpacedCommandÚSymbolFunctionÚ TextFunctionÚUndersetFunction©ÚallowedÚ extractedN)r r! r" r# Ú extracttextr% r r r' r' P s7 € € € € € Ø1Ð1ð &Ð&ðð ð ðð €K€K€Kr r' c ó* — e Zd ZdZddddœZdddd œZd
S ) Ú EscapeConfigr( Ú õ ’u ‘)r ú'ú`z&z<z>)ú&ú<ú>N)r r! r" r# ÚcharsÚentitiesr% r r r? r? i sB € € € € € Ø1Ð1ð Ø
Ø
ð
ð
€Eð Ø
Ø
ðð €H€H€Hr r? c ó¨
— e Zd ZdZi dd“dd“dd“dd “d
d “d d
“dd“dd“dd“dd“dd“dd“dd“d d “d d “d d!“d"d#“d$d%i¥Zej ¦ « D ]
\ ZZ e ed&ez < Œd'd(d)d*d+œZ
g d,¢g d-¢g d.¢g d/¢g d0¢g d1¢d2gd3gd4œZ d5d6d5d5d7d8œZ d9d:d;dd?d@dAdBdCdDœ Z
ej ¦ « D ]
\ ZZ e e
d&ez < Œi d*dE“dFdG“dHdG“dIdJ“dKdL“dMdN“dOdP“dQdR“dSdT“dUdR“dVdT“dWdT“dXdR“dYdZ“d[d\“d]d^“d_d`“i dad3“dbd3“dcd2“dddE“dedf“dgdh“didh“djdk“dld3“dmd2“dndo“dpdq“drd&“dsdN“dtdu“dvdR“dwdx“¥i dydx“dzdZ“d{d|“d}d~“dd€“dd‚“dƒd„“d…d†“d‡dˆ“d‰dŠ“d‹dŒ“ddŽ“dd“d‘d’“d“dG“d”d•“d–d•“¥i d—d˜“d™dš“d›dœ“ddž“dŸd “d¡d¢“d£d¤“d¥d¦“d§d¨“d©dª“d«d¬“dd®“d¯d°“d±d²“d³d´“dµd¶“d·d¸“¥d¹dºd»d¼d½d¾d¿dÀdÁdÂdÃdÄdÅdÆdÇdÈœ¥Zi Ze ej ¦ « e ej ¦ « e ej ¦ « e ej ¦ « e ej ¦ « e ej ¦ « e ej ¦ « e dÉ„ e ¦ « D ¦ « ¦ « dÊdËdÌdÍdÎdÏdodÐdÑœZdÍdÎdÏdÒœZdÓdÔdÓdÕdÖdלZdØdÙgg dÚ¢dÙdÙgdÛdÛgdÜœZ i dÝdÞ“dßdà“dádâ“dãdä“dådæ“dçdè“dédê“dëdì“dídî“dïdð“dñdò“dódô“dõdö“d÷dø“dùdú“dûdü“dýdþ“i dÿd “dd“dd“dd“dd“d dÞ“d
d “d d
“dd“dd“dd“dd“dd“dd“dd“d d “d d “¥i d d!“d"d#“d$d%“d&d'“d(d)“d*d+“d,d“d-d.“d/d“d0d1“d2d3“d4d5“d6d7“d8d9“d:d
“d;d“d<d“¥dddddd=d>d7d?œ¥Z i d@g dA¢“dBg dC¢“dDg dE¢“dFg dG¢“dHg dI¢“dJg dK¢“dLg dM¢“dNg dO¢“dPg dQ¢“dRg dS¢“dTg dU¢“dVg dW¢“dXg dW¢“dYg dZ¢“d[g d\¢“d]g d\¢“d^g d_¢“i d`g da¢“dbg dc¢“ddg dE¢“deg df¢“dgg dh¢“dig dj¢“dkg dl¢“dmg dn¢“dog dp¢“dqdrdhg“dsg dt¢“dug dv¢“dwg dx¢“dyg dz¢“d{g d|¢“d}g dQ¢“d~g d¢“¥g dM¢g d€¢g d\¢g d¢g d‚¢g dƒ¢g d„¢g d…¢d†œ¥Z d‡d‡dˆd‡d‡dˆd‰œZ dŠd‹iZ i dŒd“dŽd“dd‘“d’d““d”d•“d–d—“d˜d™“dšd›“dœd“dždŸ“d d¡“d¢d£“d¤d¥“d¦d§“d¨d©“dªd«“d¬d“i d®d¯“d°d±“d²d³“d´dµ“d¶d·“d¸d¹“dºd»“d¼d½“d¾d¿“dÀd±“dÁd“dÃdÄ“dÅdÆ“dÇdÈ“dÉdÊ“dËd™“dÌdÍ“¥dÎdÏdÐdÑdÒdÏdÓœ¥Z!dhdhdhdÔdˆdÕdÖd×dØdÙdÚdÛdÜdhdfdÝœZ"i dÞdß“dàdß“dádß“dâdã“dädã“dådã“dædç“dèdç“dédç“dêdë“dìdë“dídë“dîdï“dðdñ“dòdó“dôdõ“död÷“dødùdõdúdhdõdûœ¥Z#i düdý“dþdÿ“d d“dd“dd“dd“dd “d
d “d d
“dd“dd“dd“dd“dd“dd“dd“Z$ej% ¦ « D ]
\ ZZ e e$d&ez < ŒdÓd d d&d d d d!d"d#œ Z&d—d$d%œZ'd&d'd(d)d*d+d,d-d.d/d0d1œ Z(d2g d3¢iZ)d4S (5 Ú
FormulaConfigr( z\AmSz AmSz\AAõ Ã…z\AEõ Æz\DHõ Ãz\Lu Åz\Oõ Øz\OEu Å’z\THõ Þz\aaõ Ã¥z\aeõ æz\dhõ ðz\iu ız\ju È·z\lu Å‚z\oõ øz\oeu Å“z\ssõ ßz\thõ þú\z\beginrD z\endz\\)ÚbeginÚ
cellseparatorÚendÚ rowseparator)u ⎛u ⎜u âŽ)u ⎞u ⎟u ⎠)u ⎡u ⎢u ⎣)u ⎤u ⎥u ⎦)u ⎧õ ⎪u ⎨u ⎩)u ⎫r[ u ⎬u âŽú|õ ‖)ú(ú)ú[ú]Ú{Ú}r\ r] úspan class="stretchy"z z )ú\leftz\left.z\middleú\rightz\right.u Ìu ̈u Ì‚u Ì€u ̃u ̧u ÌŠu Ì©u âƒu Ì¥u ÌŒ) z\'z\"z\^z\`z\~z\cz\rz\sz \textcircledz \textsubringz\vz
z\
ú z\ z
\centerdotu â¬z\colonú: z
\copyrightõ ©z \dotminusu ∸z\dotsu …z\dotsbu ⋯z\dotscz\dotsiz\dotsmz\dotsoz\euroõ €z\guillemotleftõ «z\guillemotrightõ »z\hbaru ħz\lVertz
\Arrowvertz\lvertz\newlinez
\nobreakspaceõ  z \nolimitsr@ z \nonumberz\qquadu â€â€z\rVertz\rvertz\textasciicircumú^z\textasciitildeú~z\textbackslashz\textcopyrightz \textdegreeõ °z
\textellipsisz \textemdashu —z \textendashz \texteuroz \textgreaterrF z \textlessrE z\textordfeminineõ ªz\textordmasculineõ ºz\textquotedblleftu “z\textquotedblrightu â€z\textquoterightrA z\textregisteredõ ®z\textrightarrowu →z \textsectionõ §z\texttrademarku â„¢z\texttwosuperiorõ ²z\textvisiblespacez \thickspacez! z\;z \triangleu â–³z
\triangledownu â–½z \varnothingu ⌀z\PrÚPrz\arccosÚarccosz\arcsinÚarcsinz\arctanÚarctanz\argÚargz\cosÚcosz\coshÚcoshz\cotÚcotz\cothÚcothz\cscÚcscz\degÚdegz\detÚdetz\dimÚdimz\expÚexpÚgcdÚhomu inj limÚkerÚlgu lim infu lim supÚlnÚlogu
proj limÚsecÚsinÚsinhÚtanÚtanh)z\gcdz\homz\injlimz\kerz\lgz\liminfz\limsupz\lnz\logz\projlimz\secz\sinz\sinhz\tanz\tanhc # ó* K — | ]\ }}d |z |fV — ŒdS )rV Nr% )Ú.0ÚkeyÚvalues r ú zFormulaConfig. s/ è è € ÐJÐJ©J¨C°T˜C‘Z Ð'ÐJÐJÐJÐJÐJÐJr u ‒u$ ⋯u$ →u ⟵u ⟷u ⟶u ～)z\barz\dddotz\vecz\overleftarrowz\overleftrightarrowz\overrightarrowz\widehatz
\widetilde)z\underleftarrowz\underleftrightarrowz\underrightarrowrc ú\]z\end{ra )ÚbracketÚcomplexÚendafterÚ endbeforeÚ
squarebracketÚrÚl)rš Úcr› rœ )ÚalignÚeqnarrayÚgatheredÚ smallmatrixz \boldsymbolÚbz\mathbbzspan class="blackboard"z
\mathbb{A}u ð”¸z
\mathbb{B}u ð”¹z
\mathbb{C}u â„‚z
\mathbb{D}u ð”»z
\mathbb{E}u ð”¼z
\mathbb{F}u ð”½z
\mathbb{G}u ð”¾z
\mathbb{H}u â„z
\mathbb{J}u ð•z
\mathbb{K}u ð•‚z
\mathbb{L}u ð•ƒz
\mathbb{N}u â„•z
\mathbb{O}u ð•†z
\mathbb{P}u â„™z
\mathbb{Q}u â„šz
\mathbb{R}u â„z
\mathbb{S}u ð•Šz
\mathbb{T}u ð•‹z
\mathbb{W}u ð•Žz
\mathbb{Z}u ℤz\mathbfz\mathcalzspan class="scriptfont"z \mathcal{B}u ℬz \mathcal{E}u â„°z \mathcal{F}u ℱz \mathcal{H}u â„‹z \mathcal{I}u â„z \mathcal{L}u â„’z \mathcal{M}u ℳz \mathcal{R}u â„›z \mathfrakzspan class="fraktur"z \mathfrak{C}u â„z \mathfrak{F}u ð”‰z \mathfrak{H}u â„Œz \mathfrak{I}u â„‘z \mathfrak{R}u â„œz \mathfrak{Z}u ℨz\mathitÚiz \mathring{A}z \mathring{U}u Å®z \mathring{a}z \mathring{u}u ůz \mathring{w}u ẘz \mathring{y}u ẙz\mathrmzspan class="mathrm"z\mathscrzspan class="mathscr"z \mathscr{B}z \mathscr{E}z \mathscr{F}zspan class="mathsf"zspan class="mathtt")z \mathscr{H}z \mathscr{I}z \mathscr{L}z \mathscr{M}z \mathscr{R}z\mathsfz\mathttz
\operatornamez\addcontentsline)z{$p!}{$q!}{$r!}úf0{}Úignoredz\addtocontents)z
{$p!}{$q!}r£ r¤ z \backmatter)r@ r£ r¤ ú\binom)ú{$1}{$2}zf2{(}f0{f1{$1}f1{$2}}f2{)}zspan class="binom"zspan class="binomstack"ú span class="bigdelimiter size2"z\boxed)ú{$1}úf0{$1}zspan class="boxed"ú\cfrac)z
[$p!]{$1}{$2}ú!f0{f3{(}f1{$1}f3{)/(}f2{$2}f3{)}}úspan class="fullfraction"z span class="numerator align-$p"úspan class="denominator"úspan class="ignored"z\color)ú {$p!}{$1}r© zspan style="color: $p;"z \colorbox)r¯ r© z-span class="colorbox" style="background: $p;"ú\dbinom)r¦ u% (f0{f1{f2{$1}}f1{f2{ }}f1{f2{$2}}})zspan class="binomial"zspan class="binomrow"zspan class="binomcell"ú\dfrac)r¦ r« r¬ úspan class="numerator"r r® z
\displaystyle)r¨ r© zspan class="displaystyle"z
\fancyfoot)z
[$p!]{$q!}r£ r¤ z
\fancyheadz\fbox)r¨ r© zspan class="fbox"z \fboxrule)ú{$p!}r£ r¤ z\fboxsepz
\fcolorbox)z{$p!}{$q!}{$1}r© z∮z\bigcapu$ â‹‚z\bigcupu$ ⋃z\bigodotu$ ⨀z \bigoplusu$ â¨z
\bigotimesu$ ⨂z \bigsqcapu$ ⨅z \bigsqcupu$ ⨆z \biguplusu$ ⨄z\bigveeu$ â‹z \bigwedgeu$ â‹€z\coprodu$ âˆz\intopu- ∫z\produ$ âˆz\sumu$ ∑z\varprodu$ ⨉z\zcmpu ⨟z\zhideu ⧹z\zpipeu ⨠z \zprojectu ⨡z\intz\iintu- ∬z\iiintu- âˆz\iiiintu- ⨌z\fintu- â¨z \idotsintu3 ∫⋯∫z\ointz\oiintu- ∯u- ∰u- ∲u- ∳u- ∫u- ⨖)z\oiiintz\ointclockwisez\ointctrclockwisez \smallintz\sqintz\varointclockwiseú u  + u , u  − u  â„ z : u
 < u  = u
 > )r rg ú$rD rB ú+ú,ú-ú/ú:rE ú=rF ú@ro z\bigz span class="bigdelimiter size1"z\biglz\bigrz\Bigr§ z\Biglz\Bigrz\biggz span class="bigdelimiter size3"z\bigglz\biggrz\Biggz span class="bigdelimiter size4"z\Bigglz\Biggrz
\begin{array}zspan class="arraydef"z
\centeringzspan class="align-center"z \ensuremathzspan class="ensuremath"z \hphantomzspan class="phantom"z \noindentzspan class="noindent"zspan class="overbrace"zspan class="overline"zspan class="underbrace")z
\overbracez \overlinez\phantomz \underbracez
\underlinez \vphantomz\nleqqu ≦̸z\ngeqqu ≧̸z
\nleqslantu ⩽̸z
\ngeqslantu ⩾̸z \nsubseteqqu ⫅̸z \nsupseteqqu ⫆̸z
\nsqsubsetu ≶âŠz \shortmidu$ ∣z\shortparallelu$ ∥z
\nshortmidu$ ∤z\nshortparallelu$ ∦z \smallfrownu$ ⌢z \smallsmileu$ ⌣z \thickapproxu# ≈z \thicksimu# ∼z
\varproptou âˆz\begin{rb ú%ú\[rÀ r` Ú*) Ú
beginafterÚ beginbeforer• ÚcommandÚcommentr– Úsimpler™ Ú
unnumberedÚsub)rn Ú_zspan class="mbox"zspan class="text"zspan class="textbf"zspan class="textit"zspan class="textnormal"zspan class="textrm"zspan class="textsc"zspan class="textsf"zspan class="textsl"zspan class="texttt"zspan class="normal") z\mboxz\textz\textbfz\textitz \textnormalz\textrmz\textscz\textsfz\textslz\textttz\textupÚ
characters)ú.rÊ rj r^ r_ r` ra õ ·ú!ú;r\ rt ú"ú?N)*r r! r" r# Ú
alphacommandsr Ú mathalphaÚitemsr‘ r’ ÚarrayÚ bigbracketsÚbracketcommandsÚcombiningfunctionsÚ
mathaccentÚcommandsÚcmddictÚupdateÚmathbinÚmathopenÚ mathcloseÚ mathfenceÚmathordÚ mathpunctÚspaceÚoversetfunctionsÚundersetfunctionsÚendingsÚ environmentsÚ
fontfunctionsÚhybridfunctionsÚ hybridsizesÚlabelfunctionsÚ
limitcommandsÚmodifiedÚ onefunctionsÚspacedcommandsÚmathrelÚstartsÚsymbolfunctionsÚ
textfunctionsÚ
unmodifiedr% r r rJ rJ y sc € € € € € Ø1Ð1ðØÐ2ðàtðð tðð tð ð
tð ð tð
ð tðð tðð tðð tðð tðð tðð tðð tð ð tð ð tð!ð" tð#ð$ tð%ð €Mð( "Ô+×1Ò1Ñ3Ô3ð (ð (‰
ˆˆUØ"'ˆ
d˜3‘hÑ Ð ð Ø ØØ ð
ð
€Eð .Ð-Ð-Ø-Ð-Ð-Ø-Ð-Ð-Ø-Ð-Ð-Ø4Ð4Ð4Ø4Ð4Ð4à ˜ð !˜'ð ð €Kð *Ø2Ø+Ø*Ø4ð ð €Oð "Ø!Ø!Ø!Ø!Ø!Ø!Ø!Ø!Ø!Ø!ð ð Ðð "Ô,×2Ò2Ñ4Ô4ð -ð -‰
ˆˆUØ',И4 ™8Ñ$Ð$ðUØðUàðUð ðUð xð Uð
4ð Uð tð
Uð eðUð %ðUð 5ðUð 5ðUð 5ðUð 5ðUð 5ðUð %ð Uð ˜4ð Uð ˜Dð!Uð" /ð#Uð Uð$ 5ð%Uð& ˜ð'Uð( 3ð)Uð* Wð+Uð, ˜$ð-Uð. bð/Uð0 bð1Uð2 8ð3Uð4 5ð5Uð6 3ð7Uð8 ˜Sð9Uð: ˜Cð;Uð< ˜4ð=Uð> ˜4ð?Uð@ ˜ðAUðB ˜%ðCUðD ˜ðEUð Uð UðF ˜ðGUðH eðIUðJ ˜ðKUðL cðMUðN ˜TðOUðP ˜dðQUðR ˜eðSUðT ˜uðUUðV ˜EðWUðX ˜DðYUðZ ˜Eð[Uð\ ˜ð]Uð^ ˜5ð_Uð` ˜TðaUðb ˜cðcUðd Ð;ðeUðf Ð2ðgUð Uð Uðh hðiUðj ˜(ðkUðl ˜ðmUðp ðqUðr HðsUðt HðuUðv HðwUðx ðyUðz ð{Uð| &ð}Uð~ ðUð@ &ðAUðB ðCUðD ðEUðF ðGUðH ðIUðJ ðKUð UðL ØØ ØØØ Ø ØØØ!ØØØØØðiUð Uð U€Hðl €GØ ‡N‚N;Ô&Ñ'Ô'Ð'Ø ‡N‚N;Ô'Ñ(Ô(Ð(Ø ‡N‚N;Ô(Ñ)Ô)Ð)Ø ‡N‚N;Ô(Ñ)Ô)Ð)Ø ‡N‚N;Ô&Ñ'Ô'Ð'Ø ‡N‚N;Ô(Ñ)Ô)Ð)Ø ‡N‚N;Ô$Ñ%Ô%Ð%Ø ‡O‚OÐJÐJ¸'¿-º-¹/¼/ÐJÑJÔJÑJÔJÐJð
ð =ð =à Ø %Ø !ØØ ð'ð Ðð. "Ø!&Ø "ðð Ðð ØØØ Ø ð ð €Gð sØ#OOؘ#JؘSzð ð €Lð ؘð Ø 'Ð)Bð àvð à ,¨fð à6CÀUð ð vð ð -¨fð ð 7DÀVð ð vð ð -¨eð ð 6CÀFð ð
vð ð
-¨fð ð
7DÀUð ð vð
ð -¨eð
ð 6CÀEð
ð ð ‘uð ñ ,©Vð ñ 6CÁFð ñ ‘vð ñ -©eð ñ 6@Àð ñ Ñ.ð ñ ™ð ñ .©uð ñ 7EÙ
ð ñ ™uð ñ '5±eð ñ ™ð ñ .©uð ñ 7EÁeð ñ Ñ,ð ñ ™ð ð ð ñ !0±ð ñ :IÉ%ð ñ ™ð ñ !0±ð ñ 9HÉð ñ ‘Cð! ñ" ˜ð# ñ" /±ð# ñ$ ˜ð% ñ$ /±ð% ñ$ 7FÁuð% ñ& ™ð' ñ( Ñ)ð) ñ* Ñ+ð+ ñ, ™ð- ñ, .©uð- ñ, 7EÁeð- ð ñ. ©uÁeÙ ©uÙ)Ù)Ù/ñ7 ð ð €Mð<.ÙÐ CÑ CÐ Cð.áÐ<Ñ<Ð<ð.ñ Ð/Ñ/Ð/ð.ñ ð Rñ Rð Rð .ñ
Ð;Ñ;Ð;ð .ñ ð ~ñ ~ð ~ð
.ñ ÐEÑEÐEð.ñ Ð^Ñ^Ð^ð.ñ ð Vñ Vð Vð.ñ ð pñ pð pð.ñ ÐIÑIÐIð.ñ Ð8Ñ8Ð8ð.ñ Ð8Ñ8Ð8ð.ñ Ð9Ñ9Ð9ð .ñ Ð2Ñ2Ð2ð .ñ Ð1Ñ1Ð1ð!.ñ" ÐsÑsÐsð#.ð .ñ$ ð kñ kð kð%.ñ& ÐgÑgÐgð'.ñ( Ð0Ñ0Ð0ð).ñ* Ð=Ñ=Ð=ð+.ñ, ÐPÑPÐPð-.ñ. ÐVÑVÐVð/.ñ4 ð _ñ _ð _ð5.ñ6 ÐWÑWÐWð7.ñ8 ÐgÑgÐgð9.ñ: Ñ 0°"Ð 5ð;.ñ< Ð^Ñ^Ð^ð=.ñ> Ð SÑ SÐ Sð?.ñ@ ÐGÑGÐGðA.ñD ð rñ rð rðE.ñF ð Hñ Hð HðG.ñH ð Vñ Vð VðI.ñJ ð qñ qð qðK.ð .ðL JÑIÐIØCÑCÐCØ7Ñ7Ð7ØDÑDÐDð Kñ Kð KØRÑRÐRØ3Ñ3Ð3ØQÑQÐQñ[.ð .ð .€Oñb ¡w¹IÙ¡g¹9ñð €Kñ ‘<ð€Nð(Ù™5ð(á‘ð(ñ ‘ð(ñ ‘ð (ñ
‘ð (ñ ‘ð
(ñ ÑFð(ñ Ñ=ð(ñ Ñ=ð(ñ Ñ=ð(ñ Ñ=ð(ñ Ñ=ð(ñ Ñ=ð(ñ Ñ=ð (ñ Ñ=ð (ñ Ñ=ð!(ñ" Ñ=ð#(ð (ñ$ Ñ=ð%(ñ& ÑFð'(ñ( Ñ=ð)(ñ* Ñ=ð+(ñ, Ñ=ð-(ñ. ‘%ð/(ñ. #¡Eð/(ñ. ,5±eð/(ñ. >JÉ5ð/(ñ4 Ñ@ð5(ñ6 ÑAð7(ñ8 ÑBð9(ñ: ÑCð;(ñ< ÑAð=(ñ> ÑKð?(ñ@ ÑAðA(ñB ÑBðC(ð (ñD DÙJÙ MÙEÙBÙ MñO(ð (ð (€MðV r ©°EÁÙ
Ñ .Ñ5FÉUÑYkÙ
Ñ#5¸BÀXñð €Hð ÙÑ2ðáÑ3ðñ Ñ3ðñ Ñ2ð ñ
Ñ3ð ñ Ñ3ð
ñ Ñ3ðñ Ñ4ðñ Ñ4ðñ Ñ3ðñ Ñ4ðñ Ñ4ðñ Ñ1ð ñ Ñ2ð ñ Ñ1ð!ñ" Ñ,ð#ñ$ Ñ-ð%ñ& 0Ù-Ù+Ù1ØÙ,ñ1ð ð €Lð8á™ðñ ™ðñ ™ð ñ
™ð ñ ™ð
ñ ™ðñ ™ðñ Ñ<ðñ ÑAðñ Ñ=ðñ Ñ Bðñ Ñ>ð ñ Ñ>ð ñ Ñ>ð!ñ" Ñ;ð#ñ$ Ñ;ð%€Nð( "Ô)×/Ò/Ñ1Ô1ð )ð )‰
ˆˆUØ#(ˆt˜C‘xÑ Ð à©*ÁØ¡C±EÁSÙ ©Cñð €Fñ ™ñð €Oñ
&Ù%Ù)Ù)Ù1Ù)Ù)Ù)Ù)Ù)Ù)ñ ð €Mñ ð <ñ <ð <ð
€JJ€Jr rJ c ó0 — e Zd ZdZd„ Zd„ Zd„ Zd„ Zd„ ZdS )ÚCommandLineParserz A parser for runtime optionsc ó — || _ d S ©N)Úoptions)Úselfr s r Ú__init__zCommandLineParser.__init__% s
€ Ø ˆŒ ˆ ˆ r c ól — t |¦ « dk rdS t |¦ « dk r‹|d d¦ « rp| |¦ « \ }}|sd|z dz S |sd|z dz S t | j ||¦ « t |¦ « dk r|d d¦ « °pdS )úParse command line optionsr Nú--zOption z not recognizedz needs a value)ÚlenÚ
startswithÚ
readoptionÚsetattrr )r Úargsr‘ r’ s r Ú parseoptionsz CommandLineParser.parseoptions( sà € å ˆt‰9Œ9˜Š>ˆ>Ø4Ý$‰iŒi˜!Šmˆm Q¤× 2Ò 2°4Ñ 8Ô 8ˆmØ Ÿ š ¨Ñ.Ô.‰JˆCØð
=Ø 5Ñ(Ð+<Ñ<Ð<Øð
:Ø 3‘Ð)9Ñ9Ð9Ý D”L # uÑ -Ô -Ð -õ
$‰iŒi˜!Šmˆm Q¤× 2Ò 2°4Ñ 8Ô 8ˆmð ˆtr c ób — |d dd… }|d= d|v r| ||¦ « }n| dd¦ « }t | j |¦ « sd|fS t | j |¦ « }t |t ¦ « r|dfS t |¦ « dk r|dfS |d d¦ « r#|d }|d= || ||¦ « fS |d
d ¦ « }|d= t |t ¦ « r| |¦ « ||fS ||fS )
z$Read the key and value for an optionr é NrÆ rà r@ TrØ zutf-8)
Ú
readequalskeyÚreplaceÚhasattrr ÚgetattrÚ
isinstanceÚboolr r Ú
readquotedÚdecodeÚlistÚappend)r r rz r‘ ÚcurrentÚinitialr’ s r r z CommandLineParser.readoption5 sH € à1ŒgabbŒkˆØ ˆGØ #ˆ:ˆ:Ø×$Ò$ S¨$Ñ/Ô/ˆCˆCà—+’+˜c 2Ñ&Ô&ˆCÝt”| SÑ)Ô)ð ؘ9Рݘ$œ,¨Ñ,Ô,ˆÝ gtÑ $Ô $ð ؘ9Ð å ˆt‰9Œ9˜Š>ˆ>ؘ9Ð Ø Œ7× Ò ˜cÑ "Ô "ð 7ؘ1”gˆGØQؘŸš¨¨gÑ6Ô6Ð6Ð 6ØQ”—’˜wÑ'Ô'ˆØ ˆGÝ gtÑ $Ô $ð Ø NŠN˜5Ñ !Ô !Ð !ؘ<Ð ØEˆzÐr c óZ — t d¦ « |dd… }t |¦ « dk r³|d d¦ « s˜|d d¦ « s}t d|d z ¦ « |d|d z z
}|d= t |¦ « dk r6|d d¦ « s|d d¦ « ¯}t |¦ « dk s|d d¦ « rdS |d|dd … z z
}|S )
zRead a value between quotesÚOopsé Nr rØ r z
Appending rg r )r r r Úendswithr )r r r r’ s r r z CommandLineParser.readquotedP s € å
Š FÑÔÐؘ˜˜” ˆÝ$‰iŒi˜!Šmˆm D¨¤G×$4Ò$4°SÑ$9Ô$9ˆmÀ$ÀqÄ'×BTÒBTÐUYÑBZÔBZˆmÝ KŠK˜ t¨A¤wÑ.Ñ /Ô /Ð /Ø S˜4 œ7‘]Ñ "ˆEØQõ $‰iŒi˜!Šmˆm D¨¤G×$4Ò$4°SÑ$9Ô$9ˆmÀ$ÀqÄ'×BTÒBTÐUYÑBZÔBZˆmõ ˆt‰9Œ9˜Š>ˆ>˜T !œW× /Ò /°Ñ 5Ô 5ˆ>Ø4Ø
t˜A˜b˜D”zÑ!Ñ!ˆØˆ r c ó~ — | dd¦ « }|d }|d }| d|¦ « |S )zRead a key using equalsrÆ r r )ÚsplitÚinsert)r rz r r r‘ r’ s r r z CommandLineParser.readequalskey] s@ € à— ’ ˜#˜qÑ!Ô!ˆØAŒhˆØa”ˆØ Š AuÑ Ô Ð Øˆ
r N) r r! r" r# r r r r r r% r r rþ rþ " se € € € € € Ø"Ð"ð ð ð ð ð ð ðð ð ð6 ð ð ðð ð ð ð r rþ c óP — e Zd ZdZdZdZdZdZdZdZ dZ
i Z d„ Z d„ Z
d„ Zd„ Zd „ ZdS )
ÚOptionszA set of runtime optionsNFTc ó
— |d t _ |d= t t ¦ « }| |¦ « }|r.t |¦ « | ¦ « | ¦ « dS )r r N)r# Úlocationrþ r r r ÚusageÚprocessoptions)r r ÚparserÚresults r r zOptions.parseoptionst st € à œ7ÔØ ˆGÝ"¥7Ñ+Ô+ˆØ×$Ò$ TÑ*Ô*ˆØ ð Ý KŠK˜Ñ Ô Ð Ø JŠJ‰LŒLˆLØ ×ÒÑ Ô Ð Ð Ð r c ó6 — t j r| ¦ « t j r| ¦ « t t ¦ « D ]C}| d¦ « r,t t |t | |dd… ¦ « ¦ « ŒDdS )zProcess all options parsed.ÚmodeNéüÿÿÿ)
r# Úhelpr& ÚversionÚ showversionÚdirr r r
r )r Úparams r r' zOptions.processoptions s’ € å Œ<ð Ø JŠJ‰LŒLˆLÝ Œ?ð Ø × Ò Ñ Ô Ð å‘Z”Zð Að AˆEØ~Š~˜fÑ%Ô%ð
Aݘu¥g¨d°E¸#¸2¸#´JÑ&?Ô&?Ñ@Ô@Ð@øð Að Ar c óà — t dt j t j ¦ « j › d¦ « t d¦ « | ¦ « dS )zShow correct usagezUsage: z [options] "input string"z.Convert input string with LaTeX math to MathMLN)r r ÚpathlibÚPathr# r% ÚparentÚ showoptions©r s r r& z
Options.usageŠ si € å
Š ð 0gœl7Ô+;Ñ <Ô <Ô Cð 0ð 0ð 0ñ 1ô 1ð 1å
Š ÐDÑEÔEÐEØ ×ÒÑÔÐÐÐr c ó0 — t d¦ « t d¦ « t d¦ « t d¦ « t d¦ « t j ¦ « dS )zShow all possible optionsz1 --help: show this online helpz9 --quiet: disables all runtime messageszF --debug: enable debugging messages (for developers)z@ --version: show version number and release datezD --simplemath: do not generate fancy math constructionsN)r r r
r r7 s r r6 zOptions.showoptions‘ sp € å
Š ÐGÑHÔHÐHÝ
Š ÐOÑPÔPÐPÝ
Š Ð\Ñ]Ô]Ð]Ý
Š ÐVÑWÔWÐWÝ
Š ÐZÑ[Ô[Ð[Ý Œ‰
Œ
ˆ
ˆ
ˆ
r c óp — t dt z ¦ « t j ¦ « dS )z(Return the current eLyXer version stringz
math2html N)r r Ú __version__r
r r7 s r r/ zOptions.showversionš s( € å
Š L¥Ñ,Ñ-Ô-Ð-Ý Œ‰
Œ
ˆ
ˆ
ˆ
r )r r! r" r# r% r Úquietr. r- Ú
simplemathÚ showlinesÚbranchesr r' r& r6 r/ r% r r r# r# f s € € € € € Ø Ð à€Hà €EØ €EØ€GØ €DØ€JØ€Ià€Hð ð ð ð Að Að Aðð ð ðð ð ðð ð ð ð r r# c óJ — e Zd ZdZd„ Zd„ Z ee¦ « Z ee¦ « ZdS )ÚClonerz&An object used to clone other objects.c ó8 — | |j ¦ « S )z"Return an exact copy of an object.)ÚcreateÚ __class__)r
Úoriginals r Úclonez Cloner.clone£ s € à=ØzŠz˜(Ô,Ñ-Ô-Ð-r c óX — | |¦ « }| ¦ « |S )z"Create an object of a given class.)Ú__new__r )r
ÚtyperE s r rB z
Cloner.create¨ s( € à— ’ ˜TÑ"Ô"ˆØ
ŠÑÔÐ؈ r N)r r! r" r# rE rB r$ r% r r r@ r@ sR € € € € € Ø,Ð,ð.ð .ð .ð
ð ð ð
ˆK˜Ñ Ô €EØ
ˆ[˜Ñ
Ô
€F€F€Fr r@ c ó* — e Zd ZdZd„ Zd„ Zd„ Zd„ ZdS )ÚContainerExtractora™ A class to extract certain containers.
The config parameter is a map containing three lists:
allowed, copied and extracted.
Each of the three is a list of class names for containers.
Allowed containers are included as is into the result.
Cloned containers are cloned and placed into the result.
Extracted containers are looked into.
All other containers are silently ignored.
c ó: — |d | _ |d | _ d S )Nr; r< r: )r Úconfigs r r zContainerExtractor.__init__¾ s € Ø ˜iÔ(ˆŒ Ø Ô,ˆŒˆˆr c ó\ ‡ ‡— g Šˆ fd„}ˆ fd„}ˆˆ fd„}| |||¦ « ‰S )z8Extract a group of selected containers from a container.c ó* •— | j j ‰j v S r )rC r r; ©rœ r s €r úz,ContainerExtractor.extract..Å s ø€ ˜1œ;Ô/°4´<Ð?€ r c ó* •— | j j ‰j v S r )rC r r< rO s €r rP z,ContainerExtractor.extract..Æ s ø€ ˜aœkÔ 2°d´nÐ D€ r c ó0 •— ‰ | ‰¦ « S r )Úprocess)rœ r r s €€r rP z,ContainerExtractor.extract..Ç s ø€ ˜DŸLšL¨¨DÑ 1Ô 1€ r )Úrecursivesearch)r Ú containerÚlocateÚ recursiverS r s ` @r ÚextractzContainerExtractor.extract sS øø€ àˆØ?Ð?Ð?Ð?ˆØDÐDÐDÐDˆ Ø1Ð1Ð1Ð1Ð1ˆØ×!Ò! &¨)°WÑ=Ô=Ð=؈ r c ó˜ — |j j }|| j v r| |¦ « dS t d|z ¦ « dS )zAdd allowed containers.zUnknown container class N)rC r r; r r r )r rU r Únames r rS zContainerExtractor.processË sP € àÔ"Ô+ˆØ 4”<Ð Ð Ø KŠK˜ Ñ "Ô "Ð "Ð "Ð "å KŠKÐ2°TÑ9Ñ :Ô :Ð :Ð :Ð :r c ó† — t |¦ « }|j |_ | |¦ « |_ |S )zFReturn a new container with contents only in a safe list, recursively.)r@ rE ÚoutputrX Úcontents)r rU rE s r Ú safeclonez ContainerExtractor.safecloneÓ s5 € å— ’ ˜YÑ'Ô'ˆØ Ô'ˆŒ Ø Ÿ š iÑ0Ô0ˆŒØˆ r N)r r! r" r# r rX rS r^ r% r r rJ rJ ² sZ € € € € € ð ð ð-ð -ð -ðð ð ð;ð ;ð ;ðð ð ð ð r rJ c ó6 — e Zd ZdZd„ Zd„ Zd„ Zd„ Zd„ Zd„ Z dS ) ÚParserzA generic parserc ó" — d| _ i | _ d S )Nr )rW Ú
parametersr7 s r r zParser.__init__Þ s € ؈Œ
Ø ˆŒˆˆr c ó’ — | ¦ « ¦ « }| ¦ « |j | _ |S )zParse the header)Ú currentliner ÚnextlineÚ
linenumberrW )r ÚreaderÚheaders r Ú parseheaderzParser.parseheaderâ s> € à×#Ò#Ñ%Ô%×+Ò+Ñ-Ô-ˆØŠÑÔÐØÔ&ˆŒ
؈
r c óÌ — | ¦ « ¦ « dd¦ « }| ¦ « t |¦ « dk rdS |d }t |¦ « dk r d| j |< dS d|d vr$|d ¦ « | j |< dS |d d¦ « }|d | j |< dS )zParse a parameterrg r r NTrØ )rd Ústripr re r rb )r rg r r‘ Ú doublesplits r ÚparseparameterzParser.parseparameteré sÕ € à×"Ò"Ñ$Ô$×*Ò*Ñ,Ô,×2Ò2°3¸Ñ:Ô:ˆØŠÑÔÐÝ ˆu‰:Œ:˜Š?ˆ?Ø ˆFØAŒhˆÝ ˆu‰:Œ:˜Š?ˆ?Ø#'ˆDŒO˜CÑ Ø ˆFØ e˜A”hÐ Ð Ø#(¨¤8§>¢>Ñ#3Ô#3ˆDŒO˜CÑ Ø ˆFؘA”h—n’n SÑ)Ô)ˆ Ø *¨1œ~ˆŒ˜Ñ Ð Ð r c ó4 — | j s,t dt | ¦ « z ¦ « dS | ¦ « | j ¦ « s8 |¦ « | ¦ « | j ¦ « ¯6dS dS )z'Parse until the current ending is foundzNo ending for N)Úendingr r Ústrrd r )r rg rS s r Ú parseendingzParser.parseendingù s˜ € àŒ{ð Ý KŠKÐ(3¨t©9¬9Ñ4Ñ 5Ô 5Ð 5Ø ˆFØ×$Ò$Ñ&Ô&×1Ò1°$´+Ñ>Ô>ð Ø ˆG‰IŒIˆIð ×$Ò$Ñ&Ô&×1Ò1°$´+Ñ>Ô>ð ð ð ð ð r c ó„ — | j |¦ « }|r#| j |_ | |¦ « d S d S r )ÚfactoryÚcreatecontainerr5 r )r rg r] rU s r ÚparsecontainerzParser.parsecontainer sK € Ø”L×0Ò0°Ñ8Ô8ˆ Ø ð 'Ø #œ{ˆIÔ Ø OŠO˜IÑ &Ô &Ð &Ð &Ð &ð 'ð 'r c óP — | j j dz t | j ¦ « z dz S )zReturn a descriptionú (r_ )rC r rp rW r7 s r Ú__str__zParser.__str__ s$ € àŒ~Ô&¨Ñ-µ°D´J±´Ñ?À#ÑEÐEr N)
r r! r" r# r ri rm rq ru rx r% r r r` r` Û sy € € € € € ØÐð ð ð ðð ð ð.ð .ð .ð ð ð ð'ð 'ð 'ð Fð Fð Fð Fð Fr r` c ó — e Zd ZdZd„ ZdS )Ú LoneCommandz"A parser for just one command linec ó — g S )z Read nothingr% ©r rg s r ÚparsezLoneCommand.parse ó € àˆ r N©r r! r" r# r} r% r r rz rz s) € € € € € Ø(Ð(ðð ð ð ð r rz c ó( — e Zd ZdZg Zd„ Zd„ Zd„ ZdS )Ú
TextParserz(A parser for a command and a bit of textc óÈ — t | ¦ « d | _ |j j t
j v r!t
j |j j | _ g | _ d S r )r` r ro rC r r' rî ©r rU s r r zTextParser.__init__ sO € ÝŠ˜Ñ Ô Ð ØˆŒ Ø Ô Ô '?Ô+BÐ BÐ BÝ)Ô1°)Ô2EÔ2NÔOˆDŒK؈Œ ˆ ˆ r c óJ — t j | j ¦ « t j t j d t j d | j gz | _ g }| |¦ « s+| ||¦ « | |¦ « ¯+|S )z$Parse lines as long as they are textÚLayoutÚInset)r Ústackr ro r' rî Úisendingru ©r rg r] s r r} zTextParser.parse s• € åÔ× Ò ¤ Ñ,Ô,Ð,Ý!Ô'?Ô+BÀ8Ô+LÝ+:Ô+BÀ7Ô+KØ+/¬;ð+8ñ 8ˆŒ ð ˆØ—-’- Ñ'Ô'ð 2Ø × Ò ¨Ñ 1Ô 1Ð 1ð —-’- Ñ'Ô'ð 2àˆr c ó* — | ¦ « ¦ « }t |¦ « dk rdS |d | j v rH|d t j v r&t j |d ¦ « n g t _ dS dS )zCheck if text is endingr FT)rd r r rî r r‡ Úremove)r rg r s r rˆ zTextParser.isending+ sˆ € à×$Ò$Ñ&Ô&×,Ò,Ñ.Ô.ˆÝ ˆw‰<Œ<˜1Ò Ð Ø5Ø 1Œ:˜œ Ð %Ð %ØqŒzZÔ -Ð-Ð-ÝÔ ×'Ò'¨°¬
Ñ3Ô3Ð3Ð3à#%•
Ô Ø4؈ur N)r r! r" r# r‡ r r} rˆ r% r r r r sL € € € € € Ø.Ð.à €Eðð ð ð ð ð ð ð ð ð ð r r c ó — e Zd ZdZd„ ZdS )ÚExcludingParserz%A parser that excludes the final linec óF ‡ ‡‡— g Š‰ ‰ˆˆˆ fd„¦ « ‰S )z5Parse everything up to (and excluding) the final linec ó0 •— ‰ ‰‰ ¦ « S r )ru )r] rg r s €€€r rP z'ExcludingParser.parse..? s ø€ ¨×)<Ò)<¸VÀXÑ)NÔ)N€ r )rq r‰ s ``@r r} zExcludingParser.parse< s5 øøø€ àˆØ ×Ò˜Ð!NÐ!NÐ!NÐ!NÐ!NÐ!NÑOÔOÐO؈r Nr r% r r r r 9 s) € € € € € Ø+Ð+ðð ð ð ð r r c ó — e Zd ZdZd„ ZdS )Ú
BoundedParserz A parser bound by a final linec ód — t | |¦ « }| ¦ « |S )z*Parse everything, including the final line)r r} re r‰ s r r} zBoundedParser.parseF s, € å"×(Ò(¨¨vÑ6Ô6ˆàŠÑÔÐ؈r Nr r% r r r‘ r‘ C s) € € € € € Ø$Ð$ðð ð ð ð r r‘ c ó — e Zd ZdZd„ ZdS )Ú BoundedDummyz&A bound parser that ignores everythingc ób ‡— | ‰ˆfd„¦ « ‰ ¦ « g S )z#Parse the contents of the containerc ó, •— ‰ ¦ « S r )re )rg s €r rP z$BoundedDummy.parse..S s ø€ ¨¯ ª Ñ):Ô):€ r )rq re r| s `r r} zBoundedDummy.parseQ s8 ø€ à ×Ò˜Ð!:Ð!:Ð!:Ð!:Ñ;Ô;Ð;àŠÑÔÐ؈ r Nr r% r r r” r” N s) € € € € € Ø,Ð,ðð ð ð ð r r” c ó — e Zd ZdZd„ Zd„ ZdS )Ú StringParserzParses just a stringc ó$ — |j dz | _ g S )zDo nothing, just take noter )rf rW r| s r ri zStringParser.parseheader\ s € àÔ&¨Ñ*ˆŒ
؈ r c óV — | ¦ « }| ¦ « |S )zParse a single line)rd re r‰ s r r} zStringParser.parsea s( € à×%Ò%Ñ'Ô'ˆØŠÑÔÐ؈r N)r r! r" r# ri r} r% r r r˜ r˜ Y s8 € € € € € ØÐðð ð ð
ð ð ð ð r r˜ c ó — e Zd ZdZd„ Zd„ ZdS )ÚContainerOutputz(The generic HTML output for a container.c óZ — t dt | ¦ « z ¦ « dS )zShow an error.z gethtml() not implemented for N©r r rp rƒ s r ÚgethtmlzContainerOutput.gethtmlk s& € å
Š Ð4µs¸4±y´yÑ@ÑAÔAÐAÐAÐAr c ó — dS )z5Decide if the output is empty: by default, not empty.Fr% r7 s r ÚisemptyzContainerOutput.isemptyo s € àˆur N)r r! r" r# rŸ r¡ r% r r rœ rœ h s; € € € € € Ø.Ð.ðBð Bð Bðð ð ð ð r rœ c ó — e Zd Zd„ Zd„ ZdS )Ú EmptyOutputc ó — g S )zReturn empty HTML code.r% rƒ s r rŸ zEmptyOutput.gethtmlv r~ r c ó — dS )z"This output is particularly empty.Tr% r7 s r r¡ zEmptyOutput.isemptyz s € àˆtr N)r r! r" rŸ r¡ r% r r r£ r£ t s2 € € € € € ðð ð ðð ð ð ð r r£ c ó — e Zd ZdZd„ ZdS )Ú FixedOutputz Fixed outputc ó — |j S )zReturn constant HTML code)Úhtmlrƒ s r rŸ zFixedOutput.gethtml‚ s
€ àŒ~Ð r N©r r! r" r# rŸ r% r r r§ r§ s( € € € € € Ø€Nð ð ð ð ð r r§ c ó — e Zd ZdZd„ ZdS )ÚContentsOutputz&Outputs the contents converted to HTMLc óú — g }|j €|S |j D ]g}t |d¦ « s>t d|j j z dz t
|¦ « z ¦ « |c S || ¦ « z
}Œh|S )úReturn the HTML codeNrŸ z No html in rh )r] r r r rC r rp rŸ )r rU r© Úelements r rŸ zContentsOutput.gethtmlŠ sŽ € àˆØ Ô Ð %؈KØ Ô)ð &ð &ˆGݘ7 IÑ.Ô.ð
Ý— ’ ˜M¨GÔ,=Ô,FÑ FÈÑ MÕPSÐT[ÑP\ÔP\Ñ \Ñ]Ô]Ð]Ø Ø G—O’OÑ%Ô%Ñ %ˆDˆD؈ r Nrª r% r r r¬ r¬ ‡ s) € € € € € Ø,Ð,ð
ð
ð
ð
ð
r r¬ c óJ — e Zd ZdZdZdZdZd d„Zd„ Zd„ Z d„ Z
d„ Z d „ Z d
„ Z
dS ) Ú TaggedOutputz-Outputs an HTML tag surrounding the contents.NFc ó8 — || _ |r|| _ |r|| _ | S )z/Set the value for the tag and other attributes.)ÚtagÚ
breaklinesÚempty)r r³ r´ rµ s r ÚsettagzTaggedOutput.settagž s, € àˆŒØ ð )Ø (ˆDŒOØ ð Ø ˆDŒJ؈ r c ó — || _ | S )z Set the value for breaklines.)r´ )r r´ s r Ú
setbreaklineszTaggedOutput.setbreaklines§ s € à$ˆŒØˆ r c óø — | j r| |¦ « gS | |¦ « g}|t | |¦ « z
}| | |¦ « ¦ « |S )zReturn the HTML code.)rµ Ú selfclosingÚopenr¬ rŸ r Úclose)r rU r© s r rŸ zTaggedOutput.gethtml¬ st € à Œ:ð 1Ø×$Ò$ YÑ/Ô/Ð0Ð 0Ø— ’ ˜)Ñ$Ô$Ð%ˆØ •×&Ò& t¨YÑ7Ô7Ñ7ˆØ Š D—J’J˜yÑ)Ô)Ñ*Ô*Ð*؈ r c óf — | |¦ « sdS d| j z dz }| j r|dz S |S )zGet opening line.r@ rE rF r ©Úchecktagr³ r´ )r rU r» s r r» zTaggedOutput.openµ sD € à}Š}˜YÑ'Ô'ð Ø2ØT”X‰~ Ñ#ˆØ Œ?ð ؘ$‘;Р؈ r c óœ — | |¦ « sdS d| j ¦ « d z dz }| j rd|z dz S |S )zGet closing line.r@ zr r¾ )r rU rº s r rº zTaggedOutput.selfclosingÇ sF € à}Š}˜YÑ'Ô'ð Ø2ؘDœH‘n tÑ+ˆ Ø Œ?ð &Ø Ñ%Ð %ØÐr c ó† — | j s,t dt |¦ « z ¦ « dS | j dk rdS dS )z Check that the tag is valid.z
No tag in Fr@ T)r³ r r rp rƒ s r r¿ zTaggedOutput.checktagÐ sC € àŒxð Ý KŠK˜ ¥s¨9¡~¤~Ñ5Ñ 6Ô 6Ð 6Ø5Ø Œ8rŠ>ˆ>Ø5؈tr )FF)r r! r" r# r³ r´ rµ r¶ r¸ rŸ r» r¼ rº r¿ r% r r r± r± — s— € € € € € Ø3Ð3à
€CØ€JØ €Eðð ð ð ðð ð ð
ð ð ðð ð ðð ð ðð ð ðð ð ð ð r r± c ó, — e Zd ZdZ d„ Zd„ Zd„ Zd„ ZdS )ÚFilteredOutputz1Returns the output in the contents, but filtered:c ó — g | _ dS )zInitialize the filters.N)Úfiltersr7 s r r zFilteredOutput.__init__Þ s
€ àˆŒ ˆ ˆ r c ó> — | j ||f¦ « dS )z:Add a new filter: replace the original by the replacement.N)rÆ r )r rD Ú replacements r Ú addfilterzFilteredOutput.addfilterâ s# € à Œ ×Ò˜X {Ð 3Ñ4Ô4Ð4Ð4Ð4r c óš — g }t | |¦ « }|D ]*}| | |¦ « ¦ « Œ+|S )r® )r¬ rŸ r Úfilter)r rU r) r© Úlines r rŸ zFilteredOutput.gethtmlæ sQ € àˆÝ ×%Ò% d¨IÑ6Ô6ˆØð -ð -ˆDØ MŠM˜$Ÿ+š+ dÑ+Ô+Ñ ,Ô ,Ð ,Ð ,؈
r c óT — | j D ] \ }}||v r| ||¦ « }Œ |S )z0Filter a single line with all available filters.)rÆ r )r rÌ rD rÈ s r rË zFilteredOutput.filterî s< € à%)¤\ð ;ð ;Ñ !ˆHkؘ4Ð Ð Ø—|’| H¨kÑ:Ô:ø؈ r N)r r! r" r# r rÉ rŸ rË r% r r rÄ rÄ Ú sY € € € € € Ø7Ð7Ø*ðð ð ð5ð 5ð 5ðð ð ðð ð ð ð r rÄ c ó — e Zd ZdZd„ ZdS )Ú StringOutputz Returns a bare string as outputc ó — |j gS )zReturn a bare string©Ústringrƒ s r rŸ zStringOutput.gethtmlù s € àÔ Ð!Ð!r Nrª r% r r rÏ rÏ ö s) € € € € € Ø%Ð%ð"ð "ð "ð "ð "r rÏ c ó’ — e Zd ZdZdZd„ Zd„ Zd„ Zd„ Zd„ Z d„ Z
d „ Z d
„ Z d „ Z
d „ Zd
„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zdd„Zdd„Zd„ ZdS )ÚGlobablez¤A bit of text which can be globbed (lumped together in bits).
Methods current(), skipcurrent(), checkfor() and isout() have to be
implemented by subclasses.Fc ó, — t ¦ « | _ d S r )Ú
EndingListÚ
endinglistr7 s r r zGlobable.__init__ s € Ý$™,œ,ˆŒˆˆr c ó¨ — | ¦ « rdS t | ¦ « ¦ « dk r| ¦ « dS dS )z*Check for a Unicode byte mark and skip it.Niÿþ )ÚfinishedÚordr Ú skipcurrentr7 s r Ú
checkbytemarkzGlobable.checkbytemark sR € à =Š=‰?Œ?ð Ø ˆFÝ ˆt|Š|‰~Œ~Ñ Ô &Ò (Ð (Ø × Ò Ñ Ô Ð Ð Ð ð )Ð (r c ó: — t d¦ « dS )z+Find out if we are out of the position yet.zUnimplemented isout()T©r r r7 s r ÚisoutzGlobable.isout s € å
Š Ð+Ñ,Ô,Ð,؈tr c ó: — t d¦ « dS )z Return the current character.zUnimplemented current()r@ rÞ r7 s r r zGlobable.current s € å
Š Ð-Ñ.Ô.Ð.؈rr c ó: — t d¦ « dS )z3Check for the given string in the current position.zUnimplemented checkfor()FrÞ ©r rÒ s r ÚcheckforzGlobable.checkfor s € å
Š Ð.Ñ/Ô/Ð/؈ur c ó¢ — | ¦ « r"| j s| j ¦ « dS | j | ¦ « S )z*Find out if the current text has finished.T)rß Ú leavependingr× Ú checkpendingÚcheckinr7 s r rÙ zGlobable.finished sL € à :Š:‰<Œ<ð ØÔ$ð
/Ø”×,Ò,Ñ.Ô.Ð.Ø4ØŒ×&Ò& tÑ,Ô,Ð,r c ó: — t d¦ « dS )ú)Return the current character and skip it.zUnimplemented skipcurrent()r@ rÞ r7 s r rÛ zGlobable.skipcurrent& s € å
Š Ð1Ñ2Ô2Ð2؈rr c ó° — d}| ¦ « s? |¦ « r5|| ¦ « z
}| ¦ « s
|¦ « °5|S )z>Glob a bit of text that satisfies a check on the current char.r@ )rÙ rÛ )r Ú currentcheckÚglobs r rì z
Globable.glob+ s^ € àˆØ—-’-‘/”/ð ' l l¡n¤nð 'Ø D×$Ò$Ñ&Ô&Ñ &ˆDð —-’-‘/”/ð ' l l¡n¤nð 'àˆ r c ó4 ‡ — ‰ ˆ fd„¦ « S )zGlob a bit of alpha textc óP •— ‰ ¦ « ¦ « S r ©r Úisalphar7 s €r rP z$Globable.globalpha..4 ó ø€ § ¢ ¡ ¤ ×!7Ò!7Ñ!9Ô!9€ r ©rì r7 s `r Ú globalphazGlobable.globalpha2 ó ø€ àyŠyÐ9Ð9Ð9Ð9Ñ:Ô:Ð:r c ó4 ‡ — ‰ ˆ fd„¦ « S )zGlob a row of digits.c óP •— ‰ ¦ « ¦ « S r ©r Úisdigitr7 s €r rP z%Globable.globnumber..8 rñ r rò r7 s `r Ú
globnumberzGlobable.globnumber6 rô r c ó† — | ¦ « ¦ « s| ¦ « dk rdS dS )z5Return if the current character is alphanumeric or _.rÒ TF)r Úisalnumr7 s r Ú isidentifierzGlobable.isidentifier: s: € à <Š<‰>Œ>× !Ò !Ñ #Ô #ð t§|¢|¡~¤~¸Ò'<Ð'<Ø4؈ur c ó6 — | | j ¦ « S )z Glob alphanumeric and _ symbols.)rì rü r7 s r ÚglobidentifierzGlobable.globidentifier@ s € àyŠy˜Ô*Ñ+Ô+Ð+r c óˆ — | ¦ « ¦ « rdS | ¦ « dv rdS dS )z5Return if the current character is a value character:Fz{}()T©r Úisspacer7 s r ÚisvaluezGlobable.isvalueD sC € à#Ø <Š<‰>Œ>× !Ò !Ñ #Ô #ð Ø5Ø <Š<‰>Œ>˜VÐ #Ð #Ø5؈tr c ó6 — | | j ¦ « S )z'Glob a value: any symbols but brackets.)rì r r7 s r Ú globvaluezGlobable.globvalueM s € àyŠy˜œ Ñ&Ô&Ð&r c ó4 ‡ — ‰ ˆ fd„¦ « S )z(Skip all whitespace at current position.c óP •— ‰ ¦ « ¦ « S r r r7 s €r rP z$Globable.skipspace..S rñ r rò r7 s `r Ú skipspacezGlobable.skipspaceQ rô r c ól ‡ ‡— ‰ ˆˆ fd„¦ « ‰z }‰ ‰¦ « |S )z4Glob a bit of text up to (including) the magic char.c ó4 •— ‰ ¦ « ‰ k S r ©r )Ú magiccharr s €€r rP z(Globable.globincluding..W s ø€ § ¢ ¡ ¤ °9Ò!<€ r )rì Úskip)r r rì s `` r Ú
globincludingzGlobable.globincludingU s> øø€ àyŠyÐ<Ð<Ð<Ð<Ð<Ñ=Ô=À ÑIˆØ Š )Ñ Ô Ð Øˆ r c ó8 ‡ ‡— ‰ ˆˆ fd„¦ « S )z?Glob a bit of text up until (excluding) any excluded character.c ó0 •— ‰ ¦ « ‰ vS r r
)Úexcludedr s €€r rP z(Globable.globexcluding..] s ø€ § ¢ ¡ ¤ °xÐ!?€ r rò )r r s ``r Ú
globexcludingzGlobable.globexcluding[ s# øø€ àyŠyÐ?Ð?Ð?Ð?Ð?Ñ@Ô@Ð@r c ó< — | j ||¦ « dS )z Push a new ending to the bottomN)r× Úadd©r ro Úoptionals r Ú
pushendingzGlobable.pushending_ s € à Œ×Ò˜F HÑ-Ô-Ð-Ð-Ð-r Nc óô — | ¦ « r | j r|S | j | ¦ « }|r)||k r#t d|z dz |z ¦ « | |¦ « |S )z,Pop the ending found at the current positionzExpected ending z, got )rß rå r× Úpopr r r )r Úexpectedro s r Ú popendingzGlobable.popendingc s‚ € à :Š:‰<Œ<ð ˜DÔ -ð ؈OØ” ×$Ò$ TÑ*Ô*ˆØ ð K˜ FÒ*Ð*Ý KŠKÐ*¨XÑ5¸Ñ@À6ÑIÑ JÔ JÐ JØ Š &ÑÔÐ؈
r c óL — | j | ¦ « }|sdS |j S )z$Return the next ending in the queue.N)r× Ú
findendingro )r Ú
nextendings r r zGlobable.nextendingm s- € à”_×/Ò/°Ñ5Ô5ˆ
Øð Ø4ØÔ Ð r ©Fr )r r! r" r# rå r rÜ rß r rã rÙ rÛ rì ró rù rü rþ r r r r
r r r r r% r r rÔ rÔ þ s^ € € € € € ð"ð "ð €Lð'ð 'ð 'ð ð ð ðð ð ð
ð ð ð
ð ð ð
-ð -ð -ðð ð ð
ð ð ð;ð ;ð ;ð;ð ;ð ;ðð ð ð ,ð ,ð ,ðð ð ð'ð 'ð 'ð;ð ;ð ;ðð ð ð Að Að Að.ð .ð .ð .ðð ð ð ð!ð !ð !ð !ð !r rÔ c óD — e Zd ZdZd„ Zd d„Zd„ Zd„ Zd„ Zd„ Z d „ Z
d
„ Z d S )
rÖ zA list of position endingsc ó — g | _ d S r )rî r7 s r r zEndingList.__init__x s
€ ؈Œ ˆ ˆ r Fc óV — | j t ||¦ « ¦ « dS )z Add a new ending to the listN)rî r ÚPositionEndingr s r r zEndingList.add{ s( € à Œ ×ÒN¨6°8Ñ <Ô <Ñ=Ô=Ð=Ð=Ð=r c ó: — | xj |j j z
c_ dS )z/Pick any pending endings from a parse position.N)rî r× ©r Úposs r Ú pickpendingzEndingList.pickpending s € à ˆ Œ ˜œÔ.Ñ.ˆ Œ ˆ ˆ r c ó4 — | |¦ « rdS dS )zSearch for an endingTF)r r$ s r rç zEndingList.checkinƒ s € à ?Š?˜3Ñ Ô ð Ø4؈ur c óò — | ¦ « r t d¦ « dS | |¦ « }|s1t d| ¦ « z ¦ « dS t | j ¦ « D ]O}| j |¦ « ||k r |j c S |j s t d|z ¦ « ŒPt d¦ « dS )z)Remove the ending at the current positionzNo ending out of boundsr@ z
No ending at z Removed non-optional ending zNo endings left)
rß r r r r Úreversedrî r‹ ro r )r r% ro Úeachs r r zEndingList.pop‰ së € à 9Š9‰;Œ;ð Ý KŠKÐ1Ñ 2Ô 2Ð 2Ø2Ø— ’ Ñ%Ô%ˆØð Ý KŠK˜¨#¯+ª+©-¬-Ñ7Ñ 8Ô 8Ð 8Ø2Ý ˜Tœ\Ñ*Ô*ð Cð CˆDØ ŒL× Ò Ñ %Ô %Ð %ØvŠ~ˆ~Ø”{Ð"Ð"Ð"Ø”]ð
CÝ— ’ Ð :¸TÑ AÑBÔBÐBøÝ
Š Ð%Ñ&Ô&Ð&؈rr c óÎ — t | j ¦ « dk rdS t t | j ¦ « ¦ « D ](\ }}| |¦ « r|c S |j s dS Œ)dS )z'Find the ending at the current positionr N)r rî Ú enumerater) rç r )r r% Úindexro s r r zEndingList.findending› sy € å ˆtŒ|Ñ Ô Ò !Ð !Ø4Ý &¥x°´ Ñ'=Ô'=Ñ >Ô >ð ð ‰MˆE6Ø~Š~˜cÑ"Ô"ð
Ø
Ø”?ð
Øttð
àˆtr c ó” — t | j ¦ « dk r/t dt | ¦ « z dz ¦ « dS dS )z&Check if there are any pending endingsr zPending z
left openN)r rî r r rp r7 s r ræ zEndingList.checkpending¦ sG € å ˆtŒ|Ñ Ô Ò !Ð !Ý KŠK˜
¥S¨¡Y¤YÑ.° Ñ=Ñ >Ô >Ð >Ð >Ð >ð "Ð !r c ó’ — d}| j D ]}|t |¦ « dz z
}Œt | j ¦ « dk r
|dd… }|dz S )úPrintable representationz endings [r r Nr ra )rî rp r )r rÒ ro s r rx zEndingList.__str__« s[ € à ˆØ”lð (ð (ˆFØ •c˜&‘k”k CÑ'Ñ 'ˆFˆFÝ ˆtŒ|Ñ Ô ˜qÒ Ð Ø˜C˜R˜C”[ˆFؘ‰|Ðr Nr ) r r! r" r# r r r& rç r r ræ rx r% r r rÖ rÖ u s— € € € € € Ø Ð ðð ð ð>ð >ð >ð >ð/ð /ð /ðð ð ð ð ð ð$ ð ð ð?ð ?ð ?ð
ð ð ð ð r rÖ c ó$ — e Zd ZdZd„ Zd„ Zd„ ZdS )r" z An ending for a parsing positionc ó" — || _ || _ d S r ©ro r r s r r zPositionEnding.__init__¸ s € Ø ˆŒ Ø ˆŒ
ˆ
ˆ
r c ó6 — | | j ¦ « S )zCheck for the ending)rã ro r$ s r rç zPositionEnding.checkin¼ s € à|Š|˜DœKÑ(Ô(Ð(r c ó2 — d| j z }| j r|dz
}|S )r0 zEnding z (optional)r3 râ s r rx zPositionEnding.__str__À s' € à˜Tœ[Ñ(ˆØ Œ=ð $Ø mÑ #ˆF؈
r N)r r! r" r# r rç rx r% r r r" r" µ sG € € € € € Ø&Ð&ð!ð !ð !ð)ð )ð )ðð ð ð ð r r" c óN — e Zd ZdZd„ Zd„ Zd„ Zd„ Zd„ Zd„ Z d„ Z
d „ Z d
„ Z d „ Z
d S )
ÚPositionz¥A position in a text to parse.
Including those in Globable, functions to implement by subclasses are:
skip(), identifier(), extract(), isout() and current().c ó: — t | ¦ « d S r )rÔ r r7 s r r zPosition.__init__Í s € Ý×Ò˜$Ñ Ô Ð Ð Ð r c ó: — t d¦ « dS )z
Skip a stringzUnimplemented skip()NrÞ râ s r r z
Position.skipÐ s € å
Š Ð*Ñ+Ô+Ð+Ð+Ð+r c ó: — t d¦ « dS )z.Return an identifier for the current position.zUnimplemented identifier()ÚErrorrÞ r7 s r Ú
identifierzPosition.identifierÔ s € å
Š Ð0Ñ1Ô1Ð1؈wr c ó< — t d¦ « dS )zHExtract the next string of the given length, or None if not enough text,zUnimplemented extract()NrÞ ©r Úlengths r rX zPosition.extractÙ s € à/Ý
Š Ð-Ñ.Ô.Ð.؈tr c óN — || t |¦ « ¦ « k S )z)Check for a string at the given position.)rX r râ s r rã zPosition.checkforß s € à˜Ÿ š ¥c¨&¡k¤kÑ2Ô2Ò2Ð2r c óâ — | t |¦ « ¦ « }|sdS | ¦ « | t |¦ « ¦ « ¦ « k S )z!Check for a string in lower case.F)rX r Úlower)r rÒ r< s r Ú
checkforlowerzPosition.checkforlowerã sW € à—L’L¥ V¡¤Ñ-Ô-ˆ Øð Ø5Ø|Š|‰~Œ~ § ¢ c°&©k¬kÑ!:Ô!:×!@Ò!@Ñ!BÔ!BÒBÐBr c óX — | ¦ « }| |¦ « |S )ré )r r ©r r s r rÛ zPosition.skipcurrentê s& € à—,’,‘.”.ˆØ Š 'ÑÔÐ؈r c óR — | ¦ « | ¦ « S )z3Advance the position and return the next character.)rÛ r r7 s r Ú__next__zPosition.__next__ð s" € à ×ÒÑÔÐØ|Š|‰~Œ~Ð r c ó^ — | |¦ « sdS | |¦ « dS )z;Check for a string at the given position; if there, skip itFT)rã r râ s r Ú checkskipzPosition.checkskipõ s2 € à}Š}˜VÑ$Ô$ð Ø5Ø Š &ÑÔÐ؈tr c ój — t |dz | ¦ « z ¦ « dS )z2Show an error message and the position identifier.rh N)r r r< )r r s r r zPosition.errorü s- € å
Š G˜d‘N T§_¢_Ñ%6Ô%6Ñ6Ñ7Ô7Ð7Ð7Ð7r N)r r! r" r# r r r< rX rã rC rÛ rG rI r r% r r r7 r7 È s· € € € € € ð?ð ?ð ð ð ð,ð ,ð ,ðð ð ð
ð ð ð 3ð 3ð 3ðCð Cð Cðð ð ð ð ð ð
ð ð ð8ð 8ð 8ð 8ð 8r r7 c ó6 — e Zd ZdZd„ Zd„ Zd„ Zd„ Zd„ Zd„ Z dS ) Ú TextPositionz%A parse position based on a raw text.c ó~ — t | ¦ « d| _ || _ | ¦ « dS )z#Create the position from some text.r N)r7 r r% ÚtextrÜ ©r rN s r r zTextPosition.__init__ s< € å×Ò˜$Ñ Ô Ð ØˆŒØˆŒ Ø ×ÒÑ Ô Ð Ð Ð r c ó@ — | xj t |¦ « z
c_ dS )z Skip a string of characters.N)r% r râ s r r zTextPosition.skip s € à ˆŒ•C˜‘K”KÑ ˆŒˆˆr c ó — d}| j |z t | j ¦ « k r t | j ¦ « | j z
}d| j | j | j |z … z dz S )z&Return a sample of the remaining text.é rÊ ©r% r rN r> s r r< zTextPosition.identifier sZ € àˆØ Œ8fÑ s 4¤9™~œ~Ò -Ð -ݘœ‘^”^ d¤hÑ.ˆFØT”Y˜tœx¨¬°6Ñ(9Ð 9Ô:Ñ:¸SÑ@Ð@r c ó< — | j t | j ¦ « k S )z'Find out if we are out of the text yet.rS r7 s r rß zTextPosition.isout s € àŒx3˜tœy™>œ>Ò)Ð)r c ó& — | j | j S )z6Return the current character, assuming we are not out.)rN r% r7 s r r zTextPosition.current s € àŒy˜œÔ"Ð"r c ó~ — | j |z t | j ¦ « k rdS | j | j | j |z … S )zHExtract the next string of the given length, or None if not enough text.NrS r> s r rX zTextPosition.extract s< € à Œ8fÑ s 4¤9™~œ~Ò -Ð -Ø4ØŒy˜œ D¤H¨vÑ$5Ð5Ô6Ð6r N)
r r! r" r# r r r< rß r rX r% r r rL rL sw € € € € € Ø+Ð+ð ð ð ð ð ð ðAð Að Að*ð *ð *ð#ð #ð #ð7ð 7ð 7ð 7ð 7r rL c óš — e Zd ZdZdZdZdZd„ Zd„ Zd„ Z e
j fd„Z d„ Z
d„ Zd „ Zd
„ Zd „ Zd „ Zd
„ Zd„ Zd„ Zdd„Zd„ Zd„ Zd„ Zd„ ZdS )Ú Containerz.A container for text and objects in a lyx fileNc ó, — t ¦ « | _ d S r )r r] r7 s r r zContainer.__init__, s € Ý ™œˆŒ
ˆ
ˆ
r c ó — dS )zProcess contentsNr% r7 s r rS zContainer.process/ s € à ˆr c ó¤ — | j | ¦ « }t |t ¦ « r t d|z ¦ « |g}|S )zGet the resulting HTMLz Raw string )r\ rŸ r rp r r )r r© s r rŸ zContainer.gethtml3 sL € àŒ{×"Ò" 4Ñ(Ô(ˆÝ dCÑ Ô ð Ý KŠK˜
¨Ñ,Ñ -Ô -Ð -Ø6ˆD؈ r c ó’ — t | ¦ « ¦ « }|D ]"}||v r | ||| ¦ « }Œ#|S )z*Escape a line with replacements from a map)ÚsortedÚkeysr )r rÌ Ú replacementsÚpiecesÚpieces r ÚescapezContainer.escape; sS € å˜ ×)Ò)Ñ+Ô+Ñ,Ô,ˆàð @ð @ˆEؘˆ}ˆ}Ø—|’| E¨<¸Ô+>Ñ?Ô?ø؈ r c ó — d}t |¦ « }| ¦ « sØt | ¦ « ¦ « dk rtt t | ¦ « ¦ « ¦ « }|dk r,t t t |¦ « ¦ « dz ¦ « }|d|dd… z dz z
}n|| ¦ « z
}| ¦ « | ¦ « ¯Ø|S ) z/Escape all Unicode characters to HTML entities.r@ é€ Ú0xd835i ø z&#r Nr× )rL rÙ rÚ r ÚhexÚnextrÛ )r rÌ r) r% Ú codepoints r ÚescapeentitieszContainer.escapeentitiesD sÞ € àˆÝ˜4Ñ Ô ˆØ—,’,‘.”.ð Ý3—;’;‘=”=Ñ!Ô! CÒ'Ð'Ý ¥ C§K¢K¡M¤MÑ 2Ô 2Ñ 3Ô 3 Ø Ò(Ð(Ý #¥C¨S© ¬ ¡N¤N°VÑ$;Ñ <Ô ‡— g Š| |ˆfd„¦ « ‰S )z2Search for all embedded containers of a given typec ó. •— ‰ | ¦ « S r )r )rU r s €r rP z%Container.searchall..V s ø€ °4·;²;¸yÑ3IÔ3I€ r )Ú
searchprocess)r rH r s @r Ú searchallzContainer.searchallS s- ø€ àˆØ ×Ò˜4Ð!IÐ!IÐ!IÐ!IÑJÔJÐJ؈ r c óx — | |¦ « }|D ]!}|j j |¦ « Œ"|S )z3Search for all containers of a type and remove them)rm r5 r] r‹ )r rH r rU s r Ú searchremovezContainer.searchremoveY sD € à~Š~˜dÑ#Ô#ˆØ ð 8ð 8ˆIØ Ô Ô %× ,Ò ,¨YÑ 7Ô 7Ð 7Ð 7؈ r c ó: ‡— | ˆfd„|¦ « dS )z4Search for elements of a given type and process themc ó$ •— t | ‰¦ « S r )r )rU rH s €r rP z)Container.searchprocess..b s ø€ Z¸ À4Ñ-HÔ-H€ r N)Ú
locateprocess)r rH rS s ` r rl zContainer.searchprocess` s) ø€ à ×ÒÐHÐHÐHÐHÈ'ÑRÔRÐRÐRÐRr c ór — | j D ].}| ||¦ « ||¦ « r ||¦ « Œ/dS )z3Search for all embedded containers and process themN)r] rr )r rV rS rU s r rr zContainer.locateprocessd sV € à œ ð #ð #ˆIØ × #Ò # F¨GÑ 4Ô 4Ð 4؈viÑ Ô ð
#ؘ Ñ"Ô"Ð"øð #ð #r c óŠ — | j D ]:} ||¦ « r| |||¦ « ||¦ « r ||¦ « Œ;dS )z,Perform a recursive search in the container.N)r] rT )r rV rW rS rU s r rT zContainer.recursivesearchk sk € à œ ð #ð #ˆI؈y˜Ñ#Ô#ð
FØ×)Ò)¨&°)¸WÑEÔEÐE؈viÑ Ô ð
#ؘ Ñ"Ô"Ð"øð #ð #r c ó˜ — t t j ¦ « | ¦ « }d d„ |D ¦ « ¦ « S )z)Extract all text from allowed containers.r@ c 3 ó$ K — | ] }|j V — Œ d S r rÑ )r Úconstants r r“ z(Container.extracttext..v s$ è è € ÐAÐA¨8x”ÐAÐAÐAÐAÐAÐAr )rJ r' r= rX Újoin)r Ú constantss r r= zContainer.extracttexts sA € å&¥Ô'BÑCÔC×KÒKÈDÑQÔQˆ ØwŠwÐAÐA°yÐAÑAÔAÑAÔAÐAr c ó — |t | j ¦ « k rdS t | j | d¦ « rdS |t | j ¦ « k r• || j | ¦ « rd| j | _ |j | j | ¦ « | j |¦ « |t | j ¦ « k r || j | ¦ « °| j ||¦ « dS )z*Group some adjoining elements into a groupNÚgroupedT)r r] r r{ r r r! )r r- ÚgroupÚ isingroups r r| zContainer.groupx sô € à •C˜œ
Ñ&Ô&Ò &Ð &Ø ˆFÝ 4”= Ô'¨Ñ 3Ô 3ð Ø ˆFØ•c˜$œ-Ñ(Ô(Ò(Ð(¨Y¨Y°t´}ÀUÔ7KÑ-LÔ-LÐ(Ø+/ˆDŒM˜%Ô Ô (Ø ŒN× !Ò ! $¤-°Ô"6Ñ 7Ô 7Ð 7Ø ŒM× Ò ˜eÑ $Ô $Ð $ð •c˜$œ-Ñ(Ô(Ò(Ð(¨Y¨Y°t´}ÀUÔ7KÑ-LÔ-LÐ(ð
Œ
× Ò ˜U EÑ*Ô*Ð*Ð*Ð*r c ó — | j | }| j |¦ « t |j ¦ « dk rL| j ||j ¦ « ¦ « t |j ¦ « dk °JdS dS )z)Remove a container but leave its contentsr N)r] r r r! )r r- rU s r r‹ zContainer.remove„ s… € à”M %Ô(ˆ Ø Œ
×Ò˜%Ñ Ô Ð Ý)Ô$Ñ%Ô%¨Ò)Ð)Ø ŒM× Ò ¨ Ô(:×(>Ò(>Ñ(@Ô(@Ñ AÔ AÐ Aõ )Ô$Ñ%Ô%¨Ò)Ð)Ð)Ð)Ð)Ð)r r c ó¤ — t d|z t | ¦ « z ¦ « | j D ]}| |dz ¦ « ŒdS )zShow in a treez r N)r r rp r] Útree)r ÚlevelrU s r r€ zContainer.tree‹ sW € å
Š D˜5‘L¥3 t¡9¤9Ñ,Ñ-Ô-Ð-Ø œ ð &ð &ˆIØ NŠN˜5 1™9Ñ %Ô %Ð %Ð %ð &ð &r c ó2 — || j vrdS | j | S )z)Get the value of a parameter, if present.N)rb ©r rZ s r Ú getparameterzContainer.getparameter‘ s! € à t”Ð &Ð &Ø4ØŒ˜tÔ$Ð$r c ó^ — | |¦ « }|sg S | d¦ « S )z7Get the value of a comma-separated parameter as a list.r )r„ r )r rZ Ú paramtexts r ÚgetparameterlistzContainer.getparameterlist— s4 € à×%Ò% dÑ+Ô+ˆ Øð ؈IØŠ˜sÑ#Ô#Ð#r c ó` — | j }|r$|j ¦ « rdS |j }|°$dS )z&Check if the parent's output is empty.TF)r5 r\ r¡ rE s r ÚhasemptyoutputzContainer.hasemptyoutputž sD € à”+ˆØð %ØŒ~×%Ò%Ñ'Ô'ð
ØtØ ”nˆGð ð %ð ˆur c óp — | j s | j j S | j j dz t | j ¦ « z S )zGet a descriptionrÇ )rW rC r rp r7 s r rx zContainer.__str__§ s4 € àŒzð +Ø”>Ô*Ð *ØŒ~Ô&¨Ñ,s°4´:©¬Ñ>Ð>r )r )r r! r" r# Úpartkeyr5 rW r rS rŸ r? rH rb ri rm ro rl rr rT r= r| r‹ r€ r„ r‡ r‰ rx r% r r rX rX % sR € € € € € Ø4Ð4à€GØ
€FØ €Eð ð ð ð
ð
ð
ðð ð ð )5Ô(=ð ð ð ð ð
ð
ð
ð ð ð ð ð ð ðSð Sð Sð#ð #ð #ð#ð #ð #ðBð Bð Bð
+ð
+ð
+ðBð Bð Bð&ð &ð &ð &ð %ð %ð %ð $ð $ð $ðð ð ð?ð ?ð ?ð ?ð ?r rX c ó — e Zd ZdZd„ ZdS )ÚBlackBoxz)A container that does not output anythingc ó` — t ¦ « | _ t ¦ « | _ g | _ d S r )rz r( r£ r\ r] r7 s r r zBlackBox.__init__± s# € Ý!‘m”mˆŒ Ý!‘m”mˆŒ ؈Œ
ˆ
ˆ
r N)r r! r" r# r r% r r r r ® s) € € € € € Ø/Ð/ðð ð ð ð r r c ó: — e Zd ZdZdZd„ Zd„ Zd„ Zd„ Zd„ Z d„ Z
dS ) ÚStringContainerz A container for a single stringNc ó` — t ¦ « | _ t ¦ « | _ d| _ d S )Nr@ )r˜ r( rÏ r\ rÒ r7 s r r zStringContainer.__init__¼ s# € Ý"‘n”nˆŒ Ý"‘n”nˆŒ ؈Œ ˆ ˆ r c ód — | j r(| | j ¦ « | _ d| _ dS dS )z(Replace special chars from the contents.N)ÚparsedÚreplacespecialrÒ r7 s r rS zStringContainer.processÁ s8 € à Œ;ð Ø ×-Ò-¨d¬kÑ:Ô:ˆDŒKØ ˆDŒKˆKˆKð ð r c ód — | |t j ¦ « }| |¦ « }t j d |v rft
|¦ « dk rS| j rdt | j ¦ « z dz }nd}t
|| ¦ « z ¦ « |S )z%Replace all special chars from a lineÚ startcommandr zUnknown command at rh zUnknown command: ) rb r? rH Ú
changeliner' rÒ r rW rp r r rk )r rÌ Úreplacedr s r r” z StringContainer.replacespecialÇ s› € à—;’;˜t¥\Ô%:Ñ;Ô;ˆØ—?’? 8Ñ,Ô,ˆÝ Ô ! .Ô 1°XÐ =Ð =Å#ÀhÁ-Ä-ÐRSÒBSÐBSàŒzð
.Ø/µ#°d´j±/´/ÑAÀDÑHà-Ý KŠK˜ (§.¢.Ñ"2Ô"2Ñ2Ñ 3Ô 3Ð 3؈r c óB — | |t j ¦ « S r )rb r? rG )r rÌ s r r— zStringContainer.changelineÔ s € Ø{Š{˜4¥ Ô!3Ñ4Ô4Ð4r c ó — | j S )zReturn all text.rÑ r7 s r r= zStringContainer.extracttext× s
€ àŒ{Ðr c óþ — d}| j r|dt | j ¦ « z z
}d}t | j ¦ « ¦ « dk rd}|dz | j ¦ « dd… z |z dz S ) ú"Return a printable representation.r rÇ z...é r@ rw Nr_ )rW rp r rÒ rk )r r) Úellipsiss r rx zStringContainer.__str__Û sƒ € à"ˆØ Œ:ð ,Ø cC ¤
™OœOÑ+Ñ +ˆFØˆÝ ˆtŒ{× Ò Ñ"Ô"Ñ #Ô # rÒ )Ð )؈Hؘ‰}˜tœ{× 0Ò 0Ñ 2Ô 2°3°B°3Ô 7Ñ7¸(ÑBÀSÑHÐHr ) r r! r" r# r“ r rS r” r— r= rx r% r r r r · s~ € € € € € Ø%Ð%à
€Fðð ð ð
ð ð ð ð ð ð5ð 5ð 5ðð ð ðIð Ið Ið Ið Ir r c ó — e Zd ZdZd„ Zd„ ZdS )ÚConstantzA constant stringc óH — g | _ || _ t ¦ « | _ d S r )r] rÒ rÏ r\ rO s r r zConstant.__init__é s € ؈Œ
؈Œ Ý"‘n”nˆŒ ˆ ˆ r c ó — d| j z S )Nz
Constant: rÑ r7 s r rx zConstant.__str__î s € ؘdœkÑ)Ð)r N)r r! r" r# r rx r% r r r r æ s8 € € € € € ØÐð%ð %ð %ð
*ð *ð *ð *ð *r r c ó — e Zd ZdZdZdS )ÚDocumentParametersz#Global parameters for the document.FN)r r! r" r# Ú displaymoder% r r r¤ r¤ ò s € € € € € Ø)Ð)à€K€K€Kr r¤ c ó6 — e Zd ZdZd„ Zd„ Zd„ Zd„ Zd„ Zd„ Z dS ) Ú
FormulaParserzParses a formulac ó2 — |j dz | _ | |¦ « }|so| ¦ « | |¦ « }|sDt d| ¦ « ¦ « z ¦ « dgS |gS )z See if the formula is inlinedr zUnknown formula type in Úunknown)rf rW Ú parsetypere r r rd rk )r rg rH s r ri zFormulaParser.parseheaderû s’ € àÔ&¨Ñ*ˆŒ
Ø~Š~˜fÑ%Ô%ˆØð #Ø OŠOÑ Ô Ð Ø—>’> &Ñ)Ô)ˆDØð
#Ý— ’ Ð 6¸×9KÒ9KÑ9MÔ9M×9SÒ9SÑ9UÔ9UÑ UÑVÔVÐVØ!{Ð"؈vˆ
r c óî — | ¦ « t j d ¦ « dk rdS | ¦ « t j d ¦ « dk rdS | ¦ « t j d ¦ « dk rdS | ¦ « t j d ¦ « dk rdS d S )
z)Get the formula type from the first line.rÏ r Úinliner– ÚblockrÐ rÌ ÚnumberedN)rd ÚfindrJ rù r| s r rª zFormulaParser.parsetype sÏ € à × Ò Ñ Ô × $Ò $¥]Ô%9¸(Ô%CÑ DÔ DÈÒ IÐ IØ8Ø × Ò Ñ Ô × $Ò $¥]Ô%9¸)Ô%DÑ EÔ EÈÒ JÐ JØ7Ø × Ò Ñ Ô × $Ò $¥]Ô%9¸,Ô%GÑ HÔ HÈAÒ MÐ MØ7Ø × Ò Ñ Ô × $Ò $¥]Ô%9¸-Ô%HÑ IÔ IÈQÒ NÐ NØ :؈tr c óÜ — | |¦ « }| ¦ « | j ¦ « s–| ¦ « ¦ « }t |¦ « dk r t d|z ¦ « | ¦ « | ¦ « | j ¦ « ¯–| ¦ « |S )z Parse the formula until the endr zUnparsed formula line ) Ú parseformulard r ro rk r r r re )r rg ÚformulaÚstrippeds r r} zFormulaParser.parse sÌ € à×#Ò# FÑ+Ô+ˆØ×$Ò$Ñ&Ô&×1Ò1°$´+Ñ>Ô>ð Ø ×)Ò)Ñ+Ô+×1Ò1Ñ3Ô3ˆHÝ8‰}Œ}˜qÒ Ð Ý— ’ Ð 4°xÑ ?Ñ@Ô@Ð@Ø OŠOÑ Ô Ð ð ×$Ò$Ñ&Ô&×1Ò1°$´+Ñ>Ô>ð ð
ŠÑÔÐ؈r c óÞ — t j d }|| ¦ « v r`| ¦ « |d¦ « d }||v r| |||¦ « S | |||¦ « S t j d | ¦ « v r7| |t j d t j d ¦ « S t j d }t j d }|| ¦ « v r!| ¦ « ¦ « |¦ « r±| ¦ « ¦ « }| |¦ « d |¦ « }||d z |z }t j d } t j d }
| |d z |
z } || ||| ¦ « z | z S t
d |z d
z | ¦ « z ¦ « d S t j d } t j d
}
| | ¦ « v r?|
| ¦ « v r)t j d
}| ||
|¦ « S t
d| ¦ « z dz ¦ « d S )zParse the formula contentsrÏ r r– rÌ rË r r˜ r— zMissing z in r@ rÍ r• zFormula beginning z is unknown) rJ rù rd r ÚparsesinglelinerÚparsemultilinerrî rk r r r )r rg rÏ ÚrestrÌ rË r ÚendsplitÚ
startpiecer˜ r— ÚendpieceÚ begincommandÚ beginbracketÚ
endbrackets r r± zFormulaParser.parseformula s¦ € å Ô% hÔ/ˆØ V×'Ò'Ñ)Ô)Ð )Ð )Ø×%Ò%Ñ'Ô'×-Ò-¨f°aÑ8Ô8¸Ô;ˆDؘˆ~ˆ~à×,Ò,¨V°V¸VÑDÔDÐDà×'Ò'¨°¸Ñ?Ô?Ð ?Ý Ô Ô *¨f×.@Ò.@Ñ.BÔ.BÐ BÐ Bà×'Ò'¨µ
Ô0DÀYÔ0OÝ(5Ô(=¸iÔ(HñJô Jð
Jå#Ô*¨=Ô9ˆ Ý"Ô)¨,Ô7ˆ
Ø ˜&×,Ò,Ñ.Ô.Ð .Ñ .Ø×!Ò!Ñ#Ô#×)Ò)Ñ+Ô+×4Ò4°ZÑ@Ô@ð
bØ ×,Ò,Ñ.Ô.×4Ò4Ñ6Ô6Ø"Ÿ=š=¨Ñ5Ô5°aÔ8×>Ò>¸zÑJÔJØ (¨8°A¬;Ñ 6¸Ñ C
Ý )Ô 1°+Ô > Ý(Ô0°Ô<Ø$ x°¤{Ñ2°XÑ=Ø! D×$8Ò$8¸ÀÈXÑ$VÔ$VÑVÐYaÑaÐaÝ KŠK˜
ZÑ/°&Ñ8¸6×;MÒ;MÑ;OÔ;OÑOÑ PÔ PÐ PØ2Ý$Ô+¨IÔ6ˆ Ý$Ô+¨IÔ6ˆ Ø ˜6×-Ò-Ñ/Ô/Ð /Ð /°LÀF×DVÒDVÑDXÔDXÐ4XÐ4XÝ&Ô.¨yÔ9ˆJØ×'Ò'¨° ¸jÑIÔIÐ IÝ
Š Ð(¨6×+=Ò+=Ñ+?Ô+?Ñ?À-ÑOÑPÔPÐP؈rr c óº — | ¦ « ¦ « }||vr%t d|z dz |z ¦ « dS | |¦ « s%t d|z dz |z ¦ « dS | |¦ « }||t
|¦ « z t
|¦ « … }| ¦ « |S )zParse a formula in one lineúLine ú does not contain formula start r@ zFormula z does not end with )rd rk r r r r- r re )r rg Ústartro rÌ r- r· s r rµ z FormulaParser.parsesinglelinerA sÓ € à×!Ò!Ñ#Ô#×)Ò)Ñ+Ô+ˆØ ˜Ð Ð Ý KŠK˜ $™Ð)KÑKÈeÑSÑ TÔ TÐ TØ2Ø}Š}˜VÑ$Ô$ð Ý KŠK˜
TÑ)Ð,AÑAÀFÑJÑ KÔ KÐ KØ2Ø—
’
˜5Ñ!Ô!ˆØEC ™JœJÑ&¨F© ¬ |Ð3Ô4ˆØŠÑÔÐ؈ r c ó< — d}| ¦ « }||vr7t d| ¦ « z dz |z ¦ « dS | |¦ « }||t |¦ « z d… ¦ « }| |¦ « sE||dz z
}| ¦ « | ¦ « }| |¦ « ¯E||dt |¦ « … z
}| ¦ « |S )z!Parse a formula in multiple linesr@ r¿ rÀ Nr )rd r r rk r- r r re )r rg rÁ ro r² rÌ r- s r r¶ z FormulaParser.parsemultilinerO s € àˆØ×!Ò!Ñ#Ô#ˆØ ˜Ð Ð Ý KŠK˜ $§*¢*¡,¤,Ñ.Ð1SÑSÐV[Ñ[Ñ \Ô \Ð \Ø2Ø—
’
˜5Ñ!Ô!ˆØEC ™JœJÑ&Ð'Ð'Ô(×.Ò.Ñ0Ô0ˆØ—-’- Ñ'Ô'ð (Ø t˜d‘{Ñ "ˆGØ OŠOÑ Ô Ð Ø×%Ò%Ñ'Ô'ˆDð —-’- Ñ'Ô'ð (ð 4˜
#˜f™+œ+˜ ˜
Ô&Ñ&ˆØŠÑÔÐ؈r N)
r r! r" r# ri rª r} r± rµ r¶ r% r r r§ r§ ø su € € € € € ØÐð
ð
ð
ð
ð
ð
ð ð ð ð!ð !ð !ðF ð ð ð ð ð ð ð r r§ c óH — e Zd ZdZdZdZdZd„ Zd„ Zd„ Z d„ Z
d „ Z d
„ Z d „ Z
dS ) Ú
FormulaBitzA bit of a formulaNr r@ c ó: — g | _ t ¦ « | _ dS )z6The formula bit type can be 'alpha', 'number', 'font'.N)r] r¬ r\ r7 s r r zFormulaBit.__init__h s € àˆŒ
Ý$Ñ&Ô&ˆŒ ˆ ˆ r c ó — || _ | S )z!Set the internal formula factory.)rs )r rs s r Ú
setfactoryzFormulaBit.setfactorym s € à ˆŒ ؈ r c ór — | j |¦ « | xj |j z
c_ | |_ dS )z-Add any kind of formula bit already processedN)r] r rD r5 ©r Úbits r r zFormulaBit.addr s5 € à Œ
× Ò ˜SÑ!Ô!Ð!Ø ˆ
Œ
˜œ Ñ%ˆ
Œ
؈Œ
ˆ
ˆ
r c ó¾ — | xj |z
c_ | |¦ « s7t d|z dz | ¦ « z ¦ « dS dS )z0Skip a string and add it to the original formulazString z not at N)rD rI r r r< )r rÒ r% s r Ú skiporiginalzFormulaBit.skiporiginalx sd € à ˆ
Œ
˜Ñ ˆ
Œ
Ø}Š}˜VÑ$Ô$ð LÝ KŠK˜ FÑ*¨ZÑ7¸#¿.º.Ñ:JÔ:JÑJÑ KÔ KÐ KÐ KÐ Kð Lð Lr c óŠ — t | j ¦ « dk rdS t d„ | j D ¦ « ¦ « | _ | j S )zDCompute the size of the bit as the max of the sizes of all contents.r r c 3 ó$ K — | ] }|j V — Œ d S r ©Úsize©r r¯ s r r“ z)FormulaBit.computesize..‚ s$ è è € ÐBÐB¨˜œ ÐBÐBÐBÐBÐBÐBr )r r] r¼ rÐ r7 s r Ú computesizezFormulaBit.computesize~ sD € å ˆtŒ}Ñ Ô Ò "Ð "Ø1ÝÐBÐB°D´MÐBÑBÔBÑBÔBˆŒ ØŒyÐr c ó@ — | j | j ¦ « S ©zReturn a copy of itself.)rs r± rD r7 s r rE zFormulaBit.clone… s € àŒ|×(Ò(¨¬ Ñ7Ô7Ð7r c ó0 — | j j dz | j z S )zGet a string representationz read in )rC r rD r7 s r rx zFormulaBit.__str__‰ s € àŒ~Ô&¨Ñ4°t´}ÑDÐDr )r r! r" r# rH rÐ rD r rÇ r rÌ rÒ rE rx r% r r rÄ rÄ a sš € € € € € ØÐà €DØ €DØ€Hð'ð 'ð 'ð
ð ð ð
ð ð ð Lð Lð Lð ð ð ð8ð 8ð 8ðEð Eð Eð Eð Er rÄ c ó& — e Zd ZdZd„ Zdd„Zd„ ZdS )Ú TaggedBitz A tagged string in a formulac ó– — t ¦ « |¦ « | _ | t |¦ « ¦ « | S ©z Set the constant and the tag)r± r¶ r\ r r) )r rw r³ s r rw zTaggedBit.constant‘ s: € å"‘n”n×+Ò+¨CÑ0Ô0ˆŒ Ø Š• Ñ*Ô*Ñ+Ô+Ð+؈ r Fc ób — || _ t ¦ « ||¦ « | _ | S rÙ )r] r± r¶ r\ )r r] r³ r´ s r ÚcompletezTaggedBit.complete— s) € à ˆŒ
Ý"‘n”n×+Ò+¨C°Ñ<Ô<ˆŒ ؈ r c óV — t ¦ « |d¬¦ « | _ | S )z4Set the self-closing tag, no contents (as in
).T)rµ )r± r¶ r\ )r r³ s r Ú selfcompletezTaggedBit.selfcomplete s% € å"‘n”n×+Ò+¨C°tÐ+Ñ<Ô<ˆŒ ؈ r Nr )r r! r" r# rw rÛ rÝ r% r r r× r× Ž sL € € € € € Ø"Ð"ðð ð ð ð ð ð ð ð ð ð ð r r× c ó* — e Zd ZdZd„ Zd„ Zd„ Zd„ ZdS )r) z A constant string in a formulac óf — t | |¦ « || _ d| _ d| _ dS )zSet the constant stringr N)r r rD rÐ rH râ s r r zFormulaConstant.__init__¦ s1 € å×Ò˜$ Ñ'Ô'Ð'Ø ˆŒ
؈Œ ؈Œ ˆ ˆ r c ó — | j S )z+Compute the size of the constant: always 1.rÏ r7 s r rÒ zFormulaConstant.computesize s
€ àŒyÐr c ó* — t | j ¦ « S rÔ )r) rD r7 s r rE zFormulaConstant.clone± s € å ˜tœ}Ñ-Ô-Ð-r c ó — d| j z S )rœ zFormula constant: rÑ r7 s r rx zFormulaConstant.__str__µ s € à# d¤kÑ1Ð1r N)r r! r" r# r rÒ rE rx r% r r r) r) £ sV € € € € € Ø$Ð$ðð ð ðð ð ð.ð .ð .ð2ð 2ð 2ð 2ð 2r r) c ó — e Zd ZdZd„ Zd„ ZdS )r5 z A bit of text inside a formulac óN — | ¦ « ¦ « S )zDetect a bit of raw textrï r$ s r ÚdetectzRawText.detect½ ó € à{Š{‰}Œ}×$Ò$Ñ&Ô&Ð&r c ó€ — | ¦ « }| t |¦ « ¦ « d| _ dS )zParse alphabetic textÚalphaN)ró r r) rH )r r% rè s r ÚparsebitzRawText.parsebitÁ s4 € à—
’
‘”ˆØ Š• Ñ'Ô'Ñ(Ô(Ð(؈Œ ˆ ˆ r N©r r! r" r# rå ré r% r r r5 r5 º s8 € € € € € Ø$Ð$ð'ð 'ð 'ð ð ð ð ð r r5 c óL — e Zd ZdZej Zej d Zd„ Zd„ Zd„ Z dS )r2 zA symbol inside a formularÓ c óŽ — | ¦ « t j v rdS | ¦ « t j v rdS dS )zDetect a symbolTF)r r2 rü rõ r$ s r rå zFormulaSymbol.detectÎ s= € à ;Š;‰=Œ=MÔ 4Ð 4Ð 4Ø4Ø ;Š;‰=Œ=MÔ 2Ð 2Ð 2Ø4؈ur c ó² — | ¦ « t j v r*| | ¦ « |¦ « dS | ¦ « t j v r:| t j | ¦ « |¦ « dS t
d| ¦ « z dz ¦ « dS )úParse the symbolNzSymbol z
not found)r r2 rü Ú addsymbolrõ r r r$ s r ré zFormulaSymbol.parsebitÖ s¢ € à ;Š;‰=Œ=MÔ 4Ð 4Ð 4Ø NŠN˜3Ÿ;š;™=œ=¨#Ñ .Ô .Ð .Ø ˆFØ ;Š;‰=Œ=MÔ 2Ð 2Ð 2Ø NŠN=Ô1°#·+²+±-´-Ô@À#Ñ FÔ FÐ FØ ˆFÝ
Š I § ¢ ¡
¤
Ñ-° Ñ<Ñ=Ô=Ð=Ð=Ð=r c ó¤ — | | ¦ « |¦ « | j t |¦ « ¦ « dS )z Add a symbolN)rÌ r r] r r) )r Úsymbolr% s r rï zFormulaSymbol.addsymbolà sD € à ×Ò˜#Ÿ+š+™-œ-¨Ñ-Ô-Ð-Ø Œ
× Ò _¨VÑ 4Ô 4Ñ5Ô5Ð5Ð5Ð5r N)
r r! r" r# rJ rõ rü rå ré rï r% r r r2 r2 È s\ € € € € € Ø Ð à Ô%€HØ Ô)¨,Ô7€Jðð ð ð>ð >ð >ð6ð 6ð 6ð 6ð 6r r2 c ó — e Zd ZdZd„ Zd„ ZdS )r1 z A string of digits in a formulac óN — | ¦ « ¦ « S )zDetect a digitr÷ r$ s r rå zFormulaNumber.detecté ræ r c óŠ ‡— ‰ ˆfd„¦ « }| t |¦ « ¦ « d| _ dS )zParse a bunch of digitsc óP •— ‰ ¦ « ¦ « S r r÷ )r% s €r rP z(FormulaNumber.parsebit..ï s ø€ #§+¢+¡-¤-×"7Ò"7Ñ"9Ô"9€ r ÚnumberN)rì r r) rH )r r% Údigitss ` r ré zFormulaNumber.parsebití sC ø€ à—’Ð9Ð9Ð9Ð9Ñ:Ô:ˆØ Š• Ñ(Ô(Ñ)Ô)Ð)Ø ˆŒ ˆ ˆ r Nrê r% r r r1 r1 æ s8 € € € € € Ø%Ð%ð'ð 'ð 'ð ð ð ð ð r r1 c ó8 — e Zd ZdZej d Zd„ Zd„ ZdS )ÚCommentz*A LaTeX comment: % to the end of the line.rÎ c ó< — | ¦ « | j k S )z
Detect the %.)r rÁ r$ s r rå zComment.detectù s € à{Š{‰}Œ} ¤
Ò*Ð*r c óL — | xj | d¦ « z
c_ dS )z Parse to the end of the line.r N)rD r
r$ s r ré zComment.parsebitý s$ € à ˆ
Œ
˜×*Ò*¨4Ñ0Ô0Ñ0ˆ
Œ
ˆ
ˆ
r N) r r! r" r# rJ rù rÁ rå ré r% r r rù rù ô sE € € € € € Ø0Ð0à Ô Ô +€Eð+ð +ð +ð1ð 1ð 1ð 1ð 1r rù c ó$ — e Zd ZdZd„ Zd„ Zd„ ZdS )Ú
WhiteSpacez"Some white space inside a formula.c óN — | ¦ « ¦ « S )zDetect the white space.r r$ s r rå zWhiteSpace.detect ræ r c óJ — | xj | ¦ « z
c_ dS )zParse all whitespace.N)rD r r$ s r ré zWhiteSpace.parsebit s € à ˆ
Œ
˜Ÿ š ™ œ Ñ(ˆ
Œ
ˆ
ˆ
r c ó — d| j z dz S )rœ z
Whitespace: *rÊ )rD r7 s r rx zWhiteSpace.__str__
s € à ¤ Ñ.°Ñ4Ð4r N)r r! r" r# rå ré rx r% r r rý rý sG € € € € € Ø(Ð(ð'ð 'ð 'ð)ð )ð )ð5ð 5ð 5ð 5ð 5r rý c ó| — e Zd ZdZej d Zej d Zd„ Z d„ Z
d„ Z d„ Z d„ Z
d„ Zd „ Zd
„ Zd „ Zd S )
r+ z A {} bracket inside a formular• c óH — t | ¦ « d| _ dS )z'Create a (possibly literal) new bracketN)rÄ r Úinnerr7 s r r zBracket.__init__ s! € å×Ò˜DÑ!Ô!Ð!؈Œ
ˆ
ˆ
r c ó6 — | | j ¦ « S )z Detect the start of a bracket)rã rÁ r$ s r rå zBracket.detect s € à|Š|˜DœJÑ'Ô'Ð'r c ó< — | || j ¦ « | S )zParse the bracket)Ú
parsecompleteÚ innerformular$ s r ré zBracket.parsebit! ó € à ×Ò˜3 Ô 1Ñ2Ô2Ð2؈ r c ó< — | || j ¦ « | S )zParse a text bracket)r Ú innertextr$ s r Ú parsetextzBracket.parsetext& s € à ×Ò˜3 ¤Ñ/Ô/Ð/؈ r c ó< — | || j ¦ « | S )zParse a literal bracket)r Ú innerliteralr$ s r Ú parseliteralzBracket.parseliteral+ r r c óª — | | j ¦ « sÒ >Ñ @Ô @ÑAÔAˆ Ø×ÒMÔ 0°Ô ;Ñ<Ô<Ð<Ø×ÒMÔ 0°Ô ;Ñ<Ô<Ð<Ø×ÒGœMÑ*Ô*Ð*Ø—,’,‘.”.ð =Ø{Š{‰}Œ} Ð,Ð,Ø—’˜œ ×.Ò.¨sÑ3Ô3Ñ4Ô4Ð4Ø—=’= Ñ%Ô%ð )ØM”M SÑ(M”Møà—’ ¨¯ ª Ñ):Ô):Ñ;Ô;Ñ<Ô<Ð<ð
—,’,‘.”.ð =ð =ð =ð =ð =r c ó¬ — d| _ | ¦ « s£| ¦ « | j k s†| ¦ « | j k r| |¦ « n"| xj | ¦ « z
c_ | ¦ « s | ¦ « | j k ¯†| xj | j z
c_ dS )zAParse a literal inside the bracket, which does not generate HTML.r@ N)ÚliteralrÙ r ro rÁ r rÛ rD r$ s r r
zBracket.innerliteralN s± € àˆŒ Ø—,’,‘.”.ð 2¨¯ª© ¬ ¸$¼+Ò)EÐ)EØ{Š{‰}Œ} ¤
Ò*Ð*Ø×!Ò! #Ñ&Ô&Ð&Ð&à ” §¢Ñ 1Ô 1Ñ1 ” ð —,’,‘.”.ð 2¨¯ª© ¬ ¸$¼+Ò)EÐ)Eð
ˆ
Œ
˜œ Ñ%ˆ
Œ
ˆ
ˆ
r N)r r! r" r# rJ rù rÁ rî ro r rå ré r r r r r
r
r% r r r+ r+ s» € € € € € Ø#Ð#à Ô Ô +€EØ
Ô
" 9Ô
-€Fðð ð ð
(ð (ð (ðð ð ð
ð ð ð
ð ð ð
ð ð ð1ð 1ð 1ð
=ð =ð =ð &ð &ð &ð &ð &r r+ c óL — e Zd ZdZej d Zej d Zd„ Z dS )Ú
SquareBracketz A [] bracket inside a formular™ c ó: — t ¦ « }| j |_ |S )z3Return a new square bracket with the same contents.)r r] )r r• s r rE zSquareBracket.clone_ s € å ‘/”/ˆØ œ=ˆÔ؈r N)
r r! r" r# rJ rù rÁ rî ro rE r% r r r r Y sC € € € € € Ø#Ð#à Ô Ô 1€EØ
Ô
" ?Ô
3€Fðð ð ð ð r r c ó — e Zd ZdZd„ Zd„ ZdS )ÚMathsProcessorzAA processor for a maths construction inside the FormulaProcessor.c óZ — t dt | ¦ « z ¦ « dS )z$Process an element inside a formula.zUnimplemented process() in Nrž ©r r] r- s r rS zMathsProcessor.processi s& € å
Š Ð1µC¸±I´IÑ=Ñ>Ô>Ð>Ð>Ð>r c ó — d| j j z S )z Return a printable description.zMaths processor )rC r r7 s r rx zMathsProcessor.__str__m s € à! D¤NÔ$;Ñ;Ð;r N)r r! r" r# rS rx r% r r r r f s8 € € € € € ØGÐGð?ð ?ð ?ð<ð <ð <ð <ð Traverse over the contents to alter variables and space units.Nrè Úfontrö r õ  )ÚtraverserH Ú italicizer] r! r) )r r² ÚlastrÊ r] s r r& z FormulaProcessor.traversewhole s™ € àˆØ !Ÿ]š]¨7Ñ 3Ô 3ð ð ‰MˆCØŒx˜7Ò"Ð"Ø—’˜s HÑ-Ô-Ð-Ð-Ø”˜VÒ#Ð#¨Ð#°´¸hÒ1FÐ1FØ” ×#Ò# A¥°xÑ'@Ô'@ÑAÔAÐA؈DˆDð ð r c # óÄ K — |j D ]U}t |d¦ « r|j r ||j fV — Œ%t |t ¦ « r| |¦ « E d{V —† ŒVdS )zHTraverse a formula and yield a flattened structure of (bit, list) pairs.rH N)r] r rH r rÄ r/ r( s r r/ zFormulaProcessor.traverse™ s‰ è è € à”|ð 2ð 2ˆGÝw Ñ'Ô'ð
2¨G¬Lð
2Ø ˜sœ|Ð+Ð+Ð+Ð+Ð+ݘG¥ZÑ0Ô0ð
2Ø Ÿ=š=¨Ñ1Ô1Ð1Ð1Ð1Ð1Ð1Ð1Ð1øð 2ð 2r c ó| — | |¦ « }t ¦ « |gd¦ « ||< dS )z Italicize the given bit of text.r¢ N)r- r× rÛ )r rÊ r] r- s r r0 zFormulaProcessor.italicize¡ s6 € à—’˜sÑ#Ô#ˆÝ#™+œ+×.Ò.°¨u°cÑ:Ô:ˆ‰ˆˆr N) r r! r" r# r* rS r$ r% r& r/ r0 r% r r r" r" r sy € € € € € Ø,Ð,à€Jð ð ð ð *ð *ð *ð)ð )ð )ðð ð ð2ð 2ð 2ð;ð ;ð ;ð ;ð ;r r" c óT — e Zd ZdZd„ Zd„ Zd„ Zd„ Zd„ Zd„ Z d„ Z
d „ Z d
„ Z d „ Z
d „ Zd
S )r0 zA LaTeX formulac óx — t ¦ « | _ t ¦ « d¦ « | _ d S )Nzspan class="formula")r§ r( r± r¶ r\ r7 s r r zFormula.__init__ª s+ € Ý#‘o”oˆŒ Ý"‘n”n×+Ò+Ð,BÑCÔCˆŒ ˆ ˆ r c ó¸ — | j d dk r
dt _ n'dt _ | j dd¦ « | ¦ « dS )zConvert the formula to tagsr r¬ FTzdiv class="formula"N)rh r¤ r¥ r\ r¶ Úclassicr7 s r rS zFormula.process® sR € à Œ;qŒ>˜XÒ %Ð %Ø-2Õ Ô *Ð *à-1Õ Ô *Ø ŒK× Ò Ð 4°dÑ ;Ô ;Ð ;Ø Š ‰Œˆˆˆr c ó² — t ¦ « | j ¦ « }t ¦ « |¦ « | |_ |g| _ dS )zEMake the contents using classic output generation with XHTML and CSS.N)ÚFormulaFactoryr± r“ r" rS r5 r] )r Úwholes r r7 zFormula.classic· sK € å Ñ Ô ×-Ò-¨d¬kÑ:Ô:ˆÝÑÔ×"Ò" 5Ñ)Ô)Ð)؈Œ Ø ˜ˆŒ
ˆ
ˆ
r c ó´ — | d¦ « r| |¦ « n˜| d¦ « r| |¦ « nm| d¦ « r| |d¦ « nA| d¦ « r| |d¦ « n| d¦ « | ¦ « | S )z4Parse using a parse position instead of self.parser.z$$rÀ z\(z\)rÉ r” zUnparseable formula)rI ÚparsedollarblockÚparsedollarinlineÚ
parseinlinetoÚ parseblocktor rS r$ s r r} z
Formula.parse¾ s× € à =Š=˜Ñ Ô ð -Ø × !Ò ! #Ñ &Ô &Ð &Ð &Ø
]Š]˜3Ñ
Ô
ð -Ø × "Ò " 3Ñ 'Ô 'Ð 'Ð 'Ø
]Š]˜5Ñ
!Ô
!ð -Ø × Ò ˜s EÑ *Ô *Ð *Ð *Ø
]Š]˜5Ñ
!Ô
!ð -Ø × Ò ˜c 5Ñ )Ô )Ð )Ð )à IŠIÐ+Ñ ,Ô ,Ð ,Ø Š ‰ŒˆØˆ r c ó@ — dg| _ | |¦ « dS )zParse a $...$ formula.r¬ N)rh Ú parsedollarr$ s r r= zFormula.parsedollarinlineÍ s% € à jˆŒ Ø ×Ò˜Ñ Ô Ð Ð Ð r c ó˜ — dg| _ | |¦ « | d¦ « s| d¦ « dS dS )zParse a $$...$$ formula.r rÀ z1Formula should be $$...$$, but last $ is missing.N)rh rA rI r r$ s r r< zFormula.parsedollarblockÒ sY € à iˆŒ Ø ×Ò˜Ñ Ô Ð Ø}Š}˜SÑ!Ô!ð KØ IŠIÐIÑ JÔ JÐ JÐ JÐ Jð Kð Kr c óŽ — | d¦ « | d¦ « | _ | d¦ « dS )zParse to the next $.rÀ N)r r r“ r r$ s r rA zFormula.parsedollarÙ sA € à ŠsÑÔÐØ×'Ò'¨Ñ,Ô,ˆŒ Ø
Š
cÑÔÐÐÐr c óB — dg| _ | ||¦ « dS )zParse a \(...\) formula.r¬ N©rh Ú parseupto©r r% Úlimits r r> zFormula.parseinlinetoß s% € à jˆŒ Ø Šs˜EÑ"Ô"Ð"Ð"Ð"r c óB — dg| _ | ||¦ « dS )zParse a \[...\] formula.r NrE rG s r r? zFormula.parseblocktoä s% € à iˆŒ Ø Šs˜EÑ"Ô"Ð"Ð"Ð"r c ó — | |¦ « | d„ ¦ « | _ | |¦ « dS )z1Parse a formula that ends with the given command.c ó — dS )NTr% r% r r rP z#Formula.parseupto..ì s € t€ r N)r rì r“ r rG s r rF zFormula.parseuptoé sA € à ŠuÑ Ô Ð Ø—h’h˜|˜|Ñ,Ô,ˆŒ Ø
Š
eÑ Ô Ð Ð Ð r c óP — | j r | j j rd| j j z dz S dS )rœ z Formula (r_ zUnnumbered formula)r‹ rö r7 s r rx zFormula.__str__ï s3 € à Œ<ð ;˜DœLÔ /ð ;Ø ¤ Ô!4Ñ4°sÑ:Ð :Ø#Ð#r N)r r! r" r# r rS r7 r} r= r< rA r> r? rF rx r% r r r0 r0 § sÅ € € € € € ØÐðDð Dð Dðð ð ð ð ð ð
ð
ð
ð ð ð ð
Kð Kð Kðð ð ð #ð #ð #ð
#ð #ð #ð
ð ð ð $ð $ð $ð $ð $r r0 c ó — e Zd ZdZd„ Zd„ ZdS )Ú WholeFormulazParse a whole formulac ó, — | ¦ « S )z"Not outside the formula is enough.)rÙ r$ s r rå zWholeFormula.detectù s € à—<’<‘>”>Ð!Ð!r c ó´ — | ¦ « sC| | j |¦ « ¦ « | ¦ « ¯AdS dS )zParse with any formula bitNr r$ s r ré zWholeFormula.parsebitý r r Nrê r% r r rN rN ö s8 € € € € € ØÐð"ð "ð "ð1ð 1ð 1ð 1ð 1r rN c ód — e Zd ZdZeeeeee gZ
ee gZ dZ d„ Z
d„ Zd„ Zd„ Zd„ Zd„ Zd „ Zd
„ Zd „ Zd S )
r9 zConstruct bits of formulaFc ó — i | _ dS )z Initialize the map of instances.N)Ú instancesr7 s r r zFormulaFactory.__init__ s
€ àˆŒˆˆr c ó~ — | ¦ « rdS | |¦ « |¦ « S )z Detect a bit of a given type.F)rÙ Úinstancerå )r rH r% s r Ú
detecttypezFormulaFactory.detecttype s7 € à <Š<‰>Œ>ð Ø5Ø}Š}˜TÑ"Ô"×)Ò)¨#Ñ.Ô.Ð.r c ó‚ — || j vs
| j | s | |¦ « | j |< | j | S )z"Get an instance of the given type.)rS rB ©r rH s r rU zFormulaFactory.instance s@ € à t”~Ð %Ð %¨T¬^¸DÔ-AÐ %Ø#'§;¢;¨tÑ#4Ô#4ˆDŒN˜4Ñ ØŒ~˜dÔ#Ð#r c ó\ — t |¦ « | ¦ « S )z+Create a new formula bit of the given type.)r@ rB rÇ rX s r rB zFormulaFactory.create s" € å}Š}˜TÑ"Ô"×-Ò-¨dÑ3Ô3Ð3r c ó„ — | ¦ « s+| |¦ « sdS | ¦ « ¯+dS )zClear any skipped types.N)rÙ Úskipanyr$ s r Ú clearskippedzFormulaFactory.clearskipped sD € à—,’,‘.”.ð Ø—<’< Ñ$Ô$ð
Øð —,’,‘.”.ð ð ˆr c óš — | j D ]B}| |¦ « |¦ « r| ||¦ « c S ŒCdS )zSkip any skipped types.N)Ú skippedtypesrU rå rª ©r r% rH s r r[ zFormulaFactory.skipany& sZ € àÔ%ð 1ð 1ˆDØ}Š}˜TÑ"Ô"×)Ò)¨#Ñ.Ô.ð
1Ø—~’~ d¨CÑ0Ô0Ð0Ð0Ð0ð
1àˆtr c ó" — | j | j z D ]0}| ||¦ « r| ||¦ « c S Œ1t d| ¦ « z ¦ « t | ¦ « ¦ « S )z.Parse any formula bit at the current location.zUnrecognized formula at ) Útypesr^ rV rª r r r< r) rÛ r_ s r r zFormulaFactory.parseany- sŠ € à”J Ô!2Ñ2ð 1ð 1ˆDØŠ˜t SÑ)Ô)ð
1Ø—~’~ d¨CÑ0Ô0Ð0Ð0Ð0ð
1å
Š Ð.°· ² Ñ1AÔ1AÑAÑBÔBÐBÝ ˜sŸšÑ 0Ô 0Ñ1Ô1Ð1r c óœ — | |¦ « }d| j |< | |¦ « }|r| | ¦ « S |S )z#Parse the given type and return it.N)rU rS ré rÇ )r rH r% rÊ Ú returnedbits r rª zFormulaFactory.parsetype5 sQ € àmŠm˜DÑ!Ô!ˆØ #ˆŒtÑ Ø—l’l 3Ñ'Ô'ˆ Ø ð 0Ø ×)Ò)¨$Ñ/Ô/Ð /؈
r c ó — t |¦ « }| t ¦ « }| |¦ « r| |¦ « |S | ¦ « sdt d| ¦ « z ¦ « | t ¦ « |d¦ « ¦ « |S )z5Parse a string of text that contains a whole formula.zUnknown formula at: úspan class="unknown") rL rB rN rå ré rÙ r r r< r r× rw )r r² r% r: s r r± zFormulaFactory.parseformula> sª € å˜7Ñ#Ô#ˆØ— ’ LÑ)Ô)ˆØ <Š<˜Ñ Ô ð Ø NŠN˜3Ñ Ô Ð ØˆLà|Š|‰~Œ~ð MÝ KŠKÐ.°· ² Ñ1AÔ1AÑAÑ BÔ BÐ BØ IŠI•i‘k”k×*Ò*¨7Ð4JÑKÔKÑ LÔ LÐ L؈ r N)r r! r" r# r2 r5 r1 r+ rù rý ra r^ Údefiningr rV rU rB r\ r[ r rª r± r% r r r9 r9 sÄ € € € € € Ø Ð ð ˜G ]°G¸WÀjÐ Q€EؘZÐ(€LØ€Hð ð ð ð/ð /ð /ð $ð $ð $ð 4ð 4ð 4ðð ð ðð ð ð2ð 2ð 2ðð ð ð ð ð ð ð r r9 c ó^ — e Zd ZdZg Zej d ZdZd„ Z d„ Z
d„ Z d„ Z d„ Z
d „ Zd
„ ZdS ) ÚFormulaCommandz A LaTeX command inside a formularÍ Nc ó@ — | t j ¦ « S )zFind the current command.)rã rh rÁ r$ s r rå zFormulaCommand.detectS s € à|Š|NÔ 0Ñ1Ô1Ð1r c óÎ — | |¦ « }| ||¦ « }|r|S | d¦ « s| d¦ « r| ||¦ « }|r|S | j j s t d|z ¦ « t ¦ « d¦ « | _
| t |¦ « ¦ « dS )zParse the command.ú\upú\UpzUnknown command re N)
ÚextractcommandÚparsewithcommandr Ú parseupgreekrs rf r r r± r¶ r\ r r) )r r% rÍ rÊ Úupgreeks r ré zFormulaCommand.parsebitW sâ € à×%Ò% cÑ*Ô*ˆØ×#Ò# G¨SÑ1Ô1ˆØ ð ؈JØ × Ò ˜fÑ %Ô %ð ¨×);Ò);¸FÑ)CÔ)Cð Ø×'Ò'¨°Ñ5Ô5ˆGØð
Ø ØŒ|Ô$ð 6Ý KŠKÐ*¨WÑ4Ñ 5Ô 5Ð 5Ý"‘n”n×+Ò+Ð,BÑCÔCˆŒ Ø Š• Ñ)Ô)Ñ*Ô*Ð*؈tr c óh — t j D ]$}||j v r| |||¦ « c S Œ%dS )z0Parse the command type once we have the command.N)rh ra Ú
commandmapÚparsecommandtype)r rÍ r% rH s r rn z FormulaCommand.parsewithcommandg sK € å"Ô(ð Að AˆDؘ$œ/Ð)Ð)Ø×,Ò,¨W°d¸CÑ@Ô@Ð@Ð@Ð@ð *àˆtr c ó– — | j |¦ « }| |¦ « | |¦ « }|r|S |S )zParse a given command type.)rs rB Ú
setcommandré )r rÍ rH r% rÊ Úreturneds r rs z FormulaCommand.parsecommandtypen sL € àŒl×!Ò! $Ñ'Ô'ˆØ ŠwÑ Ô Ð Ø—<’< Ñ$Ô$ˆØ ð ؈O؈
r c óØ — | t j ¦ « s$| dt j z ¦ « dS | ¦ « r| |¦ « S | ¦ « ¦ « r8t j | ¦ « z }| d¦ « |S t j | ¦ « z S )z.Extract the command from the current position.zMissing command start NrÊ )
rI rh rÁ r rÙ Ú emptycommandr rð ró rÛ )r r% rÍ s r rm z FormulaCommand.extractcommandw s½ € à}Š}^Ô 1Ñ2Ô2ð Ø IŠIÐ.µ Ô1EÑEÑ FÔ FÐ FØ ˆFØ <Š<‰>Œ>ð *Ø×$Ò$ SÑ)Ô)Ð )Ø ;Š;‰=Œ=× Ò Ñ "Ô "ð å$Ô*¨S¯]ª]©_¬_Ñ<ˆGà MŠM˜#Ñ Ô Ð ØˆNå Ô# c§o¢oÑ&7Ô&7Ñ7Ð7r c ó¦ — d}| ¦ « s-| ¦ « }|r| |¦ « r|}t j |z S )zuCheck for an empty command: look for command disguised as ending.
Special case against '{ \{ \} }' situation.r@ )rß r rI rh rÁ )r r% rÍ ro s r rx zFormulaCommand.emptycommand‡ sV € ð ˆØyŠy‰{Œ{ð !Ø—^’^Ñ%Ô%ˆFØð
!˜#Ÿ-š-¨Ñ/Ô/ð
!Ø Ý Ô# gÑ-Ð-r c ór — t |¦ « dk rdS | d¦ « rd|dd… z }n_| d¦ « r+d|dd… ¦ « z |dd… z }n t d|z ¦ « dS | ||¦ « }|rd|_ |S ) z Parse the Greek \up command..é Nrk rV é rl z Impossible upgreek command: r- )r r rI Úupperr r rn rH )r rÍ r% Ú upcommandrp s r ro zFormulaCommand.parseupgreek‘ sÉ € å ˆw‰<Œ<˜!Ò Ð Ø4Ø × Ò ˜fÑ %Ô %ð Ø ˜w q r rœ{Ñ*ˆIˆIØ
]Š]˜6Ñ
"Ô
"ð Ø ˜w q¨ sœ|× 1Ò 1Ñ 3Ô 3Ñ3°g¸a¸b¸b´kÑAˆIˆIå KŠKÐ6¸Ñ@Ñ AÔ AÐ AØ ˆFØ×'Ò'¨ °3Ñ7Ô7ˆØ ð "Ø!ˆGŒL؈r )r r! r" r# ra rJ rù rÁ rr rå ré rn rs rm rx ro r% r r rh rh L sš € € € € € Ø&Ð&à €EØ Ô Ô +€EØ€Jð2ð 2ð 2ðð ð ð ð ð ðð ð ð8ð 8ð 8ð .ð .ð .ðð ð ð ð r rh c ó6 — e Zd ZdZd„ Zd„ Zd„ Zd„ Zd„ Zd„ Z dS ) Ú
CommandBitz%A formula bit that includes a commandc ót — || _ | j r)| xj |z
c_ | j | j | _ dS dS )zSet the command in the bitN)rÍ rr rD Ú
translated)r rÍ s r ru zCommandBit.setcommand¥ sA € à ˆŒ Ø Œ?ð <Ø ˆMŒM˜WÑ $ˆMŒMØ "œo¨d¬lÔ ;ˆDŒOˆOˆOð <ð Œ>ð Ø4Ø”L×)Ò)¨#Ñ.Ô.ˆ Ø ŠÑÔÐØÐr c óè — | j |¦ « | j t |¦ « sdS | j t |¦ « }| |¦ « |S )zParse a square bracketN)rs r\ rV r rª r ©r r% r• s r Ú parsesquarezCommandBit.parsesquareµ se € à Œ ×!Ò! #Ñ&Ô&Ð&ØŒ|×&Ò&¥}°cÑ:Ô:ð Ø4Ø”,×(Ò( ¸Ñ<Ô<ˆØ ŠÑÔÐ؈r c óÒ — | j |¦ « | j t |¦ « sY| ¦ « s1t
d| ¦ « z ¦ « dS | ¦ « S t ¦ « | j ¦ « }|
| |¦ « ¦ « |j S )zParse a literal bracket.z No literal parameter found at: N)
rs r\ rV r+ r r r r< r rÇ r r r r† s r r zCommandBit.parseliteral¾ s¸ € à Œ ×!Ò! #Ñ&Ô&Ð&ØŒ|×&Ò&¥w°Ñ4Ô4ð #Ø—;’;‘=”=ð
Ý— ’ Ð =ÀÇÂÑ@PÔ@PÑ PÑQÔQÐQØtØ—=’=‘?”?Ð "Ý‘)”)×&Ò& t¤|Ñ4Ô4ˆØ Š×%Ò% cÑ*Ô*Ñ+Ô+Ð+،Рr c ó$ — | j |¦ « | j t |¦ « sdS t ¦ « | j ¦ « }| | |¦ « ¦ « |j S )z!Parse a square bracket literally.N)rs r\ rV r rÇ r r r r† s r Úparsesquareliteralz CommandBit.parsesquareliteralÊ sx € à Œ ×!Ò! #Ñ&Ô&Ð&ØŒ|×&Ò&¥}°cÑ:Ô:ð Ø4Ý ‘/”/×,Ò,¨T¬\Ñ:Ô:ˆØ Š×%Ò% cÑ*Ô*Ñ+Ô+Ð+،Рr c ó^ — | j |¦ « | j t |¦ « s$t d| j z ¦ « dS t ¦ « | j ¦ « |¦ « }| |¦ « |S )zParse a text parameter.zNo text parameter for N)
rs r\ rV r+ r r rÍ rÇ r r r† s r r zCommandBit.parsetextÓ s € à Œ ×!Ò! #Ñ&Ô&Ð&ØŒ|×&Ò&¥w°Ñ4Ô4ð Ý KŠKÐ0°4´<Ñ?Ñ @Ô @Ð @Ø4Ý‘)”)×&Ò& t¤|Ñ4Ô4×>Ò>¸sÑCÔCˆØ ŠÑÔÐ؈r N)
r r! r" r# ru rm r‡ r rŠ r r% r r r€ r€ ¢ st € € € € € Ø+Ð+ð<ð <ð <ðð ð ðð ð ð
ð
ð
ð ð ð ðð ð ð ð r r€ c ó& — e Zd ZdZej Zd„ ZdS )r. z%An empty command (without parameters)c ó: — t | j ¦ « g| _ dS )z"Parse a command without parametersN©r) r‚ r] r$ s r ré zEmptyCommand.parsebitã s € å(¨¬ Ñ9Ô9Ð:ˆŒ
ˆ
ˆ
r N)r r! r" r# rJ râ rr ré r% r r r. r. Þ s1 € € € € € Ø+Ð+à Ô'€Jð;ð ;ð ;ð ;ð ;r r. c ó& — e Zd ZdZej Zd„ ZdS )r6 zFind a function which is represented by a symbol (like _ or ^)c óB — | ¦ « t j v S )zFind the symbol)r r7 rr r$ s r rå zSymbolFunction.detect s € à{Š{‰}Œ}¥Ô 9Ð9Ð9r c ó — | | ¦ « ¦ « | | j ¦ « t ¦ « | j ¦ « | _ | |¦ « dS )rî N) ru r r rÍ r± r¶ r‚ r\ rm r$ s r ré zSymbolFunction.parsebit# se € à Š˜Ÿ š ™
œ
Ñ&Ô&Ð&Ø Š” Ñ Ô Ð Ý"‘n”n×+Ò+¨D¬OÑ<Ô<ˆŒ Ø ×Ò˜CÑ Ô Ð Ð Ð r N) r r! r" r# rJ rú rr rå ré r% r r r7 r7 s@ € € € € € ØDÐDà Ô.€Jð:ð :ð :ð!ð !ð !ð !ð !r r7 c ó, — e Zd ZdZej Zd„ Zd„ ZdS )r8 z-A function where parameters are read as text.c ó† — t ¦ « | j ¦ « | _ | |¦ « dS )zParse a text parameterN)r± r¶ r‚ r\ r r$ s r ré zTextFunction.parsebit0 s5 € å"‘n”n×+Ò+¨D¬OÑ<Ô<ˆŒ Ø ŠsÑÔÐÐÐr c ó — d| _ dS )zSet the type to fontr- N)rH r7 s r rS zTextFunction.process5 s
€ àˆŒ ˆ ˆ r N) r r! r" r# rJ rû rr ré rS r% r r r8 r8 + s@ € € € € € Ø3Ð3à Ô,€Jð ð ð ð
ð ð ð ð r r8 c ó& — e Zd ZdZej Zd„ ZdS )r/ z2A function of one parameter that changes the font.c ó< — d| _ | ¦ « dS )z.Simplify if possible using a single character.r- N)rH r– r7 s r rS zFontFunction.process@ s! € àˆŒ Ø × Ò Ñ!Ô!Ð!Ð!Ð!r N)r r! r" r# rJ rð rr rS r% r r r/ r/ : s3 € € € € € Ø<Ð<ð Ô,€Jð"ð "ð "ð "ð "r r/ c óD — e Zd ZdZd d„Zd„ Zd„ Zd„ Zd„ Zd„ Z d „ Z
d
„ Z d S )
Ú
BigBracketzA big bracket generator.r› c óŒ — || _ || _ || _ d| _ |t j v rt j | | _ dS dS )z(Set the size and symbol for the bracket.N)rÐ rD Ú alignmentr` rJ rÞ )r rÐ r• r¤ s r r zBigBracket.__init__O sG € àˆŒ Ø ˆŒ
Ø"ˆŒØˆŒ Ø •mÔ/Ð /Ð /Ý'Ô3°GÔ<ˆDŒKˆKˆKð 0Ð /r c ó| — t | dt t | j ¦ « ¦ « z ¦ « } ||¦ « S )z%Return the nth piece for the bracket.Úgetpiece)r rp r r` )r r- Úfunctions r r¦ zBigBracket.getpieceX s6 € å˜4 cµ#°d´kÑ2BÔ2BÑ.CÔ.CÑ!CÑDÔDˆØˆx˜‰ŒÐ r c ó — | j d S )z1Return the only piece for a single-piece bracket.r )r` ©r r- s r Ú getpiece1zBigBracket.getpiece1] s € àŒ{˜1Œ~Ð r c óx — |dk r
| j d S || j dz
k r
| j d S | j d S )zGGet the nth piece for a 3-piece bracket: parenthesis or square bracket.r r r ©r` rÐ r© s r Ú getpiece3zBigBracket.getpiece3a s@ € à AŠ:ˆ:Ø”;˜q”>Ð !Ø D”I ‘MÒ !Ð !Ø”;˜r”?Ð "ØŒ{˜1Œ~Ð r c ó´ — |dk r
| j d S || j dz
k r
| j d S || j dz
dz k r
| j d S | j d S )z7Get the nth piece for a 4-piece bracket: curly bracket.r r r| r r¬ r© s r Ú getpiece4zBigBracket.getpiece4i sb € à AŠ:ˆ:Ø”;˜q”>Ð !Ø D”I ‘MÒ !Ð !Ø”;˜q”>Ð !Ø T”Y ‘] AÑ%Ò %Ð %Ø”;˜q”>Ð !ØŒ{˜1Œ~Ð r c óŠ — | |¦ « }d| j z dz }t ¦ « ||¦ « S )z'Get the bracket piece as an array cell.zspan class="bracket align-rØ )r¦ r¤ r× rw )r r- ra Úspans r ÚgetcellzBigBracket.getcells s> € à—
’
˜eÑ$Ô$ˆØ+¨d¬nÑ<¸sÑBˆÝ‰{Œ{×#Ò# E¨4Ñ0Ô0Ð0r c ó\ — | j dk s| j s| ¦ « S g }t | j ¦ « D ]M}| |¦ « }| t
¦ « |gd¦ « ¦ « ŒNt
¦ « |d¦ « gS )z3Get the bracket as an array or as a single bracket.r úspan class="arrayrow"úspan class="array")rÐ r` ÚgetsinglebracketÚranger² r r× rÛ )r Úrowsr- Úcells r Ú getcontentszBigBracket.getcontentsy s € à Œ9˜Š>ˆ> ¤ˆ>Ø×(Ò(Ñ*Ô*Ð *؈ݘ4œ9Ñ%Ô%ð Oð OˆEØ—<’< Ñ&Ô&ˆDØ KŠK ™ œ ×,Ò,¨d¨VÐ5LÑMÔMÑ NÔ NÐ NÐ NÝ‘ ” ×$Ò$ TÐ+?Ñ@Ô@ÐAÐAr c ó® — | j dk r#t ¦ « dd¦ « gS t ¦ « | j d¦ « gS )z$Return the bracket as a single sign.rÔ r@ zspan class="emptydot"rd )rD r× rw r7 s r r¶ zBigBracket.getsinglebracketƒ sM € à Œ=˜CÒ Ð Ý ‘K”K×(Ò(¨Ð-DÑEÔEÐFÐ FÝ‘ ” ×$Ò$ T¤]Ð4KÑLÔLÐMÐMr N)r› ) r r! r" r# r r¦ rª r r¯ r² rº r¶ r% r r r¢ r¢ L sŸ € € € € € Ø Ð ð=ð =ð =ð =ð ð ð ð
ð ð ð ð ð ð ð ð ð1ð 1ð 1ð Bð Bð BðNð Nð Nð Nð Nr r¢ c ó — e Zd ZdZdZd„ ZdS )ÚFormulaEquationzA simple numbered equation.Úequationc ó’ — t ¦ « | _ | | j t
|¦ « ¦ « dS )úParse the arrayN)r¬ r\ r rs rª rN r$ s r ré zFormulaEquation.parsebit s9 € å$Ñ&Ô&ˆŒ Ø Š” ×'Ò' °cÑ:Ô:Ñ;Ô;Ð;Ð;Ð;r N©r r! r" r# ra ré r% r r r½ r½ Š s. € € € € € Ø!Ð!à €Eð<ð <ð <ð <ð Ø?CñEô EˆŒ àˆ r c óÌ — | j |¦ « | ¦ « rd S | | j t
|¦ « ¦ « d S r )rs r\ rÙ r rª rN r$ s r ré zFormulaCell.parsebitž sW € Ø Œ ×!Ò! #Ñ&Ô&Ð&Ø <Š<‰>Œ>ð Ø ˆFØ Š” ×'Ò' °cÑ:Ô:Ñ;Ô;Ð;Ð;Ð;r N)r r! r" r# rÅ ré r% r r rà rà • s8 € € € € € Ø Ð ðð ð ð <ð <ð <ð <ð — e Zd ZdZej d Zd„ Zd„ Zd„ Z dS )Ú
FormulaRowz An array row inside an arrayrX c ób — || _ t ¦ « dd¦ « | _ | S )Nr´ T)Ú
alignmentsr± r¶ r\ )r rÊ s r Ú
setalignmentszFormulaRow.setalignmentsª s* € Ø$ˆŒÝ"‘n”n×+Ò+Ð,CÀTÑJÔJˆŒ ؈ r c ó¨ — d}| | j d¬¦ « | ¦ « sr| |¦ « }| |¦ « | |¦ « |dz
}| | j ¦ « | ¦ « ¯rt | j ¦ « dk rt ¦ « | _
dS dS )zParse a whole rowr T)r r N) r rX rÙ Ú
createcellré r rI r r] r£ r\ )r r% r- r¹ s r ré zFormulaRow.parsebit¯ sÀ € àˆØ ŠtÔ)°DˆÑ9Ô9Ð9Ø—,’,‘.”.ð .Ø—?’? 5Ñ)Ô)ˆDØ MŠM˜#Ñ Ô Ð Ø HŠHT‰NŒNˆNØ Q‰JˆEØ MŠM˜$Ô,Ñ -Ô -Ð -ð —,’,‘.”.ð .õ ˆtŒ}Ñ Ô Ò "Ð "Ý%™-œ-ˆDŒKˆKˆKð #Ð "r c óª — | j |t | j ¦ « z }| j t ¦ « |¦ « S )z4Create the cell that corresponds to the given index.)rÊ r rs rB rà rÅ )r r- r¤ s r rÍ zFormulaRow.createcell¼ sA € à”O EC°´Ñ,@Ô,@Ñ$@ÔAˆ ØŒ|×"Ò"¥;Ñ/Ô/×<Ò<¸YÑGÔGÐGr N)
r r! r" r# rJ rÝ rX rË ré rÍ r% r r rÈ rÈ ¥ sY € € € € € Ø"Ð"à!Ô'¨Ô8€Mðð ð ð
(ð (ð (ðHð Hð Hð Hð Hr rÈ c ó* — e Zd ZdZd„ Zd„ Zd„ Zd„ ZdS )ÚMultiRowFormulaz A formula with multiple rows.c ó — g | _ d}| |¦ « D ]E}|rd}n| ¦ « | |¦ « | |¦ « ŒFt | j ¦ « | _ dS )z,Parse all rows, finish when no more row endsTFN)r¸ Ú iteraterowsÚaddemptyré Úaddrowr rÐ )r r% ÚfirstÚrows r Ú parserowszMultiRowFormula.parserowsÅ sƒ € àˆŒ ؈Ø×#Ò# CÑ(Ô(ð ð ˆCØð
Ø ð —
’
‘”Ø LŠL˜Ñ Ô Ð Ø KŠK˜Ñ Ô Ð Ð Ý˜œ ‘N”NˆŒ ˆ ˆ r c # óF K — t j d } | |d¦ « | j t
¦ « }| | j ¦ « V — | |¦ « r$| xj |
|¦ « z
c_ ndS Œ)z0Iterate over all rows, end when no more row endsrZ TN) rJ rÝ r rs rB rÈ rË rÊ rã rD r )r r% rZ rÖ s r rÒ zMultiRowFormula.iteraterowsÓ s™ è è € å$Ô*¨>Ô:ˆ ð Ø NŠN˜<¨Ñ .Ô .Ð .Ø”,×%Ò%¥jÑ1Ô1ˆCØ×#Ò# D¤OÑ4Ô4Ð 4Ð 4Ð 4Ø|Š|˜LÑ)Ô)ð
Ø
”
§ ¢ ¨|Ñ!<Ô!<Ñ<
”
àð r c ó€ — | j t ¦ « | j ¦ « }t | j d j ¦ « D ]Q\ }}| |¦ « }| t d¦ « ¦ « | |¦ « ŒR| |¦ « dS )zAdd an empty row.r u  N) rs rB rÈ rË rÊ r, r¸ r] rÍ r r) rÔ )r rÖ r- Ú originalcellr¹ s r rÓ zMultiRowFormula.addemptyß s € àŒl×!Ò!¥*Ñ-Ô-×;Ò;¸D¼OÑLÔLˆÝ#,¨T¬Y°r¬]Ô-CÑ#DÔ#Dð ð Ñ ˆE<Ø—>’> %Ñ(Ô(ˆDØ HŠH•_ UÑ+Ô+Ñ ,Ô ,Ð ,Ø GŠGD‰MŒMˆMˆMØ Š CÑÔÐÐÐr c ód — | j |¦ « | |¦ « dS )z2Add a row to the contents and to the list of rows.N)r¸ r r )r rÖ s r rÔ zMultiRowFormula.addrowè s+ € à Œ ×Ò˜Ñ Ô Ð Ø Š‰
Œ
ˆ
ˆ
ˆ
r N)r r! r" r# r× rÒ rÓ rÔ r% r r rÐ rÐ Â sV € € € € € Ø#Ð#ð #ð #ð #ð
ð
ð
ðð ð ðð ð ð ð r rÐ c ó" — e Zd ZdZdZd„ Zd„ ZdS )Ú FormulaArrayzAn array within a formularÝ c ó¨ — t ¦ « dd¦ « | _ | |¦ « | |¦ « dS )rÀ rµ FN)r± r¶ r\ Úparsealignmentsr× r$ s r ré zFormulaArray.parsebitó sJ € å"‘n”n×+Ò+Ð,@À%ÑHÔHˆŒ Ø × Ò ˜SÑ!Ô!Ð!Ø ŠsÑÔÐÐÐr c óÆ — d| _ | |¦ « }|r|| _ | |¦ « }g | _ |D ] }| j |¦ « Œ dS )z Parse the different alignmentsrœ N)ÚvalignrŠ r rÊ r )r r% r Úss r rß z FormulaArray.parsealignmentsù sy € 𠈌 Ø×)Ò)¨#Ñ.Ô.ˆØ ð "Ø!ˆDŒKà×#Ò# CÑ(Ô(ˆØ ˆŒØð &ð &ˆAØ ŒO× "Ò " 1Ñ %Ô %Ð %Ð %ð &ð &r N)r r! r" r# ra ré rß r% r r rÝ rÝ î s= € € € € € Ø Ð à €Eð ð ð ð &ð &ð &ð &ð &r rÝ c ó — e Zd ZdZdZd„ ZdS )Ú
FormulaMatrixz'A matrix (array with center alignment).Úmatrixc óœ — t ¦ « dd¦ « | _ d| _ dg| _ | |¦ « dS )z(Parse the matrix, set alignments to 'c'.rµ Frœ N)r± r¶ r\ rá rÊ r× r$ s r ré zFormulaMatrix.parsebit
sF € å"‘n”n×+Ò+Ð,@À%ÑHÔHˆŒ ؈Œ Ø ˜%ˆŒØ ŠsÑÔÐÐÐr NrÁ r% r r rä rä
s. € € € € € Ø-Ð-à €Eð ð ð ð ð r rä c ó — e Zd ZdZdZd„ ZdS )Ú FormulaCaseszA cases statementÚcasesc óä — t ¦ « | _ ddg| _ | |¦ « | j D ]N}|j D ]D}|j dd¦ « |j t d¦ « ¦ « ŒEŒOt ¦ « | j dd¦ « }t t | j ¦ « dd¦ « }| ¦ « |gz | _ dS )zParse the casesr› zspan class="case align-l"Tu  zspan class="bracketcases"rb N)
r¬ r\ rÊ r× r] r¶ r r) r× rÛ r¢ r rº )r r% rÖ r¹ rÝ Úbraces r ré zFormulaCases.parsebit
sç € å$Ñ&Ô&ˆŒ Ø ˜*ˆŒØ ŠsÑÔÐØ”=ð =ð =ˆCØœ ð
=ð
=Ø” ×"Ò"Ð#>ÀÑEÔEÐEØ”
×$Ò$¥_°UÑ%;Ô%;Ñ<Ô<Ð<Ð<ð
=õ ‘ ” ×$Ò$ T¤]Ð4OÐQUÑVÔVˆÝ3˜tœ}Ñ-Ô-¨s°CÑ8Ô8ˆØ ×)Ò)Ñ+Ô+¨u¨gÑ5ˆŒ
ˆ
ˆ
r NrÁ r% r r rè rè
s. € € € € € ØÐà €Eð 6ð 6ð 6ð 6ð 6r rè c ó — e Zd ZdZd„ ZdS )ÚEquationEnvironmentz;A \begin{}...\end equation environment with rows and cells.c óð — | j dd¦ « }t ¦ « d|z d¦ « | _ |t
j v rt
j | | _ nut d| j z ¦ « t ¦ « d¦ « | _ |
t d|z ¦ « ¦ « dg| _ | |¦ « d S )
z Parse the whole environment.rÊ r@ zspan class="environment %s"Fz Unknown equation environment re z \begin{%s} r› N)
ra r r± r¶ r\ rJ rï rÊ r r r r) r× )r r% Ú environments r ré z EquationEnvironment.parsebit*
sÓ € à”j×(Ò(¨¨bÑ1Ô1ˆ Ý"‘n”n×+Ò+Ø5°kÑAÀ5ñJô JˆŒ à -Ô4Ð 4Ð 4Ý +Ô 8¸Ô EˆDŒOˆOå KŠKÐ7¸$¼*ÑDÑ EÔ EÐ Eå&™.œ.×/Ò/Ð0FÑGÔGˆDŒKØ HŠH•_ ^°KÑ%?Ñ@Ô@Ñ AÔ AÐ Aà "˜eˆDŒOØ ŠsÑÔÐÐÐr N)r r! r" r# ré r% r r rí rí '
s) € € € € € ØCÐCð ð ð ð ð r rí c óH — e Zd ZdZej d diZeee e
gZ d„ Z d„ Z
dS )Ú BeginCommandzEA \begin{}...\end command and what it entails (array, cases, aligned)rW r@ c ól — | |¦ « }| |¦ « }t j d dz |z dz }| |¦ « | |¦ « | |¦ « | xj | |¦ « z
c_ |j | _ dS )zParse the begin commandrY rb rc N)
r ÚfindbitrJ rÝ r ré r rD r rÐ )r r% rÍ rÊ ro s r ré zBeginCommand.parsebitB
sž € à×#Ò# CÑ(Ô(ˆØlŠl˜7Ñ#Ô#ˆÝ Ô$ UÔ+¨cÑ1°GÑ;¸cÑAˆØ ŠvÑ Ô Ð Ø Š SÑÔÐØ Š‰
Œ
ˆ
Ø ˆ
Œ
˜Ÿ š vÑ.Ô.Ñ.ˆ
Œ
Ø”HˆŒ ˆ ˆ r c óæ — t j D ]=}| dd¦ « |j k r | j |¦ « c S Œ>| j t ¦ « }||_ |S )z7Find the command bit corresponding to the \begin{piece}rÊ r@ )rñ ra r ra rs rB rí )r ra rH rÊ s r ró zBeginCommand.findbitM
sr € å Ô&ð 1ð 1ˆDØ}Š}˜S "Ñ%Ô%¨¬Ò3Ð3Ø”|×*Ò*¨4Ñ0Ô0Ð0Ð0Ð0ð 4àŒl×!Ò!Õ"5Ñ6Ô6ˆØˆŒ ؈
r N)r r! r" r# rJ rÝ rr r½ rÝ rè rä ra ré ró r% r r rñ rñ ;
sX € € € € € ØMÐMà Ô% gÔ.°Ð3€Jà
˜l¨L¸-Ð H€Eð ð ð ðð ð ð ð r rñ c ó( — e Zd Zej Zd„ Zd„ ZdS )r- c óP — | j }| |¦ « }|s$t d| j z ¦ « dS t |t ¦ « si t t j ¦ « }|
|¦ « d }n3# t $ r& t d| j z ¦ « Y dS w xY w|j
d¦ « rd}nd}|j d|… |z |j |d… z |_ t j d|j ¦ « |_ dS ) zParse a combining function.z)Missing parameter for combining function Nr z!No base character found for "%s".r. r r ÚNFC)r‚ Úparsesingleparameterr r rÍ r r) rJ r' r= rX Ú
IndexErrorrÒ r Ú unicodedataÚ normalize)r r% Ú combiningr„ Ú extractorr¢ s r ré zCombiningFunction.parsebit^
s1 € à”Oˆ Ø×-Ò-¨cÑ2Ô2ˆ Øð Ý KŠKÐCÀdÄlÑRÑ SÔ SÐ SØ ˆFõ ˜)¥_Ñ5Ô5ð ð
Ý .Ô/JÑ KÔ K Ø %× -Ò -¨iÑ 8Ô 8¸Ô ; øÝ ð
ð
ð
Ý— ’ Ð ?À$Ä,Ñ NÑOÔOÐOØð
øøøð
Ô × &Ò & xÑ 0Ô 0ð ؈AˆAàˆAØ$Ô+¨B¨Q¨BÔ/°)Ñ;¸iÔ>NÈqÈrÈrÔ>RÑRˆ Ôå&Ô0°¸ Ô8HÑIÔIˆ ÔÐÐs Á4B Â,B>Â=B>c óŒ — | j |¦ « | ¦ « rdS | |¦ « S )z&Parse a parameter, or a single letter.N)rs r\ rÙ rm r$ s r rø z&CombiningFunction.parsesingleparameterx
sA € à Œ ×!Ò! #Ñ&Ô&Ð&Ø <Š<‰>Œ>ð Ø4Ø×"Ò" 3Ñ'Ô'Ð'r N)r r! r" rJ rà rr ré rø r% r r r- r- Z
s= € € € € € à Ô1€JðJð Jð Jð4(ð (ð (ð (ð (r r- c ó& — e Zd ZdZej Zd„ ZdS )r4 z;A function that decorates some bit of text with an overset.c ó — | j }t ¦ « |d¦ « | _ | |¦ « | _ t
¦ « d¦ « | _ | j
d| j ¦ « t
¦ « d¦ « | j _ | ¦ « dS )zParse an overset-functionr¾ úspan class="embellished"r úspan class="base"N© r‚ r× rw rñ rm r„ r± r¶ r\ r] r! r– ©r r% rñ s r ré zOversetFunction.parsebit…
ó¢ € à” ˆÝ ‘k”k×*Ò*¨6°5Ñ9Ô9ˆŒ Ø ×,Ò,¨SÑ1Ô1ˆŒÝ"‘n”n×+Ò+Ð,FÑGÔGˆŒ Ø Œ
× Ò ˜Q ¤ Ñ,Ô,Ð,Ý ,¡¤× 5Ò 5Ð6IÑ JÔ JˆŒÔ Ø × Ò Ñ!Ô!Ð!Ð!Ð!r N)r r! r" r# rJ rì rr ré r% r r r4 r4 €
s1 € € € € € ØAÐAà Ô/€Jð"ð "ð "ð "ð "r r4 c ó& — e Zd ZdZej Zd„ ZdS )r9 zŠ>˜( EÑ *Ô *ð 5Ø×#Ò# H¨eÑ4Ô4Ð 4ð 5ð 5r c óÞ — | ||dz ¦ « }|sdS | |||¦ « }| || |¦ « | || |¦ « dS )zProcess a left bracket.r N)Ú findrightÚfindmaxÚresize)r r] r- Ú
rightindexrÐ s r r2 z BracketProcessor.processleft$ sr € à—^’^ H¨e°a©iÑ8Ô8ˆ
Øð Ø ˆFØ|Š|˜H e¨ZÑ8Ô8ˆØ Š H˜U”O TÑ*Ô*Ð*Ø Š H˜ZÔ(¨$Ñ/Ô/Ð/Ð/Ð/r c ó: — | || d¦ « S )z0Check if the command at the given index is left.re ©Úcheckdirectionr s r r1 zBracketProcessor.checkleft- s € à×"Ò" 8¨E¤?°HÑ=Ô=Ð=r c ó: — | || d¦ « S )z1Check if the command at the given index is right.rf r9 r s r Ú
checkrightzBracketProcessor.checkright1 s € à×"Ò" 8¨E¤?°IÑ>Ô>Ð>r c óF — t |t ¦ « sdS |j |k S )z6Check if the given bit is the desired bracket command.F)r r, rÍ )r rÊ rÍ s r r: z BracketProcessor.checkdirection5 s& € å˜#~Ñ.Ô.ð Ø5ØŒ{˜gÒ%Ð%r c óÜ — d}|t |¦ « k rV| ||¦ « r|dz
}| ||¦ « r|dz }|dk r|S |dz
}|t |¦ « k °VdS )z9Find the right bracket starting at the given index, or 0.r r N)r r1 r< )r r] r- Údepths r r4 zBracketProcessor.findright; s‡ € àˆØ•c˜(‘m”mÒ#Ð#Ø~Š~˜h¨Ñ.Ô.ð
ؘ‘
ØŠ˜x¨Ñ/Ô/ð
ؘ‘
ؘŠzˆzØ Ø Q‰JˆEð •c˜(‘m”mÒ#Ð#ð ˆtr c óH — |||… }t d„ |D ¦ « ¦ « S )z@Find the max size of the contents between the two given indices.c 3 ó$ K — | ] }|j V — Œ d S r rÏ rÑ s r r“ z+BracketProcessor.findmax..K s$ è è € Ð6Ð6 G7”<Ð6Ð6Ð6Ð6Ð6Ð6r )r¼ )r r] Ú leftindexr7 Úsliceds r r5 zBracketProcessor.findmaxH s. € à˜) JÐ.Ô/ˆÝÐ6Ð6¨vÐ6Ñ6Ô6Ñ6Ô6Ð6r c óÞ — | ¦ « }|j dd¦ « }t |||¦ « }t ¦ « |_ | ¦ « |_ dS )z+Resize a bracket command to the given size.rV r@ N)r= rÍ r r¢ r¬ r\ rº r] )r rÍ rÐ r- r¤ r• s r r6 zBracketProcessor.resizeM sb € à×'Ò'Ñ)Ô)ˆ Ø”O×+Ò+¨D°"Ñ5Ô5ˆ Ý ˜T 9¨iÑ8Ô8ˆÝ'Ñ)Ô)ˆŒØ"×.Ò.Ñ0Ô0ˆÔÐÐr N) r r! r" r# rS r2 r1 r< r: r4 r5 r6 r% r r r/ r/ s’ € € € € € Ø'Ð'ð5ð 5ð 5ð0ð 0ð 0ð>ð >ð >ð?ð ?ð ?ð&ð &ð &ð ð ð ð7ð 7ð 7ð
1ð 1ð 1ð 1ð 1r r/ c ó: — e Zd ZdZ ddgZd„ Zd„ Zd„ Zd„ ZdS ) ÚParameterDefinitionz3The definition of a parameter in a hybrid function.)r` ra )rb rc c óL — d | _ d| _ d| _ d | _ d | _ d S )NF)rZ r r r’ Ú literalvaluer7 s r r z ParameterDefinition.__init__g s, € ؈Œ Ø ˆŒ Ø ˆŒ
؈Œ
Ø ˆÔÐÐr c ó` — t j D ]ñ\ }}| |¦ « r×|dk rd| _ | d¦ « s5t d| ¦ « z dz ¦ « dS | ¦ « | _ | d¦ « rd| _ | |¦ « s2t d| ¦ « z ¦ « dS | c S Œòt d | ¦ « z ¦ « dS )
z2Parse a parameter definition: [$0], {$x}, {$1!}...r` TrÀ z$Wrong parameter name, did you mean $rÙ NrÖ zWrong parameter closing z'Wrong character in parameter template: )
rF Ú
parambracketsrI r r r r rÛ rZ r )r r% ÚopeningÚclosings r r} zParameterDefinition.parsen s € å"5Ô"Cð
ð
Ñ ˆWgØ}Š}˜WÑ%Ô%ð
ؘc’>>Ø$(D”MØ—}’} SÑ)Ô)ð Ý—K’KÐ FÈÏÊÉ Ì Ñ VÐY\Ñ \Ñ]Ô]Ð]Ø ˜4˜4Ø ŸOšOÑ -Ô -” Ø—=’= Ñ%Ô%ð (Ø#'D”LØ—}’} WÑ-Ô-ð Ý—K’KÐ :¸S¿_º_Ñ=NÔ=NÑ NÑOÔOÐOØ ˜4˜4Ø ð
õ Š Ð=ÀÇÂÑ@QÔ@QÑQÑRÔRÐR؈tr c óN — | j r`| j r| |¦ « | _ n| |¦ « | _ | j rt | j ¦ « | _ dS dS | j r | |¦ « | _ dS | |¦ « | _ dS )z/Read the parameter itself using the definition.N) r r rŠ rH r r) r’ r‡ rm )r r% r§ s r ÚreadzParameterDefinition.read s¯ € à Œ<ð
6ØŒ}ð
?Ø$,×$?Ò$?ÀÑ$DÔ$DÔ!Ð!à$,×$9Ò$9¸#Ñ$>Ô$>Ô!ØÔ ð
@Ý ,¨TÔ->Ñ ?Ô ?”
ð
@ð
@à
Œ]ð 6Ø!×-Ò-¨cÑ2Ô2ˆDŒJˆJˆJà!×0Ò0°Ñ5Ô5ˆDŒJˆJˆJr c óh — d| j z }| j r|dt | j ¦ « z z
}n|dz
}|S )rœ zparam rh z (empty))rZ r’ rp )r r) s r rx zParameterDefinition.__str__ s@ € à˜DœIÑ%ˆØ Œ:ð !Ø dS ¤™_œ_Ñ,Ñ ,ˆFˆFà jÑ ˆF؈
r N) r r! r" r# rJ r r} rN rx r% r r rF rF ^ sl € € € € € Ø9Ð9Ø>ØAØ9Ø\à Ð,€Mð!ð !ð !ðð ð ð& 6ð 6ð 6ð ð ð ð ð r rF c ó2 — e Zd ZdZ d„ Zd„ Zd„ Zd„ Zd„ ZdS )ÚParameterFunctionzFA function with a variable number of parameters defined in a template.c ó” — i | _ | |¦ « D ]*}| || ¦ « || j d|j z < Œ+dS )z*Read the params according to the template.rÀ N)ÚparamsÚ paramdefsrN rZ ©r Ú readtemplater% Úparamdefs r Ú
readparamsz ParameterFunction.readparams sX € àˆŒ Ø Ÿš |Ñ4Ô4ð 8ð 8ˆHØ MŠM˜#˜tÑ $Ô $Ð $Ø/7ˆDŒK˜˜hœmÑ+Ñ ,Ð ,ð 8ð 8r c # óÊ K — t |¦ « }| ¦ « s=t ¦ « |¦ « }|r|V — | ¦ « ¯;dS dS )z*Read each param definition in the templateN)rL rÙ rF r} rU s r rT zParameterFunction.paramdefs¤ ss è è € å˜<Ñ(Ô(ˆØ—,’,‘.”.ð Ý*Ñ,Ô,×2Ò2°3Ñ7Ô7ˆHØð
Ø ð —,’,‘.”.ð ð ð ð ð r c ó2 — || j vrdS | j | S )zGet a parameter as parsed.N)rS rƒ s r ÚgetparamzParameterFunction.getparam¬ s! € à t”{Ð "Ð "Ø4ØŒ{˜4Ô Ð r c ó6 — | |¦ « j S )z Get the value of a parameter.)r[ r’ rƒ s r ÚgetvaluezParameterFunction.getvalue² s € à}Š}˜TÑ"Ô"Ô(Ð(r c óP — | |¦ « }|r|j sdS |j S )z%Get the literal value of a parameter.N)r[ rH )r rZ r1 s r Úgetliteralvaluez!ParameterFunction.getliteralvalue¶ s3 € à—
’
˜dÑ#Ô#ˆØð ˜EÔ .ð Ø4ØÔ!Ð!r N) r r! r" r# rX rT r[ r] r_ r% r r rQ rQ ™ sh € € € € € ØLÐLØ;ð8ð 8ð 8ð ð ð ð!ð !ð !ð )ð )ð )ð"ð "ð "ð "ð "r rQ c óP — e Zd ZdZej Zd„ Zd„ Zd„ Z d„ Z
d„ Z d„ Z d„ Z
d „ Zd
S ) ÚHybridFunctiona
A parameter function where the output is also defined using a template.
The template can use a number of functions; each function has an associated
tag.
Example: [f0{$1},span class="fbox"] defines a function f0 which corresponds
to a span of class fbox, yielding $1.
Literal parameters can be used in tags definitions:
[f0{$1},span style="color: $p;"]
yields $1, where $p is a literal parameter.
Sizes can be specified in hybridsizes, e.g. adding parameter sizes. By
default the resulting size is the max of all arguments. Sizes are used
to generate the right parameters.
A function followed by a single / is output as a self-closing XHTML tag:
[f0/,hr]
will generate
.
c óÂ — | j d }| j d }| ||¦ « | |¦ « | _ | ¦ « dS )z*Parse a function with [] and {} parametersr r N)r‚ rX Ú writeparamsr] Úcomputehybridsize)r r% rV Ú
writetemplates r ré zHybridFunction.parsebitÒ s[ € à” qÔ)ˆ Ø œ¨Ô*ˆ
Ø Š˜ cÑ*Ô*Ð*Ø ×(Ò(¨ Ñ7Ô7ˆŒ
Ø × Ò Ñ Ô Ð Ð Ð r c óF — | t |¦ « ¦ « S )z*Write all params according to the template)ÚwriteposrL )r re s r rc zHybridFunction.writeparamsÚ s € à}Š}\¨-Ñ 8Ô 8Ñ9Ô9Ð9r c óØ — g }| ¦ « sR| d¦ « r-| |¦ « }|r| |¦ « nû| d¦ « r4| |¦ « }|r d|_ | |¦ « n²| d¦ « r*| | dd¦ « ¦ « ns| d¦ « r*| | dd¦ « ¦ « n4| t | ¦ « ¦ « ¦ « | ¦ « ¯R|S )z/Write all params as read in the parse position.rÀ ÚfNr^ Úleftr_ Úright) rÙ rI Ú
writeparamr Ú
writefunctionrH Ú writebracketr) rÛ )r r% r) r1 r§ s r rg zHybridFunction.writeposÞ sU € àˆØ—,’,‘.”.ñ BØ}Š}˜SÑ!Ô!ð
BØ Ÿš¨Ñ,Ô,Øð )Ø—M’M %Ñ(Ô(Ð(øØ— ’ ˜sÑ#Ô#ð
BØ ×-Ò-¨cÑ2Ô2Øð ,Ø$(H”MØ—M’M (Ñ+Ô+Ð+øØ— ’ ˜sÑ#Ô#ð
BØ—
’
˜d× /Ò /°¸Ñ <Ô <Ñ=Ô=Ð=Ð=Ø— ’ ˜sÑ#Ô#ð
BØ—
’
˜d× /Ò /°¸Ñ =Ô =Ñ>Ô>Ð>Ð>à—
’
o¨c¯oªoÑ.?Ô.?Ñ @Ô @ÑAÔAÐAð —,’,‘.”.ñ Bð ˆ
r c ó> — d| ¦ « z }|| j vr t d|z ¦ « dS | j | sdS | d¦ « r)| ¦ « | j | j _ | j | j S )z*Write a single param of the form $0, $x...rÀ zUnknown parameter NrÔ )rÛ rS r r rI ró r’ rH )r r% rZ s r rl zHybridFunction.writeparamó s’ € àS—_’_Ñ&Ô&Ñ&ˆØ t”{Ð "Ð "Ý KŠKÐ,¨tÑ3Ñ 4Ô 4Ð 4Ø4ØŒ{˜4Ô ð Ø4Ø =Š=˜Ñ Ô ð ;Ø+.¯=ª=©?¬?ˆDŒK˜Ô Ô #Ô (ØŒ{˜4Ô Ô&Ð&r c óì — | |¦ « }|sdS | d¦ « r!t ¦ « |¦ « S | d¦ « s t d¦ « dS | d¦ « | |¦ « }| ¦ « t |¦ « dk rdS t ¦ «
||¦ « S )z"Write a single function f0,...,fn.NrÄ rb z Function should be defined in {}rc r ) ÚreadtagrI r× rÝ r r r rg r r rÛ )r r% r³ r] s r rm z HybridFunction.writefunctionÿ sØ € àlŠl˜3Ñ Ô ˆØð Ø4Ø =Š=˜Ñ Ô ð 1å ‘;”;×+Ò+¨CÑ0Ô0Ð 0Ø}Š}˜SÑ!Ô!ð Ý KŠKÐ:Ñ ;Ô ;Ð ;Ø4Ø ŠsÑÔÐØ—=’= Ñ%Ô%ˆØ
Š
‰ŒˆÝ ˆx‰=Œ=˜AÒ Ð Ø4݉{Œ{×#Ò# H¨cÑ2Ô2Ð2r c ó– — | ¦ « ¦ « s1t d| ¦ « z ¦ « dS t | ¦ « ¦ « }d|z t
| j ¦ « k r/t dt |¦ « z dz ¦ « dS | j d|z }d|vr|S | j D ]h}||v rb| j | }|j
s't d|z dz |z d z ¦ « ŒA|j r|j }nd
}| ||¦ « }Œi|S ) zJGet the tag corresponding to the given index. Does parameter substitution.z Function should be f0,...,f9: fNr z
Function fz is not definedrÀ zParameters in tag z should be literal: {z!}r@ )
r rø r r ÚintrÛ r r‚ rp rS r rH r )r r% r- r³ Úvariabler1 r’ s r rq zHybridFunction.readtag sI € à{Š{‰}Œ}×$Ò$Ñ&Ô&ð Ý KŠKÐ9¸C¿KºK¹M¼MÑIÑ JÔ JÐ JØ4ÝC—O’OÑ%Ô%Ñ&Ô&ˆØ ˆu‰9•s˜4œ?Ñ+Ô+Ò +Ð +Ý KŠK˜ ¥s¨5¡z¤zÑ1Ð4EÑEÑ FÔ FÐ FØ4ØŒo˜a %™iÔ(ˆØ cˆ>ˆ>؈JØ œ ð
3ð
3ˆHؘ3ˆˆØ œ HÔ-Ø ”}ð Ý—K’KÐ 4°sÑ :Ð=TÑ TÐW_Ñ _ÐbfÑ fÑgÔgÐgØ ØÔ%ð Ø !Ô .EEà EØ—k’k (¨EÑ2Ô2ø؈
r c óh — | j t ¦ « ||¦ « S )z4Return a new bracket looking at the given direction.)rs rB r, r+ s r rn zHybridFunction.writebracket* s( € àŒ|×"Ò"¥>Ñ2Ô2×9Ò9¸)ÀYÑOÔOÐOr c óÐ — | j t j vr| ¦ « dS t ¦ « | ¦ « | _ | j D ]}| j |_ ŒdS )z(Compute the size of the hybrid function.N)rÍ Ú
HybridSizeÚ configsizesrÒ ÚgetsizerÐ r] )r r¯ s r rd z HybridFunction.computehybridsize. sh € à Œ s € àÔ% hÔ&6Ô7ˆ
Ø ”Oð Að AˆDØzÐ!Ð!Ø ” tÔ,Ô2×>Ò>Ñ@Ô@Ø '× /Ò /°µc¸$±i´iÑ @Ô @
øØ *Ð Ð Ý KŠKÐ?À*ÑLÑ MÔ MÐ MØ1ÝJÑ Ô Ð r N)r r! r" r# rJ rò rx ry r% r r rw rw 9 s1 € € € € € Ø1Ð1à Ô+€Kð
ð
ð
ð
ð
r rw c ó — t ¦ « }| | ¦ « }t ¦ « |¦ « | ¦ « d | ¦ « ¦ « S )z Convert some TeX math to HTML.r@ )r9 r± r" rS rx rŸ )r² rs r: s r Ú math2htmlr N sa € å Ñ Ô €GØ × Ò Ñ )Ô )€EÝÑÔ× Ò ˜uÑ%Ô%Ð%Ø ‡M‚MO„O€OØ
7Š75—=’=‘?”?Ñ #Ô #Ð#r c ó4 — t j } t ¦ « | ¦ « t | ¦ « dk r(t
d¦ « t ¦ « t | d ¦ « }t
|¦ « dS )z6Main function, called if invoked from the command liner z"Usage: math2html.py escaped_stringr N)
r
Úargvr# r r r r r r r )r r) s r Úmainr‚ W su € å Œ8€DÝ I„I×Ò˜4Ñ Ô Ð Ý
ˆ4y„yA‚~€~Ý
Š Ð8Ñ9Ô9Ð9Ý ‰ŒˆÝ
t˜A”wÑ
Ô
€FÝ ‡M‚M&ÑÔÐÐÐr Ú__main__)Zr3 r
rú Údocutils.utils.mathr r: r r' r? rJ rþ r# r@ rJ r` rz r r r‘ r” r˜ rœ r£ r§ r¬ r± rÄ rÏ rÔ rÖ r" r7 rL rX r r r r¤ r§ rÄ r× r) r5 r2 r1 rù rý r+ r r r" r0 rN r9 rh r€ r. r6 r* r3 r7 r8 r/ ra r¢ r½ rà rÈ rÐ rÝ rä rè rí rñ r- r4 r9 r r
r r, r/ r* rF rQ ra rw r r‚ r r% r r úr… sÈ ðð0 €€€Ø
€
€
€
Ø Ð Ð Ð à +Ð +Ð +Ð +Ð +Ð +ð !€ ð+ ð + ð + ð + ð + ñ + ô + ð + ð\ð ð ð ð ñ ô ð ð2
ð
ð
ð
ð
ñ
ô
ð
ð f
ð f
ð f
ð f
ð f
ñ f
ô f
ð f
ðR
Að Að Að Að Añ Aô Að AðH7ð 7ð 7ð 7ð 7ñ 7ô 7ð 7ðt!ð !ð !ð !ð !ñ !ô !ð !ð$&ð &ð &ð &ð &ñ &ô &ð &ðR.Fð .Fð .Fð .Fð .Fñ .Fô .Fð .Fðbð ð ð ð &ñ ô ð ð"ð "ð "ð "ð "ñ "ô "ð "ðJð ð ð ð fñ ô ð ðð ð ð ð Oñ ô ð ðð ð ð ð 6ñ ô ð ð ð ð ð ð 6ñ ô ð ð ð ð ð ð ñ ô ð ðð ð ð ð /ñ ô ð ð ð ð ð ð /ñ ô ð ð
ð
ð
ð
ð
_ñ
ô
ð
ð @ð @ð @ð @ð @>ñ @ô @ð @ðFð ð ð ð ^ñ ô ð ð8"ð "ð "ð "ð "?ñ "ô "ð "ðt!ð t!ð t!ð t!ð t!ñ t!ô t!ð t!ðn= ð = ð = ð = ð = ñ = ô = ð = ð@ð ð ð ð ñ ô ð ð&68ð 68ð 68ð 68ð 68ˆxñ 68ô 68ð 68ðr!7ð !7ð !7ð !7ð !78ñ !7ô !7ð !7ðHF?ð F?ð F?ð F?ð F?ñ F?ô F?ð F?ðRð ð ð ð ˆyñ ô ð ð,Ið ,Ið ,Ið ,Ið ,Iiñ ,Iô ,Ið ,Ið^ *ð *ð *ð *ð *ˆñ *ô *ð *ðð ð ð ð ñ ô ð ð fð fð fð fð fFñ fô fð fðR*Eð *Eð *Eð *Eð *Eñ *Eô *Eð *EðZð ð ð ð
ñ ô ð ð*2ð 2ð 2ð 2ð 2hñ 2ô 2ð 2ð. ð ð ð ð ˆjñ ô ð ð 6ð 6ð 6ð 6ð 6Jñ 6ô 6ð 6ð< ð ð ð ð Jñ ô ð ð 1ð 1ð 1ð 1ð 1ˆjñ 1ô 1ð 1ð
5ð
5ð
5ð
5ð
5ñ
5ô
5ð
5ð D&ð D&ð D&ð D&ð D&ˆjñ D&ô D&ð D&ðN
ð
ð
ð
ð
Gñ
ô
ð
ð <ð <ð <ð <ð <ñ <ô <ð <ð2;ð 2;ð 2;ð 2;ð 2;ñ 2;ô 2;ð 2;ðjL$ð L$ð L$ð L$ð L$ˆiñ L$ô L$ð L$ð^
1ð
1ð
1ð
1ð
1:ñ
1ô
1ð
1ðFð Fð Fð Fð Fñ Fô Fð FðRSð Sð Sð Sð SZñ Sô Sð Sðl9ð 9ð 9ð 9ð 9 ñ 9ô 9ð 9ðx;ð ;ð ;ð ;ð ;:ñ ;ô ;ð ;ð
Qð
Qð
Qð
Qð
QJñ
Qô
Qð
Qð ð ð ð ð <ñ ô ð ð"#ð #ð #ð #ð #zñ #ô #ð #ð(!ð !ð !ð !ð !Zñ !ô !ð !ð" ð ð ð ð :ñ ô ð ð "ð "ð "ð "ð "Ð#ñ "ô "ð "ð Ð Ô ˜ ¨ Ð8Ñ 8Ð Ô à,Ð 0°,Ø-ð!€Ô ð
;Nð ;Nð ;Nð ;Nð ;Nñ ;Nô ;Nð ;Nð|<ð <ð <ð <ð HTML conversion from eLyXer
:latex2mathml: LaTeX math -> presentational MathML
:unichar2tex: Unicode character to LaTeX math translation table
:tex2unichar: LaTeX math to Unicode character translation dictionaries
:tex2mathml_extern: Wrapper for 3rd party TeX -> MathML converters
c ój — | d¦ « }d d„ |D ¦ « ¦ « S )zAReturn string (LaTeX math) `code` with environments stripped out.z\begin{c 3 óL K — | ] }| d ¦ « d V — Œ dS )z\end{éÿÿÿÿN)Úsplit)Ú.0Úchunks ú|/builddir/build/BUILD/imunify360-venv-2.6.2/opt/imunify360/venv/lib/python3.11/site-packages/docutils/utils/math/__init__.pyú z toplevel_code.. sG è è € ð 0ð 0Ø $ð !Ÿ;š; xÑ0Ô0°Ô4ð 0ð 0ð 0ð 0ð 0ð 0ó )r Újoin)ÚcodeÚchunkss r Ú
toplevel_coder sE € à
ZŠZ˜
Ñ
#Ô
#€FØ ?Š?ð 0ð 0Ø(.ð0ñ 0ô 0ñ 0ô 0ð 0r
Fc ój — t | ¦ « d¦ « dk rd}nd}|s|dz
}|S )a: Return the right math environment to display `code`.
The test simply looks for line-breaks (``\``) outside environments.
Multi-line formulae are set with ``align``, one-liners with
``equation``.
If `numbered` evaluates to ``False``, the "starred" versions are used
to suppress numbering.
z\\é ÚalignÚequationÚ*)r Úfind)r ÚnumberedÚenvs r Úpick_math_environmentr $ sG € õ TÑÔ× Ò Ñ&Ô&¨!Ò+Ð+؈ˆàˆØ ð Ø ˆs‰
ˆØ €Jr
N)F)Ú__doc__r r © r
r úr s< ðð ð ð"0ð 0ð 0ðð ð ð ð ð r
PK ! 'weø! ø! - __pycache__/tex2mathml_extern.cpython-311.pycnu „[µü¤ §
¥ Þih ã ór — d Z ddlZdZd d„Zd d„Zd d„Zd d„Zed k rd
Z e ee¦ « ¦ « dS dS )
zšWrappers for TeX->MathML conversion by external tools
This module is provisional:
the API is not settled and may change with any minor Docutils version.
é NzP\documentclass{article}
\usepackage{amsmath}
\begin{document}
%s
\end{document}
c ó‚ — t j g d¢t j t j t j d¬¦ « }|j t
| z d¦ « ¦ « |j ¦ « |j ¦ « }|j
¦ « d¦ « }|r0| d¦ « dk s|s|
|¦ « t j g d¢t j t j t j d¬¦ « }|j |¦ « |j ¦ « |j ¦ « d¦ « }|j
¦ « d¦ « }|r0| d¦ « dk s|s|
|¦ « | d¦ « | d ¦ « d
z } }||| … }d |v rt |¦ « ‚|S ) zdConvert LaTeX math code to MathML with LaTeXML_
.. _LaTeXML: http://dlmf.nist.gov/LaTeXML/
)Úlatexmlú-z--preload=amsfontsz--preload=amsmathz--inputencoding=utf8T©ÚstdinÚstdoutÚstderrÚ close_fdsúutf-8ÚErrorr )Ú latexmlpostr z--nonumbersectionsz--format=xhtmlz--úé zclass="ltx_ERROR)Ú
subprocessÚPopenÚPIPEr ÚwriteÚdocument_templateÚencodeÚcloser Úreadr ÚdecodeÚfindÚerrorÚ SyntaxError)
Ú math_codeÚreporterÚpÚ latexml_codeÚ latexml_errÚpost_pÚresultÚ
post_p_errÚstartÚends
ú…/builddir/build/BUILD/imunify360-venv-2.6.2/opt/imunify360/venv/lib/python3.11/site-packages/docutils/utils/math/tex2mathml_extern.pyr r s € õ
Ôð ð ð õ *œÝ *¤Ý *¤Ø#'ð )ñ )ô )€Að „G‡M‚MÕ$ yÑ0×8Ò8¸ÑAÔAÑBÔBÐBØ„G‡M‚MO„O€OØ”8—=’=‘?”?€LØ”(—-’-‘/”/×(Ò(¨Ñ1Ô1€KØð $[×%Ò% gÑ.Ô.°!Ò3Ð3¸<Ð3ØŠ{Ñ#Ô#Ð#å
Ô
ð !ð !ð !õ %/¤OÝ%/¤_Ý%/¤_Ø(,ð
.ñ
.ô
.€Fð „L×Ò|Ñ$Ô$Ð$Ø
„L×ÒÑÔÐØ
Œ]×
Ò
Ñ
!Ô
!×
(Ò
(¨Ñ
1Ô
1€FØ” ×#Ò#Ñ%Ô%×,Ò,¨WÑ5Ô5€JØð #Z—_’_ WÑ-Ô-°Ò2Ð2¸&Ð2ØŠzÑ"Ô"Ð"ð —’˜WÑ%Ô% v§{¢{°9Ñ'=Ô'=¸aÑ'?ˆ3€EØ
E˜#IÔ
€FؘVÐ#Ð#ݘ&Ñ!Ô!Ð!Ø €Mó c ó$ — t j g d¢t j t j t j d¬¦ « }|j t
| z d¦ « ¦ « |j ¦ « |j ¦ « }|j
¦ « d¦ « }| d¦ « dk rCd
d„ | ¦ « D ¦ « ¦ « }t d |z ¦ « ‚|r| d
¦ « dk s|s| |¦ « | d ¦ « | d ¦ « d
z }}|||… S )zgConvert LaTeX math code to MathML with TtM_
.. _TtM: http://hutchinson.belmont.ma.us/tth/mml/
)Úttmz-uz-rTr r z **** Unknownr ú
c 3 óD K — | ]}| d ¦ « ¯|V — Œ dS )z****N)Ú
startswith)Ú.0Úlines r' ú zttm.._ sF è è € ð 4ð 4 Ø Ÿ?š?¨6Ñ2Ô2ð4˜ð 4ð 4ð 4ð 4ð 4ð 4r( z&
Message from external converter TtM:
ú
**** Errorr r r )r r r r r r r r r r r r r ÚjoinÚ
splitlinesr r )r r r r# ÚerrÚmsgr% r& s r' r* r* L sp € õ
Ôð ð ð õ
*œÝ *¤Ý *¤Ø#'ð )ñ )ô )€Að „G‡M‚MÕ$ yÑ0×8Ò8¸ÑAÔAÑBÔBÐBØ„G‡M‚MO„O€OØ
ŒX]Š]‰_Œ_€FØ
Œ(-Š-‰/Œ/×
Ò
Ñ
)Ô
)€CØ
‡x‚xÑ Ô 1Ò$Ð$ØiŠið 4ð 4¨¯ ª Ñ)9Ô)9ð 4ñ 4ô 4ñ 4ô 4ˆåÐDÀSÑHÑIÔIÐIØð C—H’H˜\Ñ*Ô*¨aÒ/Ð/°vÐ/ØŠsÑÔÐØ—’˜WÑ%Ô% v§{¢{°9Ñ'=Ô'=¸aÑ'?ˆ3€EØ %˜)Ô Ð r( Tc ó” — g d¢}|rd}nd}| d¦ « t j dg|z t j t j t j d¬¦ « }|j | d¦ « ¦ « |j ¦ « |j ¦ «
d¦ « }|j ¦ «
d¦ « }| d ¦ « d
k rE|| d ¦ « d z | d
¦ « … }t d|z ¦ « ‚|r0| d¦ « d
k s|s| |¦ « | d¦ « d z | d¦ « }
} d|›d|| |
… ›d}|S )zlConvert LaTeX math code to MathML with blahtexml_
.. _blahtexml: http://gva.noekeon.org/blahtexml/
)
ú--mathmlz
--indentedz --spacingÚmoderatez--mathml-encodingÚrawz--other-encodingr9 z--doctype-xhtml+mathmlz--annotate-TeXÚ z display="block"z
--displaymathÚ blahtexmlTr r zr z é z
z.
Message from external converter blahtexml:
%sr1 zz z0
)Úappendr r r r r r r r r r r r r r ) r Úinliner ÚoptionsÚ mathmode_argr r# r4 r5 r% r& s r' r; r; h s¼ € ð
ð ð €Gð ð (؈ ˆ à)ˆ ØŠÑ'Ô'Ð'åÔ˜+˜ wÑ.Ý )œÝ *¤Ý *¤Ø#'ð )ñ )ô )€Að
„G‡M‚M)×"Ò" 7Ñ+Ô+Ñ,Ô,Ð,Ø„G‡M‚MO„O€OØ
ŒX]Š]‰_Œ_×
#Ò
# GÑ
,Ô
,€FØ
Œ(-Š-‰/Œ/×
Ò
Ñ
)Ô
)€Cà
‡{‚{9Ñ Ô Ò"Ð"ØV—[’[ Ñ-Ô-¨aÑ/°· ² ¸LÑ0IÔ0IÐIÔJˆÝÐLØ ñ ñ !ô !ð !àð S—X’X˜lÑ+Ô+¨qÒ0Ð0¸Ð0ØŠsÑÔÐØ—’˜ZÑ(Ô(¨Ñ*¨F¯KªK¸ Ñ,DÔ,Dˆ3€E€Eà , ¨f°U¸3°YÔ.?Ð.?Ð.?ðA€Fà €Mr( c óð — t j g d¢t j t j t j d¬¦ « }|j | d¦ « ¦ « |j ¦ « |j ¦ « d¦ « }|j
¦ « d¦ « ¦ « }| ¦ « }|r)|r|
|¦ « t d|z ¦ « ‚|dk rt d|z ¦ « ‚| d¦ « | d ¦ « d
z }}|||… S ) zXConvert LaTeX math code to MathML with pandoc_
.. _pandoc: https://pandoc.org/
)Úpandocr7 z --from=latexTr r z1
Error message from external converter pandoc:
%sr z.
Error code from external converter pandoc:
%sr r r )r r r r r r r r r r r ÚstripÚwaitr r r )r r r r# r4 Úxr% r& s r' rB rB ‘ s` € õ
Ôð ð ð õ *œÝ *¤Ý *¤Ø#'ð )ñ )ô )€Að „G‡M‚M)×"Ò" 7Ñ+Ô+Ñ,Ô,Ð,Ø„G‡M‚MO„O€OØ
ŒX]Š]‰_Œ_×
#Ò
# GÑ
,Ô
,€FØ
Œ(-Š-‰/Œ/×
Ò
Ñ
)Ô
)×
/Ò
/Ñ
1Ô
1€CØ Š‰Œ€Aà
ð !Ø ð Ø NŠN˜3Ñ Ô Ð ÝÐOØ ñ ñ !ô !ð !àˆA‚v€vÝÐLØ ñ ñ ô ð ð —’˜WÑ%Ô% v§{¢{°9Ñ'=Ô'=¸aÑ'?ˆ3€EØ %˜)Ô Ð r( Ú__main__uR \frac{\partial \sin^2(\alpha)}{\partial \vec r}\varpi \mathbb{R} \, \text{Grüße})N)TN)
Ú__doc__r r r r* r; rB Ú__name__ÚexampleÚprint© r( r' úrL s¶ ððð ð Ð Ð Ð ðÐ ð-ð -ð -ð -ð` ð ð ð ð8&ð &ð &ð &ðR ð ð ð ðD ˆzÒÐð9€Gð
€Eˆ)ˆ)GÑ
Ô
Ñ Ô Ð Ð Ð ð Ðr( PK ! ¤â¶žt t ' __pycache__/unichar2tex.cpython-311.pycnu „[µü¤ §
¥ ÞiÙG ã ó¶ — i d d“dd“dd“dd“dd “d
d “d d
“dd“dd“dd“dd“dd“dd“dd“d d “d d “d d!“i d"d#“d$d%“d&d'“d(d)“d*d+“d,d-“d.d/“d0d1“d2d3“d4d5“d6d7“d8d9“d:d;“dd?“d@dA“dBdC“¥i dDdE“dFdG“dHdI“dJdK“dLdM“dNdO“dPdQ“dRdS“dTdU“dVdW“dXdY“dZd[“d\d]“d^d_“d`da“dbdc“ddde“¥i dfdg“dhdi“djdk“dldm“dndo“dpdo“dqdr“dsdt“dudv“dwdx“dydz“d{d|“d}d~“dd€“dd‚“dƒd„“d…d†“¥i d‡dˆ“d‰dŠ“d‹dŒ“ddŽ“dd“d‘d’“d“d”“d•d–“d—d˜“d™dš“d›dœ“ddž“dŸd “d¡d¢“d£d¤“d¥d¦“d§d¨“¥i d©dª“d«d¬“dd®“d¯d°“d±d²“d³d´“dµd¶“d·d¸“d¹dº“d»d¼“d½d¾“d¿dÀ“dÁd“dÃdÄ“dÅdÆ“dÇdÈ“dÉdÊ“¥i dËdÌ“dÍdΓdÏdГdÑdÒ“dÓdÔ“dÕdÖ“d×dØ“dÙdÚ“dÛdÜ“dÝdÞ“dßdà“dádâ“dãdä“dådæ“dçdè“dédê“dëdì“¥i dídî“dïdð“dñdò“dódô“dõdö“d÷dø“dùdú“dûdü“dýdþ“dÿd “dd“dd“dd“dd“d d
“d d “d
d“¥i dd“dd“dd“dd“dd“dd“dd “d d “d d “d!d"“d#d$“d%d&“d'd(“d)d*“d+d,“d-d.“d/d0“¥i d1d2“d3d4“d5d6“d7d8“d9d:“d;d<“d=d>“d?d@“dAdB“dCdD“dEdF“dGdH“dIdJ“dKdL“dMdN“dOdP“dQdR“¥i dSdT“dUdV“dWdX“dYdZ“d[dz“d\d]“d^d_“d`da“dbdc“ddde“dfdg“dhdi“djdk“dldm“dndo“dpdq“drds“¥i dtdu“dvdw“dxdy“dzd{“d|d}“d~d“d€d“d‚dƒ“d„d…“d†d‡“dˆd‰“dŠd‹“dŒd“dŽd“dd‘“d’d““d”d•“¥i d–d—“d˜d™“dšd›“dœd“dždŸ“d d¡“d¢d£“d¤d¥“d¦d§“d¨d©“dªd«“d¬d“d®d¯“d°d±“d²d³“d´dµ“d¶d·“¥i d¸d¹“dºd»“d¼d½“d¾d¿“dÀdÁ“dÂdÓdÄdÅ“dÆdÇ“dÈdÉ“dÊdË“dÌdÍ“dÎdÏ“dÐdÑ“dÒdÓ“dÔdÕ“dÖdדdØdÙ“¥i dÚdÛ“dÜdÝ“dÞdß“dàdá“dâdã“dädå“dædç“dèdé“dêdë“dìdí“dîdï“dðdñ“dòdó“dôdõ“död÷“dødù“dúdû“¥i düdý“dþdÿ“d d“dd“dd“dd“dd “d
d “d d
“dd“dd“dd“dd“dd“dd“dd“d d “¥i d d “d d!“d"d#“d$d%“d&d'“d(d)“d*d+“d,d-“d.d/“d0d1“d2d3“d4d5“d6d7“d8d9“d:d;“d<d=“d>d?“¥i d@dA“dBdC“dDdE“dFdG“dHdI“dJdK“dLdM“dNdO“dPdQ“dRdS“dTdU“dVdW“dXdY“dZd[“d\d]“d^d_“d`da“¥i dbdc“ddde“dfdg“dhdi“djdk“dldm“dndo“dpdq“drds“dtdu“dvdw“dxdy“dzd{“d|d}“d~d“d€d“d‚dƒ“¥i d„d…“d†d‡“dˆd‰“dŠd‹“dŒd“dŽd“dd‘“d’d““d”d•“d–d—“d˜d™“dšd›“dœd“dždŸ“d d¡“d¢d£“d¤d¥“¥i d¦d§“d¨d©“dªd«“d¬d“d®d¯“d°d±“d²d³“d´dµ“d¶d·“d¸d¹“dºd»“d¼d½“d¾d¿“dÀdÁ“dÂdÓdÄdÅ“dÆdÇ“¥i dÈdÉ“dÊdË“dÌdÍ“dÎdÏ“dÐdÑ“dÒdÓ“dÔdÕ“dÖdדdØdÙ“dÚdÛ“dÜdÝ“dÞdß“dàdá“dâdã“dädå“dædç“dèdé“¥i dêdë“dìdí“dîdï“dðdñ“dòdó“dôdõ“död÷“dødù“dúdû“düdý“dþdÿ“d d“dd“dd“dd“dd “d
d “¥i d d
“dd“dd“dd“dd“dd“dd“dd“d d “d d “d d!“d"d#“d$d%“d&d'“d(d)“d*d+“d,d-“¥i d.d/“d0d1“d2d3“d4d5“d6d7“d8d9“d:d;“d<d=“d>d?“d@dA“dBdC“dDdE“dFdG“dHdI“dJdK“dLdM“dNdO“¥i dPdQ“dRdS“dTdU“dVdW“dXdY“dZd[“d\d]“d^d_“d`da“dbdc“ddde“dfdg“dhdi“djdk“dldm“dndo“dpdq“¥i drds“dtdu“dvdw“dxdy“dzd{“d|d}“d~d“d€d“d‚dƒ“d„d…“d†d‡“dˆd‰“dŠd‹“dŒd“dŽd“dd‘“d’d““¥i d”d•“d–d—“d˜d™“dšd›“dœd“dždŸ“d d¡“d¢d£“d¤d¥“d¦d§“d¨d©“dªd«“d¬d“d®d¯“d°d±“d²d³“d´dµ“¥i d¶d·“d¸d¹“dºd»“d¼d½“d¾d¿“dÀdÁ“dÂdÓdÄdÅ“dÆdÇ“dÈdÉ“dÊdË“dÌdÍ“dÎdÏ“dÐdÑ“dÒdÓ“dÔdÕ“dÖdד¥i dØdÙ“dÚdÛ“dÜdÝ“dÞdß“dàdá“dâdã“dädå“dædç“dèdé“dêdë“dìdí“dîdï“dðdñ“dòdó“dôdõ“död÷“dødù“¥i dúdû“düdý“dþdÿ“d d“dd“dd“dd“dd “d
d “d d
“dd“dd“dd“dd“dd“dd“dd“¥i d d “d d “d d!“d"d#“d$d%“d&d'“d(d)“d*d+“d,d-“d.d/“d0d1“d2d3“d4d5“d6d7“d8d9“d:d;“d<d=“¥i d>d?“d@dA“dBdC“dDdE“dFdG“dHdI“dJdK“dLdM“dNdO“dPdQ“dRdS“dTdU“dVdW“dXdY“dZd[“d\d]“d^d_“¥i d`da“dbdc“ddde“dfdg“dhdi“djdk“dldm“dndo“dpdq“drds“dtdu“dvdw“dxdy“dzd{“d|d}“d~d“d€d“¥i d‚dƒ“d„d…“d†d‡“dˆd‰“dŠd‹“dŒd“dŽd“dd‘“d’d““d”d•“d–d—“d˜d™“dšd›“dœd“dždŸ“d d¡“d¢d£“¥i d¤d¥“d¦d§“d¨d©“dªd«“d¬d“d®d¯“d°d±“d²d³“d´dµ“d¶d·“d¸d¹“dºd»“d¼d½“d¾d¿“dÀdÁ“dÂdÓdÄdÅ“¥i dÆdÇ“dÈdÉ“dÊdË“dÌdÍ“dÎdÏ“dÐdÑ“dÒdÓ“dÔdÕ“dÖdדdØdÙ“dÚdÛ“dÜdÝ“dÞdß“dàdá“dâdã“dädå“dædç“¥i dèdé“dêdë“dìdí“dîdï“dðdñ“dòdó“dôdõ“död÷“dødù“dúdû“düdý“dþdÿ“d d“dd“dd“dd“dd “¥i d
d “d d
“dd“dd“dd“dd“dd“dd“dd“d d “d d “d d!“d"d#“d$d%“d&d'“d(d)“d*d+“¥i d,d-“d.d/“d0d1“d2d3“d4d5“d6d7“d8d9“d:d;“d<d=“d>d?“d@dA“dBdC“dDdE“dFdG“dHdI“dJdK“dLdM“¥i dNdO“dPdQ“dRdS“dTdU“dVdW“dXdY“dZd[“d\d]“d^d_“d`da“dbdc“ddde“dfdg“dhdi“djdk“dldm“dndo“¥i dpdq“drds“dtdu“dvdw“dxdy“dzd{“d|d}“d~d“d€d“d‚dƒ“d„d…“d†d‡“dˆd‰“dŠd‹“dŒd“dŽd“dd‘“¥i d’d“d“d“d”d•“d–d—“d˜d™“dšd›“dœd“dždŸ“d d¡“d¢d£“d¤d¥“d¦d§“d¨d©“dªd«“d¬d“d®d¯“d°d±“¥i d²d³“d´dµ“d¶d·“d¸d¹“dºd»“d¼d½“d¾d¿“dÀd/“dÁd1“dÂd3“dÃd5“dÄd7“dÅd9“dÆd;“dÇd=“dÈd?“dÉdA“¥i dÊdC“dËdE“dÌdG“dÍdI“dÎdK“dÏdM“dÐdO“dÑdQ“dÒdS“dÓdU“dÔdW“dÕdY“dÖd[“d×d]“dØd8“dÙdk“dÚd_“¥i dÛdg“dÜda“dÝdi“dÞdc“dßdà“dádâ“dãdä“dådæ“dçdè“dédê“dëdì“dídî“dïdð“dñdò“dódô“dõdö“d÷dø“¥i dùdú“dûdü“dýdþ“dÿd “dd“dd“dd“dd“d d
“d d “d
d“dd“dd“dd“dd“dd“dd“¥Z dS ( é ú~é£ z\pounds é¥ z\yen é§ z\S é¬ z\neg é± z\pm é¶ z\P é× z\times éð z\eth é÷ z\div i1 z\imath i7 z\jmath i“ z\Gamma i” z\Delta i˜ z\Theta i› z\Lambda iž z\Xi i z\Pi i£ z\Sigma i¥ z \Upsilon i¦ z\Phi i¨ z\Psi i© z\Omega i± z\alpha i² z\beta i³ z\gamma i´ z\delta iµ z \varepsilon i¶ z\zeta i· z\eta i¸ z\theta i¹ z\iota iº z\kappa i» z\lambda i¼ z\mu i½ z\nu i¾ z\xi iÀ z\pi iÁ z\rho i z
\varsigma ià z\sigma iÄ z\tau iÅ z \upsilon iÆ z\varphi iÇ z\chi iÈ z\psi iÉ z\omega iÑ z
\vartheta iÕ z\phi iÖ z\varpi iÝ z \digamma ið z
\varkappa iñ z\varrho iõ z \epsilon iö z
\backepsilon i z\quad i i z\, i z\| i z\dagger i! z \ddagger i" z\bullet i& z\ldots i2 z\prime i5 z \backprime i_ z\: i! z
\mathbb{C}i ! z \mathcal{H}i ! z \mathfrak{H}i
! z
\mathbb{H}i! z\hslash i! z \mathcal{I}i! z\Im i! z \mathcal{L}i! z\ell i! z
\mathbb{N}i! z\wp i! z
\mathbb{P}i! z
\mathbb{Q}i! z \mathcal{R}i ! z\Re i ! z
\mathbb{R}i$! z
\mathbb{Z}i'! z\mho i(! z \mathfrak{Z}i,! z \mathcal{B}i-! z \mathfrak{C}i0! z \mathcal{E}i1! z \mathcal{F}i2! z\Finv i3! z \mathcal{M}i5! z\aleph i6! z\beth i7! z\gimel i8! z\daleth i! z \leftarrow i‘! z \uparrow i’! z \rightarrow i“! z \downarrow i”! z\leftrightarrow i•! z
\updownarrow i–! z \nwarrow i—! z \nearrow i˜! z \searrow i™! z \swarrow iš! z \nleftarrow i›! z
\nrightarrow iž! z\twoheadleftarrow i ! z\twoheadrightarrow i¢! z\leftarrowtail i£! z\rightarrowtail i¦! z\mapsto i©! z\hookleftarrow iª! z\hookrightarrow i«! z\looparrowleft i¬! z\looparrowright i! z\leftrightsquigarrow i®! z\nleftrightarrow i°! z\Lsh i±! z\Rsh i¶! z\curvearrowleft i·! z\curvearrowright iº! z\circlearrowleft i»! z\circlearrowright i¼! z\leftharpoonup i½! z\leftharpoondown i¾! z\upharpoonright i¿! z\upharpoonleft iÀ! z\rightharpoonup iÁ! z\rightharpoondown iÂ! z\downharpoonright iÃ! z\downharpoonleft iÄ! z\rightleftarrows iÆ! z\leftrightarrows iÇ! z\leftleftarrows iÈ! z \upuparrows iÉ! z\rightrightarrows iÊ! z\downdownarrows iË! z\leftrightharpoons iÌ! z\rightleftharpoons iÍ! z \nLeftarrow iÎ! z\nLeftrightarrow iÏ! z
\nRightarrow iÐ! z \Leftarrow iÑ! z \Uparrow iÒ! z \Rightarrow iÓ! z \Downarrow iÔ! z\Leftrightarrow iÕ! z
\Updownarrow iÚ! z \Lleftarrow iÛ! z
\Rrightarrow iÝ! z\rightsquigarrow ià! z\dashleftarrow iâ! z\dashrightarrow i " z\forall i" z \complement i" z \partial i" z\exists i" z \nexists i" z
\emptyset i" z\nabla i" z\in i " z\notin i " z\ni i" z\prod i" z\coprod i" z\sum i" ú-i" z\mp i" z \dotplus i" z\slash i" z\smallsetminus i" z\ast i" z\circ i" i" z\surd i" z \sqrt[3] i " z \sqrt[4] i " z\propto i " z\infty i " z\angle i!" z\measuredangle i"" z\sphericalangle i#" z\mid i$" z\nmid i%" z
\parallel i&" z \nparallel i'" z\wedge i(" z\vee i)" z\cap i*" z\cup i+" z\int i," z\iint i-" z\iiint i." z\oint i4" z \therefore i5" z \because i6" ú:i<" z\sim i=" z \backsim i@" z\wr iA" z\nsim iB" z\eqsim iC" z\simeq iE" z\cong iG" z\ncong iH" z\approx iJ" z
\approxeq iM" z\asymp iN" z\Bumpeq iO" z\bumpeq iP" z\doteq iQ" z\Doteq iR" z\fallingdotseq iS" z\risingdotseq iV" z\eqcirc iW" z\circeq i\" z \triangleq i`" z\neq ia" z\equiv id" z\leq ie" z\geq if" z\leqq ig" z\geqq ih" z\lneqq ii" z\gneqq ij" z\ll ik" z\gg il" z \between in" z\nless io" z\ngtr ip" z\nleq iq" z\ngeq ir" z \lesssim is" z\gtrsim iv" z \lessgtr iw" z \gtrless iz" z\prec i{" z\succ i|" z
\preccurlyeq i}" z
\succcurlyeq i~" z \precsim i" z \succsim i€" z\nprec i" z\nsucc i‚" z\subset iƒ" z\supset i†" z
\subseteq i‡" z
\supseteq iˆ" z \nsubseteq i‰" z \nsupseteq iŠ" z \subsetneq i‹" z \supsetneq iŽ" z\uplus i" z
\sqsubset i" z
\sqsupset i‘" z \sqsubseteq i’" z \sqsupseteq i“" z\sqcap i”" z\sqcup i•" z\oplus i–" z\ominus i—" z\otimes i˜" z\oslash i™" z\odot iš" z
\circledcirc i›" z \circledast i" z
\circleddash iž" z \boxplus iŸ" z
\boxminus i " z
\boxtimes i¡" z\boxdot i¢" z\vdash i£" z\dashv i¤" z\top i¥" z\bot i§" z\models i¨" z\vDash i©" z\Vdash iª" z\Vvdash i¬" z\nvdash i" z\nvDash i®" z\nVdash i¯" z\nVDash i²" z\vartriangleleft i³" z\vartriangleright i´" z\trianglelefteq iµ" z\trianglerighteq i¸" z
\multimap iº" z
\intercal i»" z\veebar i¼" z
\barwedge iÀ" z
\bigwedge iÁ" z\bigvee iÂ" z\bigcap iÃ" z\bigcup iÄ" z \diamond iÅ" z\cdot iÆ" z\star iÇ" z\divideontimes iÈ" z\bowtie iÉ" z\ltimes iÊ" z\rtimes iË" z\leftthreetimes iÌ" z\rightthreetimes iÍ" z \backsimeq iÎ" z
\curlyvee iÏ" z \curlywedge iÐ" z\Subset iÑ" z\Supset iÒ" z\Cap iÓ" z\Cup iÔ" z \pitchfork iÖ" z \lessdot i×" z\gtrdot iØ" z\lll iÙ" z\ggg iÚ" z \lesseqgtr iÛ" z \gtreqless iÞ" z
\curlyeqprec iß" z
\curlyeqsucc ià" z \npreceq iá" z \nsucceq iæ" z\lnsim iç" z\gnsim iè" z
\precnsim ié" z
\succnsim iê" z\ntriangleleft ië" z\ntriangleright iì" z\ntrianglelefteq ií" z\ntrianglerighteq iî" z\vdots iï" z\cdots iñ" z\ddots i# z\lceil i # z\rceil i
# z\lfloor i # z\rfloor i # z
\ulcorner i # z
\urcorner i # z
\llcorner i # z
\lrcorner i"# z\frown i## z\smile iª# z \bracevert i°# z \lmoustache i±# z \rmoustache iÐ# z \arrowvert iÞ# z \overbrace iß# z \underbrace iÇ$ z
\circledR iÈ$ z
\circledS i²% z\blacktriangle i³% z\bigtriangleup i·% z\triangleright i¼% z\blacktriangledown i½% z\bigtriangledown iÁ% z\triangleleft iÇ% z \Diamond iÊ% z \lozenge iï% z \bigcirc iû% z\square iü% z
\blacksquare i& z \bigstar i`& z \spadesuit ia& z \heartsuit ib& z
\diamondsuit ic& z
\clubsuit im& z\flat in& z \natural io& z\sharp i' z \checkmark i ' z \maltese iÂ' z\perp iË' z\diagup iÍ' z
\diagdown iè' z\langle ié' z\rangle iî' z\lgroup iï' z\rgroup iõ' z\longleftarrow iö' z\longrightarrow i÷' z\longleftrightarrow iø' z\Longleftarrow iù' z\Longrightarrow iú' z\Longleftrightarrow iü' z \longmapsto ië) z\blacklozenge iõ) z
\setminus i * z \bigodot i* z
\bigoplus i* z \bigotimes i* z
\biguplus i* z
\bigsqcup i * z\iiiint i?* z\amalg i^* z\doublebarwedge i}* z
\leqslant i~* z
\geqslant i…* z \lessapprox i†* z \gtrapprox i‡* z\lneq iˆ* z\gneq i‰* z
\lnapprox iŠ* z
\gnapprox i‹* z \lesseqqgtr iŒ* z \gtreqqless i•* z
\eqslantless i–* z \eqslantgtr i¯* z\preceq i°* z\succeq iµ* z
\precneqq i¶* z
\succneqq i·* z \precapprox i¸* z \succapprox i¹* z
\precnapprox iº* z
\succnapprox iÅ* z \subseteqq iÆ* z \supseteqq iË* z \subsetneqq iÌ* z \supsetneqq i + z\Box i Ô z
\mathbf{A}iÔ z
\mathbf{B}iÔ z
\mathbf{C}iÔ z
\mathbf{D}iÔ z
\mathbf{E}iÔ z
\mathbf{F}iÔ z
\mathbf{G}iÔ z
\mathbf{H}iÔ z
\mathbf{I}i Ô z
\mathbf{J}i
Ô z
\mathbf{K}i Ô z
\mathbf{L}i Ô z
\mathbf{M}i
Ô z
\mathbf{N}iÔ z
\mathbf{O}iÔ z
\mathbf{P}iÔ z
\mathbf{Q}iÔ z
\mathbf{R}iÔ z
\mathbf{S}iÔ z
\mathbf{T}iÔ z
\mathbf{U}iÔ z
\mathbf{V}iÔ z
\mathbf{W}iÔ z
\mathbf{X}iÔ z
\mathbf{Y}iÔ z
\mathbf{Z}iÔ z
\mathbf{a}iÔ z
\mathbf{b}i Ô z
\mathbf{c}i Ô z
\mathbf{d}i Ô z
\mathbf{e}i Ô z
\mathbf{f}i Ô z
\mathbf{g}i!Ô z
\mathbf{h}i"Ô z
\mathbf{i}i#Ô z
\mathbf{j}i$Ô z
\mathbf{k}i%Ô z
\mathbf{l}i&Ô z
\mathbf{m}i'Ô z
\mathbf{n}i(Ô z
\mathbf{o}i)Ô z
\mathbf{p}i*Ô z
\mathbf{q}i+Ô z
\mathbf{r}i,Ô z
\mathbf{s}i-Ô z
\mathbf{t}i.Ô z
\mathbf{u}i/Ô z
\mathbf{v}i0Ô z
\mathbf{w}i1Ô z
\mathbf{x}i2Ô z
\mathbf{y}i3Ô z
\mathbf{z}i4Ô ÚAi5Ô ÚBi6Ô ÚCi7Ô ÚDi8Ô ÚEi9Ô ÚFi:Ô ÚGi;Ô ÚHi<Ô ÚIi=Ô ÚJi>Ô ÚKi?Ô ÚLi@Ô ÚMiAÔ ÚNiBÔ ÚOiCÔ ÚPiDÔ ÚQiEÔ ÚRiFÔ ÚSiGÔ ÚTiHÔ ÚUiIÔ ÚViJÔ ÚWiKÔ ÚXiLÔ ÚYiMÔ ÚZiNÔ ÚaiOÔ ÚbiPÔ ÚciQÔ ÚdiRÔ ÚeiSÔ ÚfiTÔ ÚgiVÔ ÚiiWÔ ÚjiXÔ ÚkiYÔ ÚliZÔ Úmi[Ô Úni\Ô Úoi]Ô Úpi^Ô Úqi_Ô Úri`Ô ÚsiaÔ ÚtibÔ ÚuicÔ ÚvidÔ ÚwieÔ ÚxifÔ ÚyigÔ ÚziœÔ z \mathcal{A}ižÔ z \mathcal{C}iŸÔ z \mathcal{D}i¢Ô z \mathcal{G}i¥Ô z \mathcal{J}i¦Ô z \mathcal{K}i©Ô z \mathcal{N}iªÔ z \mathcal{O}i«Ô z \mathcal{P}i¬Ô z \mathcal{Q}i®Ô z \mathcal{S}i¯Ô z \mathcal{T}i°Ô z \mathcal{U}i±Ô z \mathcal{V}i²Ô z \mathcal{W}i³Ô z \mathcal{X}i´Ô z \mathcal{Y}iµÔ z \mathcal{Z}iÕ z \mathfrak{A}iÕ z \mathfrak{B}iÕ z \mathfrak{D}iÕ z \mathfrak{E}i Õ z \mathfrak{F}i
Õ z \mathfrak{G}i
Õ z \mathfrak{J}iÕ z \mathfrak{K}iÕ z \mathfrak{L}iÕ z \mathfrak{M}iÕ z \mathfrak{N}iÕ z \mathfrak{O}iÕ z \mathfrak{P}iÕ z \mathfrak{Q}iÕ z \mathfrak{S}iÕ z \mathfrak{T}iÕ z \mathfrak{U}iÕ z \mathfrak{V}iÕ z \mathfrak{W}iÕ z \mathfrak{X}i Õ z \mathfrak{Y}i Õ z \mathfrak{a}i Õ z \mathfrak{b}i Õ z \mathfrak{c}i!Õ z \mathfrak{d}i"Õ z \mathfrak{e}i#Õ z \mathfrak{f}i$Õ z \mathfrak{g}i%Õ z \mathfrak{h}i&Õ z \mathfrak{i}i'Õ z \mathfrak{j}i(Õ z \mathfrak{k}i)Õ z \mathfrak{l}i*Õ z \mathfrak{m}i+Õ z \mathfrak{n}i,Õ z \mathfrak{o}i-Õ z \mathfrak{p}i.Õ z \mathfrak{q}i/Õ z \mathfrak{r}i0Õ z \mathfrak{s}i1Õ z \mathfrak{t}i2Õ z \mathfrak{u}i3Õ z \mathfrak{v}i4Õ z \mathfrak{w}i5Õ z \mathfrak{x}i6Õ z \mathfrak{y}i7Õ z \mathfrak{z}i8Õ z
\mathbb{A}i9Õ z
\mathbb{B}i;Õ z
\mathbb{D}i<Õ z
\mathbb{E}i=Õ z
\mathbb{F}i>Õ z
\mathbb{G}i@Õ z
\mathbb{I}iAÕ z
\mathbb{J}iBÕ z
\mathbb{K}iCÕ z
\mathbb{L}iDÕ z
\mathbb{M}iFÕ z
\mathbb{O}iJÕ z
\mathbb{S}iKÕ z
\mathbb{T}iLÕ z
\mathbb{U}iMÕ z
\mathbb{V}iNÕ z
\mathbb{W}iOÕ z
\mathbb{X}iPÕ z
\mathbb{Y}i\Õ z\Bbbk i Õ z
\mathsf{A}i¡Õ z
\mathsf{B}i¢Õ z
\mathsf{C}i£Õ z
\mathsf{D}i¤Õ z
\mathsf{E}i¥Õ z
\mathsf{F}i¦Õ z
\mathsf{G}i§Õ z
\mathsf{H}i¨Õ z
\mathsf{I}i©Õ z
\mathsf{J}iªÕ z
\mathsf{K}i«Õ z
\mathsf{L}i¬Õ z
\mathsf{M}iÕ z
\mathsf{N}i®Õ z
\mathsf{O}i¯Õ z
\mathsf{P}i°Õ z
\mathsf{Q}i±Õ z
\mathsf{R}i²Õ z
\mathsf{S}i³Õ z
\mathsf{T}i´Õ z
\mathsf{U}iµÕ z
\mathsf{V}i¶Õ z
\mathsf{W}i·Õ z
\mathsf{X}i¸Õ z
\mathsf{Y}i¹Õ z
\mathsf{Z}iºÕ z
\mathsf{a}i»Õ z
\mathsf{b}i¼Õ z
\mathsf{c}i½Õ z
\mathsf{d}i¾Õ z
\mathsf{e}i¿Õ z
\mathsf{f}iÀÕ z
\mathsf{g}iÁÕ z
\mathsf{h}iÂÕ z
\mathsf{i}iÃÕ z
\mathsf{j}iÄÕ z
\mathsf{k}iÅÕ z
\mathsf{l}iÆÕ z
\mathsf{m}iÇÕ z
\mathsf{n}iÈÕ z
\mathsf{o}iÉÕ z
\mathsf{p}iÊÕ z
\mathsf{q}iËÕ z
\mathsf{r}iÌÕ z
\mathsf{s}iÍÕ z
\mathsf{t}iÎÕ z
\mathsf{u}iÏÕ z
\mathsf{v}iÐÕ z
\mathsf{w}iÑÕ z
\mathsf{x}iÒÕ z
\mathsf{y}iÓÕ z
\mathsf{z}ipÖ z
\mathtt{A}iqÖ z
\mathtt{B}irÖ z
\mathtt{C}isÖ z
\mathtt{D}itÖ z
\mathtt{E}iuÖ z
\mathtt{F}ivÖ z
\mathtt{G}iwÖ z
\mathtt{H}ixÖ z
\mathtt{I}iyÖ z
\mathtt{J}izÖ z
\mathtt{K}i{Ö z
\mathtt{L}i|Ö z
\mathtt{M}i}Ö z
\mathtt{N}i~Ö z
\mathtt{O}iÖ z
\mathtt{P}i€Ö z
\mathtt{Q}iÖ z
\mathtt{R}i‚Ö z
\mathtt{S}iƒÖ z
\mathtt{T}i„Ö z
\mathtt{U}i…Ö z
\mathtt{V}i†Ö z
\mathtt{W}i‡Ö z
\mathtt{X}iˆÖ z
\mathtt{Y}i‰Ö z
\mathtt{Z}iŠÖ z
\mathtt{a}i‹Ö z
\mathtt{b}i΅ z
\mathtt{c}iÖ z
\mathtt{d}iŽÖ z
\mathtt{e}iÖ z
\mathtt{f}iÖ z
\mathtt{g}i‘Ö z
\mathtt{h}i’Ö z
\mathtt{i}i“Ö z
\mathtt{j}i”Ö z
\mathtt{k}i•Ö z
\mathtt{l}i–Ö z
\mathtt{m}i—Ö z
\mathtt{n}i˜Ö z
\mathtt{o}i™Ö z
\mathtt{p}išÖ z
\mathtt{q}i›Ö z
\mathtt{r}iυ z
\mathtt{s}iÖ z
\mathtt{t}ižÖ z
\mathtt{u}iŸÖ z
\mathtt{v}i Ö z
\mathtt{w}i¡Ö z
\mathtt{x}i¢Ö z
\mathtt{y}i£Ö z
\mathtt{z}i¤Ö i¥Ö iªÖ z\mathbf{\Gamma}i«Ö z\mathbf{\Delta}i¯Ö z\mathbf{\Theta}i²Ö z\mathbf{\Lambda}iµÖ z \mathbf{\Xi}i·Ö z \mathbf{\Pi}iºÖ z\mathbf{\Sigma}i¼Ö z\mathbf{\Upsilon}i½Ö z
\mathbf{\Phi}i¿Ö z
\mathbf{\Psi}iÀÖ z\mathbf{\Omega}iäÖ z\mathit{\Gamma}iåÖ z\mathit{\Delta}iéÖ z\mathit{\Theta}iìÖ z\mathit{\Lambda}iïÖ z \mathit{\Xi}iñÖ z \mathit{\Pi}iôÖ z\mathit{\Sigma}iöÖ z\mathit{\Upsilon}i÷Ö z
\mathit{\Phi}iùÖ z
\mathit{\Psi}iúÖ z\mathit{\Omega}iüÖ iýÖ iþÖ iÿÖ i × i× i× i× i× i× i× i× i× i × i × i × i
× i× i× i× i× i× i× i× i× i× i× i× i× i× i× iÎ× z
\mathbf{0}iÏ× z
\mathbf{1}iÐ× z
\mathbf{2}iÑ× z
\mathbf{3}iÒ× z
\mathbf{4}iÓ× z
\mathbf{5}iÔ× z
\mathbf{6}iÕ× z
\mathbf{7}iÖ× z
\mathbf{8}i×× z
\mathbf{9}iâ× z
\mathsf{0}iã× z
\mathsf{1}iä× z
\mathsf{2}iå× z
\mathsf{3}iæ× z
\mathsf{4}iç× z
\mathsf{5}iè× z
\mathsf{6}ié× z
\mathsf{7}iê× z
\mathsf{8}ië× z
\mathsf{9}iö× z
\mathtt{0}i÷× z
\mathtt{1}iø× z
\mathtt{2}iù× z
\mathtt{3}iú× z
\mathtt{4}iû× z
\mathtt{5}iü× z
\mathtt{6}iý× z
\mathtt{7}iþ× z
\mathtt{8}iÿ× z
\mathtt{9}N)Ú
uni2tex_table© ó ú/builddir/build/BUILD/imunify360-venv-2.6.2/opt/imunify360/venv/lib/python3.11/site-packages/docutils/utils/math/unichar2tex.pyúrF s01 ðð` Ø €cð` à €kð` ð €hð` ð €fð ` ð
€hð ` ð €gð
` ð €fð` ð €jð` ð €hð` ð €hð` ð €zð` ð €zð` ð €zð` ð €zð ` ð €zð ` ð €{ð!` ð" €wð#` ð ` ð$ €wð%` ð& €zð'` ð( €|ð)` ð* €xð+` ð, €xð-` ð. €zð/` ð0 €zð1` ð2 €yð3` ð4 €zð5` ð6 €zð7` ð8 €ð9` ð: €yð;` ð< €xð=` ð> €zð?` ð@ €yðA` ðB €zðC` ðD €{ðE` ð ` ð ` ðF €wðG` ðH €wðI` ðJ €wðK` ðL €wðM` ðN €xðO` ðP €}ðQ` ðR €zðS` ðT €xðU` ðV €|ðW` ðX €{ðY` ðZ €xð[` ð\ €xð]` ð^ €zð_` ð` €}ða` ðb €xðc` ðd €zðe` ðf €|ðg` ð ` ð ` ðh €}ði` ðj €{ðk` ðl €|ðm` ðn Ððo` ðp ˆ ðq` ðr ˆ ðs` ðt ˆðu` ðv ˆðw` ðx ˆ ðy` ðz ˆ ð{` ð| ˆ ð}` ð~ ˆ
ð` ð@ ˆ
ðA` ðB ˆðC` ðD ˆðE` ðF ˆ
ðG` ðH ˆðI` ð ` ð ` ðJ ˆðK` ðL ˆ
ðM` ðN ˆ ðO` ðP ˆðQ` ðR ˆðS` ðT ˆðU` ðV ˆðW` ðX ˆ
ðY` ðZ ˆð[` ð\ ˆ
ð]` ð^ ˆ
ð_` ð` ˆða` ðb ˆðc` ðd ˆ
ðe` ðf ˆ
ðg` ðh ˆði` ðj ˆðk` ð ` ð ` ðl ˆðm` ðn ˆðo` ðp ˆðq` ðr ˆðs` ðt ˆ ðu` ðv ˆðw` ðx ˆ
ðy` ðz ˆ ð{` ð| ˆ
ð}` ð~ ˆ ð` ð@ ˆðA` ðB ˆ ðC` ðD ˆðE` ðF ˆðG` ðH ÐðI` ðJ ÐðK` ðL ˆ ðM` ð ` ð ` ðN ˆ ðO` ðP ˆ ðQ` ðR ˆ ðS` ðT ˆðU` ðV ÐðW` ðX Ð ðY` ðZ Ð ð[` ð\ Ðð]` ð^ Ðð_` ð` ˆ ða` ðb Ððc` ðd Ððe` ðf Ððg` ðh Ðði` ðj Ð ðk` ðl Ð ðm` ðn ˆðo` ð ` ð ` ðp ˆðq` ðr Ððs` ðt Ð ðu` ðv Ð ðw` ðx Ð ðy` ðz Ðð{` ð| Ð ð}` ð~ Ðð` ð@ ÐðA` ðB ÑðC` ñD Ñ ðE` ñF Ñ ðG` ñH Ñ ðI` ñJ Ñ ðK` ñL Ñ ðM` ñN ÑðO` ñP ‰ðQ` ð ` ð ` ñR Ñ ðS` ñT ÑðU` ñV Ñ ðW` ñX Ñ ðY` ñZ ‰ð[` ñ\ Ñ ð]` ñ^ Ñð_` ñ` ‰ða` ñb ‰ ðc` ñd ‰ðe` ñf ‰ðg` ñh Ñði` ñj Ñðk` ñl ‰ðm` ñn Ñðo` ñp Ñ ðq` ñr Ñðs` ð ` ð ` ñt Ñðu` ñv ‰ ðw` ñx ‰ðy` ñz ‰ ð{` ñ| ‰ ð}` ñ~ ‰ ð` ñ@ ‰
ðA` ñB ‰
ðC` ñD ‰ðE` ñF ‰
ðG` ñH ‰ðI` ñJ ‰ ðK` ñL ‰ ðM` ñN ‰ðO` ñP ‰ðQ` ñR ‰ðS` ñT ‰ ðU` ð ` ð ` ñV ‰
ðW` ñX ÑðY` ñZ ‰ð[` ñ\ ‰ ð]` ñ^ ˆ ð_` ñ` ‰ ða` ñb ‰ ðc` ñd ‰ ðe` ñf ‰ ðg` ñh ‰
ði` ñj ‰
ðk` ñl Ñðm` ñn Ñðo` ñp ‰ðq` ñr ‰ ðs` ñt ‰
ðu` ñv ‰ðw` ð ` ð ` ñx ‰
ðy` ñz ‰ð{` ñ| ‰ð}` ñ~ ‰ð` ñ@ ‰ðA` ñB ‰ ðC` ñD ‰
ðE` ñF ‰ ðG` ñH ‰ðI` ñJ ‰ ðK` ñL ‰ðM` ñN ‰ðO` ñP ‰ ðQ` ñR ‰ðS` ñT ‰ ðU` ñV ‰
ðW` ñX ‰
ðY` ð ` ð ` ñZ ‰ ð[` ñ\ ‰
ð]` ñ^ ‰ ð_` ñ` ‰
ða` ñb ‰
ðc` ñd ‰ ðe` ñf ‰ ðg` ñh ‰
ði` ñj ‰
ðk` ñl Ñðm` ñn Ñðo` ñp ‰ ðq` ñr ‰ ðs` ñt ‰ðu` ñv ‰ðw` ñx ‰
ðy` ñz ‰ð{` ð ` ð ` ñ| ‰ð}` ñ~ ‰ ð` ñ@ ‰ ðA` ñB ‰
ðC` ñD ‰
ðE` ñF ‰ðG` ñH ‰ðI` ñJ ‰ ðK` ñL ‰
ðM` ñN ‰ ðO` ñP ‰ ðQ` ñR ‰ ðS` ñT ‰ ðU` ñV ‰ ðW` ñX ‰ ðY` ñZ ‰ ð[` ñ\ ‰ ð]` ð ` ð ` ñ^ ‰ ð_` ñ` Ñða` ñb Ñðc` ñd ‰ ðe` ñf ‰ ðg` ñh ‰
ði` ñj ‰
ðk` ñl ‰ ðm` ñn ‰ ðo` ñp ‰
ðq` ñr ‰
ðs` ñt ‰ðu` ñv ‰ðw` ñx ‰ðy` ñz ‰ð{` ñ| ‰
ð}` ñ~ ‰
ð` ð ` ð ` ñ@ ‰
ðA` ñB ‰ðC` ñD ‰ðE` ñF ‰
ðG` ñH ‰
ðI` ñJ ‰
ðK` ñL ‰ ðM` ñN ‰ ðO` ñP ‰ ðQ` ñR ‰ ðS` ñT ÑðU` ñV ‰ðW` ñX ÑðY` ñZ ‰ ð[` ñ\ ‰
ð]` ñ^ ‰
ð_` ñ` ‰ ða` ð ` ð ` ñb ‰
ðc` ñd ‰
ðe` ñf ‰ðg` ñh ‰ði` ñj ‰ ðk` ñl ‰
ðm` ñn ‰
ðo` ñp ‰ ðq` ñr ‰ ðs` ñt ‰ ðu` ñv ‰ ðw` ñx ‰ ðy` ñz Ñ ð{` ñ| Ñ ð}` ñ~ Ñð` ñ@ Ñ ðA ` ñB ‰
ðC ` ð ` ð ` ñD ‰
ðE ` ñF ‰ ðG ` ñH ‰
ðI ` ñJ ‰
ðK ` ñL ‰ ðM ` ñN ‰ ðO ` ñP ‰ ðQ ` ñR ‰ ðS ` ñT ‰ ðU ` ñV ‰ ðW ` ñX ÑðY ` ñZ ‰ ð[ ` ñ\ ‰ ð] ` ñ^ ‰ ð_ ` ñ` Ñða ` ñb Ñ ðc ` ñd ‰ðe ` ð ` ð ` ñf ‰
ðg ` ñh ‰ði ` ñj ‰ ðk ` ñl ‰ ðm ` ñn ‰ðo ` ñp ‰ðq ` ñr ‰ðs ` ñt ‰ ðu ` ñv ‰ ðw ` ñx ‰ðy ` ñz ‰ð{ ` ñ| ‰ð} ` ñ~ ‰ð ` ñ@
ÑðA
` ñB
ÑðC
` ñD
‰ ðE
` ñF
‰ ðG
` ð ` ð ` ñH
‰
ðI
` ñJ
‰
ðK
` ñL
‰
ðM
` ñN
‰
ðO
` ñP
ÑðQ
` ñR
ÑðS
` ñT
Ñ ðU
` ñV
Ñ ðW
` ñX
‰
ðY
` ñZ
‰
ð[
` ñ\
‰
ð]
` ñ^
‰
ð_
` ñ`
‰
ða
` ñb
‰ ðc
` ñd
‰ ðe
` ñf
‰
ðg
` ñh
‰
ði
` ð ` ð ` ñj
‰
ðk
` ñl
‰
ðm
` ñn
‰
ðo
` ñp
‰
ðq
` ñr
‰ðs
` ñt
‰ðu
` ñv
‰ðw
` ñx
‰ðy
` ñz
‰ð{
` ñ|
‰ð}
` ñ~
‰
ð
` ñ@ ‰
ðA ` ñB ÑðC ` ñD ÑðE ` ñF ÑðG ` ñH Ñ ðI ` ñJ Ñ ðK ` ð ` ð ` ñL ÑðM ` ñN ‰ ðO ` ñP ‰ ðQ ` ñR ‰ ðS ` ñT ‰ ðU ` ñV ÑðW ` ñX ‰ ðY ` ñZ ‰ð[ ` ñ\ ‰ð] ` ñ^ Ñð_ ` ñ` ‰
ða ` ñb ‰ ðc ` ñd ‰ ðe ` ñf ‰
ðg ` ñh ‰ði ` ñj ‰ ðk ` ñl ‰ ðm ` ð ` ð ` ñn ‰ ðo ` ñp ‰
ðq ` ñr ‰ ðs ` ñt ‰ ðu ` ñv ‰ ðw ` ñx ‰ ðy ` ñz Ñð{ ` ñ| Ñð} ` ñ~ Ñ ð ` ñ@ ÑðA ` ñB ÑðC ` ñD Ñ ðE ` ñF ‰ðG ` ñH ÑðI ` ñJ ‰
ðK ` ñL ‰ ðM ` ñN ‰
ðO ` ð ` ð ` ñP ‰ðQ ` ñR ‰
ðS ` ñT ‰
ðU ` ñV ‰ ðW ` ñX ‰
ðY ` ñZ Ñð[ ` ñ\ ‰
ð] ` ñ^ ‰
ð_ ` ñ` ‰ða ` ñb ‰ðc ` ñd ‰ ðe ` ñf ‰ ðg ` ñh ‰
ði ` ñj ‰
ðk ` ñl ‰ðm ` ñn ‰ðo ` ñp Ñðq ` ð ` ð ` ñr ‰ðs ` ñt ‰ ðu ` ñv ‰ ðw ` ñx ‰
ðy ` ñz ‰
ð{ ` ñ| ‰ð} ` ñ~ ‰ð ` ñ@
ÑðA
` ñB
ÑðC
` ñD
‰ðE
` ñF
‰ðG
` ñH
‰ðI
` ñJ
‰ðK
` ñL
‰ðM
` ñN
‰ ðO
` ñP
‰ ðQ
` ñR
‰ ðS
` ð ` ð ` ñT
‰ ðU
` ñV
‰ ðW
` ñX
‰ ðY
` ñZ
‰ ð[
` ñ\
‰ ð]
` ñ^
‰ ð_
` ñ`
‰ ða
` ñb
‰ ðc
` ñd
‰ ðe
` ñf
‰ ðg
` ñh
‰ ði
` ñj
‰ ðk
` ñl
‰ ðm
` ñn
‰ ðo
` ñp
‰ ðq
` ñr
‰ ðs
` ñt
‰ ðu
` ð ` ð ` ñv
‰ ðw
` ñx
‰ ðy
` ñz
‰ ð{
` ñ|
‰ ð}
` ñ~
‰ ð
` ñ@ ‰ ðA` ñB ‰ ðC` ñD ‰ ðE` ñF ‰ ðG` ñH ‰ ðI` ñJ ‰ ðK` ñL ‰ ðM` ñN ‰ ðO` ñP ‰ ðQ` ñR ‰ ðS` ñT ‰ ðU` ñV ‰ ðW` ð ` ð ` ñX ‰ ðY` ñZ ‰ ð[` ñ\ ‰ ð]` ñ^ ‰ ð_` ñ` ‰ ða` ñb ‰ ðc` ñd ‰ ðe` ñf ‰ ðg` ñh ‰ ði` ñj ‰ ðk` ñl ‰ ðm` ñn ‰ ðo` ñp ‰ ðq` ñr ‰ ðs` ñt ‰ ðu` ñv ‰ðw` ñx ‰ðy` ð ` ð ` ñz ‰ð{` ñ| ‰ð}` ñ~ ‰ð` ñ@ ‰ðA` ñB ‰ðC` ñD ‰ðE` ñF ‰ðG` ñH ‰ðI` ñJ ‰ðK` ñL ‰ðM` ñN ‰ðO` ñP ‰ðQ` ñR ‰ðS` ñT ‰ðU` ñV ‰ðW` ñX ‰ðY` ñZ ‰ð[` ð ` ð ` ñ\ ‰ð]` ñ^ ‰ð_` ñ` ‰ða` ñb ‰ðc` ñd ‰ðe` ñf ‰ðg` ñh ‰ði` ñj ‰ðk` ñl ‰ðm` ñn ‰ðo` ñp ‰ðq` ñr ‰ðs` ñt ‰ðu` ñv ‰ðw` ñx ‰ðy` ñz ‰ð{` ñ| ‰ð}` ð ` ð ` ñ~ ‰ð` ñ@ ‰ðA` ñB ‰ðC` ñD ‰ðE` ñF ‰ðG` ñH ‰ðI` ñJ ‰ðK` ñL ‰ðM` ñN ‰ðO` ñP ‰ðQ` ñR ‰ðS` ñT ‰ðU` ñV ‰ðW` ñX ‰ðY` ñZ ‰ð[` ñ\ ‰ ð]` ñ^ ‰ ð_` ð ` ð ` ñ` ‰ ða` ñb ‰ ðc` ñd ‰ ðe` ñf ‰ ðg` ñh ‰ ði` ñj ‰ ðk` ñl ‰ ðm` ñn ‰ ðo` ñp ‰ ðq` ñr ‰ ðs` ñt ‰ ðu` ñv ‰ ðw` ñx ‰ ðy` ñz ‰ ð{` ñ| ‰ ð}` ñ~ ‰ ð` ñ@ ‰ ðA` ð ` ð ` ñB ‰ ðC` ñD ‰ ðE` ñF ‰ ðG` ñH ‰ ðI` ñJ ‰ ðK` ñL ‰ ðM` ñN ‰ ðO` ñP ‰ ðQ` ñR ‰ ðS` ñT ‰ ðU` ñV ‰ ðW` ñX ‰ ðY` ñZ ‰ ð[` ñ\ ‰ ð]` ñ^ ‰ ð_` ñ` ‰ ða` ñb ‰ ðc` ð ` ð ` ñd ‰ ðe` ñf ‰ ðg` ñh ‰ ði` ñj ‰ ðk` ñl ‰ ðm` ñn ‰ ðo` ñp ‰ ðq` ñr ‰ ðs` ñt ‰ ðu` ñv ‰ ðw` ñx ‰ ðy` ñz ‰ ð{` ñ| ‰ ð}` ñ~ ‰ ð` ñ@ ‰ ðA` ñB ‰ ðC` ñD ‰ ðE` ð ` ð ` ñF ‰ ðG` ñH ‰ ðI` ñJ ‰ ðK` ñL ‰ ðM` ñN ‰ ðO` ñP ‰ ðQ` ñR ‰ ðS` ñT ‰ ðU` ñV ‰ ðW` ñX ‰ ðY` ñZ ‰ ð[` ñ\ ‰ ð]` ñ^ ‰ ð_` ñ` ‰ ða` ñb ‰ ðc` ñd ‰ ðe` ñf ‰ ðg` ð ` ð ` ñh ‰ ði` ñj ‰ ðk` ñl ‰ ðm` ñn ‰ ðo` ñp ‰ ðq` ñr ‰ ðs` ñt ‰ ðu` ñv ‰ ðw` ñx ‰ ðy` ñz ‰ ð{` ñ| ‰ ð}` ñ~ ‰ ð` ñ@ ‰ ðA` ñB ‰ ðC` ñD ‰ðE` ñF ‰ ðG` ñH ‰ ðI` ð ` ð ` ñJ ‰ ðK` ñL ‰ ðM` ñN ‰ ðO` ñP ‰ ðQ` ñR ‰ ðS` ñT ‰ ðU` ñV ‰ ðW` ñX ‰ ðY` ñZ ‰ ð[` ñ\ ‰ ð]` ñ^ ‰ ð_` ñ` ‰ ða` ñb ‰ ðc` ñd ‰ ðe` ñf ‰ ðg` ñh ‰ ði` ñj ‰ ðk` ð ` ð ` ñl ‰ ðm` ñn ‰ ðo` ñp ‰ ðq` ñr ‰ ðs` ñt ‰ ðu` ñv ‰ ðw` ñx ‰ ðy` ñz ‰ ð{` ñ| ‰ ð}` ñ~ ‰ ð` ñ@ ‰ ðA` ñB ‰ ðC` ñD ‰ ðE` ñF ‰ ðG` ñH ‰ ðI` ñJ ‰ ðK` ñL ‰ ðM` ð ` ð ` ñN ‰ ðO` ñP ‰ ðQ` ñR ‰ ðS` ñT ‰ ðU` ñV ‰ ðW` ñX ‰ ðY` ñZ ‰ ð[` ñ\ ‰ ð]` ñ^ ‰ ð_` ñ` ‰ ða` ñb ‰ ðc` ñd ‰ ðe` ñf ‰ ðg` ñh ‰ ði` ñj ‰ ðk` ñl ‰ ðm` ñn ‰ ðo` ð ` ð ` ñp ‰ ðq` ñr ‰ ðs` ñt ‰ ðu` ñv ‰ ðw` ñx ‰ ðy` ñz ‰ ð{` ñ| ‰ ð}` ñ~ ‰ ð` ñ@ ‰ ðA` ñB ‰ ðC` ñD ‰ ðE` ñF ‰ ðG` ñH ‰ ðI` ñJ ‰ ðK` ñL ‰ ðM` ñN ‰ ðO` ñP ‰ ðQ` ð ` ð ` ñR ‰ ðS` ñT ‰ ðU` ñV ‰ ðW` ñX ‰ ðY` ñZ ‰ ð[` ñ\ ‰ ð]` ñ^ ‰ ð_` ñ` ‰ ða` ñb ‰ ðc` ñd ‰ ðe` ñf ‰ ðg` ñh ‰ ði` ñj ‰ ðk` ñl ‰ ðm` ñn ‰ ðo` ñp ‰ ðq` ñr ‰ ðs` ð ` ð ` ñt ‰ ðu` ñv ‰ ðw` ñx ‰ ðy` ñz ‰ ð{` ñ| ‰ ð}` ñ~ ‰ ð` ñ@ ‰ ðA` ñB ‰ ðC` ñD ‰ ðE` ñF ‰ ðG` ñH ‰ ðI` ñJ ‰ ðK` ñL ‰ ðM` ñN ‰ ðO` ñP ‰ ðQ` ñR ‰ ðS` ñT ‰ ðU` ð ` ð ` ñV ˆðW` ñX ˆðY` ñZ Ñ ð[` ñ\ Ñ ð]` ñ^ Ñ ð_` ñ` Ñ ða` ñb Ñ ðc` ñd Ñ ðe` ñf Ñ ðg` ñh Ñ ði` ñj Ñ ðk` ñl Ñ ðm` ñn Ñ ðo` ñp Ñ ðq` ñr Ñ ðs` ñt Ñ ðu` ñv Ñ ðw` ð ` ð ` ñx Ñ ðy` ñz Ñ ð{` ñ| Ñ ð}` ñ~ Ñ ð` ñ@ Ñ ðA` ñB Ñ ðC` ñD Ñ ðE` ñF ˆðG` ñH ˆðI` ñJ ˆðK` ñL ˆðM` ñN ˆ ðO` ñP ˆðQ` ñR ˆðS` ñT ˆðU` ñV ˆðW` ñX ˆðY` ð ` ð ` ñZ ˆð[` ñ\ ˆð]` ñ^ ˆð_` ñ` ˆða` ñb ˆðc` ñd ˆðe` ñf ˆ ðg` ñh ˆði` ñj ˆðk` ñl ˆ ðm` ñn ˆðo` ñp ˆðq` ñr ˆðs` ñt ˆðu` ñv ‰ ðw` ñx ˆ ðy` ñz ˆ ð{` ð ` ð ` ñ| ˆ ð}` ñ~ ˆð` ñ@ ˆðA` ñB ˆðC` ñD ‰ ðE` ñF ‰ ðG` ñH ‰ ðI` ñJ ‰ ðK` ñL ‰ ðM` ñN ‰ ðO` ñP ‰ ðQ` ñR ‰ ðS` ñT ‰ ðU` ñV ‰ ðW` ñX ‰ ðY` ñZ ‰ ð[` ñ\ ‰ ð]` ð ` ð ` ñ^ ‰ ð_` ñ` ‰ ða` ñb ‰ ðc` ñd ‰ ðe` ñf ‰ ðg` ñh ‰ ði` ñj ‰ ðk` ñl ‰ ðm` ñn ‰ ðo` ñp ‰ ðq` ñr ‰ ðs` ñt ‰ ðu` ñv ‰ ðw` ñx ‰ ðy` ñz ‰ ð{` ñ| ‰ ð}` ñ~ ‰ ð` ð ` €
€
rD PK ! <™8ÉE» E» ( __pycache__/latex2mathml.cpython-311.pycnu „[µü¤ §
¥ Þi(É ã ó — d Z ddlZddlZddlmZmZ ej Zded< dddd d
d d d
ddddœ Zddddddddddœ Z e
d„ dD ¦ « ¦ « ddd d d œZ d d d d!d"d#d$d%d&d'd(d)d$d*œ
Z i d+d,“d-d.“d/d0“d1d2“d3d4“d5d6“d7d8“d9d:“d;d<“d=d>“d?d@“dAdB“dCdD“dEdB“dFdD“dGdD“Z
e
ej ¦ « e
ej ¦ « e
ej ¦ « i dHdI“dJdK“dLdM“dNdO“dPdQ“dRdS“dTdU“dVdW“dXdY“dZd[“d\d]“d^d_“d`da“dbdc“ddde“dfdc“dgdc“deddhdidjdkdlœ¥Ze
ej ¦ « e
ej ¦ « e
ej ¦ « e
ej ¦ « e
ej ¦ « e
e
¦ « dmdndoœZdpdqdrdsdtdudvdwœZdxZdydzd{d{d|d}d}d~d~ddd€dd‚œ
Zdƒd„d…d†d‡dˆd‰dŠd‹dŒddŽdœ Zdd‘d’d“d”d•d–d—œZ d˜d‘d’d™d”dšœZ d›dœddžœZ dŸd d¡d¢d£d¤œZ d¥d¥d¦d§d¨d©dªd«d¬œZ ddd®œd¯dd®œd¯d°d®œd¯d±d®œd²œZ!i i fddd³d´œi fe!dµ i fe!d¶ i fi d·dife!dµ d·dife!d¶ d·difd¸œZ"g d¹¢Z#ddd°d°d±d±dºdºd»d»d¼œ
Z$ G d½„ d¾¦ « Z% G d¿„ dÀe%¦ « Z& G dÁ„ dÂe%¦ « Z' G dÄ dÄe%¦ « Z( G dÅ„ dÆe(¦ « Z) G dÇ„ dÈe(¦ « Z* G dÉ„ dÊe(¦ « Z+ G dË„ dÌe(¦ « Z, G dÍ„ dÎe(¦ « Z- G dÏ„ dÐe(¦ « Z. G dÑ„ dÒe%¦ « Z/ G dÓ„ dÔe/¦ « Z0 G dÕ„ dÖe/¦ « Z1 G dׄ dØe/¦ « Z2 G dÙ„ dÚe/¦ « Z3 G dÛ„ dÜe%¦ « Z4 G dÝ„ dÞe4¦ « Z5 G dß„ dàe4¦ « Z6 G dá„ dâe4¦ « Z7 G dã„ däe5¦ « Z8 G då„ dæe6¦ « Z9 G dç„ dèe7¦ « Z: G dé„ dêe4¦ « Z; G dë„ dìe%¦ « Z< G dí„ dîe%¦ « Z=dï„ Z>dð„ Z?dñ„ Z@dò„ ZAdó„ ZBdô„ ZCdõ„ ZDdö„ ZEdþdø„ZFdù„ ZGdú„ ZHdû„ ZIdü„ ZJdÿdý„ZKdS ( z™Convert LaTex maths code into presentational MathML.
This module is provisional:
the API is not settled and may change with any minor Docutils version.
é N)Ú tex2unicharÚ
toplevel_codeu â„Úhbaru Φu Ξõ Σu Ψu Δu Θu Ï’õ Î u Ωõ Γu Λ) ÚPhiÚXiÚSigmaÚPsiÚDeltaÚThetaÚUpsilonÚPiÚOmegaÚGammaÚLambdau lim infu lim supu inj limu
proj limÚlim) ÚliminfÚlimsupÚinjlimÚprojlimÚ varlimsupÚ varliminfÚ
varprojlimÚ varinjlimÚ operatornamec # ó K — | ]}||fV — Œ d S ©N© )Ú.0Únames ú€/builddir/build/BUILD/imunify360-venv-2.6.2/opt/imunify360/venv/lib/python3.11/site-packages/docutils/utils/math/latex2mathml.pyú r$ B s> è è € ð Að A $$˜ ð Að Að Að Að Að Aó )ÚarccosÚarcsinÚarctanÚargÚcosÚcoshÚcotÚcothÚcscÚdegÚdetÚdimÚexpÚgcdÚhomÚkerÚlgÚlnÚlogÚPrÚsecÚsinÚsinhÚtanÚtanh)TTFz0.278em)FTTú0.444em)FTFz0.667em)FFTr? )ÚbmodÚpmodÚmodÚpodÚboldÚitalicÚ monospaceÚnormalz
sans-serifÚscriptz bold-italicz
double-struckÚfrakturzsans-serif-italiczsans-serif-bold-italic)
Ú
boldsymbolÚmathbfÚmathitÚmathttÚmathrmÚmathsfÚmathcalÚmathbfitÚmathbbÚmathfrakÚmathsfitÚ
mathsfbfitÚmathscrÚ backslashú\Úuparrowu â†‘Ú downarrowu â†“Ú updownarrowu ↕ÚUparrowu â‡‘Ú Downarrowu â‡“Ú Updownarrowu ⇕Ú
lmoustacheu ⎰Ú
rmoustacheu âŽ±Ú arrowvertu âÚ bracevertu ⎪Úlvertú|ÚlVertõ ‖ÚrvertÚrVertÚ ArrowvertÚnleqqu ≦̸Úngeqqu â‰§Ì¸Ú nleqslantu â©½Ì¸Ú ngeqslantu ⩾̸Úngtrlessu ≹Únlessgtru ≸Ú
nsubseteqqu ⫅̸Ú
nsupseteqqu â«†Ì¸Ú centerdotu â¬Ú
varnothingu âŒ€Ú varproptou âˆÚtriangleu â–³Ú triangledownu â–½Údotsbõ ⋯Údotscu …ÚdotsiÚdotsmÚsupÚinfÚmaxÚmin)Údotsor r| r} r~ r u ∼u ≈)ÚthicksimÚ thickapproxu ∣u ∥u ∤u ∦u ⌢u ⌣u ∫)ÚshortmidÚ
shortparallelÚ nshortmidÚnshortparallelÚ
smallfrownÚ
smallsmileÚsmallint)ÚbigcapÚbigcupÚbigodotÚbigoplusÚ bigotimesÚbigsqcupÚbiguplusÚbigveeÚbigwedgeÚcoprodÚintopÚointopÚprodÚsumr r~ r r| r} Ú2emÚ1emz0.2778emz0.25emz0.2222emz0.1667emz -0.1667emz -0.2222emz -0.2778em)
ÚqquadÚquadÚ
thickspaceú;ú Úmedspaceú:Ú thinspaceú,Ú negthinspaceú!Ú negmedspaceÚ
negthickspace)õ ´u Ì)u ˉu Ì„)u ˘u ̆)u ˇu ÌŒ)u Ë™u ̇)õ ¨u ̈)rx u ⃛)ú`u Ì€)u ˆu Ì‚)u Ëšu ÌŠ)u Ëœu ̃)õ →u ⃗) ÚacuteÚbarÚbreveÚcheckÚdotÚddotÚdddotÚgraveÚhatÚmathringÚtildeÚvec)u âžçš™™™™™É¿)õ â†r· )u ↔r· )Ú_r· )rª r· )ú^g à¿)ú~g333333Ó¿)Ú overbraceÚ
overleftarrowÚoverleftrightarrowÚoverlineÚoverrightarrowÚwidehatÚ widetilde)u âŸgš™™™™™¹?)r¹ gš™™™™™é¿)Ú
underbraceÚunderleftarrowÚunderleftrightarrowÚ underlineÚunderrightarrowu −u ∶õ  )ú-r r» u ℾu â„¿õ â…€u ℽu ℼ)r r r u γu Ï€)Ú rË )ú(ú))ú[ú])Ú{Ú})rd rd )rf rf )rÐ rË )ÚmatrixÚ smallmatrixÚpmatrixÚbmatrixÚBmatrixÚvmatrixÚVmatrixÚcasesT)Ú displaystyleÚ scriptlevelFé é )rÚ Ú textstyleÚ scriptstyleÚscriptscriptstyleÚcfrac)rÚ rÛ ÚCLASSrÚ rÞ Ú
linethickness)Úfracrá ÚdfracÚtfracÚbinomÚdbinomÚtbinom)rË z1.2emz1.623emz2.047emz2.470emé é )
ÚleftÚrightÚbiglÚbigrÚBiglÚBigrÚbigglÚbiggrÚBigglÚBiggrc óÜ — e Zd ZdZdZ dZ dZ ed¦ « d ed¦ « d ed¦ « d d
d iZd d
dœZ dZ
d„ Z d„ Z d„ Z
d„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd d„Zd „ Zd d „Zd „ ZdS ) Úmathz8Base class for MathML elements and root of MathML trees.Nr úz>ú&z&ia zÚtrueÚfalse)TFÚspanc ó¾ — g | _ | |¦ « i | _ | ¦ « D ]$}|| | j | ¦ « < Œ%dS )a Set up node with `children` and `attributes`.
Attributes are downcased: Use CLASS to set "class" value.
>>> math(mn(3), CLASS='test')
math(mn(3), class='test')
>>> math(CLASS='test').toprettyxml()
''
N)ÚchildrenÚextendÚ
attributesÚkeysÚlower)Úselfrÿ r Úkeys r# Ú__init__z
math.__init__Z sd € 𠈌
Ø Š HÑ Ô Ð à ˆŒØ —?’?Ñ$Ô$ð ;ð ;ˆCð ,6°c¬?ˆDŒO˜CŸIšI™KœKÑ (Ð (ð ;ð ;r% c óž — d„ t | dg ¦ « D ¦ « }t | d¦ « r'| t | j ¦ « ¦ « t | t ¦ « r | j r| d¦ « |d„ | j ¦ « D ¦ « z
}| j
j dd |¦ « z z S )Nc ó, — g | ]}t |¦ « ‘ŒS r )Úrepr)r! Úitems r# ú
z!math.__repr__..n s € ÐHÐHÐH $•4˜‘:”:ÐHÐHÐHr% rÿ Údataz switch=Truec ó& — g | ]\ }}|®|›d|›‘ŒS )Nú=r ©r! ÚkÚvs r# r z!math.__repr__..s s2 € ð &ð &ð &¡t q¨!Ø}ð ˜Q˜Q NØ$}}r% z(%s)z, )
ÚgetattrÚhasattrÚappendr r Ú
isinstanceÚ
MathSchemaÚswitchr ÚitemsÚ __class__Ú__name__Újoin)r Úcontents r# Ú__repr__z
math.__repr__m sÐ € ØHÐH'°$¸
ÀBÑ*GÔ*GÐHÑHÔHˆÝ 4˜Ñ Ô ð ,Ø NŠN4 ¤ ™?œ?Ñ +Ô +Ð +Ý dJÑ 'Ô 'ð *¨D¬Kð *Ø NŠN˜=Ñ )Ô )Ð )Øð &ð &¨t¬×/DÒ/DÑ/FÔ/Fð &ñ &ô &ñ &ˆð Œ~Ô&¨°$·)²)¸GÑ2DÔ2DÑ)DÑDÐDr% c ó* — t | j ¦ « S r )Úlenrÿ ©r s r# Ú__len__z math.__len__x s € Ý4”=Ñ!Ô!Ð!r% c ó — | j | S r ©r )r r s r# Ú __getitem__zmath.__getitem__} s € ØŒ˜sÔ#Ð#r% c ó — || j |< d S r r# )r r r
s r# Ú __setitem__zmath.__setitem__€ s € Ø #ˆŒ˜Ñ Ð Ð r% c ó& — | j j |i |¤ŽS r )r Úget)r ÚargsÚkwargss r# r( zmath.getƒ s € Ø"ˆtŒÔ" DÐ3¨FÐ3Ð3Ð3r% c óD — | j duot | ¦ « | j k S )z;Return boolean indicating whether children may be appended.N)Ú nchildrenr r s r# Úfullz math.full† s& € à” dÐ*ð 0ݘ‘I”I ¤ Ò/ð 1r% c óä — | ¦ « rt d| z ¦ « ‚| j |¦ « | |_ | ¦ « r| ¦ « S | S )zšAppend child and return self or first non-full parent.
If self is full, go up the tree and return first non-full node or
`None`.
zNode %s already full!)r- Ú SyntaxErrorrÿ r ÚparentÚclose)r Úchilds r# r z math.append‹ sh € ð 9Š9‰;Œ;ð >Ý Ð 5¸Ñ <Ñ=Ô=Ð =Ø Œ
× Ò ˜UÑ#Ô#Ð#؈Œ Ø 9Š9‰;Œ;ð Ø—:’:‘<”<Р؈ r% c ó: — |D ]}| |¦ « Œ| S r )r )r rÿ r2 s r# r z math.extend™ s+ € Ø ð ð ˆEØ KŠK˜Ñ Ô Ð Ð Øˆ r% c óz — | j }|1| ¦ « r |j }|| ¦ « ° |S )z7Close element and return first non-full parent or None.)r0 r- )r r0 s r# r1 z
math.closež s= € à”ˆØÐ V§[¢[¡]¤]Ð Ø”]ˆFð Ð V§[¢[¡]¤]Ð àˆ
r% c óP — d | ¦ « ¦ « S )z,Return XML representation of self as string.rË )r Ú_xmlr s r# Ú toprettyxmlzmath.toprettyxml¥ s € àwŠwt—y’y‘{”{Ñ#Ô#Ð#r% c óz — | ¦ « g| |¦ « z d| j j z gz S )Nz)Ú xml_starttagÚ _xml_bodyr r ©r Úlevels r# r6 z math._xml© sB € Ø×"Ò"Ñ$Ô$Ð%Ø—.’. Ñ'Ô'ñ(à˜Tœ^Ô 4Ñ4Ð5ñ6ð 7r% c ó” — d„ | j ¦ « D ¦ « }dd | j j g|¢R ¦ « z S )Nc 3 óš K — | ]F\ }}|®|›dt |¦ « dd¦ « dd¦ « ›dV — ŒGd S )Nz="ÚTruerû ÚFalserü ú")ÚstrÚreplacer s r# r$ z$math.xml_starttag..¯ sh è è € ð #ð #ÙQ˜ØMð ˜a˜a¥ Q¡¤§ ¢ °¸Ñ!?Ô!?×!GÒ!GÈÐQXÑ!YÔ!YÐ!YÐ!YÐZà!MMMð#ð #r% z<%s>rž )r r r r r )r Úattrss r# r9 zmath.xml_starttag® sW € ð#ð #Ø !œ_× 2Ò 2Ñ 4Ô 4ð#ñ #ô #ˆð ˜Ÿš $¤.Ô"9Ð!B¸EÐ!BÐ!BÑCÔCÑCÐCr% c óâ — g }| j D ]J}| dd|dz z g¦ « | | |dz ¦ « ¦ « ŒK| dd|z g¦ « |S )Nú
z rÜ )rÿ r r6 )r r< Úxmlr2 s r# r: zmath._xml_body´ s} € ؈ؔ]ð ,ð ,ˆEØ JŠJ˜˜d e¨A¡gÑ .Ð/Ñ 0Ô 0Ð 0Ø JŠJu—z’z %¨¡'Ñ*Ô*Ñ +Ô +Ð +Ð +Ø
Š
D˜$ ™,Ð'Ñ(Ô(Ð(؈
r% c ó” — | d dk S # t $ r/ | j ¦ « cY S # t $ r Y Y dS w xY ww xY w)z;Return true, if `self` or a parent has ``display='block'``.ÚdisplayÚblockF)ÚKeyErrorr0 Úis_blockÚAttributeErrorr s r# rL z
math.is_block¼ st € ð ؘ ”? gÒ-Ð -øÝð ð ð ð
Ø”{×+Ò+Ñ-Ô-Ð-Ð-Ð-øÝ!ð
ð
ð
Ø uuuð
øøøð øøøs( ‚ Ž
A™4±A´
A¾AÁAÁA©r )r Ú
__module__Ú __qualname__Ú__doc__r, r0 Ú_levelÚordÚ xml_entitiesÚ _boolstringsÚ html_tagnamer r r! r$ r& r( r- r r r1 r7 r6 r9 r: rL r r% r# r÷ r÷ D sp € € € € € ØBÐBà€IØ-à
€FØ)Ø
€F𠈈C‰Œ&Ø ˆˆC‰Œ&Ø ˆˆC‰Œ'ØÐ#ð €Lð !¨Ð1Ð1€LØCà€LØ+ð;ð ;ð ;ð& Eð Eð Eð"ð "ð "ð
$ð $ð $ð$ð $ð $ð4ð 4ð 4ð1ð 1ð 1ð
ð ð ð ð ð ð
ð ð ð$ð $ð $ð7ð 7ð 7ð 7ð
Dð Dð Dð ð ð ð ð ð ð ð ð r% r÷ c ó — e Zd ZdS )ÚmtableN©r rO rP r r% r# rX rX â ó € € € € € € € r% rX c ó" ‡ — e Zd ZdZˆ fd„Zˆ xZS )Úmrowz*Group sub-expressions as a horizontal row.c ó •— | j }t |t ¦ « rU|j dk rJt |j ¦ « |_ | j |_ | j D ] }||_ Œ
| ¦ « S t | ¦ « dk re | j d |j |j | ¦ « < || j d _ n$# t t f$ r | j d cY S w xY wt ¦ « ¦ « S )z¹Close element and return first non-full parent or None.
Remove , if it is single child and the parent infers an mrow
or if it has only one child element.
rÜ r ) r0 r Ú
MathRowSchemar, r rÿ r1 ÚindexrM Ú
ValueErrorÚsuper)r r0 r2 r s €r# r1 z
mrow.closeî sü ø€ ð ”ˆÝ fmÑ ,Ô ,ð "°Ô1AÀQÒ1FÐ1FÝ " 6¤?Ñ 3Ô 3ˆFÔ Ø "œmˆFŒOØ œ ð
&ð
&Ø %” Ø—<’<‘>”>Ð !Ý ˆt‰9Œ9˜Š>ˆ>ð
(Ø?C¼}ÈQÔ?O” ¤× 5Ò 5°dÑ ;Ô ;Ñ<Ø*0”
˜aÔ Ô'Ð'øÝ"¥JÐ/ð
(ð
(ð
(Ø”} QÔ'Ð'Ð'Ð'ð
(øøøå‰wŒw}Š}‰ŒÐ s Â?C à C(Ã'C()r rO rP rQ r1 Ú
__classcell__©r s @r# r\ r\ ë s> ø€ € € € € Ø4Ð4ð ð ð ð ð ð ð ð ð r% r\ c ó — e Zd ZdZdS )r^ zCBase class for elements treating content as a single inferred mrow.N)r rO rP rQ r r% r# r^ r^
s € € € € € ØMÐMÐMÐMr% r^ c ó — e Zd ZdS )ÚmtrNrY r r% r# rf rf rZ r% rf c ó — e Zd ZdS )ÚmtdNrY r r% r# rh rh rZ r% rh c ó — e Zd ZdZdS )ÚmencloserÜ N©r rO rP r, r r% r# rj rj ó € € € € € Ø€I€I€Ir% rj c ó — e Zd ZdZdS )ÚmphantomrÜ Nrk r r% r# rn rn rl r% rn c ó — e Zd ZdZdS )ÚmsqrtrÜ Nrk r r% r# rp rp rl r% rp c ó — e Zd ZdZdS )ÚmstylerÜ Nrk r r% r# rr rr rl r% rr c ó. ‡ — e Zd ZdZdZˆ fd„Zdd„Zˆ xZS )Ú MathTokenzbToken Element: contains textual data instead of children.
Base class for mo, mi, and mn.
r c óH •— || _ t ¦ « j di |¤Ž d S )Nr )r ra r )r r r r s €r# r zMathToken.__init__) s- ø€ ؈Œ ؉ŒÔÐ&Ð&˜:Ð&Ð&Ð&Ð&Ð&r% c ó\ — t | j ¦ « | j ¦ « gS r )rB r Ú translaterT r; s r# r: zMathToken._xml_body- s$ € ÝD”I‘”×(Ò(¨Ô):Ñ;Ô;Ð<Ð>> tex_cmdname('mymacro2') # up to first non-letter
('mymacro', '2')
>>> tex_cmdname('name 2') # strip trailing whitespace
('name', '2')
>>> tex_cmdname('_2') # single non-letter character
('_', '2')
z([a-zA-Z]+) *(.*)Nz(.?)(.*)rÜ rÝ ©ÚreÚmatchÚgroup©ÚstringÚms r# Ú tex_cmdnamer¡ ˆ sK € õ ŒÐ% vÑ.Ô.€AØ€yÝ ŒH[ &Ñ )Ô )ˆØ 7Š71‰:Œ:q—w’w˜q‘z”zÐ !Ð!r% c óŒ — t j d| ¦ « }|€d| fS | d¦ « | d¦ « fS )zmReturn leading number literal and remainder of `string`.
>>> tex_number('123.4')
('123.4', '')
z([0-9.,]*[0-9]+)(.*)NrË rÜ rÝ rš rž s r# Ú
tex_numberr£ ¥ sD € õ ŒÐ(¨&Ñ1Ô1€AØ€yØ6ˆzÐØ 7Š71‰:Œ:q—w’w˜q‘z”zÐ !Ð!r% c óŒ — t j d| t j ¦ « }| dddd¦ « \ }}}}|p|p||fS )zÝReturn first simple TeX token and remainder of `string`.
>>> tex_token('\command{without argument}')
('\command', '{without argument}')
>>> tex_token('or first character')
('o', 'r first character')
a% ((?P\\[a-zA-Z]+)\s* # TeX command, skip whitespace
|(?P\\.) # one-character TeX command
|(?P.?)) # first character (or empty)
(?P.*$) # remaining part of string
ÚcmdÚchcmdÚchÚ remainder)r› rœ ÚVERBOSEr )rŸ r r¥ r¦ r§ r¨ s r# Ú tex_tokenrª À sZ € õ Œð ð bœjñ *ô *€Að
!"§¢¨¨w¸¸kÑ JÔ JÑ €CˆIØ Ð %Ð ˜2˜yÐ (Ð(r% c ó — d}d}d}| d¦ « s| dd… | dd… fS | D ]4}|dz
}|rd}n |dk rd}n|dk r|dz
}n |dk r|dz }|dk r nŒ5t d ¦ « ‚| d|dz
… | |d… fS )
z°Return first TeX group or token and remainder of `string`.
>>> tex_group('{first group} returned without brackets')
('first group', ' returned without brackets')
r FrÐ NrÜ rX TrÑ z Group without closing bracket)Ú
startswithr/ )rŸ Ú split_indexÚ
nest_levelÚescapeÚcs r# Ú tex_groupr± ß sç € ð €KØ€JØ
€Fà × Ò ˜SÑ !Ô !ð &àbqbŒz˜6 ! " "œ:Ð%Ð%Ø
ð
;ð
;ˆØqш Ø ð ؈FˆFØ
$ŠYˆY؈FˆFØ
#ŠXˆXØ ˜!‰OˆJˆJØ
#ŠXˆXØ ˜!‰OˆJØ ˜Š?ˆ?Ø ˆEð õ Ð9Ñ:Ô:Ð:Ø !K ‘M/Ô " F¨;¨<¨<Ô$8Ð 8Ð8r% c ó‚ — t | ¦ « \ }}|dk r$t | ¦ « ¦ « \ }}||fS )a Return first TeX group or token and remainder of `string`.
>>> tex_token_or_group('\command{without argument}')
('\command', '{without argument}')
>>> tex_token_or_group('first character')
('f', 'irst character')
>>> tex_token_or_group(' also whitespace')
(' ', 'also whitespace')
>>> tex_token_or_group('{first group} keep rest')
('first group', ' keep rest')
rÐ )rª r± Úlstrip)rŸ r) r¨ s r# Útex_token_or_groupr´ sA € õ ˜vÑ&Ô&N€CˆØ
ˆc‚z€zÝ" 6§=¢=¡?¤?Ñ3Ô3‰ˆˆYØ ˆ>Ðr% c ó — t j d| t j ¦ « }|€| d¦ « sd| fS | d¦ « | d¦ « fS # t
$ r t
d| z ¦ « ‚w xY w)a$ Return optional argument and remainder.
>>> tex_optarg('[optional argument] returned without brackets')
('optional argument', ' returned without brackets')
>>> tex_optarg('{empty string, if there is no optional arg}')
('', '{empty string, if there is no optional arg}')
z½\s* # leading whitespace
\[(?P(\\]|[^\[\]]|\\])*)\] # [group] without nested groups
(?P.*$)
NrÎ rË Úoptargr¨ z+Could not extract optional argument from %r)r› rœ r© r¬ r rM r/ rž s r# Ú
tex_optargr· & s¢ € õ Œð ð bœjñ *ô *€Að €y˜×*Ò*¨3Ñ/Ô/€yØ6ˆzÐðRØwŠwxÑ Ô !§'¢'¨+Ñ"6Ô"6Ð6Ð6øÝ ð Rð Rð RÝÐGÈ&ÑPÑQÔQÐQðRøøøs ½)A' Á' Bc óB — d | ¦ « ¦ « }| }t |¦ « dk ra|d |dd… }}|dk rŒ-|dk r(t |¦ « \ }}t || |¦ « \ } }n|dv rt | |¦ « } nð|dk r't
¦ « }| |¦ « |} nÃ|dk r| ¦ « } n§|d k r9t ¦ « }| ¦ « |¦ « |} nh|
¦ « r$| t |¦ « ¦ « } n0| ¦ « r8t |¦ « \ }}| t ||z ¦ « ¦ « } nä|t v ryi }|d
k rE| j r>| j d }t# |d d
¦ « d
v s| d¦ « dk rd|d< | t' t | fi |¤Ž¦ « } nb|dv r%| t' |d¬¦ « ¦ « } n9|dv r#| t' |¦ « ¦ « } nt) d|z ¦ « ‚t |¦ « dk °a|S )uÎ Append MathML conversion of `string` to `node` and return it.
>>> parse_latex_math(math(), r'lpha')
math(mi('α'))
>>> parse_latex_math(mrow(), r'x_{n}')
mrow(msub(mi('x'), mi('n')))
rž r rÜ NrX ú_^rÐ rÑ rú rÉ r… r z([=ÚclassÚmathopenÚprefixÚformz/()[]|F©Ústretchyz
+*=<>,.!?`';@zUnsupported character: "%s")r Úsplitr r¡ Ú
handle_cmdÚhandle_script_or_limitr\ r r1 rh Úisalphar{ Úisdigitr£ r Úanomalous_charsrÿ r r( r} r/ ) ÚnoderŸ Útreer° ÚcmdnameÚnew_nodeÚnumberr Ú
previous_nodes r# Úparse_latex_mathrÌ E sˆ € ð XŠXf—l’l‘n”nÑ
%Ô
%€FØ €Då
ˆf‰+Œ+˜Š/‰/à˜1”I˜v a b bœzˆ6ˆà Š8ˆ8Ø Ø Š9ˆ9Ý )¨&Ñ 1Ô 1‰OˆGVÝ% g¨t°VÑ<Ô<‰LˆD&‘&Ø
$ˆYˆYÝ)¨$°Ñ2Ô2ˆD‰DØ
#ŠXˆXÝ‘v”vˆHØ KŠK˜Ñ !Ô !Ð !؈D‰DØ
#ŠXˆXØ—:’:‘<”<ˆD‰DØ
#ŠXˆXÝ‘u”uˆHØ JŠJ‰LŒL× Ò Ñ )Ô )Ð )؈D‰DØ
YŠY‰[Œ[ð AØ—;’;r !™uœuÑ%Ô%ˆD‰DØ
YŠY‰[Œ[ð AÝ '¨Ñ /Ô /‰NˆFFØ—;’;r ! F¡(™|œ|Ñ,Ô,ˆDˆDØ
•/Ð
!Ð
!ð ˆJØCŠxˆx˜DœMˆxØ $¤
¨bÔ 1
ݘM¨6°3Ñ7Ô7¸5Ð@Ð@Ø$×(Ò(¨Ñ1Ô1°ZÒ?Ð?Ø)1J˜vÑ&Ø—;’;r¥/°!Ô"4Ð CÐ C¸
Ð CÐ CÑDÔDˆDˆDØ
(ˆ]ˆ]Ø—;’;r !¨eÐ 4Ñ 4Ô 4Ñ5Ô5ˆDˆDØ
/Ð
!Ð
!Ø—;’;r !™uœuÑ%Ô%ˆDˆDå Ð ;¸aÑ ?Ñ@Ô@Ð @õS ˆf‰+Œ+˜Š/‰/ðT €Kr% c ó0 — | t v rAt t | ¦ « }| t v rd|d< | |¦ « }||fS | t v r | dk r$t |¦ « \ }}t |d¬¦ « }nt t | ¦ « }| dk r t
|t d¦ « ¦ « }nm| dk r t |t d ¦ « d
¬ ¦ « }nG| d k r t
|t d
¦ « ¦ « }n#| dk r t
|t d¦ « ¦ « }| |¦ « }|r,|d dvr"| t d¦ « ¦ « }||fS | t v r/t | \ }}}}|r)| t d||¬¦ « ¦ « }||fS |
¦ « rd}| t |¬¦ « ¦ « }|r$| t dd
¬¦ « ¦ « }|rE| t d¦ « ¦ « }| t d¬¦ « ¦ « }t |¦ « \ }}t ||¦ « }|r$| t dd
¬¦ « ¦ « }||fS | t v ró| dk rddi} nd t | i} | d k rd | d< t |¦ « \ }}
| d ¦ « r#t |d d … |¦ « }| d!k rt ||¦ « }| ¦ « s|d"k r$| t |fi | ¤Ž¦ « }||
fS t% dmi | ¤Ž} | | ¦ « | |fS | d#k r*| t d$d%d&d'¬(¦ « ¦ « }||fS | d)k rt |d*¦ « }||fS | t& v r3| t t& | d+¬,¦ « ¦ « }||fS | t( v r3| t t( | d-¬.¦ « ¦ « }||fS | t* v rUi } | t, v r|r|d d/v rd0| d1< n | d2v rd3| d< | t t* | fi | ¤Ž¦ « }||fS | t. v r i } t0 t. | }
t |¦ « \ }}|d4vrF t2 | d ¦ « }n$# t6 $ r t9 d5| ›d6|›d7¦ « ‚w xY w|
r|
| d8< |
| d9< d0| d:< | d;k s| d<¦ « r%t= ¦ « }| |¦ « |}|d=k r | t |fi | ¤Ž¦ « | d>k s| d?¦ « r| ¦ « }||fS | d@k r©tA |¦ « \ }}|dAk r|dB|z fS | d ¦ « r7 t* |d d … }n # t6 $ r t9 dC|z ¦ « ‚w xY wtC j" dD|dEz ¦ « }| t |¦ « ¦ « }||fS | dFv r’t |¦ « \ }}| # dG¦ « }tI |¦ « D ]W\ }}|dHz dk r9tK j& dIdJ|¦ « }| tO |¦ « ¦ « }ŒGt ||¦ « ŒX||fS | tP v r5| t dKtP | z ¬¦ « ¦ « }||fS | dLv rntS |¦ « \ }}| dM¦ « r dNtU |d dO… ¦ « dPz z }| t dK|z ¬¦ « ¦ « }||fS | dQk r'tW ¦ « }| |¦ « ||fS | dRk r)tY dS¬T¦ « }| |¦ « ||fS | dUk rt[ |¦ « \ }}|rDt= ¦ « }t] |d0¬V¦ « }t ||¦ « | ¦ « nt_ ¦ « }| |¦ « ||fS | t` v rÝt` | \ }}| dWk rHt[ |¦ « \ }}d;d>dXœ}||v r-| 1 ¦ « }|| |dY< dZ|| z |d< te dmi |¤Žx}}| d[¦ « r4t= t d¦ « |t d¦ « d[¬\¦ « }d]|_3 |r
t% |fi |¤Ž}| |¦ « ||fS | d k rZti ¦ « }tk |¦ « }| ¦ « ¦ « |¦ « ||fS | tl v rgt t tl | d d
¬¦ « d0¬V¦ « }| d^k rd
|j7 d d_< | |_8 | |¦ « ||fS | tr v rRt t tr | d d0¬ ¦ « d0d
¬`¦ « }| |_8 | |¦ « ||fS | dak r)t d0¬V¦ « }| |¦ « ||fS | tt v rOt
t tt | d ¦ « d0¬V¦ « }| |_8 | |¦ « ||fS | dbk r)t
d0¬V¦ « }| |¦ « ||fS | dcv rÂt[ |¦ « \ }}t t* dd| d d … z ¦ « } |ratw | ¦ « }t t= ¦ « |¦ « } ty | ¦ « d k r
| j7 d } | | ¦ « nt | ¦ « }| |¦ « ||fS | tz v r»t% dmi tz | ¤Ž}d |_3 t} |t< ¦ « rLty |¦ « dk r9||j? j7 |j? j7 @ |¦ « < |j? |_? n8|jA jB dek r| |¦ « nt9 df| z ¦ « ‚||fS | dg¦ « r.tA |¦ « \ }}
|dhv r|
}t‡ ||| ¬i¦ « }||fS | djk rt‰ ||¦ « S | dkk rt‹ ||¦ « S t9 dl| z ¦ « ‚)nuj Process LaTeX command `name` followed by `string`.
Append result to `node`.
If needed, parse `string` for command argument.
Return new current node and remainder of `string`:
>>> handle_cmd('hbar', math(), r' rac')
(math(mi('â„')), ' \frac')
>>> handle_cmd('hspace', math(), r'{1ex} (x)')
(math(mspace(width='1ex')), ' (x)')
z
capital-greekrº r rG )Ú mathvariantr r¹ r õ ¯F)Úaccentr r¸ r rª r )rº r¹ u â¡rB )ÚlspaceÚrspacer™ )ÚwidthrÌ r¾ ú0.333emrÍ rJ rÎ rV rX rÜ NrR rÊ Úcolonr ÚpostfixÚ0z0.28em)r½ rÑ rÒ Úidotsintz\int\dotsi\intzfont-weight: bold)Ústylez75%)Úmathsizez _^TÚ
movablelimits)rc re r» z()[]/|.zUnsupported "\z
" delimiter "z"!ÚmaxsizeÚminsizeÚ symmetricrì Úlú.rí ÚrÚnotrÐ z{\not z\not: Cannot negate: "%s"!ÚNFCu ̸)ÚtextÚmboxÚtextrmú$rÝ z(^ | $)rÈ z%s)Úhspacer˜ Úmuz%semr„ é ÚphantomÚboxedÚbox)ÚnotationÚsqrt)r rá )rß rá Únumalignz numalign-rç )râ rê r¶ rÐ )r rÐ ÚoversetÚunderset)Ú
xleftarrowÚ xrightarrowÚlongr÷ z3Declaration "\%s" must be first command in a group.Úlimitsr¹ )rö ÚbeginÚendzUnknown LaTeX command: \r )FÚlettersr{ Úgreek_capitalsr Ú functionsr´ rŽ r} r Úmodulo_functionsrL r˜ rÌ Úmath_alphabetsr¬ r( rR rà rr Úthick_operatorsÚsmall_operatorsÚ operatorsrÛ Ú
bigdelimitersÚdelimiter_sizesÚ stretchablesr³ rK r/ Úendswithr\ r1 rª Ú unicodedataÚ normalizerÀ Ú enumerater› Úsubry Úspacesr± Úfloatrn rj r· r” rp Ú fractionsÚcopyr– r, rh rf Úaccentsrÿ Útex_cmdÚoverÚunderr’ r Ú
layout_stylesr r0 r_ r r r Úbegin_environmentÚend_environment) r" rÆ rŸ rÉ r) ÚbinaryÚnamedÚ parenthesesÚpaddingr r¨ rÙ Údelimiter_attributesÚsizeÚ delimiterÚrowÚpartsÚiÚpartÚradixÚ indexnodeÚ
style_attsÚ frac_attsr¶ Úoptargsrä ÚentryÚ subscriptÚbaseÚsub_nodes r# rÁ rÁ ˜ sƒ € ð& w€€Ý•g˜d”mÑ$Ô$ˆØ •>Ð !Ð !ð !0ˆHWÑ Ø{Š{˜8Ñ$Ô$ˆØVˆ|Ðà yÐÑð >Ò !Ð !õ -¨VÑ4Ô4‰KˆCݘ#¨8Ð4Ñ4Ô4ˆHˆHå) Dœ/Ñ*Ô*ˆHà ;Ò Ð Ý ˜h¨3©¬Ñ0Ô0ˆHˆHØ
[Ò
Ð
Ý ˜X¥r¨$¡x¤x¸Ð>Ñ>Ô>ˆHˆHØ
\Ò
!Ð
!Ý ˜h¨8© ¬ Ñ5Ô5ˆHˆHØ
[Ò
Ð
Ý ˜h¨8© ¬ Ñ5Ô5ˆHà{Š{˜8Ñ$Ô$ˆð ð -f˜Q”i zÐ1Ð1Ø—;’;r (™|œ|Ñ,Ô,ˆDØVˆ|Ðà Õ Ð Ñ Ý0@ÀÔ0FÑ-ˆ˜ WØ ð Ø—;’;r %°ÀÐ HÑ HÔ HÑIÔIˆDؘ<Ð à =Š=‰?Œ?ð ؈GØ{Š{6¨Ð0Ñ0Ô0Ñ1Ô1ˆØ ð 8Ø—;’;r #°Ð 6Ñ 6Ô 6Ñ7Ô7ˆDØ ð 8Ø—;’;r %™yœyÑ)Ô)ˆDØ—;’;v¨IÐ 6Ñ 6Ô 6Ñ7Ô7ˆDÝ(¨Ñ0Ô0‰ ˆˆVÝ cÑ*Ô*ˆØ ð 8Ø—;’;r #°Ð 6Ñ 6Ô 6Ñ7Ô7ˆDØVˆ|Ðà ~Ð Ð Ø <Ò Ð Ø! <Ð0ˆJˆJà' ¸Ô)=Ð>ˆJØ 9Ò Ð Ø"+ˆJwÑ å+¨FÑ3Ô3‰ˆˆYØ >Š>˜$Ñ Ô ð ,õ —+’+˜c ! " "œg sÑ+Ô+ˆCØ 8Ò Ð õ —*’*˜S #Ñ&Ô&ˆCØ ;Š;‰=Œ=ð #˜C 8šO˜OØ—;’;r #Ð 4Ð 4¨Ð 4Ð 4Ñ5Ô5ˆDؘ?Ð "åÐ$Ð$˜Ð$Ð$ˆØ Š EÑÔÐØfˆ}Ð ð ˆw‚€Ø{Š{2˜c¨ ¸#ÀhÐOÑOÔOÑPÔPˆØVˆ|Ðà ˆzÒÐÝ Ð&7Ñ8Ô8ˆØVˆ|Ðà Ð Ð Ø{Š{2o¨dÔ 3Ð;NÐOÑOÔOÑPÔPˆØVˆ|Ðà Ð Ð Ø{Š{2o¨dÔ 3¸eÐDÑDÔDÑEÔEˆØVˆ|Ðà yÐÐ؈
Ø •=Ð Ð VÐ °°q´ ¸UÐ0BÐ0BØ*.ˆJÑ 'Ð 'Ø
Ð'Ð
'Ð
'Ø",ˆJwÑ Ø{Š{2i¨œoÐ<Ð<°Ð<Ð<Ñ=Ô=ˆØVˆ|Ðà }Ð Ñ Ø !Ð Ý }¨TÔ 2Ô3ˆÝ .¨vÑ 6Ô 6ш 6Ø ˜IÐ %Ð %ð
7Ý (¨×)9Ò)9¸$Ñ)?Ô)?Ô @ øÝð
7ð
7ð
7Ý!kØ%) T T¨9¨9¨9ð#6ñ 7ô 7ð 7ð
7øøøð ð 5Ø.2Ð Ñ +Ø.2Ð Ñ +Ø04Ð Ñ -Ø 6Š>ˆ>˜TŸ]š]¨3Ñ /Ô /ˆ>Ý‘&”&ˆCØ KŠK˜Ñ Ô Ð ØˆDØ ˜Ò Ð Ø KŠK˜9Ð=Ð=Ð(<Ð=Ð=Ñ >Ô >Ð >Ø 7Š?ˆ?˜dŸmšm¨CÑ 0Ô 0ˆ?Ø—:’:‘<”<ˆDØVˆ|Ðà ˆu‚}€}Ý Ñ'Ô'‰ ˆˆVØ #Š:ˆ:ؘ VÑ+Ð+Ð +Ø >Š>˜$Ñ Ô ð Eð
EÝ A B B¤Ô(øÝð
Eð
Eð
EÝ!Ð"?ÀÑ"CÑDÔDÐDð
EøøøåÔ# E¨3¨x©<Ñ8Ô8ˆØ{Š{2˜c™7œ7Ñ#Ô#ˆØVˆ|Ðð Ð)Ð)Ð)Ý(¨Ñ0Ô0‰ ˆˆVØ— ’ ˜#‘”ˆÝ Ñ'Ô'ð -ð -‰GˆAˆtØ1‰u˜ŠzˆzÝ”v˜i¨°4Ñ8Ô8Ø—{’{¥5¨¡;¤;Ñ/Ô/å tÑ,Ô,Ð,Ð,ØVˆ|Ðð v€~€~Ø{Š{6¨V°D¬\Ñ(9Ð:Ñ:Ô:Ñ;Ô;ˆØVˆ|Ðà Ð#Ð#Ð#Ý Ñ'Ô'‰ ˆˆVØ <Š<˜Ñ Ô ð 0àE # c r c¤(™OœO¨BÑ .Ñ/ˆCØ{Š{6¨¨S©Ð1Ñ1Ô1Ñ2Ô2ˆØVˆ|Ðà ˆyÒÐÝ‘:”:ˆØ Š HÑ Ô Ð Ø˜Ð Ð à ˆw‚€Ý UÐ+Ñ+Ô+ˆØ Š HÑ Ô Ð Ø˜Ð Ð ð
ˆv‚~€~Ý" 6Ñ*Ô*‰
ˆˆvØ ð Ý ™œˆIÝ ˜Y¨tÐ4Ñ4Ô4ˆHÝ ˜Y¨Ñ .Ô .Ð .Ø OŠOÑ Ô Ð Ð å ‘w”wˆHØ Š HÑ Ô Ð Ø˜Ð Ð à yÐÐÝ"+¨D¤/Ñ ˆYØ 7Š?ˆ?Ý '¨Ñ /Ô /‰NˆFFØ "¨Ð1Ð1ˆGØ˜Ð Ð Ø %ŸNšNÑ ,Ô , Ø(/°¬ ˜*Ñ%Ø%0°7¸6´?Ñ%B ˜'Ñ"Ý Ð,Ð, )Ð,Ð,Ð,ˆ4Ø =Š=˜Ñ !Ô !ð #ÝB˜s™GœG Xr°#©w¬w¸gÐFÑFÔFˆHØ!"ˆHÔ Ø ð 6Ý ˜hÐ5Ð5¨*Ð5Ð5ˆHØ Š HÑ Ô Ð ØVˆ|Ðà ˆt‚|€|Ý‘”ˆÝu‘:”:ˆØ
Š
‰ Œ ×ÒÑ Ô ×#Ò# HÑ-Ô-Ð-Øfˆ}Ð à w€€ÝG DœM¨!Ô ,°uÐ=Ñ=Ô=ÀdÐKÑKÔKˆØ 5Š=ˆ=Ø-2ˆHÔ ˜aÔ Ñ *Ø ˆÔØ Š HÑ Ô Ð Ø˜Ð Ð à t€|€|õ D œJ qœM°$Ð7Ñ7Ô7Ø $¨Uð4ñ 4ô 4ˆà ˆÔØ Š HÑ Ô Ð Ø˜Ð Ð à ˆyÒÐÝ Ð%Ñ%Ô%ˆØ Š HÑ Ô Ð Ø˜Ð Ð à u€}€}Ý"U 4œ[¨œ^Ñ,Ô,°TÐ:Ñ:Ô:ˆØ ˆÔØ Š HÑ Ô Ð Ø˜Ð Ð à ˆzÒÐÝ Ð&Ñ&Ô&ˆØ Š HÑ Ô Ð Ø˜Ð Ð à Ð,Ð,Ð,Ý & vÑ .Ô .ш 6Ý•)˜F 4¨¨¨¤8™OÔ,Ñ-Ô-ˆØ ð #Ý! $Ñ'Ô'ˆHÝ'©¬° Ñ:Ô:ˆHÝ8‰}Œ} Ò!Ð!Ø#Ô,¨QÔ/Ø OŠO˜HÑ %Ô %Ð %Ð %å ˜T‘{”{ˆHØ Š HÑ Ô Ð Ø˜Ð Ð à }Ð Ð ÝÐ0Ð0M¨$Ô /Ð0Ð0ˆØ !ˆÔÝ dDÑ !Ô !ð 4¥c¨$¡i¤i°1¢n nàEMˆDŒKÔ ¤Ô!5×!;Ò!;¸DÑ!AÔ!AÑ BØ "œkˆHŒOˆOØ
Œ^Ô
$¨Ò
.Ð
.Ø KŠK˜Ñ !Ô !Ð !Ð !å ð ,Ø.2ñ 3ñ 4ô 4ð
4à˜Ð Ð à ‡}‚}XÑ Ô ð Ý" 6Ñ*Ô*‰ˆˆYØ $ˆ;ˆ;Ø ˆFÝ)¨$°¸DÐAÑAÔAˆDØVˆ|Ðð ˆw‚€Ý vÑ.Ô.Ð.à ˆu‚}€}Ý ˜t VÑ,Ô,Ð,å
Ð1°DÑ8Ñ
9Ô
9Ð9s Ô T" Ô"!UØ+Y Ù Y rË c ó — | j ¦ « }|dk rd|d< n#|dk st |dd¦ « t v rd|d< |dk rŽt |t
¦ « rt
|j ddiŽ}nôt |t ¦ « rt |j ddiŽ}nÍ|d v s |dk r&| dd
¦ « rt |¦ « }nt |¦ « }n|d k r‡t |t ¦ « rt
|j Ž }nct |t ¦ « rt |j Ž }n?|d v s |dk r&| dd
¦ « rt |¦ « }nt |¦ « }| |¦ « |S ) z)Append script or limit element to `node`.rö FrÛ r rË Tr¹ r )rö rÛ Nrº )
rÿ r‚ r rÛ r r r’ rŠ rŒ r( rŽ rˆ r )rÆ r° rö r2 rÉ s r# r r ù s’ € à ŒM× Ò Ñ Ô €EØ
ÒÐØ!&ˆˆoÑ Ð Ø
OÒ
#Ð
#Ý
U˜F BÑ
'Ô
'=Ð
8Ð
8Ø!%ˆˆoÑ àˆC‚x€xÝ eUÑ #Ô #ð #Ý! 5¤>Ð?¸$Ð?Ð?ˆHˆHÝ
˜tÑ
$Ô
$ð #Ý ¤Ð<°tÐ<Ð<ˆHˆHØÐ3Ð3Ð3ؘ2’ %§)¢)¨O¸TÑ"BÔ"B Ý ˜e‘}”}ˆHˆHå˜E‘{”{ˆHˆHØ
ˆcŠˆÝ eVÑ $Ô $ð #Ý! 5¤>Ð2ˆHˆHÝ
˜tÑ
$Ô
$ð #Ý ¤Ð/ˆHˆHØÐ3Ð3Ð3ؘ2’ %§)¢)¨O¸TÑ"BÔ"B Ý ˜U‘|”|ˆHˆHå˜E‘{”{ˆH؇K‚KÑÔÐØ €Or% c ó0 — t |¦ « \ }}|t v rét | d }i }|r]t t |¦ « ¦ « }|dk r#t t |d¬¦ « ¦ « }d|d< | |¦ « |} n7|dk r1d|d < d
|d < t d ¬
¦ « }| |¦ « |} t
¦ « }| t t |¦ « fi |¤Ž¦ « |} nt d¦ « ‚| |fS )Nr rÙ z0.17em)rÒ rì Ú columnalignrÓ z0.02emÚ
rowspacingrÔ Ú
columnspacingÚ1)rÛ úEnvironment not supported!)
r± Úmatricesr\ r} r rr rh rX rf r/ )rÆ rŸ r" Úleft_delimiterr Úwrapperr$ s r# r r s- € Ý ˜VÑ$Ô$L€Dˆ&Ø xÐÐÝ! $œ ¨Ô*ˆØˆ
Ø ð Ý2˜nÑ-Ô-Ñ.Ô.ˆGØwŠˆÝ r .¸Ð BÑ BÔ BÑCÔCØ,2
˜=Ñ)Ø KŠK˜Ñ Ô Ð ØˆDˆDØ
]Ò
"Ð
"Ø'/ˆJ|Ñ $Ø*3ˆJÑ 'Ý ¨Ð-Ñ-Ô-ˆGØ KŠK˜Ñ Ô Ð ØˆDõ ‘”ˆØ Š •F3˜u™:œ:Ð4Ð4¨Ð4Ð4Ñ5Ô5Ð5؈ˆåÐ6Ñ7Ô7Ð7Ø ˆ<Ðr% c óœ — t |¦ « \ }}|t v rŸ| ¦ « ¦ « ¦ « } t | d }|r7| t |¦ « ¦ « } | ¦ « } n*|dk r| ¦ « } nt d¦ « ‚| |fS )NrÜ rÙ r. )r± r/ r1 r r} r/ )rÆ rŸ r" Úright_delimiters r# r r 6 s± € Ý ˜VÑ$Ô$L€Dˆ&Ø xÐÐØzŠz‰|Œ|×!Ò!Ñ#Ô#×)Ò)Ñ+Ô+ˆÝ" 4œ.¨Ô+ˆØ ð Ø—;’;r /Ñ 2Ô 2Ñ3Ô3ˆDØ—:’:‘<”<ˆDˆDØ
WŠ_ˆ_Ø—:’:‘<”<ˆDøåÐ6Ñ7Ô7Ð7Ø ˆ<Ðr% c ón — t d„ | D ¦ « ¦ « }|dk rdS t |dz dz ¦ « S )Nc 3 ól K — | ]/}| d ¦ « | d¦ « z
V — Œ0dS ©rú z\&N©Úcount©r! r s r# r$ z'tex_equation_columns..H ó= è è € ÐAÐA°SˆsyŠy˜‰~Œ~ § ¢ ¨%Ñ 0Ô 0Ñ0ÐAÐAÐAÐAÐAÐAr% r rÝ rÜ )r~ Úint)ÚrowsÚtabss r# Útex_equation_columnsr> G s@ € Ý ÐAÐA¸DÐAÑAÔAÑ AÔ A€DØ ˆq‚y€y؈qÝ ˆtA‰v˜‰z‰?Œ?Ðr% c óè — dddœ}t d„ | D ¦ « ¦ « }|rQddg|z }ddg|z }d |d |d
z … ¦ « |d < d |d |… ¦ « |d < |S )
NÚalignT)rº rÚ c 3 ól K — | ]/}| d ¦ « | d¦ « z
V — Œ0dS r6 r7 r9 s r# r$ z#align_attributes..[ r: r% rí rì r× r˜ rž rÜ r* r, )r~ r )r< Úattsr= ÚalignsÚspacings r# Úalign_attributesrE X sš € Ø Ø ð "ð "€Då ÐAÐA¸DÐAÑAÔAÑ AÔ A€DØ ð 9ؘ6Ð" TÑ)ˆØ˜, Ñ%ˆØ !Ÿhšh v¨g¨t°A©v¨g¤Ñ 7Ô 7ˆˆ]ÑØ #§¢¨°°$°¬ Ñ 8Ô 8ˆˆ_Ñ Ø €Kr% c óv — t d¬¦ « }|}|s‚d|d< t | ¦ « d¦ « }t |¦ « dk rHt ¦ « }| t
t |¦ « fi t |¦ « ¤Ž¦ « t || ¦ « |
¦ « S )zoReturn string with MathML code corresponding to `tex_math`.
Set `inline` to False for displayed math.
z"http://www.w3.org/1998/Math/MathML)ÚxmlnsrJ rI z\\rÜ ) r÷ r rÀ r rh r rX rf rE rÌ r7 )Útex_mathÚinlineÚ math_treerÆ r< s r# Ú
tex2mathmlrK m s € õ Ð?Ð@Ñ@Ô@€IØ €DØ ð ?Ø &ˆ )Ñ Ý ˜XÑ&Ô&×,Ò,¨UÑ3Ô3ˆÝ ˆt‰9Œ9qŠ=ˆ=å‘5”5ˆDØ × Ò V¥C¨¡I¤Ið >ð >Ý&6°tÑ&<Ô&<ð >ð >ñ
?ô
?ð
?åT˜8Ñ$Ô$Ð$Ø × Ò Ñ "Ô "Ð"r% )rË )T)LrQ r› r Údocutils.utils.mathr r Ú mathalpharù rú rû Úupdaterü rý r Ú mathfencer» Ú mathcloser ÚmathbinÚmathrelÚmathordÚ mathpunctÚmathoprþ rÿ rÛ r r
r r rÅ rR r/ r r r r r÷ rX r\ r^ rf rh rj rn rp rr rt ry r{ r} r r rˆ rŠ rŒ rŽ r r’ r” r– r˜ r¡ r£ rª r± r´ r· rÌ rÁ r r r r> rE rK r r% r# úrV sL
ðð ð ð
€ € € Ø Ð Ð Ð à :Ð :Ð :Ð :Ð :Ð :Ð :Ð :ð Ô
€Ø€ˆð
˜8¨hØ ˜h°Ø˜x°(Ø
ð +ð +€ð Ø Ø Ø àØØØàð
ð
€ ð
× Ò ð Að Að@ðAñ Aô Añ Aô Að Að
-Ø ,Ø ,Ø ,ð ð Ð ð ØØØ ØØ ØØ Ø!ØØ%Ø*Øð ð €ð.à4ðð 8ðð 8ð ð
8ð ð 8ð
ð 8ðð 8ðð 8ðð 8ðð 8ðð 8ðð #ðð (ð ð #ð ð (ð!ð" (ð#€ ð&
× Ò KÔ)Ñ *Ô *Ð *Ø × Ò KÔ(Ñ )Ô )Ð )Ø × Ò KÔ)Ñ *Ô *Ð *ð
à .ð
ð .ð
ð .ð
ð
.ð
ð .ð
ð .ð
ð .ð
ð .ð
ð ð
ð (ð
ð ð
ð ð
ð Hð
ð" ˆXð#
ð$ ˆXð%
ð& ˆXð'
ð( ˆXð)
ð* à Ø Ø Ø Ø ð7
ð
ð
€ ð:
× Ò Ô$Ñ %Ô %Ð %Ø × Ò Ô$Ñ %Ô %Ð %Ø × Ò Ô$Ñ %Ô %Ð %Ø × Ò Ô&Ñ 'Ô 'Ð 'Ø × Ò Ô#Ñ $Ô $Ð $Ø × Ò Ñ Ô Ð ð Ø ðð €ð Ø Ø Ø Ø Ø Ø ð ð €ð4€
ð !Ø Ø%Ø%Ø#Ø%Ø%Ø%Ø%Ø&Ø&Ø&Ø&ð
ð
€ð$ !Ø Ø Ø Ø Ø Ø!Ø Ø Ø Ø Ø!ð ð €ð( -Ø ,Ø ,Ø ,Ø ,Ø ,Ø ,ð ð €ð !1Ø 0Ø 0Ø 0Ø 0ð ð €ð !Ø Ø ðð €ð ØØØØð
ð
€ð Ø ØØØØØ#Øð
ð
€ð +/ÀÐBÐBØ*/ÀÐBÐBØ*/ÀÐBÐBØ*/ÀÐBÐBð ð €
ð 2ˆhØ $°aØ ð"ð "Ø#%ð'à ˜^Ô,¨bÐ1Ø ˜[Ô)¨2Ð.ØO QÐ'Ð(Ø ˜^Ô,¨ÀÐ.BÐCØ ˜[Ô)¨O¸QÐ+?Ð@ð
ð
€ ð AÐ@Ð@€ØØØØØØØØØØð
ð
€
ð @ ð @ ð @ ð @ ð @ ñ @ ô @ ð @ ð| Ð Ð Ð Ð ˆTÑ Ô Ð ð ð ð ð ð ˆ4ñ ô ð ð>Nð Nð Nð Nð NDñ Nô Nð Nð Ð Ð Ð Ð ˆ-Ñ Ô Ð Ø Ð Ð Ð Ð ˆ-Ñ Ô Ð ðð ð ð ð ˆ}ñ ô ð ðð ð ð ð ˆ}ñ ô ð ðð ð ð ð ˆMñ ô ð ðð ð ð ð ˆ]ñ ô ð ð =ð =ð =ð =ð =ñ =ô =ð =ð Ð Ð Ð Ð ˆIÑ Ô Ð Ø Ð Ð Ð Ð ˆÑ Ô Ð Ø Ð Ð Ð Ð ˆÑ Ô Ð Ø Ð Ð Ð Ð ˆÑ Ô Ð ð ð ð ð ð ñ ô ð ð, Ð Ð Ð Ð ˆ:Ñ Ô Ð Ø Ð Ð Ð Ð ˆ:Ñ Ô Ð ðð ð ð ð ˆjñ ô ð ð Ð Ð Ð Ð ˆTÑ Ô Ð Ø Ð Ð Ð Ð ˆDÑ Ô Ð ð" Ð Ð Ð Ð Ñ Ô Ð ðð ð ð ð ˆJñ ô ð ðð ð ð ð ˆDñ ô ð ðð ð ð ð ˆTñ ô ð ð"ð "ð "ð:
"ð
"ð
"ð6)ð )ð )ð> 9ð 9ð 9ðbð ð ð,Rð Rð Rð>7ð 7ð 7ðf{:ð {:ð {:ðB ð ð ð ðBð ð ð8 ð ð ð"ð ð ð" ð ð ð*#ð #ð #ð #ð #ð #r% PK ! 3œT}h h tex2mathml_extern.pynu „[µü¤ # :Id: $Id: tex2mathml_extern.py 9250 2022-11-16 14:01:31Z milde $
# :Copyright: © 2015 Günter Milde.
# :License: Released under the terms of the `2-Clause BSD license`_, in short:
#
# Copying and distribution of this file, with or without modification,
# are permitted in any medium without royalty provided the copyright
# notice and this notice are preserved.
# This file is offered as-is, without any warranty.
#
# .. _2-Clause BSD license: https://opensource.org/licenses/BSD-2-Clause
"""Wrappers for TeX->MathML conversion by external tools
This module is provisional:
the API is not settled and may change with any minor Docutils version.
"""
import subprocess
document_template = r"""\documentclass{article}
\usepackage{amsmath}
\begin{document}
%s
\end{document}
"""
def latexml(math_code, reporter=None):
"""Convert LaTeX math code to MathML with LaTeXML_
.. _LaTeXML: http://dlmf.nist.gov/LaTeXML/
"""
p = subprocess.Popen(['latexml',
'-', # read from stdin
'--preload=amsfonts',
'--preload=amsmath',
'--inputencoding=utf8',
],
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
close_fds=True)
p.stdin.write((document_template % math_code).encode('utf-8'))
p.stdin.close()
latexml_code = p.stdout.read()
latexml_err = p.stderr.read().decode('utf-8')
if reporter and (latexml_err.find('Error') >= 0 or not latexml_code):
reporter.error(latexml_err)
post_p = subprocess.Popen(['latexmlpost',
'-',
'--nonumbersections',
'--format=xhtml',
# '--linelength=78', # experimental
'--'
],
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
close_fds=True)
post_p.stdin.write(latexml_code)
post_p.stdin.close()
result = post_p.stdout.read().decode('utf-8')
post_p_err = post_p.stderr.read().decode('utf-8')
if reporter and (post_p_err.find('Error') >= 0 or not result):
reporter.error(post_p_err)
# extract MathML code:
start, end = result.find('')+7
result = result[start:end]
if 'class="ltx_ERROR' in result:
raise SyntaxError(result)
return result
def ttm(math_code, reporter=None):
"""Convert LaTeX math code to MathML with TtM_
.. _TtM: http://hutchinson.belmont.ma.us/tth/mml/
"""
p = subprocess.Popen(['ttm',
# '-i', # italic font for equations. Default roman.
'-u', # unicode encoding. (Default iso-8859-1).
'-r', # output raw MathML (no wrapper)
],
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
close_fds=True)
p.stdin.write((document_template % math_code).encode('utf-8'))
p.stdin.close()
result = p.stdout.read()
err = p.stderr.read().decode('utf-8')
if err.find('**** Unknown') >= 0:
msg = '\n'.join(line for line in err.splitlines()
if line.startswith('****'))
raise SyntaxError('\nMessage from external converter TtM:\n'+msg)
if reporter and err.find('**** Error') >= 0 or not result:
reporter.error(err)
start, end = result.find('')+7
return result[start:end]
def blahtexml(math_code, inline=True, reporter=None):
"""Convert LaTeX math code to MathML with blahtexml_
.. _blahtexml: http://gva.noekeon.org/blahtexml/
"""
options = ['--mathml',
'--indented',
'--spacing', 'moderate',
'--mathml-encoding', 'raw',
'--other-encoding', 'raw',
'--doctype-xhtml+mathml',
'--annotate-TeX',
]
if inline:
mathmode_arg = ''
else:
mathmode_arg = ' display="block"'
options.append('--displaymath')
p = subprocess.Popen(['blahtexml']+options,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
close_fds=True)
p.stdin.write(math_code.encode('utf-8'))
p.stdin.close()
result = p.stdout.read().decode('utf-8')
err = p.stderr.read().decode('utf-8')
if result.find('') >= 0:
msg = result[result.find('')+9:result.find('')]
raise SyntaxError('\nMessage from external converter blahtexml:\n%s'
% msg)
if reporter and (err.find('**** Error') >= 0 or not result):
reporter.error(err)
start, end = result.find('')+9, result.find('')
result = ('\n') % (mathmode_arg, result[start:end])
return result
def pandoc(math_code, reporter=None):
"""Convert LaTeX math code to MathML with pandoc_
.. _pandoc: https://pandoc.org/
"""
p = subprocess.Popen(['pandoc',
'--mathml',
'--from=latex',
],
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
close_fds=True)
p.stdin.write(math_code.encode('utf-8'))
p.stdin.close()
result = p.stdout.read().decode('utf-8')
err = p.stderr.read().decode('utf-8').strip()
x = p.wait()
if err:
if reporter:
reporter.error(err)
raise SyntaxError('\nError message from external converter pandoc:\n%s'
% err)
if x != 0:
raise SyntaxError('\nError code from external converter pandoc:\n%s'
% x)
start, end = result.find('')+7
return result[start:end]
# self-test
if __name__ == "__main__":
example = ('\\frac{\\partial \\sin^2(\\alpha)}{\\partial \\vec r}'
'\\varpi \\mathbb{R} \\, \\text{Grüße}')
# print(latexml('$'+example+'$'))
# print(ttm('$'+example.replace('\\mathbb{R}', '')+'$'))
print(blahtexml(example))
# print(pandoc('$'+example+'$'))
PK ! Ÿ”W/(É (É latex2mathml.pynu „[µü¤ # :Id: $Id: latex2mathml.py 9338 2023-04-08 21:08:47Z milde $
# :Copyright: © 2005 Jens Jørgen Mortensen [1]_
# © 2010, 2021 Günter Milde.
#
# :License: Released under the terms of the `2-Clause BSD license`_, in short:
#
# Copying and distribution of this file, with or without modification,
# are permitted in any medium without royalty provided the copyright
# notice and this notice are preserved.
# This file is offered as-is, without any warranty.
#
# .. _2-Clause BSD license: https://opensource.org/licenses/BSD-2-Clause
#
# .. [1] the original `rst2mathml.py` in `sandbox/jensj/latex_math`
"""Convert LaTex maths code into presentational MathML.
This module is provisional:
the API is not settled and may change with any minor Docutils version.
"""
# Usage:
#
# >>> from latex2mathml import *
import re
import unicodedata
from docutils.utils.math import tex2unichar, toplevel_code
# Character data
# --------------
# LaTeX math macro to Unicode mappings.
# Character categories.
# identifiers ->
letters = tex2unichar.mathalpha
letters['hbar'] = '\u210F' # compatibility mapping to â„ (\hslash).
# (ħ LATIN SMALL LETTER H WITH STROKE is upright)
# special case: Capital Greek letters: (upright in TeX style)
greek_capitals = {
'Phi': '\u03a6', 'Xi': '\u039e', 'Sigma': '\u03a3',
'Psi': '\u03a8', 'Delta': '\u0394', 'Theta': '\u0398',
'Upsilon': '\u03d2', 'Pi': '\u03a0', 'Omega': '\u03a9',
'Gamma': '\u0393', 'Lambda': '\u039b'}
# functions ->
functions = {
# functions with a space in the name
'liminf': 'lim\u202finf',
'limsup': 'lim\u202fsup',
'injlim': 'inj\u202flim',
'projlim': 'proj\u202flim',
# embellished function names (see handle_cmd() below)
'varlimsup': 'lim',
'varliminf': 'lim',
'varprojlim': 'lim',
'varinjlim': 'lim',
# custom function name
'operatorname': None,
}
functions.update((name, name) for name in
('arccos', 'arcsin', 'arctan', 'arg', 'cos',
'cosh', 'cot', 'coth', 'csc', 'deg',
'det', 'dim', 'exp', 'gcd', 'hom',
'ker', 'lg', 'ln', 'log', 'Pr',
'sec', 'sin', 'sinh', 'tan', 'tanh'))
# Function with limits: 'lim', 'sup', 'inf', 'max', 'min':
# use to allow "movablelimits" attribute (see below).
# modulo operator/arithmetic
modulo_functions = {
# cmdname: (binary, named, parentheses, padding)
'bmod': (True, True, False, '0.278em'), # a mod n
'pmod': (False, True, True, '0.444em'), # a (mod n)
'mod': (False, True, False, '0.667em'), # a mod n
'pod': (False, False, True, '0.444em'), # a (n)
}
# math font selection -> or
math_alphabets = {
# 'cmdname': 'mathvariant value' # package
'boldsymbol': 'bold',
'mathbf': 'bold',
'mathit': 'italic',
'mathtt': 'monospace',
'mathrm': 'normal',
'mathsf': 'sans-serif',
'mathcal': 'script',
'mathbfit': 'bold-italic', # isomath
'mathbb': 'double-struck', # amssymb
'mathfrak': 'fraktur', # amssymb
'mathsfit': 'sans-serif-italic', # isomath
'mathsfbfit': 'sans-serif-bold-italic', # isomath
'mathscr': 'script', # mathrsfs
# unsupported: bold-fraktur
# bold-script
# bold-sans-serif
}
# operator, fence, or separator ->
stretchables = {
# extensible delimiters allowed in left/right cmds
'backslash': '\\',
'uparrow': '\u2191', # ↑ UPWARDS ARROW
'downarrow': '\u2193', # ↓ DOWNWARDS ARROW
'updownarrow': '\u2195', # ↕ UP DOWN ARROW
'Uparrow': '\u21d1', # ⇑ UPWARDS DOUBLE ARROW
'Downarrow': '\u21d3', # ⇓ DOWNWARDS DOUBLE ARROW
'Updownarrow': '\u21d5', # ⇕ UP DOWN DOUBLE ARROW
'lmoustache': '\u23b0', # ⎰ … CURLY BRACKET SECTION
'rmoustache': '\u23b1', # ⎱ … LEFT CURLY BRACKET SECTION
'arrowvert': '\u23d0', # â VERTICAL LINE EXTENSION
'bracevert': '\u23aa', # ⎪ CURLY BRACKET EXTENSION
'lvert': '|', # left |
'lVert': '\u2016', # left ‖
'rvert': '|', # right |
'rVert': '\u2016', # right ‖
'Arrowvert': '\u2016', # ‖
}
stretchables.update(tex2unichar.mathfence)
stretchables.update(tex2unichar.mathopen) # Braces
stretchables.update(tex2unichar.mathclose) # Braces
# >>> print(' '.join(sorted(set(stretchables.values()))))
# [ \ ] { | } ‖ ↑ ↓ ↕ ⇑ ⇓ ⇕ ⌈ ⌉ ⌊ ⌋ ⌜ ⌠⌞ ⌟ ⎪ ⎰ ⎱ â ⟅ ⟆ ⟦ ⟧ ⟨ ⟩ ⟮ ⟯ ⦇ ⦈
operators = {
# negated symbols without pre-composed Unicode character
'nleqq': '\u2266\u0338', # ≦̸
'ngeqq': '\u2267\u0338', # ≧̸
'nleqslant': '\u2a7d\u0338', # ⩽̸
'ngeqslant': '\u2a7e\u0338', # ⩾̸
'ngtrless': '\u2277\u0338', # txfonts
'nlessgtr': '\u2276\u0338', # txfonts
'nsubseteqq': '\u2AC5\u0338', # ⫅̸
'nsupseteqq': '\u2AC6\u0338', # ⫆̸
# compatibility definitions:
'centerdot': '\u2B1D', # BLACK VERY SMALL SQUARE | mathbin
'varnothing': '\u2300', # ⌀ DIAMETER SIGN | empty set
'varpropto': '\u221d', # ∠PROPORTIONAL TO | sans serif
'triangle': '\u25B3', # WHITE UP-POINTING TRIANGLE | mathord
'triangledown': '\u25BD', # WHITE DOWN-POINTING TRIANGLE | mathord
# alias commands:
'dotsb': '\u22ef', # ⋯ with binary operators/relations
'dotsc': '\u2026', # … with commas
'dotsi': '\u22ef', # ⋯ with integrals
'dotsm': '\u22ef', # ⋯ multiplication dots
'dotso': '\u2026', # … other dots
# functions with movable limits (requires )
'lim': 'lim',
'sup': 'sup',
'inf': 'inf',
'max': 'max',
'min': 'min',
}
operators.update(tex2unichar.mathbin) # Binary symbols
operators.update(tex2unichar.mathrel) # Relation symbols, arrow symbols
operators.update(tex2unichar.mathord) # Miscellaneous symbols
operators.update(tex2unichar.mathpunct) # Punctuation
operators.update(tex2unichar.mathop) # Variable-sized symbols
operators.update(stretchables)
# special cases
thick_operators = {
# style='font-weight: bold;'
'thicksim': '\u223C', # ∼
'thickapprox': '\u2248', # ≈
}
small_operators = {
# mathsize='75%'
'shortmid': '\u2223', # ∣
'shortparallel': '\u2225', # ∥
'nshortmid': '\u2224', # ∤
'nshortparallel': '\u2226', # ∦
'smallfrown': '\u2322', # ⌢ FROWN
'smallsmile': '\u2323', # ⌣ SMILE
'smallint': '\u222b', # ∫ INTEGRAL
}
# Operators and functions with limits above/below in display formulas
# and in index position inline (movablelimits=True)
movablelimits = ('bigcap', 'bigcup', 'bigodot', 'bigoplus', 'bigotimes',
'bigsqcup', 'biguplus', 'bigvee', 'bigwedge',
'coprod', 'intop', 'ointop', 'prod', 'sum',
'lim', 'max', 'min', 'sup', 'inf')
# Depending on settings, integrals may also be in this category.
# (e.g. if "amsmath" is loaded with option "intlimits", see
# http://mirror.ctan.org/macros/latex/required/amsmath/amsldoc.pdf)
# movablelimits.extend(('fint', 'iiiint', 'iiint', 'iint', 'int', 'oiint',
# 'oint', 'ointctrclockwise', 'sqint',
# 'varointclockwise',))
# horizontal space ->
spaces = {'qquad': '2em', # two \quad
'quad': '1em', # 18 mu
'thickspace': '0.2778em', # 5mu = 5/18em
';': '0.2778em', # 5mu thickspace
' ': '0.25em', # inter word space
'medspace': '0.2222em', # 4mu = 2/9em
':': '0.2222em', # 4mu medspace
'thinspace': '0.1667em', # 3mu = 1/6em
',': '0.1667em', # 3mu thinspace
'negthinspace': '-0.1667em', # -3mu = -1/6em
'!': '-0.1667em', # negthinspace
'negmedspace': '-0.2222em', # -4mu = -2/9em
'negthickspace': '-0.2778em', # -5mu = -5/18em
}
# accents ->
accents = {
# TeX: (spacing, combining)
'acute': ('´', '\u0301'),
'bar': ('ˉ', '\u0304'),
'breve': ('˘', '\u0306'),
'check': ('ˇ', '\u030C'),
'dot': ('Ë™', '\u0307'),
'ddot': ('¨', '\u0308'),
'dddot': ('⋯', '\u20DB'),
'grave': ('`', '\u0300'),
'hat': ('ˆ', '\u0302'),
'mathring': ('Ëš', '\u030A'),
'tilde': ('˜', '\u0303'), # tilde ~ or small tilde ˜?
'vec': ('→', '\u20d7'), # → too heavy, accents="false"
# TODO: ddddot
}
# limits etc. -> or
over = {
# TeX: (char, offset-correction/em)
'overbrace': ('\u23DE', -0.2), # DejaVu Math -0.6
'overleftarrow': ('\u2190', -0.2),
'overleftrightarrow': ('\u2194', -0.2),
'overline': ('_', -0.2), # \u2012 does not stretch
'overrightarrow': ('\u2192', -0.2),
'widehat': ('^', -0.5),
'widetilde': ('~', -0.3),
}
under = {'underbrace': ('\u23DF', 0.1), # DejaVu Math -0.7
'underleftarrow': ('\u2190', -0.2),
'underleftrightarrow': ('\u2194', -0.2),
'underline': ('_', -0.8),
'underrightarrow': ('\u2192', -0.2),
}
# Character translations
# ----------------------
# characters with preferred alternative in mathematical use
# cf. https://www.w3.org/TR/MathML3/chapter7.html#chars.anomalous
anomalous_chars = {'-': '\u2212', # HYPHEN-MINUS -> MINUS SIGN
':': '\u2236', # COLON -> RATIO
'~': '\u00a0', # NO-BREAK SPACE
}
# blackboard bold (Greek characters not working with "mathvariant" (Firefox 78)
mathbb = {'Γ': '\u213E', # ℾ
'Î ': '\u213F', # â„¿
'Σ': '\u2140', # ⅀
'γ': '\u213D', # ℽ
'π': '\u213C', # ℼ
}
# Matrix environments
matrices = {
# name: fences
'matrix': ('', ''),
'smallmatrix': ('', ''), # smaller, see begin_environment()!
'pmatrix': ('(', ')'),
'bmatrix': ('[', ']'),
'Bmatrix': ('{', '}'),
'vmatrix': ('|', '|'),
'Vmatrix': ('\u2016', '\u2016'), # ‖
'cases': ('{', ''),
}
layout_styles = {
'displaystyle': {'displaystyle': True, 'scriptlevel': 0},
'textstyle': {'displaystyle': False, 'scriptlevel': 0},
'scriptstyle': {'displaystyle': False, 'scriptlevel': 1},
'scriptscriptstyle': {'displaystyle': False, 'scriptlevel': 2},
}
# See also https://www.w3.org/TR/MathML3/chapter3.html#presm.scriptlevel
fractions = {
# name: style_attrs, frac_attrs
'frac': ({}, {}),
'cfrac': ({'displaystyle': True, 'scriptlevel': 0,
'CLASS': 'cfrac'}, {}), # in LaTeX with padding
'dfrac': (layout_styles['displaystyle'], {}),
'tfrac': (layout_styles['textstyle'], {}),
'binom': ({}, {'linethickness': 0}),
'dbinom': (layout_styles['displaystyle'], {'linethickness': 0}),
'tbinom': (layout_styles['textstyle'], {'linethickness': 0}),
}
delimiter_sizes = ['', '1.2em', '1.623em', '2.047em', '2.470em']
bigdelimiters = {'left': 0,
'right': 0,
'bigl': 1,
'bigr': 1,
'Bigl': 2,
'Bigr': 2,
'biggl': 3,
'biggr': 3,
'Biggl': 4,
'Biggr': 4,
}
# MathML element classes
# ----------------------
class math:
"""Base class for MathML elements and root of MathML trees."""
nchildren = None
"""Expected number of children or None"""
# cf. https://www.w3.org/TR/MathML3/chapter3.html#id.3.1.3.2
parent = None
"""Parent node in MathML DOM tree."""
_level = 0 # indentation level (static class variable)
xml_entities = {
# for invalid and invisible characters
ord('<'): '<',
ord('>'): '>',
ord('&'): '&',
0x2061: '',
}
_boolstrings = {True: 'true', False: 'false'}
"""String representation of boolean MathML attribute values."""
html_tagname = 'span'
"""Tag name for HTML representation."""
def __init__(self, *children, **attributes):
"""Set up node with `children` and `attributes`.
Attributes are downcased: Use CLASS to set "class" value.
>>> math(mn(3), CLASS='test')
math(mn(3), class='test')
>>> math(CLASS='test').toprettyxml()
''
"""
self.children = []
self.extend(children)
self.attributes = {}
for key in attributes.keys():
# Use .lower() to allow argument `CLASS` for attribute `class`
# (Python keyword). MathML uses only lowercase attributes.
self.attributes[key.lower()] = attributes[key]
def __repr__(self):
content = [repr(item) for item in getattr(self, 'children', [])]
if hasattr(self, 'data'):
content.append(repr(self.data))
if isinstance(self, MathSchema) and self.switch:
content.append('switch=True')
content += ["%s=%r"%(k, v) for k, v in self.attributes.items()
if v is not None]
return self.__class__.__name__ + '(%s)' % ', '.join(content)
def __len__(self):
return len(self.children)
# emulate dictionary-like access to attributes
# see `docutils.nodes.Element` for dict/list interface
def __getitem__(self, key):
return self.attributes[key]
def __setitem__(self, key, item):
self.attributes[key] = item
def get(self, *args, **kwargs):
return self.attributes.get(*args, **kwargs)
def full(self):
"""Return boolean indicating whether children may be appended."""
return (self.nchildren is not None
and len(self) >= self.nchildren)
def append(self, child):
"""Append child and return self or first non-full parent.
If self is full, go up the tree and return first non-full node or
`None`.
"""
if self.full():
raise SyntaxError('Node %s already full!' % self)
self.children.append(child)
child.parent = self
if self.full():
return self.close()
return self
def extend(self, children):
for child in children:
self.append(child)
return self
def close(self):
"""Close element and return first non-full parent or None."""
parent = self.parent
while parent is not None and parent.full():
parent = parent.parent
return parent
def toprettyxml(self):
"""Return XML representation of self as string."""
return ''.join(self._xml())
def _xml(self, level=0):
return ([self.xml_starttag()]
+ self._xml_body(level)
+ ['' % self.__class__.__name__])
def xml_starttag(self):
attrs = ('%s="%s"' % (k, str(v).replace('True', 'true').replace('False', 'false'))
for k, v in self.attributes.items()
if v is not None)
return '<%s>' % ' '.join((self.__class__.__name__, *attrs))
def _xml_body(self, level=0):
xml = []
for child in self.children:
xml.extend(['\n', ' ' * (level+1)])
xml.extend(child._xml(level+1))
xml.extend(['\n', ' ' * level])
return xml
def is_block(self):
"""Return true, if `self` or a parent has ``display='block'``."""
try:
return self['display'] == 'block'
except KeyError:
try:
return self.parent.is_block()
except AttributeError:
return False
# >>> n2 = math(mn(2))
# >>> n2
# math(mn(2))
# >>> n2.toprettyxml()
# ''
# >>> len(n2)
# 1
# >>> eq3 = math(id='eq3', display='block')
# >>> eq3
# math(id='eq3', display='block')
# >>> eq3.toprettyxml()
# ''
# >>> len(eq3)
# 0
# >>> math(CLASS='bold').xml_starttag()
# '