const CONNECTED_RANGES: &[(u32, u32)] = &[
(0x0600, 0x06FF),
(0x0750, 0x077F),
(0x07C0, 0x07FF),
(0x0900, 0x097F),
(0x0980, 0x09FF),
(0x0A00, 0x0A7F),
(0x0700, 0x074F),
(0x0780, 0x07BF),
(0x1800, 0x18AF),
];
const CONNECTED_LANGUAGES: &[&str] = &[
"ar", "fa", "ur", "ps", "sd", "ckb", "ug", "bal", "syr", "nqo", "mn", "hi", "bn", "pa", "mr",
"ne", "sa", "as", "kok", "doi", "brx", "mai", "bho", "mni", "new", "ks", "adlm", "rhg",
];
const CONNECTED_NAMES: &[&str] = &[
"NotoSansAdlam",
"NotoSansHanifiRohingya",
"NotoSansMongolian",
];
fn u16_at(d: &[u8], at: usize) -> Option<u16> {
Some(u16::from_be_bytes([*d.get(at)?, *d.get(at + 1)?]))
}
fn u32_at(d: &[u8], at: usize) -> Option<u32> {
Some(u32::from_be_bytes([
*d.get(at)?,
*d.get(at + 1)?,
*d.get(at + 2)?,
*d.get(at + 3)?,
]))
}
pub(crate) fn composites_run(
merg: Option<&[u8]>,
meta: Option<&[u8]>,
name: Option<&[u8]>,
gpos: &[u8],
covers: impl Fn(u32) -> bool,
) -> bool {
if let Some(m) = merg {
let count = u16_at(m, 2).unwrap_or(0);
let off = u16_at(m, 4).unwrap_or(0) as usize;
return count > 0 && m.get(off).is_some_and(|b| b & 1 != 0);
}
if let Some(ps) = name.and_then(postscript_name) {
if ps.starts_with(".SFNS") || ps.contains("PingFang") {
return false;
}
if CONNECTED_NAMES.contains(&ps.as_str()) {
return true;
}
}
if let Some(dlng) = meta.and_then(design_languages) {
for lang in dlng.split(',') {
let base = lang.trim().split('-').next().unwrap_or("");
if CONNECTED_LANGUAGES.contains(&base) {
return true;
}
}
}
for (lo, hi) in CONNECTED_RANGES {
if (*lo..=*hi).any(&covers) {
return true;
}
}
has_curs(gpos)
}
fn has_curs(gpos: &[u8]) -> bool {
let Some(list) = u16_at(gpos, 6).map(usize::from) else {
return false;
};
let Some(count) = u16_at(gpos, list).map(usize::from) else {
return false;
};
(0..count).any(|i| gpos.get(list + 2 + i * 6..list + 6 + i * 6) == Some(b"curs"))
}
fn design_languages(meta: &[u8]) -> Option<&str> {
let count = u32_at(meta, 12)? as usize;
for i in 0..count {
let rec = 16 + i * 12;
if meta.get(rec..rec + 4)? != b"dlng" {
continue;
}
let off = u32_at(meta, rec + 4)? as usize;
let len = u32_at(meta, rec + 8)? as usize;
return core::str::from_utf8(meta.get(off..off.checked_add(len)?)?).ok();
}
None
}
fn postscript_name(name: &[u8]) -> Option<String> {
let count = u16_at(name, 2)? as usize;
let storage = u16_at(name, 4)? as usize;
for i in 0..count {
let rec = 6 + i * 12;
if u16_at(name, rec + 6)? != 6 {
continue;
}
let platform = u16_at(name, rec)?;
let len = u16_at(name, rec + 8)? as usize;
let off = u16_at(name, rec + 10)? as usize;
let raw = name.get(storage + off..storage.checked_add(off)?.checked_add(len)?)?;
return Some(if matches!(platform, 0 | 3) {
raw.chunks(2)
.filter_map(|c| c.get(1).map(|b| *b as char))
.collect()
} else {
raw.iter().map(|b| *b as char).collect()
});
}
None
}
#[cfg(test)]
mod tests {
use super::*;
fn merg(entry: u8) -> Vec<u8> {
let mut t = vec![0u8; 12];
t[2..4].copy_from_slice(&1u16.to_be_bytes()); t[4..6].copy_from_slice(&11u16.to_be_bytes()); t[11] = entry;
t
}
fn meta(dlng: &str) -> Vec<u8> {
let mut t = vec![0u8; 28];
t[12..16].copy_from_slice(&1u32.to_be_bytes()); t[16..20].copy_from_slice(b"dlng");
t[20..24].copy_from_slice(&28u32.to_be_bytes()); t[24..28].copy_from_slice(&(dlng.len() as u32).to_be_bytes());
t.extend_from_slice(dlng.as_bytes());
t
}
fn gpos(tag: &[u8; 4]) -> Vec<u8> {
let mut t = vec![0u8; 10];
t[6..8].copy_from_slice(&10u16.to_be_bytes()); t.extend_from_slice(&1u16.to_be_bytes()); t.extend_from_slice(tag);
t.extend_from_slice(&0u16.to_be_bytes()); t
}
#[test]
fn merg_decides_alone() {
assert!(composites_run(Some(&merg(1)), None, None, &[], |_| false));
assert!(!composites_run(Some(&merg(0x22)), None, None, &[], |cp| cp == 0x628));
}
#[test]
fn a_connected_design_language_is_enough() {
for lang in ["ar", "fa,en", "en,hi", "ur-Arab"] {
assert!(
composites_run(None, Some(&meta(lang)), None, &[], |_| false),
"{lang}"
);
}
for lang in ["he", "th", "zh-Hant", "ja,ko", "en"] {
assert!(
!composites_run(None, Some(&meta(lang)), None, &[], |_| false),
"{lang}"
);
}
}
#[test]
fn one_covered_codepoint_is_enough() {
assert!(composites_run(None, None, None, &[], |cp| cp == 0x60B));
assert!(!composites_run(None, None, None, &[], |cp| (0x590..=0x5FF).contains(&cp)));
}
#[test]
fn cursive_attachment_is_the_last_term() {
assert!(composites_run(None, None, None, &gpos(b"curs"), |_| false));
assert!(!composites_run(None, None, None, &gpos(b"kern"), |_| false));
}
}