je-editor 0.0.57__py3-none-any.whl → 0.0.59__py3-none-any.whl

venv/Lib/site-packages/docutils/utils/math/math2html.py

@@ -1,3171 +0,0 @@
-#! /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 os.path
-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 = {
-      '&': '&',
-      '<': '&lt;',
-      '>': '&gt;',
-      }
-
-
-class FormulaConfig:
-  "Configuration class from elyxer.config file"
-
-  alphacommands = {
-      '\\AmS': '<span class="textsc">AmS</span>',
-      '\\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.': '<span class="leftdot"></span>',
-      '\\middle': 'span class="stretchy"',
-      '\\right': 'span class="stretchy"',
-      '\\right.': '<span class="rightdot"></span>',
-      }
-
-  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 = {
-      '\\\\': '<br/>',
-      '\\\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': '<i>\u0127</i>', # ħ LATIN SMALL LETTER H WITH STROKE
-      '\\lVert': '‖',
-      '\\Arrowvert':  '\u2016', # ‖
-      '\\lvert': '|',
-      '\\newline': '<br/>',
-      '\\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': '<span class="thickspace"> </span>', # 5/13 em
-      '\\;': '<span class="thickspace"> </span>', # 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':    '<span class="smallsymbol">⋯</span>',
-      # '\\ddot':     '··', # ¨ too high
-      # '\\dot':      '·',
-      # '\\grave':    '`',
-      # '\\hat':      '^',
-      # '\\mathring': '˚',
-      # '\\tilde':    '~',
-      '\\vec':      '<span class="smallsymbol">→</span>',
-      # 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':    '<span class="bigoperator integral">∮</span>',
-      '\\bigcap':    '<span class="bigoperator">⋂</span>',
-      '\\bigcup':    '<span class="bigoperator">⋃</span>',
-      '\\bigodot':   '<span class="bigoperator">⨀</span>',
-      '\\bigoplus':  '<span class="bigoperator">⨁</span>',
-      '\\bigotimes': '<span class="bigoperator">⨂</span>',
-      '\\bigsqcap':  '<span class="bigoperator">⨅</span>',
-      '\\bigsqcup':  '<span class="bigoperator">⨆</span>',
-      '\\biguplus':  '<span class="bigoperator">⨄</span>',
-      '\\bigvee':    '<span class="bigoperator">⋁</span>',
-      '\\bigwedge':  '<span class="bigoperator">⋀</span>',
-      '\\coprod':    '<span class="bigoperator">∐</span>',
-      '\\intop':     '<span class="bigoperator integral">∫</span>',
-      '\\prod':      '<span class="bigoperator">∏</span>',
-      '\\sum':       '<span class="bigoperator">∑</span>',
-      '\\varprod':   '<span class="bigoperator">⨉</span>',
-      '\\zcmp': '⨟', '\\zhide': '⧹', '\\zpipe': '⨠', '\\zproject': '⨡',
-      # integrals have limits in index position with LaTeX default settings
-      # TODO: move to commands?
-      '\\int': '<span class="bigoperator integral">∫</span>',
-      '\\iint': '<span class="bigoperator integral">∬</span>',
-      '\\iiint': '<span class="bigoperator integral">∭</span>',
-      '\\iiiint': '<span class="bigoperator integral">⨌</span>',
-      '\\fint': '<span class="bigoperator integral">⨏</span>',
-      '\\idotsint': '<span class="bigoperator integral">∫⋯∫</span>',
-      '\\oint': '<span class="bigoperator integral">∮</span>',
-      '\\oiint': '<span class="bigoperator integral">∯</span>',
-      '\\oiiint': '<span class="bigoperator integral">∰</span>',
-      '\\ointclockwise': '<span class="bigoperator integral">∲</span>',
-      '\\ointctrclockwise': '<span class="bigoperator integral">∳</span>',
-      '\\smallint': '<span class="smallsymbol integral">∫</span>',
-      '\\sqint': '<span class="bigoperator integral">⨖</span>',
-      '\\varointclockwise': '<span class="bigoperator integral">∲</span>',
-      }
-
-  modified = {
-      '\n': '', ' ': '', '$': '', '&': '	', '\'': '’', '+': '\u2009+\u2009',
-      ',': ',\u2009', '-': '\u2009−\u2009', '/': '\u2009⁄\u2009', ':': ' : ', '<': '\u2009&lt;\u2009',
-      '=': '\u2009=\u2009', '>': '\u2009&gt;\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': '<span class="smallsymbol">∣</span>',
-      '\\shortparallel': '<span class="smallsymbol">∥</span>',
-      '\\nshortmid': '<span class="smallsymbol">∤</span>',
-      '\\nshortparallel': '<span class="smallsymbol">∦</span>',
-      '\\smallfrown': '<span class="smallsymbol">⌢</span>',
-      '\\smallsmile': '<span class="smallsymbol">⌣</span>',
-      '\\thickapprox': '<span class="boldsymbol">≈</span>',
-      '\\thicksim': '<span class="boldsymbol">∼</span>',
-      '\\varpropto': '<span class="mathsf">\u221d</span>', # ∝ 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('Usage: ' + os.path.basename(Options.location)
-                + ' [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 = '</' + self.tag.split()[0] + '>'
-    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 <hr/>)."
-    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 <span class="fbox">$1</span>.
-  Literal parameters can be used in tags definitions:
-    [f0{$1},span style="color: $p;"]
-  yields <span style="color: $p;">$1</span>, 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 <hr/>.
-  """
-
-  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 <hr/>
-      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()