Lines
0 %
Functions
Branches
100 %
//! `morx` layout transformations.
use std::cmp;
use tinyvec::{tiny_vec, TinyVec};
use crate::error::ParseError;
use crate::glyph_position::TextDirection;
use crate::gsub::{Feature, FeatureMask, GlyphOrigin, RawGlyph, RawGlyphFlags};
use crate::scripts::horizontal_text_direction;
use crate::tables::aat::{
CLASS_CODE_DELETED, CLASS_CODE_EOT, CLASS_CODE_OOB, DELETED_GLYPH, MAX_LEN, MAX_OPS,
};
use crate::tables::morx::{
self, Chain, ClassLookupTable, ContextualSubtable, InsertionSubtable, LigatureSubtable,
LookupTable, MorxTable, NonContextualSubtable, RearrangementSubtable, RearrangementVerb,
StxTable, Subtable, SubtableHeader, SubtableType,
use crate::tables::morx::{ContextualEntryFlag, LigatureEntryFlag};
/// Perform a lookup in a class lookup table.
fn lookup(glyph: u16, lookup_table: &ClassLookupTable<'_>) -> Option<u16> {
match &lookup_table.lookup_table {
LookupTable::Format0(lookup_values) => lookup_values.get_item(usize::from(glyph)),
LookupTable::Format2(lookup_segments) => {
lookup_segments.iter().find_map(|lookup_segment| {
lookup_segment
.contains(glyph)
.then_some(lookup_segment.lookup_value)
})
}
LookupTable::Format4(lookup_segments) => {
for lookup_segment in lookup_segments {
// The segments are meant to be non-overlapping so if a segment contains the glyph
// then we always return a result.
if lookup_segment.contains(glyph) {
let index = usize::from(glyph - lookup_segment.first_glyph);
return lookup_segment.lookup_values.get_item(index);
None
LookupTable::Format6(lookup_entries) => lookup_entries.iter().find_map(|lookup_entry| {
(lookup_entry.glyph == glyph).then_some(lookup_entry.lookup_value)
}),
LookupTable::Format8(lookup_table) => lookup_table.lookup(glyph),
LookupTable::Format10(lookup_table) => lookup_table.lookup(glyph),
fn get_class<'a, T, U>(glyphs: &[RawGlyph<()>], i: usize, subtable: &T) -> u16
where
T: StxTable<'a, U>,
{
let class_table = subtable.class_table();
match glyphs.get(i) {
Some(g) => {
if g.glyph_index == DELETED_GLYPH {
CLASS_CODE_DELETED
} else {
lookup(g.glyph_index, class_table).unwrap_or(CLASS_CODE_OOB)
None => CLASS_CODE_EOT,
fn get_entry<'a, T, U>(class: u16, next_state: u16, subtable: &T) -> Result<&U, ParseError>
let entry_table_index = subtable
.state_array()
.0
.get(usize::from(next_state))
.and_then(|s| s.get_item(usize::from(class)))
.ok_or(ParseError::BadIndex)?;
subtable
.entry_table()
.get(usize::from(entry_table_index))
.ok_or(ParseError::BadIndex)
struct RearrangementTransformation<'a> {
max_ops: isize,
glyphs: &'a mut Vec<RawGlyph<()>>,
next_state: u16,
mark_first_index: usize,
mark_last_index: usize,
impl<'a> RearrangementTransformation<'a> {
fn new(glyphs: &'a mut Vec<RawGlyph<()>>) -> RearrangementTransformation<'a> {
RearrangementTransformation {
max_ops: MAX_OPS,
glyphs,
next_state: 0,
mark_first_index: 0,
mark_last_index: 0,
fn process_glyphs(
&mut self,
rearrangement_subtable: &RearrangementSubtable<'_>,
) -> Result<(), ParseError> {
let len = self.glyphs.len();
let mut i = 0;
while i <= len {
let class = get_class(self.glyphs, i, rearrangement_subtable);
let entry = get_entry(class, self.next_state, rearrangement_subtable)?;
self.next_state = entry.next_state;
if entry.mark_first() {
self.mark_first_index = i;
if entry.mark_last() {
self.mark_last_index = cmp::min(i + 1, len);
if self.mark_first_index < self.mark_last_index {
let seq = &mut self.glyphs[self.mark_first_index..self.mark_last_index];
rearrange_glyphs(entry.verb(), seq);
// Guard against infinite loop during end-of-text processing, which is caused by the
// presence of the DONT_ADVANCE flag.
if class == CLASS_CODE_EOT {
break;
self.max_ops -= 1;
if !entry.dont_advance() || self.max_ops <= 0 {
i += 1;
Ok(())
fn rearrange_glyphs<T>(verb: RearrangementVerb, seq: &mut [T]) {
use RearrangementVerb::*;
let len = seq.len();
match verb {
Verb1 if len > 1 => seq.rotate_left(1),
Verb2 if len > 1 => seq.rotate_right(1),
Verb3 if len > 1 => seq.swap(0, len - 1),
Verb4 if len > 2 => seq.rotate_left(2),
Verb5 if len > 1 => {
seq.swap(0, 1);
seq.rotate_left(2);
Verb6 if len > 2 => seq.rotate_right(2),
Verb7 if len > 1 => {
seq.rotate_right(2);
Verb8 if len > 2 => {
seq[2..].rotate_left(1);
Verb9 if len > 2 => {
Verb10 if len > 2 => {
seq.rotate_right(1);
seq[1..].rotate_left(2);
Verb11 if len > 2 => {
Verb12 if len > 3 => {
seq[2..].rotate_left(2);
Verb13 if len > 3 => {
Verb14 if len > 3 => {
Verb15 if len > 3 => {
_ => {}
struct ContextualSubstitution<'a> {
mark_index: Option<usize>,
impl<'a> ContextualSubstitution<'a> {
fn new(glyphs: &'a mut Vec<RawGlyph<()>>) -> ContextualSubstitution<'a> {
ContextualSubstitution {
mark_index: None,
contextual_subtable: &ContextualSubtable<'_>,
while i <= self.glyphs.len() {
// It appears that no substitutions occur if mark isn't set prior to end-of-text.
if i == self.glyphs.len() && self.mark_index.is_none() {
return Ok(());
let class = get_class(self.glyphs, i, contextual_subtable);
let entry = get_entry(class, self.next_state, contextual_subtable)?;
if entry.mark_index != 0xFFFF {
let lookup_table = contextual_subtable
.substitution_subtables
.get(usize::from(entry.mark_index))
// In the event that a mark isn't set, implicitly mark the first glyph.
let mark_index = self.mark_index.unwrap_or(0);
let mark_glyph = self.glyphs[mark_index].glyph_index;
if let Some(mark_glyph_subst) = lookup(mark_glyph, lookup_table) {
self.glyphs[mark_index].glyph_index = mark_glyph_subst;
self.glyphs[mark_index].glyph_origin = GlyphOrigin::Direct;
if entry.current_index != 0xFFFF {
// End-of-text substitutions appear to operate on the end glyph.
let j = cmp::min(i, self.glyphs.len().saturating_sub(1));
.get(usize::from(entry.current_index))
let current_glyph = self.glyphs[j].glyph_index;
if let Some(current_glyph_subst) = lookup(current_glyph, lookup_table) {
self.glyphs[j].glyph_index = current_glyph_subst;
self.glyphs[j].glyph_origin = GlyphOrigin::Direct;
if entry.flags.contains(ContextualEntryFlag::SET_MARK) {
self.mark_index = Some(i);
if !entry.flags.contains(ContextualEntryFlag::DONT_ADVANCE) || self.max_ops <= 0 {
struct LigatureSubstitution<'a> {
component_stack: TinyVec<[usize; 32]>,
impl<'a> LigatureSubstitution<'a> {
fn new(glyphs: &'a mut Vec<RawGlyph<()>>) -> LigatureSubstitution<'a> {
let len = glyphs.len();
LigatureSubstitution {
component_stack: TinyVec::with_capacity(len),
ligature_subtable: &LigatureSubtable<'_>,
let class = get_class(self.glyphs, i, ligature_subtable);
let entry = get_entry(class, self.next_state, ligature_subtable)?;
self.next_state = entry.next_state_index;
if entry.flags.contains(LigatureEntryFlag::SET_COMPONENT) {
// `i` points to one past the buffer, so don't push it.
} else if self.component_stack.last() == Some(&i) {
// When DONT_ADVANCE == true, avoid pushing the same index twice.
self.component_stack.push(i);
if entry.flags.contains(LigatureEntryFlag::PERFORM_ACTION) {
let mut action_index = usize::from(entry.lig_action_index);
let mut ligature_list_index = 0;
let mut unicodes = tiny_vec!([char; 32]);
let mut end_i = None;
'stack: loop {
let popped_i = match self.component_stack.pop() {
Some(popped_i) => popped_i,
None => break 'stack, // Stack underflow.
if end_i.is_none() {
end_i = Some(popped_i);
let glyph = &mut self.glyphs[popped_i];
let glyph_index = glyph.glyph_index;
let variation = glyph.variation;
// Mark glyph for deletion; copy its `.unicodes` content into a temp buffer.
glyph.glyph_index = DELETED_GLYPH;
for &u in glyph.unicodes.iter().rev() {
unicodes.push(u);
let action = &ligature_subtable.action_table.0[action_index];
action_index += 1;
let component_index = i32::from(glyph_index) + action.offset();
let component_index = usize::try_from(component_index)?;
ligature_list_index += &ligature_subtable
.component_table
.component_array
.read_item(component_index)?;
// `last` implies `store`.
if action.last() || action.store() {
let ligature_glyph_index = ligature_subtable
.ligature_list
.get(ligature_list_index)
*glyph = RawGlyph {
unicodes: unicodes.iter().rev().copied().collect(),
glyph_index: ligature_glyph_index,
liga_component_pos: 0,
glyph_origin: GlyphOrigin::Direct,
flags: RawGlyphFlags::empty(),
extra_data: (),
variation,
// Push ligature onto stack, only when the next state is non-zero.
if self.next_state != 0 {
self.component_stack.push(popped_i);
i = end_i.ok_or(ParseError::BadIndex)?;
if action.last() {
break 'stack;
if !entry.flags.contains(LigatureEntryFlag::DONT_ADVANCE) || self.max_ops <= 0 {
fn noncontextual_substitution(
glyphs: &mut [RawGlyph<()>],
noncontextual_subtable: &NonContextualSubtable<'_>,
for glyph in glyphs.iter_mut() {
match lookup(glyph.glyph_index, &noncontextual_subtable.lookup_table) {
Some(subst) if subst != glyph.glyph_index => {
glyph.glyph_index = subst;
glyph.glyph_origin = GlyphOrigin::Direct;
Some(_) | None => (),
struct Insertion<'a> {
impl<'a> Insertion<'a> {
fn new(glyphs: &'a mut Vec<RawGlyph<()>>) -> Insertion<'a> {
Insertion {
insertion_subtable: &InsertionSubtable<'_>,
let class = get_class(self.glyphs, i, insertion_subtable);
let entry = get_entry(class, self.next_state, insertion_subtable)?;
let mark_pos = i;
if entry.marked_insert_index != 0xFFFF {
let before = entry.marked_insert_before();
let count = entry.marked_insert_count();
if self.glyphs.len() + count >= MAX_LEN {
let mut mark_index = self.mark_index.unwrap_or(0);
if !before {
mark_index += 1;
let mut insert_index = usize::from(entry.marked_insert_index);
for j in 0..count {
let glyph = RawGlyph {
// Use dotted circle as placeholder character for inserted glyph.
unicodes: tiny_vec!([char; 1] => '◌'),
glyph_index: insertion_subtable.action_table.0[insert_index].0,
variation: None,
self.glyphs.insert(j + mark_index, glyph);
insert_index += 1;
i += count;
if entry.current_insert_index != 0xFFFF {
let before = entry.current_insert_before();
let count = entry.current_insert_count();
let mut k = cmp::min(i, self.glyphs.len().saturating_sub(1));
k += 1;
let mut insert_index = usize::from(entry.current_insert_index);
self.glyphs.insert(j + k, glyph);
if entry.dont_advance() {
// The documentation for DONT_ADVANCE states: "If set, don't update the glyph
// index before going to the new state."
if entry.set_mark() {
self.mark_index = Some(mark_pos);
pub fn apply(
morx_table: &MorxTable<'_>,
glyphs: &mut Vec<RawGlyph<()>>,
feature_mask: FeatureMask,
script_tag: u32,
for chain in morx_table.chains.iter() {
apply_chain(chain, glyphs, feature_mask, script_tag)?;
fn apply_chain(
chain: &Chain<'_>,
let subfeatureflags: u32 = subfeatureflags(chain, feature_mask)?;
for subtable in chain.subtables.iter() {
if subfeatureflags & subtable.subtable_header.sub_feature_flags != 0 {
apply_subtable(subtable, glyphs, script_tag)?;
fn apply_subtable(
subtable: &Subtable<'_>,
let reverse_glyphs = reverse_glyphs(&subtable.subtable_header, script_tag);
if reverse_glyphs {
glyphs.reverse();
match &subtable.subtable_body {
SubtableType::Rearrangement(rearrangement_subtable) => {
let mut rearrangement_trans = RearrangementTransformation::new(glyphs);
rearrangement_trans.process_glyphs(rearrangement_subtable)?;
SubtableType::Contextual(contextual_subtable) => {
let mut contextual_subst = ContextualSubstitution::new(glyphs);
contextual_subst.process_glyphs(contextual_subtable)?;
SubtableType::Ligature(ligature_subtable) => {
let mut liga_subst = LigatureSubstitution::new(glyphs);
liga_subst.process_glyphs(ligature_subtable)?;
SubtableType::NonContextual(noncontextual_subtable) => {
noncontextual_substitution(glyphs, noncontextual_subtable)?
SubtableType::Insertion(insertion_subtable) => {
let mut insertion = Insertion::new(glyphs);
insertion.process_glyphs(insertion_subtable)?
// Determines if the glyph buffer should be reversed prior to (and after) applying a subtable.
// Note: the glyph buffer is always in logical order.
fn reverse_glyphs(subtable_header: &SubtableHeader, script_tag: u32) -> bool {
let descending_order = subtable_header.coverage.descending_order();
let logical_order = subtable_header.coverage.logical_order();
match (descending_order, logical_order) {
// The subtable is processed in layout order (the same order as the glyphs, which is always
// left-to-right).
(false, false) => match horizontal_text_direction(script_tag) {
TextDirection::LeftToRight => false,
TextDirection::RightToLeft => true,
},
// The subtable is processed in reverse layout order (the order opposite that of the
// glyphs, which is always right-to-left).
(true, false) => match horizontal_text_direction(script_tag) {
TextDirection::LeftToRight => true,
TextDirection::RightToLeft => false,
// The subtable is processed in logical order (the same order as the characters, which may
// be left-to-right or right-to-left).
(false, true) => false,
// The subtable is processed in reverse logical order (the order opposite that of the
// characters, which may be right-to-left or left-to-right).
(true, true) => true,
fn subfeatureflags(chain: &Chain<'_>, feature_mask: FeatureMask) -> Result<u32, ParseError> {
let mut subfeature_flags = chain.chain_header.default_flags;
for entry in chain.feature_array.iter() {
if should_apply_feature(entry, feature_mask) {
subfeature_flags = (subfeature_flags & entry.disable_flags) | entry.enable_flags;
Ok(subfeature_flags)
fn should_apply_feature(entry: morx::Feature, mask: FeatureMask) -> bool {
// Feature type:
const LIGATURE_TYPE: u16 = 1;
// Feature selectors:
const COMMON_LIGATURES_ON: u16 = 2;
const COMMON_LIGATURES_OFF: u16 = 3;
const CONTEXTUAL_LIGATURES_ON: u16 = 18;
const CONTEXTUAL_LIGATURES_OFF: u16 = 19;
const HISTORICAL_LIGATURES_ON: u16 = 20;
const HISTORICAL_LIGATURES_OFF: u16 = 21;
const NUMBER_CASE_TYPE: u16 = 21;
const OLD_STYLE_NUMBERS: u16 = 0;
const LINING_NUMBERS: u16 = 1;
const NUMBER_SPACING_TYPE: u16 = 6;
const TABULAR_NUMBERS: u16 = 0;
const PROPORTIONAL_NUMBERS: u16 = 1;
const FRACTION_TYPE: u16 = 11;
const NO_FRACTIONS: u16 = 0;
const FRACTIONS_STACKED: u16 = 1;
const FRACTIONS_DIAGONAL: u16 = 2;
const VERTICAL_POSITION_TYPE: u16 = 10;
const ORDINALS: u16 = 3;
const TYPOGRAPHIC_EXTRAS_TYPE: u16 = 14;
const SLASHED_ZERO_ON: u16 = 4;
const SLASHED_ZERO_OFF: u16 = 5;
const LOWERCASE_TYPE: u16 = 37;
const LOWERCASE_SMALL_CAPS: u16 = 1;
const UPPERCASE_TYPE: u16 = 38;
const UPPERCASE_SMALL_CAPS: u16 = 1;
match (entry.feature_type, entry.feature_setting) {
(NUMBER_CASE_TYPE, LINING_NUMBERS) => mask.contains(Feature::LNUM),
(NUMBER_CASE_TYPE, OLD_STYLE_NUMBERS) => mask.contains(Feature::ONUM),
(NUMBER_SPACING_TYPE, PROPORTIONAL_NUMBERS) => mask.contains(Feature::PNUM),
(NUMBER_SPACING_TYPE, TABULAR_NUMBERS) => mask.contains(Feature::TNUM),
(FRACTION_TYPE, FRACTIONS_DIAGONAL) => mask.contains(Feature::FRAC),
(FRACTION_TYPE, FRACTIONS_STACKED) => mask.contains(Feature::AFRC),
(FRACTION_TYPE, NO_FRACTIONS) => {
!mask.contains(Feature::FRAC) && !mask.contains(Feature::AFRC)
(VERTICAL_POSITION_TYPE, ORDINALS) => mask.contains(Feature::ORDN),
(TYPOGRAPHIC_EXTRAS_TYPE, SLASHED_ZERO_ON) => mask.contains(Feature::ZERO),
(TYPOGRAPHIC_EXTRAS_TYPE, SLASHED_ZERO_OFF) => !mask.contains(Feature::ZERO),
(LOWERCASE_TYPE, LOWERCASE_SMALL_CAPS) => {
mask.contains(Feature::SMCP) || mask.contains(Feature::C2SC)
(UPPERCASE_TYPE, UPPERCASE_SMALL_CAPS) => mask.contains(Feature::C2SC),
(LIGATURE_TYPE, COMMON_LIGATURES_ON) => mask.contains(Feature::LIGA),
(LIGATURE_TYPE, COMMON_LIGATURES_OFF) => !mask.contains(Feature::LIGA),
(LIGATURE_TYPE, HISTORICAL_LIGATURES_ON) => mask.contains(Feature::HLIG),
(LIGATURE_TYPE, HISTORICAL_LIGATURES_OFF) => !mask.contains(Feature::HLIG),
(LIGATURE_TYPE, CONTEXTUAL_LIGATURES_ON) => mask.contains(Feature::CLIG),
(LIGATURE_TYPE, CONTEXTUAL_LIGATURES_OFF) => !mask.contains(Feature::CLIG),
_ => false,
#[cfg(test)]
mod tests {
use super::*;
use crate::font::MatchingPresentation;
use crate::gsub::FeatureMaskExt;
use crate::tables::{FontTableProvider, MaxpTable, OpenTypeFont};
use crate::tests::read_fixture;
use crate::{binary::read::ReadScope, tag, Font};
mod rearrangement {
#[test]
fn test_verb1() {
let mut seq = ['A', 'x'];
rearrange_glyphs(Verb1, &mut seq);
assert_eq!(['x', 'A'], seq);
let mut seq = ['A'];
assert_eq!(['A'], seq);
fn test_verb2() {
let mut seq = ['x', 'D'];
rearrange_glyphs(Verb2, &mut seq);
assert_eq!(['D', 'x'], seq);
let mut seq = ['D'];
assert_eq!(['D'], seq);
fn test_verb3() {
let mut seq = ['A', 'x', 'D'];
rearrange_glyphs(Verb3, &mut seq);
assert_eq!(['D', 'x', 'A'], seq);
let mut seq = ['A', 'D'];
assert_eq!(['D', 'A'], seq);
fn test_verb4() {
let mut seq = ['A', 'B', 'x'];
rearrange_glyphs(Verb4, &mut seq);
assert_eq!(['x', 'A', 'B'], seq);
let mut seq = ['A', 'B'];
assert_eq!(['A', 'B'], seq);
fn test_verb5() {
rearrange_glyphs(Verb5, &mut seq);
assert_eq!(['x', 'B', 'A'], seq);
assert_eq!(['B', 'A'], seq);
fn test_verb6() {
let mut seq = ['x', 'C', 'D'];
rearrange_glyphs(Verb6, &mut seq);
assert_eq!(['C', 'D', 'x'], seq);
let mut seq = ['C', 'D'];
assert_eq!(['C', 'D'], seq);
fn test_verb7() {
rearrange_glyphs(Verb7, &mut seq);
assert_eq!(['D', 'C', 'x'], seq);
assert_eq!(['D', 'C'], seq);
fn test_verb8() {
let mut seq = ['A', 'x', 'C', 'D'];
rearrange_glyphs(Verb8, &mut seq);
assert_eq!(['C', 'D', 'x', 'A'], seq);
let mut seq = ['A', 'C', 'D'];
assert_eq!(['C', 'D', 'A'], seq);
fn test_verb9() {
rearrange_glyphs(Verb9, &mut seq);
assert_eq!(['D', 'C', 'x', 'A'], seq);
assert_eq!(['D', 'C', 'A'], seq);
fn test_verb10() {
let mut seq = ['A', 'B', 'x', 'D'];
rearrange_glyphs(Verb10, &mut seq);
assert_eq!(['D', 'x', 'A', 'B'], seq);
let mut seq = ['A', 'B', 'D'];
assert_eq!(['D', 'A', 'B'], seq);
fn test_verb11() {
rearrange_glyphs(Verb11, &mut seq);
assert_eq!(['D', 'x', 'B', 'A'], seq);
assert_eq!(['D', 'B', 'A'], seq);
fn test_verb12() {
let mut seq = ['A', 'B', 'x', 'C', 'D'];
rearrange_glyphs(Verb12, &mut seq);
assert_eq!(['C', 'D', 'x', 'A', 'B'], seq);
let mut seq = ['A', 'B', 'C', 'D'];
assert_eq!(['C', 'D', 'A', 'B'], seq);
fn test_verb13() {
rearrange_glyphs(Verb13, &mut seq);
assert_eq!(['C', 'D', 'x', 'B', 'A'], seq);
assert_eq!(['C', 'D', 'B', 'A'], seq);
fn test_verb14() {
rearrange_glyphs(Verb14, &mut seq);
assert_eq!(['D', 'C', 'x', 'A', 'B'], seq);
assert_eq!(['D', 'C', 'A', 'B'], seq);
fn test_verb15() {
rearrange_glyphs(Verb15, &mut seq);
assert_eq!(['D', 'C', 'x', 'B', 'A'], seq);
assert_eq!(['D', 'C', 'B', 'A'], seq);
#[cfg(feature = "prince")]
fn zapfino() -> Result<(), ParseError> {
let buffer = read_fixture("../../../tests/data/fonts/morx/Zapfino.ttf");
let otf = ReadScope::new(&buffer).read::<OpenTypeFont<'_>>().unwrap();
let table_provider = otf.table_provider(0).expect("error reading font file");
let maxp_data = table_provider
.read_table_data(tag::MAXP)
.expect("unable to read maxp table data");
let maxp = ReadScope::new(&maxp_data).read::<MaxpTable>().unwrap();
let morx_data = table_provider
.read_table_data(tag::MORX)
.expect("unable to read morx data");
let morx = ReadScope::new(&morx_data)
.read_dep::<MorxTable<'_>>(maxp.num_glyphs)
.expect("unable to parse morx table");
let provider = otf.table_provider(0).expect("error reading font file");
let mut font = Font::new(provider)?;
// Map text to glyphs and then apply font shaping
let script = tag!(b"latn");
let mut glyphs = font.map_glyphs("ptgffigpfl", script, MatchingPresentation::NotRequired);
let feature_mask = FeatureMask::default_mask();
apply(&morx, &mut glyphs, feature_mask, script)?;
let expected = [
(585, "p"),
(604, "t"),
(541, "g"),
(1086, "ffi"),
(65535, "f"),
(65535, "i"),
(1108, "pf"),
(565, "l"),
];
let actual = glyphs
.iter()
.map(|glyph| (glyph.glyph_index, glyph.unicodes.iter().collect::<String>()))
.collect::<Vec<_>>();
let actual = actual
.map(|(gid, text)| (*gid, text.as_str()))
assert_eq!(actual, expected);
let mut glyphs = font.map_glyphs("ptpfgffigpfl", script, MatchingPresentation::NotRequired);
// There is a ligature for the whole string Zapfino
let mut glyphs = font.map_glyphs("Zapfino", script, MatchingPresentation::NotRequired);
(1059, "Zapfino"),
(65535, "a"),
(65535, "p"),
(65535, "n"),
(65535, "o"),