r"""

try: # This will succeed if symbol is a single Unicode char

return ord(symbol)

except TypeError:

pass

try: # Is symbol a TeX symbol (i.e. \alpha)

return tex2uni[symbol.strip("\\")]

except KeyError as err:

raise ValueError(

f"{symbol!r} is not a valid Unicode character or TeX/Type1 symbol"

"""

width: float

height: float

depth: float

glyphs: list[tuple[FT2Font, float, int, float, float]]

"""

ox: float

oy: float

width: float

height: float

depth: float

r"""

def __init__(self, box: Box):

self.box = box

self.glyphs: list[tuple[float, float, FontInfo]] = [] # (ox, oy, info)

self.rects: list[tuple[float, float, float, float]] = [] # (x1, y1, x2, y2)

def to_vector(self) -> VectorParse:

w, h, d = map(

np.ceil, [self.box.width, self.box.height, self.box.depth])

gs = [(info.font, info.fontsize, info.num, ox, h - oy + info.offset)

for ox, oy, info in self.glyphs]

rs = [(x1, h - y2, x2 - x1, y2 - y1)

for x1, y1, x2, y2 in self.rects]

return VectorParse(w, h + d, d, gs, rs)

def to_raster(self, *, antialiased: bool) -> RasterParse:

# Metrics y's and mathtext y's are oriented in opposite directions,

# hence the switch between ymin and ymax.

xmin = min([*[ox + info.metrics.xmin for ox, oy, info in self.glyphs],

*[x1 for x1, y1, x2, y2 in self.rects], 0]) - 1

ymin = min([*[oy - info.metrics.ymax for ox, oy, info in self.glyphs],

*[y1 for x1, y1, x2, y2 in self.rects], 0]) - 1

xmax = max([*[ox + info.metrics.xmax for ox, oy, info in self.glyphs],

*[x2 for x1, y1, x2, y2 in self.rects], 0]) + 1

ymax = max([*[oy - info.metrics.ymin for ox, oy, info in self.glyphs],

*[y2 for x1, y1, x2, y2 in self.rects], 0]) + 1

w = xmax - xmin

h = ymax - ymin - self.box.depth

d = ymax - ymin - self.box.height

image = np.zeros((math.ceil(h + max(d, 0)), math.ceil(w)), np.uint8)

# Ideally, we could just use self.glyphs and self.rects here, shifting

# their coordinates by (-xmin, -ymin), but this yields slightly

# different results due to floating point slop; shipping twice is the

# old approach and keeps baseline images backcompat.

shifted = ship(self.box, (-xmin, -ymin))

for ox, oy, info in shifted.glyphs:

info.font.draw_glyph_to_bitmap(

image, int(ox), int(oy - info.metrics.iceberg), info.glyph,

antialiased=antialiased)

for x1, y1, x2, y2 in shifted.rects:

height = max(int(y2 - y1) - 1, 0)

if height == 0:

center = (y2 + y1) / 2

y = int(center - (height + 1) / 2)

else:

y = int(y1)

x1 = math.floor(x1)

x2 = math.ceil(x2)

image[y:y+height+1, x1:x2+1] = 0xff

"""

advance: float

height: float

width: float

xmin: float

xmax: float

ymin: float

ymax: float

iceberg: float

font: FT2Font

fontsize: float

postscript_name: str

metrics: FontMetrics

num: int

glyph: Glyph

"""

def __init__(self, default_font_prop: FontProperties, load_glyph_flags: LoadFlags):

"""

self.default_font_prop = default_font_prop

self.load_glyph_flags = load_glyph_flags

def get_kern(self, font1: str, fontclass1: str, sym1: str, fontsize1: float,

font2: str, fontclass2: str, sym2: str, fontsize2: float,

dpi: float) -> float:

"""

return 0.

def _get_font(self, font: str) -> FT2Font:

raise NotImplementedError

def _get_info(self, font: str, font_class: str, sym: str, fontsize: float,

dpi: float) -> FontInfo:

raise NotImplementedError

def get_metrics(self, font: str, font_class: str, sym: str, fontsize: float,

dpi: float) -> FontMetrics:

r"""

info = self._get_info(font, font_class, sym, fontsize, dpi)

return info.metrics

def render_glyph(self, output: Output, ox: float, oy: float, font: str,

font_class: str, sym: str, fontsize: float, dpi: float) -> None:

"""

info = self._get_info(font, font_class, sym, fontsize, dpi)

output.glyphs.append((ox, oy, info))

def render_rect_filled(self, output: Output,

x1: float, y1: float, x2: float, y2: float) -> None:

"""

output.rects.append((x1, y1, x2, y2))

def get_xheight(self, font: str, fontsize: float, dpi: float) -> float:

"""

raise NotImplementedError()

def get_underline_thickness(self, font: str, fontsize: float, dpi: float) -> float:

"""

raise NotImplementedError()

def get_sized_alternatives_for_symbol(self, fontname: str,

sym: str) -> list[tuple[str, str]]:

"""

"""

def __init__(self, default_font_prop: FontProperties, load_glyph_flags: LoadFlags):

super().__init__(default_font_prop, load_glyph_flags)

# Per-instance cache.

self._get_info = functools.cache(self._get_info) # type: ignore[method-assign]

self._fonts = {}

self.fontmap: dict[str | int, str] = {}

filename = findfont(self.default_font_prop)

default_font = get_font(filename)

self._fonts['default'] = default_font

self._fonts['regular'] = default_font

def _get_font(self, font: str | int) -> FT2Font:

if font in self.fontmap:

basename = self.fontmap[font]

else:

# NOTE: An int is only passed by subclasses which have placed int keys into

# `self.fontmap`, so we must cast this to confirm it to typing.

basename = T.cast(str, font)

cached_font = self._fonts.get(basename)

if cached_font is None and os.path.exists(basename):

cached_font = get_font(basename)

self._fonts[basename] = cached_font

self._fonts[cached_font.postscript_name] = cached_font

self._fonts[cached_font.postscript_name.lower()] = cached_font

return T.cast(FT2Font, cached_font) # FIXME: Not sure this is guaranteed.

def _get_offset(self, font: FT2Font, glyph: Glyph, fontsize: float,

dpi: float) -> float:

if font.postscript_name == 'Cmex10':

return (glyph.height / 64 / 2) + (fontsize/3 * dpi/72)

return 0.

def _get_glyph(self, fontname: str, font_class: str,

sym: str) -> tuple[FT2Font, int, bool]:

raise NotImplementedError

# The return value of _get_info is cached per-instance.

def _get_info(self, fontname: str, font_class: str, sym: str, fontsize: float,

dpi: float) -> FontInfo:

font, num, slanted = self._get_glyph(fontname, font_class, sym)

font.set_size(fontsize, dpi)

glyph = font.load_char(num, flags=self.load_glyph_flags)

xmin, ymin, xmax, ymax = (val / 64 for val in glyph.bbox)

offset = self._get_offset(font, glyph, fontsize, dpi)

metrics = FontMetrics(

advance=glyph.linearHoriAdvance / 65536,

height=glyph.height / 64,

width=glyph.width / 64,

xmin=xmin,

xmax=xmax,

ymin=ymin + offset,

ymax=ymax + offset,

# iceberg is the equivalent of TeX's "height"

iceberg=glyph.horiBearingY / 64 + offset,

slanted=slanted

)

return FontInfo(

font=font,

fontsize=fontsize,

postscript_name=font.postscript_name,

metrics=metrics,

num=num,

glyph=glyph,

offset=offset

)

def get_xheight(self, fontname: str, fontsize: float, dpi: float) -> float:

font = self._get_font(fontname)

font.set_size(fontsize, dpi)

pclt = font.get_sfnt_table('pclt')

if pclt is None:

# Some fonts don't store the xHeight, so we do a poor man's xHeight

metrics = self.get_metrics(

fontname, mpl.rcParams['mathtext.default'], 'x', fontsize, dpi)

return metrics.iceberg

xHeight = (pclt['xHeight'] / 64.0) * (fontsize / 12.0) * (dpi / 100.0)

return xHeight

def get_underline_thickness(self, font: str, fontsize: float, dpi: float) -> float:

# This function used to grab underline thickness from the font

# metrics, but that information is just too un-reliable, so it

# is now hardcoded.

return ((0.75 / 12.0) * fontsize * dpi) / 72.0

def get_kern(self, font1: str, fontclass1: str, sym1: str, fontsize1: float,

font2: str, fontclass2: str, sym2: str, fontsize2: float,

dpi: float) -> float:

if font1 == font2 and fontsize1 == fontsize2:

info1 = self._get_info(font1, fontclass1, sym1, fontsize1, dpi)

info2 = self._get_info(font2, fontclass2, sym2, fontsize2, dpi)

font = info1.font

return font.get_kerning(info1.num, info2.num, Kerning.DEFAULT) / 64

return super().get_kern(font1, fontclass1, sym1, fontsize1,

"""

_fontmap = {

'cal': 'cmsy10',

'rm': 'cmr10',

'tt': 'cmtt10',

'it': 'cmmi10',

'bf': 'cmb10',

'sf': 'cmss10',

'ex': 'cmex10',

}

def __init__(self, default_font_prop: FontProperties, load_glyph_flags: LoadFlags):

self._stix_fallback = StixFonts(default_font_prop, load_glyph_flags)

super().__init__(default_font_prop, load_glyph_flags)

for key, val in self._fontmap.items():

fullpath = findfont(val)

self.fontmap[key] = fullpath

self.fontmap[val] = fullpath

_slanted_symbols = set(r"\int \oint".split())

def _get_glyph(self, fontname: str, font_class: str,

sym: str) -> tuple[FT2Font, int, bool]:

font = None

if fontname in self.fontmap and sym in latex_to_bakoma:

basename, num = latex_to_bakoma[sym]

slanted = (basename == "cmmi10") or sym in self._slanted_symbols

font = self._get_font(basename)

elif len(sym) == 1:

slanted = (fontname == "it")

font = self._get_font(fontname)

if font is not None:

num = ord(sym)

if font is not None and font.get_char_index(num) != 0:

return font, num, slanted

else:

return self._stix_fallback._get_glyph(fontname, font_class, sym)

# The Bakoma fonts contain many pre-sized alternatives for the

# delimiters. The AutoSizedChar class will use these alternatives

# and select the best (closest sized) glyph.

_size_alternatives = {

'(': [('rm', '('), ('ex', '\xa1'), ('ex', '\xb3'),

('ex', '\xb5'), ('ex', '\xc3')],

')': [('rm', ')'), ('ex', '\xa2'), ('ex', '\xb4'),

('ex', '\xb6'), ('ex', '\x21')],

'{': [('cal', '{'), ('ex', '\xa9'), ('ex', '\x6e'),

('ex', '\xbd'), ('ex', '\x28')],

'}': [('cal', '}'), ('ex', '\xaa'), ('ex', '\x6f'),

('ex', '\xbe'), ('ex', '\x29')],

# The fourth size of '[' is mysteriously missing from the BaKoMa

# font, so I've omitted it for both '[' and ']'

'[': [('rm', '['), ('ex', '\xa3'), ('ex', '\x68'),

('ex', '\x22')],

']': [('rm', ']'), ('ex', '\xa4'), ('ex', '\x69'),

('ex', '\x23')],

r'\lfloor': [('ex', '\xa5'), ('ex', '\x6a'),

('ex', '\xb9'), ('ex', '\x24')],

r'\rfloor': [('ex', '\xa6'), ('ex', '\x6b'),

('ex', '\xba'), ('ex', '\x25')],

r'\lceil': [('ex', '\xa7'), ('ex', '\x6c'),

('ex', '\xbb'), ('ex', '\x26')],

r'\rceil': [('ex', '\xa8'), ('ex', '\x6d'),

('ex', '\xbc'), ('ex', '\x27')],

r'\langle': [('ex', '\xad'), ('ex', '\x44'),

('ex', '\xbf'), ('ex', '\x2a')],

r'\rangle': [('ex', '\xae'), ('ex', '\x45'),

('ex', '\xc0'), ('ex', '\x2b')],

r'\__sqrt__': [('ex', '\x70'), ('ex', '\x71'),

('ex', '\x72'), ('ex', '\x73')],

r'\backslash': [('ex', '\xb2'), ('ex', '\x2f'),

('ex', '\xc2'), ('ex', '\x2d')],

r'/': [('rm', '/'), ('ex', '\xb1'), ('ex', '\x2e'),

('ex', '\xcb'), ('ex', '\x2c')],

r'\widehat': [('rm', '\x5e'), ('ex', '\x62'), ('ex', '\x63'),

('ex', '\x64')],

r'\widetilde': [('rm', '\x7e'), ('ex', '\x65'), ('ex', '\x66'),

('ex', '\x67')],

r'<': [('cal', 'h'), ('ex', 'D')],

r'>': [('cal', 'i'), ('ex', 'E')]

}

for alias, target in [(r'\leftparen', '('),

(r'\rightparen', ')'),

(r'\leftbrace', '{'),

(r'\rightbrace', '}'),

(r'\leftbracket', '['),

(r'\rightbracket', ']'),

(r'\{', '{'),

(r'\}', '}'),

(r'\[', '['),

(r'\]', ']')]:

_size_alternatives[alias] = _size_alternatives[target]

def get_sized_alternatives_for_symbol(self, fontname: str,

sym: str) -> list[tuple[str, str]]:

"""

# Some glyphs are not present in the `cmr10` font, and must be brought in

# from `cmsy10`. Map the Unicode indices of those glyphs to the indices at

# which they are found in `cmsy10`.

_cmr10_substitutions = {

0x00D7: 0x00A3, # Multiplication sign.

0x2212: 0x00A1, # Minus sign.

}

def __init__(self, default_font_prop: FontProperties, load_glyph_flags: LoadFlags):

# This must come first so the backend's owner is set correctly

fallback_rc = mpl.rcParams['mathtext.fallback']

font_cls: type[TruetypeFonts] | None = {

'stix': StixFonts,

'stixsans': StixSansFonts,

'cm': BakomaFonts

}.get(fallback_rc)

self._fallback_font = (font_cls(default_font_prop, load_glyph_flags)

if font_cls else None)

super().__init__(default_font_prop, load_glyph_flags)

for texfont in "cal rm tt it bf sf bfit".split():

prop = mpl.rcParams['mathtext.' + texfont]

font = findfont(prop)

self.fontmap[texfont] = font

prop = FontProperties('cmex10')

font = findfont(prop)

self.fontmap['ex'] = font

# include STIX sized alternatives for glyphs if fallback is STIX

if isinstance(self._fallback_font, StixFonts):

stixsizedaltfonts = {

0: 'STIXGeneral',

1: 'STIXSizeOneSym',

2: 'STIXSizeTwoSym',

3: 'STIXSizeThreeSym',

4: 'STIXSizeFourSym',

5: 'STIXSizeFiveSym'}

for size, name in stixsizedaltfonts.items():

fullpath = findfont(name)

self.fontmap[size] = fullpath

self.fontmap[name] = fullpath

_slanted_symbols = set(r"\int \oint".split())

def _map_virtual_font(self, fontname: str, font_class: str,

uniindex: int) -> tuple[str, int]:

return fontname, uniindex

def _get_glyph(self, fontname: str, font_class: str,

sym: str) -> tuple[FT2Font, int, bool]:

try:

uniindex = get_unicode_index(sym)

found_symbol = True

except ValueError:

uniindex = ord('?')

found_symbol = False

_log.warning("No TeX to Unicode mapping for %a.", sym)

fontname, uniindex = self._map_virtual_font(

fontname, font_class, uniindex)

new_fontname = fontname

# Only characters in the "Letter" class should be italicized in 'it'

# mode. Greek capital letters should be Roman.

if found_symbol:

if fontname == 'it' and uniindex < 0x10000:

char = chr(uniindex)

if (unicodedata.category(char)[0] != "L"

or unicodedata.name(char).startswith("GREEK CAPITAL")):

new_fontname = 'rm'

slanted = (new_fontname == 'it') or sym in self._slanted_symbols

found_symbol = False

font = self._get_font(new_fontname)

if font is not None:

if (uniindex in self._cmr10_substitutions

and font.family_name == "cmr10"):

font = get_font(

cbook._get_data_path("fonts/ttf/cmsy10.ttf"))

uniindex = self._cmr10_substitutions[uniindex]

glyphindex = font.get_char_index(uniindex)

if glyphindex != 0:

found_symbol = True

if not found_symbol:

if self._fallback_font:

if (fontname in ('it', 'regular')

and isinstance(self._fallback_font, StixFonts)):

fontname = 'rm'

g = self._fallback_font._get_glyph(fontname, font_class, sym)

family = g[0].family_name

if family in list(BakomaFonts._fontmap.values()):

family = "Computer Modern"

_log.info("Substituting symbol %s from %s", sym, family)

return g

else:

if (fontname in ('it', 'regular')

and isinstance(self, StixFonts)):

return self._get_glyph('rm', font_class, sym)

_log.warning("Font %r does not have a glyph for %a [U+%x], "

"substituting with a dummy symbol.",

new_fontname, sym, uniindex)

font = self._get_font('rm')

uniindex = 0xA4 # currency char, for lack of anything better

slanted = False

return font, uniindex, slanted

def get_sized_alternatives_for_symbol(self, fontname: str,

sym: str) -> list[tuple[str, str]]:

if self._fallback_font:

return self._fallback_font.get_sized_alternatives_for_symbol(

fontname, sym)

_fontmap: dict[str | int, str] = {}

def __init__(self, default_font_prop: FontProperties, load_glyph_flags: LoadFlags):

# This must come first so the backend's owner is set correctly

if isinstance(self, DejaVuSerifFonts):

self._fallback_font = StixFonts(default_font_prop, load_glyph_flags)

else:

self._fallback_font = StixSansFonts(default_font_prop, load_glyph_flags)

self.bakoma = BakomaFonts(default_font_prop, load_glyph_flags)

TruetypeFonts.__init__(self, default_font_prop, load_glyph_flags)

# Include Stix sized alternatives for glyphs

self._fontmap.update({

1: 'STIXSizeOneSym',

2: 'STIXSizeTwoSym',

3: 'STIXSizeThreeSym',

4: 'STIXSizeFourSym',

5: 'STIXSizeFiveSym',

})

for key, name in self._fontmap.items():

fullpath = findfont(name)

self.fontmap[key] = fullpath

self.fontmap[name] = fullpath

def _get_glyph(self, fontname: str, font_class: str,

sym: str) -> tuple[FT2Font, int, bool]:

# Override prime symbol to use Bakoma.

if sym == r'\prime':

return self.bakoma._get_glyph(fontname, font_class, sym)

else:

# check whether the glyph is available in the display font

uniindex = get_unicode_index(sym)

font = self._get_font('ex')

if font is not None:

glyphindex = font.get_char_index(uniindex)

if glyphindex != 0:

return super()._get_glyph('ex', font_class, sym)

# otherwise return regular glyph

"""

_fontmap = {

'rm': 'DejaVu Serif',

'it': 'DejaVu Serif:italic',

'bf': 'DejaVu Serif:weight=bold',

'bfit': 'DejaVu Serif:italic:bold',

'sf': 'DejaVu Sans',

'tt': 'DejaVu Sans Mono',

'ex': 'DejaVu Serif Display',

0: 'DejaVu Serif',

"""

_fontmap = {

'rm': 'DejaVu Sans',

'it': 'DejaVu Sans:italic',

'bf': 'DejaVu Sans:weight=bold',

'bfit': 'DejaVu Sans:italic:bold',

'sf': 'DejaVu Sans',

'tt': 'DejaVu Sans Mono',

'ex': 'DejaVu Sans Display',

0: 'DejaVu Sans',

"""

_fontmap: dict[str | int, str] = {

'rm': 'STIXGeneral',

'it': 'STIXGeneral:italic',

'bf': 'STIXGeneral:weight=bold',

'bfit': 'STIXGeneral:italic:bold',

'nonunirm': 'STIXNonUnicode',

'nonuniit': 'STIXNonUnicode:italic',

'nonunibf': 'STIXNonUnicode:weight=bold',

0: 'STIXGeneral',

1: 'STIXSizeOneSym',

2: 'STIXSizeTwoSym',

3: 'STIXSizeThreeSym',

4: 'STIXSizeFourSym',

5: 'STIXSizeFiveSym',

}

_fallback_font = None

_sans = False

def __init__(self, default_font_prop: FontProperties, load_glyph_flags: LoadFlags):

TruetypeFonts.__init__(self, default_font_prop, load_glyph_flags)

for key, name in self._fontmap.items():

fullpath = findfont(name)

self.fontmap[key] = fullpath

self.fontmap[name] = fullpath

def _map_virtual_font(self, fontname: str, font_class: str,

uniindex: int) -> tuple[str, int]:

# Handle these "fonts" that are actually embedded in

# other fonts.

font_mapping = stix_virtual_fonts.get(fontname)

if (self._sans and font_mapping is None

and fontname not in ('regular', 'default')):

font_mapping = stix_virtual_fonts['sf']

doing_sans_conversion = True

else:

doing_sans_conversion = False

if isinstance(font_mapping, dict):

try:

mapping = font_mapping[font_class]

except KeyError:

mapping = font_mapping['rm']

elif isinstance(font_mapping, list):

mapping = font_mapping

else:

mapping = None

if mapping is not None:

# Binary search for the source glyph

lo = 0

hi = len(mapping)

while lo < hi:

mid = (lo+hi)//2

range = mapping[mid]

if uniindex < range[0]:

hi = mid

elif uniindex <= range[1]:

break

else:

lo = mid + 1

if range[0] <= uniindex <= range[1]:

uniindex = uniindex - range[0] + range[3]

fontname = range[2]

elif not doing_sans_conversion:

# This will generate a dummy character

uniindex = 0x1

fontname = mpl.rcParams['mathtext.default']

# Fix some incorrect glyphs.

if fontname in ('rm', 'it'):

uniindex = stix_glyph_fixes.get(uniindex, uniindex)

# Handle private use area glyphs

if fontname in ('it', 'rm', 'bf', 'bfit') and 0xe000 <= uniindex <= 0xf8ff:

fontname = 'nonuni' + fontname

return fontname, uniindex

@functools.cache

def get_sized_alternatives_for_symbol( # type: ignore[override]

self,

fontname: str,

sym: str) -> list[tuple[str, str]] | list[tuple[int, str]]:

fixes = {

'\\{': '{', '\\}': '}', '\\[': '[', '\\]': ']',

'<': '\N{MATHEMATICAL LEFT ANGLE BRACKET}',

'>': '\N{MATHEMATICAL RIGHT ANGLE BRACKET}',

}

sym = fixes.get(sym, sym)

try:

uniindex = get_unicode_index(sym)

except ValueError:

return [(fontname, sym)]

alternatives = [(i, chr(uniindex)) for i in range(6)

if self._get_font(i).get_char_index(uniindex) != 0]

# The largest size of the radical symbol in STIX has incorrect

# metrics that cause it to be disconnected from the stem.

if sym == r'\__sqrt__':

alternatives = alternatives[:-1]

"""

"""

# Percentage of x-height of additional horiz. space after sub/superscripts

script_space: T.ClassVar[float] = 0.05

# Percentage of x-height that sub/superscripts drop below the baseline

subdrop: T.ClassVar[float] = 0.4

# Percentage of x-height that superscripts are raised from the baseline

sup1: T.ClassVar[float] = 0.7

# Percentage of x-height that subscripts drop below the baseline

sub1: T.ClassVar[float] = 0.3

# Percentage of x-height that subscripts drop below the baseline when a

# superscript is present

sub2: T.ClassVar[float] = 0.5

# Percentage of x-height that sub/superscripts are offset relative to the

# nucleus edge for non-slanted nuclei

delta: T.ClassVar[float] = 0.025

# Additional percentage of last character height above 2/3 of the

# x-height that superscripts are offset relative to the subscript

# for slanted nuclei

delta_slanted: T.ClassVar[float] = 0.2

# Percentage of x-height that superscripts and subscripts are offset for

# integrals

script_space = 0.075

subdrop = 0.2

sup1 = 0.45

sub1 = 0.2

sub2 = 0.3

delta = 0.075

delta_slanted = 0.3

script_space = 0.1

sup1 = 0.8

sub2 = 0.6

delta = 0.05

delta_slanted = 0.3

script_space = 0.05

sup1 = 0.8

delta_slanted = 0.6

'DejaVu Sans': DejaVuSansFontConstants,

'DejaVu Sans Mono': DejaVuSansFontConstants,

'DejaVu Serif': DejaVuSerifFontConstants,

'cmb10': ComputerModernFontConstants,

'cmex10': ComputerModernFontConstants,

'cmmi10': ComputerModernFontConstants,

'cmr10': ComputerModernFontConstants,

'cmss10': ComputerModernFontConstants,

'cmsy10': ComputerModernFontConstants,

'cmtt10': ComputerModernFontConstants,

'STIXGeneral': STIXFontConstants,

'STIXNonUnicode': STIXFontConstants,

'STIXSizeFiveSym': STIXFontConstants,

'STIXSizeFourSym': STIXFontConstants,

'STIXSizeThreeSym': STIXFontConstants,

'STIXSizeTwoSym': STIXFontConstants,

'STIXSizeOneSym': STIXFontConstants,

# Map the fonts we used to ship, just for good measure

'Bitstream Vera Sans': DejaVuSansFontConstants,

'Bitstream Vera': DejaVuSansFontConstants,

constants = _font_constant_mapping.get(

state.fontset._get_font(state.font).family_name, FontConstantsBase)