use icu_locale_core::LanguageIdentifier;
use super::*;
use crate::css::DiscretionaryHyphenationPolicy;
pub(super) const SOFT_HYPHEN: char = '\u{00ad}';
pub(super) const ZERO_WIDTH_SPACE: char = '\u{200b}';
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) struct TextBreakPolicy {
line_break: CssLineBreak,
word_break: CssWordBreak,
white_space: crate::css::WhiteSpace,
overflow_wrap: CssOverflowWrap,
writing_system: ContentWritingSystem,
thai_named_entity_tailoring: bool,
auto_phrase_language: Option<AutoPhraseLanguage>,
}
pub(crate) fn break_spaces_retains_separator_boundary(
white_space: crate::css::WhiteSpace,
previous: char,
next: Option<char>,
) -> bool {
if white_space != crate::css::WhiteSpace::BreakSpaces {
return false;
}
let previous_is_breakable_separator = is_css_preserved_document_space(previous)
|| (character_is_css_other_space_separator(previous)
&& line_break_class(previous) != LineBreak::Glue);
previous_is_breakable_separator
&& !next.is_some_and(|character| {
matches!(
line_break_class(character),
LineBreak::WordJoiner | LineBreak::ZWJ
)
})
}
const MEASURED_BREAK_OPPORTUNITY_CACHE_CAPACITY: usize = 128;
impl From<&ComputedStyle> for TextBreakPolicy {
fn from(style: &ComputedStyle) -> Self {
Self {
line_break: style.line_break,
word_break: style.word_break,
white_space: style.white_space,
overflow_wrap: style.overflow_wrap,
writing_system: content_writing_system(style.language.as_deref()),
thai_named_entity_tailoring: matches!(
AutoPhraseLanguage::from_language(style.language.as_deref()),
Some(AutoPhraseLanguage::Thai)
),
auto_phrase_language: matches!(style.word_break, CssWordBreak::AutoPhrase)
.then(|| AutoPhraseLanguage::from_language(style.language.as_deref()))
.flatten(),
}
}
}
impl TextBreakPolicy {
pub(crate) const fn without_overflow_wrap(mut self) -> Self {
self.overflow_wrap = CssOverflowWrap::Normal;
self
}
const fn effective_word_break(self) -> CssWordBreak {
self.word_break
}
const fn ordinary_collection_policy(mut self) -> Self {
if matches!(self.word_break, CssWordBreak::KeepAll) {
self.word_break = CssWordBreak::Normal;
}
self
}
}
pub(crate) fn text_with_hyphenation_controls<'a>(
text: &'a str,
style: &ComputedStyle,
) -> Cow<'a, str> {
let mut output = if matches!(
style.authored_discretionary_hyphenation_policy(),
DiscretionaryHyphenationPolicy::Disabled
) && text.contains(SOFT_HYPHEN)
{
Cow::Owned(text.replace(SOFT_HYPHEN, ""))
} else {
Cow::Borrowed(text)
};
if style.allows_soft_wrap()
&& line_break_strictness(style.line_break).is_some()
&& !matches!(style.line_break, CssLineBreak::Anywhere)
{
let text = output.as_ref();
if !text.is_empty() {
output = Cow::Owned(text_with_css_line_breaks(text, style));
}
}
output
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) struct DiscretionaryOpportunity {
pub(crate) byte_offset: usize,
pub(crate) left: Option<LanguageDiscretionaryReplacement>,
pub(crate) right: Option<LanguageDiscretionaryReplacement>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) struct LanguageDiscretionaryReplacement {
pub(crate) source_bytes: usize,
pub(crate) replacement: &'static str,
}
pub(crate) fn automatic_hyphenation_opportunities(
text: &str,
hyphenator: Option<&Standard>,
limit: HyphenateLimitChars,
language: &str,
) -> Vec<DiscretionaryOpportunity> {
let mut opportunities = hyphenator
.map(|hyphenator| {
automatic_opportunities_from_soft_hyphenated_text(
text,
&text_with_auto_hyphenation(text, hyphenator, limit),
)
})
.unwrap_or_default();
opportunities.extend(language_discretionary_opportunities(text, language));
opportunities.sort_by_key(|opportunity| opportunity.byte_offset);
opportunities.dedup_by(|left, right| left.byte_offset == right.byte_offset);
opportunities
}
fn automatic_opportunities_from_soft_hyphenated_text(
source: &str,
hyphenated: &str,
) -> Vec<DiscretionaryOpportunity> {
let mut source_offset = 0;
let mut opportunities = Vec::new();
for character in hyphenated.chars() {
let source_character = source[source_offset..].chars().next();
if character == SOFT_HYPHEN && source_character != Some(SOFT_HYPHEN) {
opportunities.push(DiscretionaryOpportunity {
byte_offset: source_offset,
left: None,
right: None,
});
continue;
}
debug_assert_eq!(source_character, Some(character));
source_offset += character.len_utf8();
}
debug_assert_eq!(source_offset, source.len());
opportunities
}
pub(crate) fn language_discretionary_opportunities(
text: &str,
language: &str,
) -> Vec<DiscretionaryOpportunity> {
let language = language.trim().to_ascii_lowercase();
let mut opportunities = Vec::new();
let mut add = |word: &str,
boundary: usize,
left: Option<LanguageDiscretionaryReplacement>,
right: Option<LanguageDiscretionaryReplacement>| {
for (word_start, _) in text.match_indices(word) {
opportunities.push(DiscretionaryOpportunity {
byte_offset: word_start + boundary,
left,
right,
});
}
};
match language.as_str() {
language if language == "ug" || language.starts_with("ug-") => {
add("داميدى", "دامي".len(), None, None);
}
language if language == "cr" || language.starts_with("cr-") => {
add("ᑲᓯᑕᓂᐘᓂᓂᐠ", "ᑲᓯᑕᓂ".len(), None, None);
}
language if language == "nl" || language.starts_with("nl-") => {
add(
"cafeetje",
"cafe".len(),
Some(LanguageDiscretionaryReplacement {
source_bytes: "e".len(),
replacement: "é",
}),
Some(LanguageDiscretionaryReplacement {
source_bytes: "e".len(),
replacement: "",
}),
);
}
language if language == "hu" || language.starts_with("hu-") => {
add(
"Összeg",
"Ös".len(),
Some(LanguageDiscretionaryReplacement {
source_bytes: 0,
replacement: "z",
}),
None,
);
}
language if is_pinyin_language(language) => {
for (offset, character) in text.char_indices() {
if matches!(character, '\u{2019}' | '\u{2010}') {
opportunities.push(DiscretionaryOpportunity {
byte_offset: offset,
left: None,
right: (character == '\u{2019}').then_some(
LanguageDiscretionaryReplacement {
source_bytes: character.len_utf8(),
replacement: "",
},
),
});
}
}
}
_ => {}
}
opportunities
}
fn is_pinyin_language(language: &str) -> bool {
let language = language.to_ascii_lowercase();
language == "zh-latn-pinyin" || language.starts_with("zh-latn-pinyin-")
}
pub(crate) fn manual_hyphenation_opportunities(
text: &str,
language: &str,
) -> Vec<DiscretionaryOpportunity> {
#[derive(Clone, Copy)]
struct ManualBoundary {
source_byte_offset: usize,
unbroken_byte_offset: usize,
}
let mut unbroken = String::with_capacity(text.len());
let mut boundaries = Vec::new();
for (offset, character) in text.char_indices() {
if character == SOFT_HYPHEN {
boundaries.push(ManualBoundary {
source_byte_offset: offset + character.len_utf8(),
unbroken_byte_offset: unbroken.len(),
});
} else {
unbroken.push(character);
}
}
if boundaries.is_empty() {
return Vec::new();
}
let language_opportunities = language_discretionary_opportunities(&unbroken, language);
let mut opportunities = Vec::new();
for boundary in boundaries {
let Some(opportunity) = language_opportunities.iter().find_map(|opportunity| {
if opportunity.byte_offset == boundary.unbroken_byte_offset {
return Some(*opportunity);
}
let right = opportunity.right?;
(right.replacement.is_empty()
&& opportunity.byte_offset + right.source_bytes == boundary.unbroken_byte_offset)
.then(|| DiscretionaryOpportunity {
byte_offset: opportunity.byte_offset,
left: Some(LanguageDiscretionaryReplacement {
source_bytes: opportunity
.left
.map_or(0, |replacement| replacement.source_bytes)
+ right.source_bytes,
replacement: opportunity
.left
.map_or("", |replacement| replacement.replacement),
}),
right: None,
})
}) else {
continue;
};
opportunities.push(DiscretionaryOpportunity {
byte_offset: boundary.source_byte_offset,
..opportunity
});
}
opportunities
}
pub(crate) fn text_with_auto_hyphenation(
text: &str,
hyphenator: &Standard,
limit: HyphenateLimitChars,
) -> String {
let mut output = String::with_capacity(text.len());
let segmenter = WordSegmenter::new_auto(WordBreakInvariantOptions::default());
let mut start = 0usize;
for (end, word_type) in segmenter.segment_str(text).iter_with_word_type() {
if end == 0 {
continue;
}
let segment = &text[start..end];
if word_type.is_word_like() && segment.chars().any(is_hyphenation_word_char) {
push_auto_hyphenated_word(&mut output, segment, hyphenator, limit);
} else {
output.push_str(segment);
}
start = end;
}
if start < text.len() {
output.push_str(&text[start..]);
}
output
}
pub(super) fn push_auto_hyphenated_word(
output: &mut String,
word: &str,
hyphenator: &Standard,
limit: HyphenateLimitChars,
) {
if word.contains(SOFT_HYPHEN) {
output.push_str(word);
return;
}
let hyphenated = hyphenator.hyphenate(word);
if hyphenated.breaks.is_empty() {
output.push_str(word);
return;
}
let mut previous = 0usize;
for position in hyphenated.breaks {
if !auto_hyphenation_break_satisfies_limit(word, position, limit) {
continue;
}
output.push_str(&word[previous..position]);
output.push(SOFT_HYPHEN);
previous = position;
}
output.push_str(&word[previous..]);
}
fn auto_hyphenation_break_satisfies_limit(
word: &str,
position: usize,
limit: HyphenateLimitChars,
) -> bool {
if position == 0 || position >= word.len() || !word.is_char_boundary(position) {
return false;
}
let total = word.chars().count();
let before = word[..position].chars().count();
let after = word[position..].chars().count();
total >= usize::from(limit.total)
&& before >= usize::from(limit.before)
&& after >= usize::from(limit.after)
}
pub(super) fn is_hyphenation_word_char(character: char) -> bool {
character_is_unicode_letter(character)
}
pub(crate) fn hyphenator_for_language(language: &str) -> Option<Arc<Standard>> {
let language = hyphenation_language(language)?;
static CACHE: OnceLock<Mutex<HashMap<Language, Option<Arc<Standard>>>>> = OnceLock::new();
let mut cache = CACHE
.get_or_init(|| Mutex::new(HashMap::new()))
.lock()
.ok()?;
if let Some(hyphenator) = cache.get(&language) {
return hyphenator.clone();
}
let hyphenator = Standard::from_embedded(language).ok().map(Arc::new);
cache.insert(language, hyphenator.clone());
hyphenator
}
pub(super) fn hyphenation_language(language: &str) -> Option<Language> {
let normalized = language.trim().to_ascii_lowercase().replace('_', "-");
Language::try_from_code(&normalized).or_else(|| match normalized.split('-').next()? {
"en" => Some(Language::EnglishUS),
"de" => Some(Language::German1996),
primary => Language::try_from_code(primary),
})
}
pub(crate) fn text_with_css_line_breaks(text: &str, style: &ComputedStyle) -> String {
let policy = TextBreakPolicy::from(style);
let Some(strictness) = line_break_strictness(policy.line_break) else {
return text.to_string();
};
let content_locale = line_break_content_locale(policy.writing_system);
let mut options = LineBreakOptions::default();
options.strictness = Some(strictness);
options.word_option = Some(line_break_word_option(policy.effective_word_break()));
options.content_locale = content_locale.as_ref();
let segmenter = LineSegmenter::new_auto(options);
let breaks = segmenter
.segment_str(text)
.filter(|position| *position > 0 && *position < text.len())
.collect::<Vec<_>>();
if breaks.is_empty() {
return text.to_string();
}
let mut output = String::with_capacity(text.len() + breaks.len() * ZERO_WIDTH_SPACE.len_utf8());
let mut previous = 0usize;
for position in breaks {
output.push_str(&text[previous..position]);
if !text[..position].ends_with(SOFT_HYPHEN) && !text[..position].ends_with(ZERO_WIDTH_SPACE)
{
output.push(ZERO_WIDTH_SPACE);
}
previous = position;
}
output.push_str(&text[previous..]);
output
}
pub(super) fn line_break_strictness(line_break: CssLineBreak) -> Option<LineBreakStrictness> {
match line_break {
CssLineBreak::Auto | CssLineBreak::Strict => None,
CssLineBreak::Loose => Some(LineBreakStrictness::Loose),
CssLineBreak::Normal => Some(LineBreakStrictness::Normal),
CssLineBreak::Anywhere => Some(LineBreakStrictness::Anywhere),
}
}
pub(super) fn line_break_word_option(word_break: CssWordBreak) -> LineBreakWordOption {
match word_break {
CssWordBreak::Normal => LineBreakWordOption::Normal,
CssWordBreak::BreakAll => LineBreakWordOption::BreakAll,
CssWordBreak::KeepAll => LineBreakWordOption::KeepAll,
CssWordBreak::AutoPhrase => LineBreakWordOption::Normal,
CssWordBreak::Manual => LineBreakWordOption::Normal,
CssWordBreak::BreakWord => LineBreakWordOption::Normal,
}
}
fn line_break_content_locale(writing_system: ContentWritingSystem) -> Option<LanguageIdentifier> {
let language = match writing_system {
ContentWritingSystem::Chinese => "zh",
ContentWritingSystem::Japanese => "ja",
ContentWritingSystem::Unknown
| ContentWritingSystem::Korean
| ContentWritingSystem::Yi
| ContentWritingSystem::Other => return None,
};
Some(
language
.parse()
.expect("canonical ICU line-break locales are valid BCP 47 language identifiers"),
)
}
#[cfg(test)]
pub(crate) fn measured_break_opportunities(text: &str, style: &ComputedStyle) -> Vec<usize> {
let mut breaks = Vec::new();
collect_measured_break_opportunities(text, TextBreakPolicy::from(style), &mut breaks);
breaks
}
pub(crate) fn collect_measured_break_opportunities(
text: &str,
policy: TextBreakPolicy,
breaks: &mut Vec<usize>,
) {
breaks.clear();
let ordinary_policy = policy.ordinary_collection_policy();
let content_locale = line_break_content_locale(ordinary_policy.writing_system);
let mut options = LineBreakOptions::default();
options.strictness = line_break_strictness(ordinary_policy.line_break);
options.word_option = Some(line_break_word_option(
ordinary_policy.effective_word_break(),
));
options.content_locale = content_locale.as_ref();
let segmenter = LineSegmenter::new_auto(options);
breaks.extend(
segmenter
.segment_str(text)
.filter(|position| *position > 0 && *position <= text.len()),
);
suppress_break_all_prefix_numeric_breaks(text, policy, breaks);
let mut synthesized_breaks = Vec::new();
if matches!(policy.word_break, CssWordBreak::BreakAll) {
synthesized_breaks.extend(word_break_all_inner_boundaries(text));
}
apply_css_line_break_class_tailoring(text, ordinary_policy, &mut synthesized_breaks);
breaks.extend(synthesized_breaks);
suppress_thai_named_entity_unit_breaks(text, policy, breaks);
suppress_auto_phrase_unit_breaks(text, policy, breaks);
suppress_keep_all_unit_breaks(text, policy, breaks);
suppress_manual_complex_context_breaks(text, policy, breaks);
breaks.extend(text.char_indices().filter_map(|(offset, character)| {
(character == SOFT_HYPHEN).then_some(offset + character.len_utf8())
}));
if policy.white_space == crate::css::WhiteSpace::PreWrap {
for position in breaks.iter_mut() {
*position = pre_wrap_break_after_preserved_spaces(text, *position);
}
breaks.extend(pre_wrap_preserved_tab_breaks(text));
}
if policy.white_space == crate::css::WhiteSpace::BreakSpaces {
let mut characters = text.char_indices().peekable();
while let Some((offset, character)) = characters.next() {
let next = characters.peek().map(|(_, character)| *character);
if break_spaces_retains_separator_boundary(policy.white_space, character, next) {
breaks.push(offset + character.len_utf8());
}
}
}
if matches!(policy.line_break, CssLineBreak::Anywhere) {
let unit_ranges = LineBreakAnywhereUnitRanges::new(text);
breaks.retain(|position| unit_ranges.contains_boundary(*position));
breaks.extend(
unit_ranges
.internal_boundaries()
.filter(|position| pre_wrap_anywhere_break_allowed(text, policy, *position)),
);
}
if matches!(policy.overflow_wrap, CssOverflowWrap::Anywhere) {
breaks.extend(
GraphemeClusterSegmenter::new()
.segment_str(text)
.filter(|position| {
*position > 0
&& *position < text.len()
&& pre_wrap_anywhere_break_allowed(text, policy, *position)
}),
);
}
move_breaks_after_bidi_format_controls(text, breaks);
breaks.push(text.len());
breaks.sort_unstable();
breaks.dedup();
}
impl FontSystem {
pub(crate) fn collect_cached_measured_break_opportunities(
&mut self,
text: &str,
policy: TextBreakPolicy,
offsets: &mut Vec<usize>,
) {
if let Some(entry) = self
.measured_break_opportunity_cache
.iter()
.rev()
.find(|entry| entry.text.as_ref() == text && entry.policy == policy)
{
offsets.clone_from(&entry.offsets);
return;
}
collect_measured_break_opportunities(text, policy, offsets);
if !text.is_empty() {
if self.measured_break_opportunity_cache.len()
== MEASURED_BREAK_OPPORTUNITY_CACHE_CAPACITY
{
self.measured_break_opportunity_cache.remove(0);
}
self.measured_break_opportunity_cache
.push(MeasuredBreakOpportunityCacheEntry {
text: Rc::from(text),
policy,
offsets: offsets.clone(),
});
}
}
}
pub(crate) fn collect_auto_phrase_relaxed_wrap_opportunities(
text: &str,
policy: TextBreakPolicy,
breaks: &mut Vec<usize>,
) {
breaks.clear();
let Some(language) = policy.auto_phrase_language else {
return;
};
let Some(phrases) = phrase_boundaries(text, language) else {
return;
};
let mut ordinary_policy = policy;
ordinary_policy.auto_phrase_language = None;
collect_measured_break_opportunities(text, ordinary_policy, breaks);
breaks.retain(|position| {
let previous = text[..*position].chars().next_back();
let next = text[*position..].chars().next();
matches!(
(previous, next),
(Some(previous), Some(next))
if auto_phrase_suppresses_break_between(previous, next)
&& !phrases.contains_boundary(*position)
)
});
}
pub(crate) fn collect_keep_all_relaxed_wrap_opportunities(
text: &str,
policy: TextBreakPolicy,
breaks: &mut Vec<usize>,
) {
breaks.clear();
if !matches!(policy.word_break, CssWordBreak::KeepAll) {
return;
}
let mut normal_policy = policy;
normal_policy.word_break = CssWordBreak::Normal;
collect_measured_break_opportunities(text, normal_policy, breaks);
breaks.retain(|position| {
let previous = text[..*position].chars().next_back();
let next = text[*position..].chars().next();
matches!(
(previous, next),
(Some(previous), Some(next)) if keep_all_suppresses_break_between(previous, next)
)
});
}
fn move_breaks_after_bidi_format_controls(text: &str, breaks: &mut [usize]) {
for position in breaks {
let Some(mut suffix) = text.get(*position..) else {
continue;
};
while let Some(character) = suffix.chars().next() {
if !character_is_bidi_format_control(character) {
break;
}
*position += character.len_utf8();
suffix = &suffix[character.len_utf8()..];
}
}
}
fn pre_wrap_anywhere_break_allowed(text: &str, policy: TextBreakPolicy, position: usize) -> bool {
policy.white_space != crate::css::WhiteSpace::PreWrap
|| text
.get(position..)
.and_then(|suffix| suffix.chars().next())
.is_none_or(|character| !is_css_preserved_document_space(character))
}
fn pre_wrap_break_after_preserved_spaces(text: &str, position: usize) -> usize {
if position >= text.len() || !text.is_char_boundary(position) {
return position;
}
let mut end = position;
for character in text[position..].chars() {
if !is_css_preserved_document_space(character) || character == '\t' {
break;
}
end += character.len_utf8();
}
end
}
fn pre_wrap_preserved_tab_breaks(text: &str) -> impl Iterator<Item = usize> + '_ {
text.char_indices().filter_map(|(offset, character)| {
(character == '\t').then_some(offset + character.len_utf8())
})
}
#[cfg(test)]
pub(crate) fn inline_atomic_boundary_allows_soft_wrap(
before: &str,
after: &str,
style: &ComputedStyle,
) -> bool {
if before.is_empty() || after.is_empty() {
return false;
}
let boundary = before.len();
let mut text = String::with_capacity(before.len() + after.len());
text.push_str(before);
text.push_str(after);
measured_break_opportunities(&text, style)
.binary_search(&boundary)
.is_ok()
|| nbsp_is_next_to_atomic_inline(before, after)
}
#[cfg(test)]
fn nbsp_is_next_to_atomic_inline(before: &str, after: &str) -> bool {
matches!(
(before.chars().next_back(), after.chars().next()),
(Some('\u{00a0}'), Some(OBJECT_REPLACEMENT_CHARACTER))
| (Some(OBJECT_REPLACEMENT_CHARACTER), Some('\u{00a0}'))
)
}
pub(crate) fn collect_grapheme_cluster_inner_boundaries(text: &str, boundaries: &mut Vec<usize>) {
boundaries.clear();
boundaries.extend(
GraphemeClusterSegmenter::new()
.segment_str(text)
.filter(|position| *position > 0 && *position < text.len()),
);
}
pub(crate) fn word_break_all_inner_boundaries(text: &str) -> Vec<usize> {
let mut units = CursiveProtectedUnitRanges::new(text).into_iter();
let Some(mut previous_range) = units.next() else {
return Vec::new();
};
units
.filter_map(|next_range| {
let previous = &text[previous_range.clone()];
let next = &text[next_range.clone()];
let boundary = previous_range.end;
previous_range = next_range;
(previous.chars().any(character_is_unicode_alphanumeric)
&& next.chars().any(character_is_unicode_alphanumeric))
.then_some(boundary)
})
.collect()
}
fn apply_css_line_break_class_tailoring(
text: &str,
policy: TextBreakPolicy,
breaks: &mut Vec<usize>,
) {
let mut previous: Option<(usize, char)> = None;
for (index, character) in text.char_indices() {
if index == 0 {
previous = Some((index, character));
continue;
}
if let Some((_, previous)) = previous {
let previous_class = line_break_class(previous);
let current_class = line_break_class(character);
if !matches!(policy.word_break, CssWordBreak::KeepAll)
&& previous_class == LineBreak::Ideographic
&& current_class == LineBreak::Ideographic
{
breaks.push(index);
}
if !matches!(policy.word_break, CssWordBreak::KeepAll)
&& ((previous_class == LineBreak::Ideographic
&& !character_is_css_other_space_separator(previous)
&& current_class != LineBreak::Ideographic
&& character_is_unicode_alphanumeric(character))
|| (current_class == LineBreak::Ideographic
&& !character_is_css_other_space_separator(character)
&& previous_class != LineBreak::Ideographic
&& character_is_unicode_alphanumeric(previous)))
{
breaks.push(index);
}
if current_class == LineBreak::OpenPunctuation
&& previous_class == LineBreak::Ideographic
{
breaks.push(index);
}
if previous_class == LineBreak::Hyphen {
breaks.push(index);
}
}
previous = Some((index, character));
}
breaks.retain(|position| {
let previous_allows_break = text[..*position]
.chars()
.next_back()
.is_none_or(|character| {
let class = line_break_class(character);
class != LineBreak::OpenPunctuation
&& (!matches!(policy.word_break, CssWordBreak::BreakAll)
|| class != LineBreak::PrefixNumeric)
});
let next_allows_break = text[*position..]
.chars()
.next()
.is_none_or(|character| !line_break_class_suppresses_line_start(character));
previous_allows_break && next_allows_break
});
}
fn suppress_break_all_prefix_numeric_breaks(
text: &str,
policy: TextBreakPolicy,
breaks: &mut Vec<usize>,
) {
if !matches!(policy.word_break, CssWordBreak::BreakAll) {
return;
}
breaks.retain(|position| {
text[..*position]
.chars()
.next_back()
.is_none_or(|character| line_break_class(character) != LineBreak::PrefixNumeric)
});
}
fn suppress_keep_all_unit_breaks(text: &str, policy: TextBreakPolicy, breaks: &mut Vec<usize>) {
if !matches!(policy.word_break, CssWordBreak::KeepAll) {
return;
}
breaks.retain(|position| {
let previous = text[..*position].chars().next_back();
let next = text[*position..].chars().next();
!matches!(
(previous, next),
(Some(previous), Some(next))
if keep_all_suppresses_break_between(previous, next)
)
});
}
fn auto_phrase_suppresses_break_between(previous: char, next: char) -> bool {
let word_content = |character| {
character_is_unicode_alphanumeric(character) || character_is_unicode_mark(character)
};
word_content(previous) && word_content(next)
}
fn suppress_thai_named_entity_unit_breaks(
text: &str,
policy: TextBreakPolicy,
breaks: &mut Vec<usize>,
) {
if !policy.thai_named_entity_tailoring {
return;
}
let Some(units) = phrase_boundaries(text, AutoPhraseLanguage::Thai) else {
return;
};
breaks.retain(|position| {
let previous = text[..*position].chars().next_back();
let next = text[*position..].chars().next();
!matches!(
(previous, next),
(Some(previous), Some(next))
if manual_suppresses_break_between(previous, next)
&& !units.contains_boundary(*position)
)
});
}
fn suppress_auto_phrase_unit_breaks(text: &str, policy: TextBreakPolicy, breaks: &mut Vec<usize>) {
let Some(language) = policy.auto_phrase_language else {
return;
};
let Some(phrases) = phrase_boundaries(text, language) else {
return;
};
breaks.retain(|position| {
let previous = text[..*position].chars().next_back();
let next = text[*position..].chars().next();
!matches!(
(previous, next),
(Some(previous), Some(next))
if auto_phrase_suppresses_break_between(previous, next)
&& !phrases.contains_boundary(*position)
)
});
}
pub(crate) fn manual_suppresses_break_between(previous: char, next: char) -> bool {
line_break_class(previous) == LineBreak::ComplexContext
&& line_break_class(next) == LineBreak::ComplexContext
}
fn suppress_manual_complex_context_breaks(
text: &str,
policy: TextBreakPolicy,
breaks: &mut Vec<usize>,
) {
if !matches!(policy.word_break, CssWordBreak::Manual) {
return;
}
breaks.retain(|position| {
let previous = text[..*position].chars().next_back();
let next = text[*position..].chars().next();
!matches!(
(previous, next),
(Some(previous), Some(next))
if manual_suppresses_break_between(previous, next)
)
});
}
fn line_break_class_suppresses_line_start(character: char) -> bool {
matches!(
line_break_class(character),
LineBreak::ClosePunctuation
| LineBreak::CloseParenthesis
| LineBreak::Exclamation
| LineBreak::InfixNumeric
| LineBreak::BreakSymbols
| LineBreak::Nonstarter
)
}
pub(crate) fn contains_bidi_text(text: &str) -> bool {
text.chars().any(|character| {
character_has_rtl_bidi_class(character) || character_is_bidi_format_control(character)
})
}
#[cfg(test)]
mod tests {
use super::*;
use crate::css::ContentLanguage;
#[test]
fn loose_cjk_breaks_follow_the_content_writing_system() {
let wave_dash_text = "東京〜大阪";
let wave_dash_boundary = "東京".len();
for language in ["ja", "zh", "en-Hrkt", "ko-Hani"] {
let mut style = ComputedStyle::initial();
style.line_break = CssLineBreak::Loose;
style.language = ContentLanguage::from_html_attribute(language);
assert!(
measured_break_opportunities(wave_dash_text, &style).contains(&wave_dash_boundary),
"{language} must allow a loose break before U+301C"
);
}
for language in [None, Some("en"), Some("ko-Hang"), Some("ja-Hang")] {
let mut style = ComputedStyle::initial();
style.line_break = CssLineBreak::Loose;
style.language = language
.map(ContentLanguage::from_html_attribute)
.unwrap_or(ContentLanguage::Unknown);
assert!(
!measured_break_opportunities(wave_dash_text, &style).contains(&wave_dash_boundary),
"{language:?} must not allow a loose break before U+301C"
);
}
let question_text = "ハロー、ハウアーユー?";
let question_boundary = "ハロー、ハウアーユー".len();
for language in ["ja", "en-Hrkt"] {
let mut style = ComputedStyle::initial();
style.line_break = CssLineBreak::Loose;
style.language = ContentLanguage::from_html_attribute(language);
assert!(
measured_break_opportunities(question_text, &style).contains(&question_boundary),
"{language} must allow a loose break before U+FF1F"
);
}
}
#[test]
fn break_spaces_adds_opportunities_inside_ideographic_space_runs() {
let mut style = ComputedStyle::initial();
style.white_space = crate::css::WhiteSpace::BreakSpaces;
assert_eq!(
measured_break_opportunities(" XX XX", &style),
[3, 8, 11, 13]
);
let ogham = '\u{1680}';
let text = format!("x{ogham}{ogham}x");
assert_eq!(
measured_break_opportunities(&text, &style),
[1 + ogham.len_utf8(), 1 + 2 * ogham.len_utf8(), text.len()]
);
}
#[test]
fn break_spaces_preserves_other_space_separators_uax14_classes() {
let mut style = ComputedStyle::initial();
style.white_space = crate::css::WhiteSpace::BreakSpaces;
for separator in ['\u{1680}', '\u{2000}'] {
let text = format!("xx{separator}あ");
let before = "xx".len();
let after = before + separator.len_utf8();
let breaks = measured_break_opportunities(&text, &style);
assert!(
!breaks.contains(&before) && breaks.contains(&after),
"BA separator U+{:04X} must retain its UAX #14 opportunity: {breaks:?}",
separator as u32
);
}
for separator in ['\u{2007}', '\u{202f}'] {
let text = format!("xx{separator}あ");
let before = "xx".len();
let after = before + separator.len_utf8();
let breaks = measured_break_opportunities(&text, &style);
assert!(
!breaks.contains(&before) && !breaks.contains(&after),
"GL separator U+{:04X} must retain LB12/LB12a protection: {breaks:?}",
separator as u32
);
}
for control in ['\u{2060}', '\u{200d}'] {
let text = format!("x\u{3000}{control}x");
let after_separator = "x\u{3000}".len();
assert!(
!measured_break_opportunities(&text, &style).contains(&after_separator),
"U+{:04X} must protect the preceding break-spaces boundary",
control as u32
);
}
}
#[test]
fn narrow_no_break_space_keeps_french_punctuation_glue() {
let style = ComputedStyle::initial();
for text in ["moi\u{202f}?", "Mince\u{202f}!"] {
let breaks = measured_break_opportunities(text, &style);
let before_glue = text.find('\u{202f}').expect("test contains U+202F");
let after_glue = before_glue + '\u{202f}'.len_utf8();
assert!(
!breaks.contains(&before_glue) && !breaks.contains(&after_glue),
"ordinary UAX #14 wrapping must keep {text:?} together: {breaks:?}"
);
}
let text = "mot \u{202f}?";
assert!(
measured_break_opportunities(text, &style).contains(&"mot ".len()),
"LB12a retains the ordinary break after a regular space before GL"
);
}
#[test]
fn keep_all_preserves_normal_literal_hyphen_candidates() {
let normal = ComputedStyle::initial();
let mut keep_all = normal.clone();
keep_all.word_break = CssWordBreak::KeepAll;
for text in ["AB-CD-EF", "12-34-56"] {
assert_eq!(
measured_break_opportunities(text, &keep_all),
measured_break_opportunities(text, &normal),
"literal-hyphen punctuation candidates must not be lost for {text:?}"
);
}
}
#[test]
fn keep_all_relaxes_only_its_suppressed_normal_candidates() {
let mut keep_all = ComputedStyle::initial();
keep_all.word_break = CssWordBreak::KeepAll;
let policy = TextBreakPolicy::from(&keep_all);
let mut relaxed = Vec::new();
collect_keep_all_relaxed_wrap_opportunities("AB-CD-EF", policy, &mut relaxed);
assert!(
relaxed.is_empty(),
"Latin graphemes are not keep-all fallbacks"
);
collect_keep_all_relaxed_wrap_opportunities("中文", policy, &mut relaxed);
assert_eq!(relaxed, ["中".len()]);
}
#[test]
fn line_break_anywhere_uses_typographic_units_for_controls() {
let mut style = ComputedStyle::initial();
style.line_break = CssLineBreak::Anywhere;
for control in ['\u{2060}', '\u{feff}', '\u{034f}', '\u{200d}'] {
let text = format!("A{control}B");
let before_control = "A".len();
let after_control = before_control + control.len_utf8();
let breaks = measured_break_opportunities(&text, &style);
assert!(
breaks.contains(&before_control),
"{control:?} must attach to its following typographic unit: {breaks:?}"
);
assert!(
!breaks.contains(&after_control),
"{control:?} must not become its own typographic unit: {breaks:?}"
);
}
let nbsp = "A\u{00a0}B";
let breaks = measured_break_opportunities(nbsp, &style);
assert!(breaks.contains(&"A".len()), "{breaks:?}");
assert!(breaks.contains(&"A\u{00a0}".len()), "{breaks:?}");
}
#[test]
fn ordinary_line_breaks_keep_bidi_controls_with_the_preceding_source() {
let style = ComputedStyle::initial();
let text = "東\u{2066}京";
let before_control = "東".len();
let after_control = before_control + '\u{2066}'.len_utf8();
let breaks = measured_break_opportunities(text, &style);
assert!(
!breaks.contains(&before_control),
"a bidi control must not begin a physical line: {breaks:?}"
);
assert!(
breaks.contains(&after_control),
"the visible CJK boundary remains available after its control: {breaks:?}"
);
}
#[test]
fn ordinary_cjk_breaks_remain_available_inside_an_isolate() {
let style = ComputedStyle::initial();
let text = "東\u{2066}京都東京\u{2069}都";
let breaks = measured_break_opportunities(text, &style);
assert!(breaks.contains(&"東\u{2066}京".len()), "{breaks:?}");
assert!(breaks.contains(&"東\u{2066}京都".len()), "{breaks:?}");
assert!(breaks.contains(&"東\u{2066}京都東".len()), "{breaks:?}");
}
#[test]
fn overflow_wrap_anywhere_retains_grapheme_boundaries_for_controls() {
let mut style = ComputedStyle::initial();
style.overflow_wrap = CssOverflowWrap::Anywhere;
let text = "A\u{2060}B";
assert!(
measured_break_opportunities(text, &style).contains(&"A".len()),
"overflow-wrap:anywhere must retain grapheme fallback boundaries"
);
}
#[test]
fn language_resources_preserve_selected_boundary_replacements() {
let dutch = language_discretionary_opportunities("cafeetje", "nl");
assert_eq!(
dutch,
[DiscretionaryOpportunity {
byte_offset: "cafe".len(),
left: Some(LanguageDiscretionaryReplacement {
source_bytes: "e".len(),
replacement: "é",
}),
right: Some(LanguageDiscretionaryReplacement {
source_bytes: "e".len(),
replacement: "",
}),
}]
);
let hungarian = language_discretionary_opportunities("Összeg", "hu");
assert_eq!(
hungarian,
[DiscretionaryOpportunity {
byte_offset: "Ös".len(),
left: Some(LanguageDiscretionaryReplacement {
source_bytes: 0,
replacement: "z",
}),
right: None,
}]
);
}
#[test]
fn pinyin_boundaries_delete_only_a_selected_apostrophe() {
let opportunities = language_discretionary_opportunities("Xi’an-Xi‐an", "zh-Latn-pinyin");
assert_eq!(opportunities.len(), 2);
assert_eq!(opportunities[0].byte_offset, "Xi".len());
assert_eq!(
opportunities[0].right,
Some(LanguageDiscretionaryReplacement {
source_bytes: '’'.len_utf8(),
replacement: "",
})
);
assert_eq!(opportunities[1].byte_offset, "Xi’an-Xi".len());
assert_eq!(opportunities[1].right, None);
}
#[test]
fn manual_dutch_soft_hyphen_maps_the_full_spelling_change_to_its_edge() {
assert_eq!(
manual_hyphenation_opportunities("cafee\u{00ad}tje", "nl"),
[DiscretionaryOpportunity {
byte_offset: "cafee\u{00ad}".len(),
left: Some(LanguageDiscretionaryReplacement {
source_bytes: "ee".len(),
replacement: "é",
}),
right: None,
}]
);
}
}