use super::read::{tag_at, u16_at, u32_at};
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct Buffer {
pub glyphs: Vec<u16>,
pub clusters: Vec<usize>,
}
impl Buffer {
#[must_use]
pub fn new(pairs: &[(u16, usize)]) -> Self {
Self {
glyphs: pairs.iter().map(|(g, _)| *g).collect(),
clusters: pairs.iter().map(|(_, c)| *c).collect(),
}
}
#[must_use]
pub fn len(&self) -> usize {
self.glyphs.len()
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.glyphs.is_empty()
}
fn splice(&mut self, at: usize, take: usize, with: &[u16]) {
let cluster = self.clusters.get(at).copied().unwrap_or(0);
let end = (at + take).min(self.glyphs.len());
self.glyphs.splice(at..end, with.iter().copied());
self.clusters
.splice(at..end, core::iter::repeat_n(cluster, with.len()));
}
}
const MAX_DEPTH: usize = 8;
#[derive(Clone, Copy, Debug)]
pub struct Gsub<'a> {
data: &'a [u8],
script_list: usize,
feature_list: usize,
lookup_list: usize,
}
impl<'a> Gsub<'a> {
#[must_use]
pub fn parse(data: &'a [u8]) -> Option<Self> {
if u16_at(data, 0)? != 1 {
return None;
}
Some(Self {
data,
script_list: usize::from(u16_at(data, 4)?),
feature_list: usize::from(u16_at(data, 6)?),
lookup_list: usize::from(u16_at(data, 8)?),
})
}
fn features_of(&self, script: &[u8; 4]) -> Option<Vec<u16>> {
let count = usize::from(u16_at(self.data, self.script_list)?);
for i in 0..count {
let rec = self.script_list + 2 + 6 * i;
if tag_at(self.data, rec)? != *script {
continue;
}
let at = self.script_list + usize::from(u16_at(self.data, rec + 4)?);
let default = usize::from(u16_at(self.data, at)?);
if default == 0 {
return Some(Vec::new());
}
let lang = at + default;
let n = usize::from(u16_at(self.data, lang + 4)?);
let mut out = Vec::with_capacity(n + 1);
let required = u16_at(self.data, lang + 2)?;
if required != 0xFFFF {
out.push(required);
}
for j in 0..n {
out.push(u16_at(self.data, lang + 6 + 2 * j)?);
}
return Some(out);
}
None
}
#[must_use]
pub fn lookups_for_script(&self, script: &[u8; 4], tag: &[u8; 4]) -> Vec<u16> {
let allowed = self
.features_of(script)
.or_else(|| self.features_of(b"DFLT"))
.unwrap_or_default();
let mut out = Vec::new();
let Some(count) = u16_at(self.data, self.feature_list) else {
return out;
};
for i in 0..usize::from(count) {
let Some(rec) = self.feature_list.checked_add(2 + 6 * i) else {
break;
};
if tag_at(self.data, rec) != Some(*tag) {
continue;
}
if !allowed.contains(&u16::try_from(i).unwrap_or(u16::MAX)) {
continue;
}
let Some(off) = u16_at(self.data, rec + 4) else {
continue;
};
let feature = self.feature_list + usize::from(off);
let Some(n) = u16_at(self.data, feature + 2) else {
continue;
};
for j in 0..usize::from(n) {
if let Some(idx) = u16_at(self.data, feature + 4 + 2 * j)
&& !out.contains(&idx)
{
out.push(idx);
}
}
}
out
}
#[must_use]
pub fn has(&self, script: &[u8; 4], tag: &[u8; 4]) -> bool {
!self.lookups_for_script(script, tag).is_empty()
}
#[must_use]
pub fn subtables(&self, index: u16) -> Option<(u16, Vec<usize>)> {
let total = u16_at(self.data, self.lookup_list)?;
if index >= total {
return None;
}
let off = u16_at(self.data, self.lookup_list + 2 + 2 * usize::from(index))?;
let lookup = self.lookup_list + usize::from(off);
let kind = u16_at(self.data, lookup)?;
let n = usize::from(u16_at(self.data, lookup + 4)?);
let mut out = Vec::with_capacity(n);
let mut real = kind;
for j in 0..n {
let s = lookup + usize::from(u16_at(self.data, lookup + 6 + 2 * j)?);
if kind == 7 {
real = u16_at(self.data, s + 2)?;
out.push(s + u32_at(self.data, s + 4)? as usize);
} else {
out.push(s);
}
}
Some((real, out))
}
pub fn apply_feature(&self, script: &[u8; 4], tag: &[u8; 4], buf: &mut Buffer) {
for index in self.lookups_for_script(script, tag) {
let mut at = 0;
while at < buf.len() {
if self.apply_at(index, buf, at, 0) {
at += 1;
} else {
at += 1;
}
}
}
}
fn apply_at(&self, index: u16, buf: &mut Buffer, at: usize, depth: usize) -> bool {
if depth > MAX_DEPTH || at >= buf.len() {
return false;
}
let Some((kind, subs)) = self.subtables(index) else {
return false;
};
for sub in subs {
let did = match kind {
1 => self.single(sub, buf.glyphs[at]).map(|g| {
buf.glyphs[at] = g;
true
}),
2 => self.multiple(sub, buf.glyphs[at]).map(|many| {
buf.splice(at, 1, &many);
true
}),
3 => self.alternate(sub, buf.glyphs[at]).map(|g| {
buf.glyphs[at] = g;
true
}),
4 => self
.ligature_in(sub, buf.glyphs[at], &buf.glyphs[at..])
.map(|(g, n)| {
buf.splice(at, n, &[g]);
true
}),
5 | 6 => self.contextual(sub, buf, at, kind, depth),
_ => None,
};
if did == Some(true) {
return true;
}
}
false
}
fn contextual_1(
&self,
sub: usize,
buf: &mut Buffer,
at: usize,
kind: u16,
depth: usize,
) -> Option<bool> {
let coverage = sub + usize::from(u16_at(self.data, sub + 2)?);
let index = usize::from(coverage_index(self.data, coverage, buf.glyphs[at])?);
let sets = usize::from(u16_at(self.data, sub + 4)?);
if index >= sets {
return None;
}
let set = sub + usize::from(u16_at(self.data, sub + 6 + 2 * index)?);
let rules = usize::from(u16_at(self.data, set)?);
for r in 0..rules {
let rule = set + usize::from(u16_at(self.data, set + 2 + 2 * r)?);
let mut p = rule;
let backtrack = if kind == 6 {
let n = usize::from(u16_at(self.data, p)?);
p += 2;
let g: Vec<u16> = (0..n)
.map(|i| u16_at(self.data, p + 2 * i))
.collect::<Option<Vec<u16>>>()?;
p += 2 * n;
g
} else {
Vec::new()
};
let input_n = usize::from(u16_at(self.data, p)?);
p += 2;
let input: Vec<u16> = (0..input_n.saturating_sub(1))
.map(|i| u16_at(self.data, p + 2 * i))
.collect::<Option<Vec<u16>>>()?;
p += 2 * input.len();
let lookahead = if kind == 6 {
let n = usize::from(u16_at(self.data, p)?);
p += 2;
let g: Vec<u16> = (0..n)
.map(|i| u16_at(self.data, p + 2 * i))
.collect::<Option<Vec<u16>>>()?;
p += 2 * n;
g
} else {
Vec::new()
};
let record_n = usize::from(u16_at(self.data, p)?);
p += 2;
if input_n == 0 || at + input_n > buf.len() || backtrack.len() > at {
continue;
}
if !input
.iter()
.enumerate()
.all(|(k, g)| buf.glyphs[at + 1 + k] == *g)
{
continue;
}
if !backtrack
.iter()
.enumerate()
.all(|(k, g)| buf.glyphs[at - 1 - k] == *g)
{
continue;
}
let after = at + input_n;
if after + lookahead.len() > buf.len() {
continue;
}
if !lookahead
.iter()
.enumerate()
.all(|(k, g)| buf.glyphs[after + k] == *g)
{
continue;
}
let mut did = false;
for i in 0..record_n {
let rec = p + 4 * i;
let seq = usize::from(u16_at(self.data, rec)?);
let lookup = u16_at(self.data, rec + 2)?;
if self.apply_at(lookup, buf, at + seq, depth + 1) {
did = true;
}
}
return Some(did);
}
None
}
fn alternate(&self, sub: usize, glyph: u16) -> Option<u16> {
if u16_at(self.data, sub)? != 1 {
return None;
}
let coverage = sub + usize::from(u16_at(self.data, sub + 2)?);
let index = usize::from(coverage_index(self.data, coverage, glyph)?);
let count = usize::from(u16_at(self.data, sub + 4)?);
if index >= count {
return None;
}
let set = sub + usize::from(u16_at(self.data, sub + 6 + 2 * index)?);
if u16_at(self.data, set)? == 0 {
return None;
}
u16_at(self.data, set + 2)
}
fn class_of(&self, at: usize, glyph: u16) -> u16 {
let one = |()| -> Option<u16> {
let start = u16_at(self.data, at + 2)?;
let n = u16_at(self.data, at + 4)?;
let i = glyph.checked_sub(start)?;
if i >= n {
return None;
}
u16_at(self.data, at + 6 + 2 * usize::from(i))
};
let two = |()| -> Option<u16> {
let n = usize::from(u16_at(self.data, at + 2)?);
for i in 0..n {
let rec = at + 4 + 6 * i;
let (first, last) = (u16_at(self.data, rec)?, u16_at(self.data, rec + 2)?);
if glyph >= first && glyph <= last {
return u16_at(self.data, rec + 4);
}
}
None
};
match u16_at(self.data, at) {
Some(1) => one(()).unwrap_or(0),
Some(2) => two(()).unwrap_or(0),
_ => 0,
}
}
fn contextual_2(
&self,
sub: usize,
buf: &mut Buffer,
at: usize,
kind: u16,
depth: usize,
) -> Option<bool> {
let coverage = sub + usize::from(u16_at(self.data, sub + 2)?);
coverage_index(self.data, coverage, buf.glyphs[at])?;
let (back_def, input_def, ahead_def, head) = if kind == 6 {
(
sub + usize::from(u16_at(self.data, sub + 4)?),
sub + usize::from(u16_at(self.data, sub + 6)?),
sub + usize::from(u16_at(self.data, sub + 8)?),
12,
)
} else {
let d = sub + usize::from(u16_at(self.data, sub + 4)?);
(d, d, d, 8)
};
let sets = usize::from(u16_at(self.data, sub + head - 2)?);
let index = usize::from(self.class_of(input_def, buf.glyphs[at]));
if index >= sets {
return None;
}
let off = usize::from(u16_at(self.data, sub + head + 2 * index)?);
if off == 0 {
return None; }
let set = sub + off;
let rules = usize::from(u16_at(self.data, set)?);
for r in 0..rules {
let rule = set + usize::from(u16_at(self.data, set + 2 + 2 * r)?);
let mut p = rule;
let read = |p: usize, n: usize| -> Option<Vec<u16>> {
(0..n).map(|i| u16_at(self.data, p + 2 * i)).collect()
};
let backtrack = if kind == 6 {
let n = usize::from(u16_at(self.data, p)?);
p += 2;
let g = read(p, n)?;
p += 2 * n;
g
} else {
Vec::new()
};
let input_n = usize::from(u16_at(self.data, p)?);
p += 2;
let input = read(p, input_n.saturating_sub(1))?;
p += 2 * input.len();
let lookahead = if kind == 6 {
let n = usize::from(u16_at(self.data, p)?);
p += 2;
let g = read(p, n)?;
p += 2 * n;
g
} else {
Vec::new()
};
let record_n = usize::from(u16_at(self.data, p)?);
p += 2;
if input_n == 0 || at + input_n > buf.len() || backtrack.len() > at {
continue;
}
let class = |def: usize, i: usize| self.class_of(def, buf.glyphs[i]);
if !input
.iter()
.enumerate()
.all(|(k, c)| class(input_def, at + 1 + k) == *c)
{
continue;
}
if !backtrack
.iter()
.enumerate()
.all(|(k, c)| class(back_def, at - 1 - k) == *c)
{
continue;
}
let after = at + input_n;
if after + lookahead.len() > buf.len() {
continue;
}
if !lookahead
.iter()
.enumerate()
.all(|(k, c)| class(ahead_def, after + k) == *c)
{
continue;
}
let mut did = false;
for i in 0..record_n {
let rec = p + 4 * i;
let seq = usize::from(u16_at(self.data, rec)?);
let lookup = u16_at(self.data, rec + 2)?;
if self.apply_at(lookup, buf, at + seq, depth + 1) {
did = true;
}
}
return Some(did);
}
None
}
fn contextual(
&self,
sub: usize,
buf: &mut Buffer,
at: usize,
kind: u16,
depth: usize,
) -> Option<bool> {
match u16_at(self.data, sub)? {
1 => return self.contextual_1(sub, buf, at, kind, depth),
2 => return self.contextual_2(sub, buf, at, kind, depth),
3 => {}
_ => return None,
}
let mut p = sub + 2;
let backtrack = if kind == 6 {
let n = usize::from(u16_at(self.data, p)?);
p += 2;
let offs: Vec<usize> = (0..n)
.map(|i| u16_at(self.data, p + 2 * i).map(usize::from))
.collect::<Option<Vec<usize>>>()?;
p += 2 * n;
offs
} else {
Vec::new()
};
let input_n = usize::from(u16_at(self.data, p)?);
p += 2;
let input: Vec<usize> = (0..input_n)
.map(|i| u16_at(self.data, p + 2 * i).map(usize::from))
.collect::<Option<Vec<usize>>>()?;
p += 2 * input_n;
let lookahead = if kind == 6 {
let n = usize::from(u16_at(self.data, p)?);
p += 2;
let offs: Vec<usize> = (0..n)
.map(|i| u16_at(self.data, p + 2 * i).map(usize::from))
.collect::<Option<Vec<usize>>>()?;
p += 2 * n;
offs
} else {
Vec::new()
};
let record_n = usize::from(u16_at(self.data, p)?);
p += 2;
if input.is_empty() || at + input.len() > buf.len() {
return None;
}
for (k, off) in input.iter().enumerate() {
coverage_index(self.data, sub + off, buf.glyphs[at + k])?;
}
if backtrack.len() > at {
return None;
}
for (k, off) in backtrack.iter().enumerate() {
coverage_index(self.data, sub + off, buf.glyphs[at - 1 - k])?;
}
let after = at + input.len();
if after + lookahead.len() > buf.len() {
return None;
}
for (k, off) in lookahead.iter().enumerate() {
coverage_index(self.data, sub + off, buf.glyphs[after + k])?;
}
let mut did = false;
for i in 0..record_n {
let rec = p + 4 * i;
let seq = usize::from(u16_at(self.data, rec)?);
let lookup = u16_at(self.data, rec + 2)?;
if self.apply_at(lookup, buf, at + seq, depth + 1) {
did = true;
}
}
Some(did)
}
fn single(&self, sub: usize, glyph: u16) -> Option<u16> {
let coverage = sub + usize::from(u16_at(self.data, sub + 2)?);
let index = coverage_index(self.data, coverage, glyph)?;
match u16_at(self.data, sub)? {
1 => {
let delta = u16_at(self.data, sub + 4)? as i32;
u16::try_from((i32::from(glyph) + delta) & 0xFFFF).ok()
}
2 => {
if index >= u16_at(self.data, sub + 4)? {
return None;
}
u16_at(self.data, sub + 6 + 2 * usize::from(index))
}
_ => None,
}
}
fn multiple(&self, sub: usize, glyph: u16) -> Option<Vec<u16>> {
if u16_at(self.data, sub)? != 1 {
return None;
}
let coverage = sub + usize::from(u16_at(self.data, sub + 2)?);
let index = usize::from(coverage_index(self.data, coverage, glyph)?);
if index >= usize::from(u16_at(self.data, sub + 4)?) {
return None;
}
let seq = sub + usize::from(u16_at(self.data, sub + 6 + 2 * index)?);
let n = usize::from(u16_at(self.data, seq)?);
(0..n).map(|i| u16_at(self.data, seq + 2 + 2 * i)).collect()
}
fn ligature_in(&self, sub: usize, first: u16, glyphs: &[u16]) -> Option<(u16, usize)> {
let coverage = sub + usize::from(u16_at(self.data, sub + 2)?);
let index = usize::from(coverage_index(self.data, coverage, first)?);
if index >= usize::from(u16_at(self.data, sub + 4)?) {
return None;
}
let set = sub + usize::from(u16_at(self.data, sub + 6 + 2 * index)?);
let n = usize::from(u16_at(self.data, set)?);
let mut best: Option<(u16, usize)> = None;
for i in 0..n {
let lig = set + usize::from(u16_at(self.data, set + 2 + 2 * i)?);
let glyph = u16_at(self.data, lig)?;
let comps = usize::from(u16_at(self.data, lig + 2)?);
if comps == 0 || comps > glyphs.len() {
continue;
}
let matches = (1..comps)
.all(|k| u16_at(self.data, lig + 2 + 2 * k).is_some_and(|w| w == glyphs[k]));
if matches && best.is_none_or(|(_, m)| comps > m) {
best = Some((glyph, comps));
}
}
best
}
}
#[must_use]
pub fn coverage_index(d: &[u8], at: usize, glyph: u16) -> Option<u16> {
match u16_at(d, at)? {
1 => {
let n = usize::from(u16_at(d, at + 2)?);
let mut lo = 0usize;
let mut hi = n;
while lo < hi {
let mid = lo + (hi - lo) / 2;
let g = u16_at(d, at + 4 + 2 * mid)?;
if glyph < g {
hi = mid;
} else if glyph > g {
lo = mid + 1;
} else {
return u16::try_from(mid).ok();
}
}
None
}
2 => {
let n = usize::from(u16_at(d, at + 2)?);
for i in 0..n {
let rec = at + 4 + 6 * i;
let (first, last, start) =
(u16_at(d, rec)?, u16_at(d, rec + 2)?, u16_at(d, rec + 4)?);
if glyph >= first && glyph <= last {
return start.checked_add(glyph - first);
}
}
None
}
_ => None,
}
}
#[cfg(test)]
mod tests {
use super::*;
fn table(tag: &[u8; 4], lookups: &[Vec<u8>]) -> Vec<u8> {
let mut out = vec![0u8; 10];
out[0..2].copy_from_slice(&1u16.to_be_bytes());
out[2..4].copy_from_slice(&0u16.to_be_bytes());
let script_at = out.len();
out.extend_from_slice(&1u16.to_be_bytes()); out.extend_from_slice(b"arab");
out.extend_from_slice(&8u16.to_be_bytes()); out.extend_from_slice(&4u16.to_be_bytes()); out.extend_from_slice(&0u16.to_be_bytes()); out.extend_from_slice(&0u16.to_be_bytes()); out.extend_from_slice(&0xFFFFu16.to_be_bytes()); out.extend_from_slice(&1u16.to_be_bytes()); out.extend_from_slice(&0u16.to_be_bytes());
let feature_at = out.len();
out.extend_from_slice(&1u16.to_be_bytes());
out.extend_from_slice(tag);
out.extend_from_slice(&8u16.to_be_bytes()); out.extend_from_slice(&0u16.to_be_bytes()); #[allow(clippy::cast_possible_truncation)]
out.extend_from_slice(&(lookups.len() as u16).to_be_bytes());
for i in 0..lookups.len() {
#[allow(clippy::cast_possible_truncation)]
out.extend_from_slice(&(i as u16).to_be_bytes());
}
let lookup_at = out.len();
#[allow(clippy::cast_possible_truncation)]
out.extend_from_slice(&(lookups.len() as u16).to_be_bytes());
let mut at = 2 + 2 * lookups.len();
for l in lookups {
#[allow(clippy::cast_possible_truncation)]
out.extend_from_slice(&(at as u16).to_be_bytes());
at += l.len();
}
for l in lookups {
out.extend_from_slice(l);
}
#[allow(clippy::cast_possible_truncation)]
{
out[4..6].copy_from_slice(&(script_at as u16).to_be_bytes());
out[6..8].copy_from_slice(&(feature_at as u16).to_be_bytes());
out[8..10].copy_from_slice(&(lookup_at as u16).to_be_bytes());
}
out
}
fn lookup(kind: u16, sub: &[u8]) -> Vec<u8> {
let mut out = vec![];
out.extend_from_slice(&kind.to_be_bytes());
out.extend_from_slice(&0u16.to_be_bytes()); out.extend_from_slice(&1u16.to_be_bytes()); out.extend_from_slice(&8u16.to_be_bytes()); out.extend_from_slice(sub);
out
}
fn coverage(glyphs: &[u16]) -> Vec<u8> {
let mut out = vec![];
out.extend_from_slice(&1u16.to_be_bytes());
#[allow(clippy::cast_possible_truncation)]
out.extend_from_slice(&(glyphs.len() as u16).to_be_bytes());
for g in glyphs {
out.extend_from_slice(&g.to_be_bytes());
}
out
}
#[test]
fn a_single_substitution_by_delta_and_by_list() {
let mut sub = vec![];
sub.extend_from_slice(&1u16.to_be_bytes());
sub.extend_from_slice(&6u16.to_be_bytes()); sub.extend_from_slice(&100u16.to_be_bytes()); sub.extend_from_slice(&coverage(&[10, 11]));
let t = table(b"init", &[lookup(1, &sub)]);
let g = Gsub::parse(&t).expect("parses");
assert_eq!(
g.features_of(b"arab"),
Some(vec![0]),
"the script's features"
);
assert_eq!(
g.lookups_for_script(b"arab", b"init"),
vec![0],
"the feature's lookups"
);
assert_eq!(
g.subtables(0).map(|(k, s)| (k, s.len())),
Some((1, 1)),
"the subtables"
);
let mut b = Buffer::new(&[(10, 0), (11, 1), (12, 2)]);
g.apply_feature(b"arab", b"init", &mut b);
assert_eq!(b.glyphs, vec![110, 111, 12], "the uncovered glyph changed");
let mut sub = vec![];
sub.extend_from_slice(&2u16.to_be_bytes()); sub.extend_from_slice(&10u16.to_be_bytes()); sub.extend_from_slice(&2u16.to_be_bytes()); sub.extend_from_slice(&77u16.to_be_bytes());
sub.extend_from_slice(&88u16.to_be_bytes());
sub.extend_from_slice(&coverage(&[10, 11]));
let t = table(b"init", &[lookup(1, &sub)]);
let g = Gsub::parse(&t).expect("parses");
let mut b = Buffer::new(&[(10, 0), (11, 1)]);
g.apply_feature(b"arab", b"init", &mut b);
assert_eq!(b.glyphs, vec![77, 88]);
}
#[test]
fn a_multiple_substitution_keeps_the_cluster() {
let mut sub = vec![];
sub.extend_from_slice(&1u16.to_be_bytes());
sub.extend_from_slice(&8u16.to_be_bytes()); sub.extend_from_slice(&1u16.to_be_bytes()); sub.extend_from_slice(&14u16.to_be_bytes()); sub.extend_from_slice(&coverage(&[10]));
sub.extend_from_slice(&2u16.to_be_bytes()); sub.extend_from_slice(&20u16.to_be_bytes());
sub.extend_from_slice(&21u16.to_be_bytes());
let t = table(b"ccmp", &[lookup(2, &sub)]);
let g = Gsub::parse(&t).expect("parses");
let mut b = Buffer::new(&[(10, 5), (11, 6)]);
g.apply_feature(b"arab", b"ccmp", &mut b);
assert_eq!(b.glyphs, vec![20, 21, 11]);
assert_eq!(b.clusters, vec![5, 5, 6]);
}
#[test]
fn a_ligature_takes_the_longest_match() {
let mut set = vec![];
set.extend_from_slice(&2u16.to_be_bytes()); set.extend_from_slice(&6u16.to_be_bytes()); set.extend_from_slice(&12u16.to_be_bytes()); set.extend_from_slice(&50u16.to_be_bytes()); set.extend_from_slice(&2u16.to_be_bytes()); set.extend_from_slice(&11u16.to_be_bytes());
set.extend_from_slice(&51u16.to_be_bytes());
set.extend_from_slice(&3u16.to_be_bytes());
set.extend_from_slice(&11u16.to_be_bytes());
set.extend_from_slice(&12u16.to_be_bytes());
let mut sub = vec![];
sub.extend_from_slice(&1u16.to_be_bytes());
sub.extend_from_slice(&8u16.to_be_bytes()); sub.extend_from_slice(&1u16.to_be_bytes()); sub.extend_from_slice(&14u16.to_be_bytes()); sub.extend_from_slice(&coverage(&[10]));
sub.extend_from_slice(&set);
let t = table(b"rlig", &[lookup(4, &sub)]);
let g = Gsub::parse(&t).expect("parses");
let mut b = Buffer::new(&[(10, 0), (11, 1), (12, 2)]);
g.apply_feature(b"arab", b"rlig", &mut b);
assert_eq!(b.glyphs, vec![51], "the shorter ligature won");
assert_eq!(b.clusters, vec![0]);
let mut b = Buffer::new(&[(10, 0), (11, 1)]);
g.apply_feature(b"arab", b"rlig", &mut b);
assert_eq!(b.glyphs, vec![50]);
}
#[test]
fn a_feature_under_another_script_is_not_applied() {
let mut sub = vec![];
sub.extend_from_slice(&1u16.to_be_bytes());
sub.extend_from_slice(&6u16.to_be_bytes());
sub.extend_from_slice(&100u16.to_be_bytes());
sub.extend_from_slice(&coverage(&[10]));
let t = table(b"rlig", &[lookup(1, &sub)]);
let g = Gsub::parse(&t).expect("parses");
assert!(g.has(b"arab", b"rlig"));
let mut b = Buffer::new(&[(10, 0)]);
g.apply_feature(b"latn", b"rlig", &mut b);
assert_eq!(
b.glyphs,
vec![10],
"a lookup from another script was applied"
);
}
#[test]
fn a_truncated_table_is_refused_rather_than_read() {
let mut sub = vec![];
sub.extend_from_slice(&1u16.to_be_bytes());
sub.extend_from_slice(&6u16.to_be_bytes());
sub.extend_from_slice(&100u16.to_be_bytes());
sub.extend_from_slice(&coverage(&[10]));
let full = table(b"init", &[lookup(1, &sub)]);
for cut in 0..full.len() {
if let Some(g) = Gsub::parse(&full[..cut]) {
let mut b = Buffer::new(&[(10, 0)]);
g.apply_feature(b"arab", b"init", &mut b);
}
}
}
}