use super::*;
#[derive(Debug, Clone)]
pub(in crate::layout) struct RangedMeasuredMixedInlineLineItem {
pub(in crate::layout) item: MeasuredInlineItem,
pub(in crate::layout) range: std::ops::Range<usize>,
}
pub(in crate::layout) fn mixed_inline_line_needs_bidi_ordering<T>(
items: &[T],
block_style: &ComputedStyle,
) -> bool
where
T: AsRef<InlineLineItem>,
{
block_style.used_direction() == Direction::Rtl
|| inline_bidi_scope_affects_line_ordering(block_style)
|| items.iter().any(|item| match item.as_ref() {
InlineLineItem::Fragment(fragment) => {
contains_bidi_text(fragment.text())
|| inline_bidi_scope_affects_line_ordering(fragment.style())
}
InlineLineItem::Atom(atom) => {
atom.style().used_direction() != block_style.used_direction()
|| inline_bidi_scope_affects_line_ordering(atom.style())
}
InlineLineItem::Float(_) => false,
})
}
pub(in crate::layout) fn graph_remaining_allows_last_hanging_punctuation(
graph: &InlineOpportunityGraph,
position: InlineGraphPosition,
) -> bool {
let Some(run_range) = graph.run_indices_for_graph_range(InlineGraphRange {
start: position,
end: graph.end_position(),
}) else {
return true;
};
run_range.into_iter().all(|run_index| {
let run = &graph.runs[run_index];
match &run.item {
InlineLineItem::Fragment(fragment) => {
let start = if run_index == position.run_index {
position.byte_offset.min(fragment.text().len())
} else {
0
};
fragment
.text()
.get(start..)
.is_none_or(|text| text.chars().all(is_css_collapsible_whitespace))
}
InlineLineItem::Atom(atom) => atom.content().is_box_edge(),
InlineLineItem::Float(_) => false,
}
})
}
pub(in crate::layout) fn graph_remaining_after_position_is_trimmable(
graph: &InlineOpportunityGraph,
position: InlineGraphPosition,
) -> bool {
let Some(run_range) = graph.run_indices_for_graph_range(InlineGraphRange {
start: position,
end: graph.end_position(),
}) else {
return true;
};
run_range.into_iter().all(|run_index| {
let run = &graph.runs[run_index];
match &run.item {
InlineLineItem::Fragment(fragment) => {
let start = if run_index == position.run_index {
position.byte_offset.min(fragment.text().len())
} else {
0
};
fragment
.text()
.get(start..)
.is_none_or(|text| inline_suffix_text_is_trimmable(text, fragment))
}
InlineLineItem::Atom(atom) => atom.content().is_box_edge(),
InlineLineItem::Float(_) => false,
}
})
}
pub(in crate::layout) fn inline_suffix_text_is_trimmable(
text: &str,
fragment: &InlineFragment,
) -> bool {
text.chars().all(is_css_collapsible_whitespace)
|| (fragment.style().white_space == WhiteSpace::PreWrap
&& text.chars().all(is_css_preserved_document_space))
}
pub(in crate::layout) fn line_end_extended_over_adjacent_inline_float_markers(
graph: &InlineOpportunityGraph,
mut end: InlineGraphPosition,
) -> InlineGraphPosition {
while end.byte_offset == 0
&& end.run_index < graph.runs.len()
&& matches!(graph.runs[end.run_index].item, InlineLineItem::Float(_))
&& graph.runs[end.run_index].width.abs() <= INLINE_FLOAT_EPSILON
{
end = InlineGraphPosition::at_run_start(end.run_index + 1);
}
end
}
pub(in crate::layout) fn mixed_measured_inline_line_bidi_text(
items: &[MeasuredInlineItem],
bidi_scope_continuations: &BidiLineScopeContinuations,
) -> (String, Vec<RangedMeasuredMixedInlineLineItem>) {
let fallback_continuations = if bidi_scope_continuations.prefix.is_empty()
&& bidi_scope_continuations.suffix.is_empty()
{
css_bidi_scope_continuations_from_selected_items(items)
} else {
BidiLineScopeContinuations::default()
};
let prefix = if bidi_scope_continuations.prefix.is_empty() {
&fallback_continuations.prefix
} else {
&bidi_scope_continuations.prefix
};
let suffix = if bidi_scope_continuations.suffix.is_empty() {
&fallback_continuations.suffix
} else {
&bidi_scope_continuations.suffix
};
let mut text = bidi_scope_continuations.prefix_parent_context.clone();
text.push_str(prefix);
let mut ranged = Vec::new();
for (item_index, item) in items.iter().enumerate() {
let start = text.len();
match &item.item {
InlineLineItem::Fragment(fragment) => text.push_str(fragment.text()),
InlineLineItem::Atom(atom) => {
if inline_shaping_boundary_requires_bidi_join_control(items, item_index) {
text.push('\u{200c}');
} else if mixed_inline_atom_participates_in_bidi_ordering(atom) {
text.push(OBJECT_REPLACEMENT_CHARACTER);
}
}
InlineLineItem::Float(_) => {}
}
let end = text.len();
ranged.push(RangedMeasuredMixedInlineLineItem {
item: item.clone(),
range: start..end,
});
}
text.push_str(&bidi_scope_continuations.trailing_line_edge_context);
text.push_str(suffix);
text.push_str(&bidi_scope_continuations.suffix_parent_context);
(text, ranged)
}
fn inline_shaping_boundary_requires_bidi_join_control(
items: &[MeasuredInlineItem],
boundary_index: usize,
) -> bool {
let Some(MeasuredInlineItem {
item: InlineLineItem::Atom(atom),
..
}) = items.get(boundary_index)
else {
return false;
};
if !inline_atom_is_logical_shaping_boundary(atom) {
return false;
}
let neighbor_joins = |items: &[MeasuredInlineItem], reverse: bool| {
let mut iterator: Box<dyn Iterator<Item = &MeasuredInlineItem>> = if reverse {
Box::new(items.iter().rev())
} else {
Box::new(items.iter())
};
iterator.find_map(|item| match &item.item {
InlineLineItem::Fragment(fragment) => Some(
fragment
.text()
.chars()
.any(character_has_cursive_shaping_behavior),
),
InlineLineItem::Atom(_) if measured_item_is_transparent_mixed_inline_edge(item) => None,
InlineLineItem::Atom(_) | InlineLineItem::Float(_) => Some(false),
})
};
neighbor_joins(&items[..boundary_index], true) == Some(true)
|| neighbor_joins(&items[boundary_index + 1..], false) == Some(true)
}
pub(in crate::layout) fn bidi_scope_continuations_after_selected_controls(
items: &[MeasuredInlineItem],
graph_continuations: &BidiLineScopeContinuations,
) -> BidiLineScopeContinuations {
let mut continuations = graph_continuations.clone();
for item in items {
let InlineLineItem::Fragment(fragment) = &item.item else {
continue;
};
for character in fragment.text().chars().filter(is_bidi_scope_terminator) {
if continuations.suffix.starts_with(character) {
continuations.suffix.drain(..character.len_utf8());
}
}
}
if continuations.suffix.is_empty() {
continuations.suffix_parent_context.clear();
}
continuations
}
fn is_bidi_scope_terminator(character: &char) -> bool {
matches!(*character, '\u{202c}' | '\u{2069}')
}
fn css_bidi_scope_continuations_from_selected_items(
items: &[MeasuredInlineItem],
) -> BidiLineScopeContinuations {
let mut open_scopes = Vec::<(&str, &str)>::new();
let mut prefix = String::new();
for item in items {
let InlineLineItem::Fragment(fragment) = &item.item else {
continue;
};
if fragment.source() != InlineTextSource::BidiControl {
continue;
}
let Some((start, end)) = bidi_control_scope_for_style(fragment.style()) else {
continue;
};
if fragment.text() == start {
open_scopes.push((start, end));
} else if fragment.text() == end {
if open_scopes.last().is_some_and(|scope| scope.1 == end) {
open_scopes.pop();
} else {
prefix.insert_str(0, start);
}
}
}
let suffix = open_scopes.iter().rev().map(|scope| scope.1).collect();
BidiLineScopeContinuations {
prefix,
suffix,
..BidiLineScopeContinuations::default()
}
}
pub(in crate::layout) fn expand_visual_slice_with_owned_join_controls(
fragment_text: &str,
fragment_range: std::ops::Range<usize>,
visual_slice: std::ops::Range<usize>,
) -> std::ops::Range<usize> {
if visual_slice.start < fragment_range.start
|| visual_slice.end > fragment_range.end
|| visual_slice.start >= visual_slice.end
{
return visual_slice;
}
let relative_start = visual_slice.start - fragment_range.start;
let relative_end = visual_slice.end - fragment_range.start;
let Some(prefix) = fragment_text.get(..relative_start) else {
return visual_slice;
};
let Some(suffix) = fragment_text.get(relative_end..) else {
return visual_slice;
};
let start = if prefix.chars().all(character_is_join_control) {
fragment_range.start
} else {
visual_slice.start
};
let end = if suffix.chars().all(character_is_join_control) {
fragment_range.end
} else {
visual_slice.end
};
start..end
}
pub(in crate::layout) fn merge_owned_join_control_visual_ranges(
text: &str,
ranges: &mut Vec<BidiVisualRange>,
ranged_items: &[RangedMeasuredMixedInlineLineItem],
) {
let mut index = 0;
while index < ranges.len() {
let control_range = ranges[index].range.clone();
let join_controls_only = text
.get(control_range.clone())
.is_some_and(|slice| !slice.is_empty() && slice.chars().all(character_is_join_control));
if !join_controls_only {
index += 1;
continue;
}
let Some(owner) = ranged_items.iter().find(|ranged| {
matches!(ranged.item.item, InlineLineItem::Fragment(_))
&& ranged.range.start <= control_range.start
&& control_range.end <= ranged.range.end
}) else {
index += 1;
continue;
};
let is_visible_owner_range = |candidate: &BidiVisualRange| {
candidate.range.start >= owner.range.start
&& candidate.range.end <= owner.range.end
&& text.get(candidate.range.clone()).is_some_and(|slice| {
slice
.chars()
.any(|character| !character_is_join_control(character))
})
};
let owner_range_index = ranges
.iter()
.enumerate()
.find_map(|(candidate_index, candidate)| {
(candidate_index != index
&& candidate.range.end == control_range.start
&& is_visible_owner_range(candidate))
.then_some(candidate_index)
})
.or_else(|| {
ranges
.iter()
.enumerate()
.find_map(|(candidate_index, candidate)| {
(candidate_index != index
&& candidate.range.start == control_range.end
&& is_visible_owner_range(candidate))
.then_some(candidate_index)
})
});
let Some(owner_range_index) = owner_range_index else {
index += 1;
continue;
};
let owner_range = &mut ranges[owner_range_index];
owner_range.range.start = owner_range.range.start.min(control_range.start);
owner_range.range.end = owner_range.range.end.max(control_range.end);
ranges.remove(index);
if owner_range_index < index {
index -= 1;
}
}
}
pub(in crate::layout) fn mixed_inline_atom_participates_in_bidi_ordering(
atom: &InlineAtom,
) -> bool {
match atom.content() {
InlineAtomContent::InlineEdge(InlineEdgeRole::BoxEdge(_)) => false,
InlineAtomContent::StaticPositionHypothetical { .. }
| InlineAtomContent::Leader(_)
| InlineAtomContent::InlineEdge(_) => false,
_ => true,
}
}
pub(in crate::layout) fn measured_item_is_transparent_mixed_inline_edge(
item: &MeasuredInlineItem,
) -> bool {
matches!(
&item.item,
InlineLineItem::Atom(atom) if matches!(atom.content(), InlineAtomContent::InlineEdge(_))
)
}
pub(in crate::layout) fn split_mixed_inline_visual_ranges_at_transparent_inline_edges(
visual_ranges: Vec<BidiVisualRange>,
ranged_items: &[RangedMeasuredMixedInlineLineItem],
text: &str,
) -> Vec<BidiVisualRange> {
if visual_ranges.is_empty() {
return visual_ranges;
}
let mut edge_boundaries = Vec::new();
let mut bidi_owned_edge_ranges = Vec::new();
for ranged in ranged_items {
if !text.is_char_boundary(ranged.range.start) || !text.is_char_boundary(ranged.range.end) {
continue;
}
if ranged.range.start == ranged.range.end
&& measured_item_is_transparent_mixed_inline_edge(&ranged.item)
{
edge_boundaries.push(ranged.range.start);
continue;
}
if matches!(
&ranged.item.item,
InlineLineItem::Atom(atom) if inline_atom_is_logical_shaping_boundary(atom)
) {
edge_boundaries.extend([ranged.range.start, ranged.range.end]);
bidi_owned_edge_ranges.push(ranged.range.clone());
}
}
edge_boundaries.sort_unstable();
edge_boundaries.dedup();
if edge_boundaries.is_empty() {
return visual_ranges;
}
let mut split_ranges = Vec::with_capacity(visual_ranges.len());
for visual_range in visual_ranges {
let mut partitions = Vec::new();
let mut start = visual_range.range.start;
for boundary in edge_boundaries.iter().cloned().filter(|boundary| {
visual_range.range.start < *boundary && *boundary < visual_range.range.end
}) {
partitions.push(BidiVisualRange {
range: start..boundary,
direction: visual_range.direction,
});
start = boundary;
}
partitions.push(BidiVisualRange {
range: start..visual_range.range.end,
direction: visual_range.direction,
});
if matches!(visual_range.direction, ResolvedBidiDirection::Rtl)
&& bidi_owned_edge_ranges.iter().any(|edge_range| {
visual_range.range.start <= edge_range.start
&& edge_range.end <= visual_range.range.end
})
{
partitions.reverse();
}
split_ranges.extend(partitions);
}
split_ranges
}
pub(in crate::layout) fn transparent_inline_edge_precedes_visual_content(
item: &MeasuredInlineItem,
visual_direction: ResolvedBidiDirection,
) -> Option<bool> {
let InlineLineItem::Atom(atom) = &item.item else {
return None;
};
match atom.content() {
InlineAtomContent::InlineEdge(InlineEdgeRole::BoxEdge(edge)) => {
Some(match edge.physical_side {
PhysicalSide::Left => !matches!(atom.style().direction, Direction::Rtl),
PhysicalSide::Right => matches!(atom.style().direction, Direction::Rtl),
PhysicalSide::Top | PhysicalSide::Bottom => {
matches!(edge.logical_edge, InlineLogicalEdge::Start)
}
})
}
InlineAtomContent::InlineEdge(InlineEdgeRole::MetricsOnlyStrut) => Some(false),
InlineAtomContent::InlineEdge(InlineEdgeRole::TextAutospace(_)) => {
Some(matches!(visual_direction, ResolvedBidiDirection::Ltr))
}
InlineAtomContent::Canvas
| InlineAtomContent::Iframe(_)
| InlineAtomContent::Image(_)
| InlineAtomContent::Gradient { .. }
| InlineAtomContent::Svg { .. }
| InlineAtomContent::StaticPositionHypothetical { .. }
| InlineAtomContent::InlineBox { .. }
| InlineAtomContent::Ruby { .. }
| InlineAtomContent::TextCombineUpright { .. }
| InlineAtomContent::InlineFragment { .. }
| InlineAtomContent::Leader(_) => None,
}
}
pub(in crate::layout) fn reconcile_mixed_inline_fragment_edge_ownership(
items: &mut [MeasuredInlineItem],
) {
let mut keep = Vec::<(usize, InlineLogicalEdge)>::new();
let mut edge_styles = Vec::<(ComputedStyle, InlineLogicalEdge)>::new();
for (edge_index, item) in items.iter().enumerate() {
let Some((style, edge)) = measured_mixed_inline_box_edge_style(item) else {
continue;
};
edge_styles.push((style.clone(), edge.logical_edge));
if let Some(fragment_index) =
adjacent_fragment_index_for_visual_edge(items, edge_index, style, edge.logical_edge)
{
keep.push((fragment_index, edge.logical_edge));
}
}
if edge_styles.is_empty() {
return;
}
for (fragment_index, item) in items.iter_mut().enumerate() {
let InlineLineItem::Fragment(fragment) = &mut item.item else {
continue;
};
if fragment.hanging_edges().blocks_start
&& edge_styles.iter().any(|(style, edge)| {
*edge == InlineLogicalEdge::Start && *style == *fragment.style()
})
&& !keep.contains(&(fragment_index, InlineLogicalEdge::Start))
{
let mut hanging_edges = fragment.hanging_edges();
hanging_edges.blocks_start = false;
*fragment = fragment.clone().with_hanging_edges(hanging_edges);
}
if fragment.hanging_edges().blocks_end
&& edge_styles
.iter()
.any(|(style, edge)| *edge == InlineLogicalEdge::End && *style == *fragment.style())
&& !keep.contains(&(fragment_index, InlineLogicalEdge::End))
{
let mut hanging_edges = fragment.hanging_edges();
hanging_edges.blocks_end = false;
*fragment = fragment.clone().with_hanging_edges(hanging_edges);
}
}
}
pub(in crate::layout) fn measured_mixed_inline_box_edge_style(
item: &MeasuredInlineItem,
) -> Option<(&ComputedStyle, InlineBoxEdgeFragment)> {
let InlineLineItem::Atom(atom) = &item.item else {
return None;
};
let InlineAtomContent::InlineEdge(InlineEdgeRole::BoxEdge(edge)) = atom.content() else {
return None;
};
Some((atom.style(), *edge))
}
pub(in crate::layout) fn adjacent_fragment_index_for_visual_edge(
items: &[MeasuredInlineItem],
edge_index: usize,
edge_style: &ComputedStyle,
edge: InlineLogicalEdge,
) -> Option<usize> {
match edge {
InlineLogicalEdge::Start => adjacent_fragment_index_in_visual_edge_candidates(
items.iter().enumerate().skip(edge_index + 1),
edge_style,
edge,
),
InlineLogicalEdge::End => adjacent_fragment_index_in_visual_edge_candidates(
items[..edge_index].iter().enumerate().rev(),
edge_style,
edge,
),
}
}
pub(in crate::layout) fn adjacent_fragment_index_in_visual_edge_candidates<'a>(
candidates: impl Iterator<Item = (usize, &'a MeasuredInlineItem)>,
edge_style: &ComputedStyle,
edge: InlineLogicalEdge,
) -> Option<usize> {
for (index, item) in candidates {
match &item.item {
InlineLineItem::Fragment(fragment) => {
if *fragment.style() != *edge_style {
return None;
}
let paints_edge = match edge {
InlineLogicalEdge::Start => fragment.hanging_edges().blocks_start,
InlineLogicalEdge::End => fragment.hanging_edges().blocks_end,
};
return paints_edge.then_some(index);
}
InlineLineItem::Atom(atom) if atom.content().is_box_edge() => {}
InlineLineItem::Atom(_) | InlineLineItem::Float(_) => return None,
}
}
None
}
pub(in crate::layout) fn normalize_mixed_inline_visual_ranges(
text: &str,
visual_ranges: Vec<BidiVisualRange>,
fallback_direction: ResolvedBidiDirection,
) -> Vec<BidiVisualRange> {
if text.is_empty() {
return Vec::new();
}
let mut ranges = visual_ranges
.into_iter()
.filter(|visual_range| {
visual_range.range.start < visual_range.range.end
&& visual_range.range.end <= text.len()
&& text.is_char_boundary(visual_range.range.start)
&& text.is_char_boundary(visual_range.range.end)
})
.collect::<Vec<_>>();
if ranges.is_empty() {
ranges.push(BidiVisualRange {
range: 0..text.len(),
direction: fallback_direction,
});
}
for gap in uncovered_non_bidi_control_text_ranges(text, &ranges) {
attach_uncovered_visual_range(&mut ranges, gap, fallback_direction);
}
ranges
}
pub(in crate::layout) fn uncovered_non_bidi_control_text_ranges(
text: &str,
ranges: &[BidiVisualRange],
) -> Vec<std::ops::Range<usize>> {
let mut gaps = Vec::new();
let mut current_start = None;
let mut current_end = 0usize;
for (start, character) in text.char_indices() {
let end = start + character.len_utf8();
let covered = character_is_bidi_format_control(character)
|| ranges
.iter()
.any(|range| range.range.start <= start && end <= range.range.end);
if covered {
if let Some(gap_start) = current_start.take() {
gaps.push(gap_start..current_end);
}
} else {
current_start.get_or_insert(start);
current_end = end;
}
}
if let Some(gap_start) = current_start {
gaps.push(gap_start..current_end);
}
gaps
}
pub(in crate::layout) fn attach_uncovered_visual_range(
ranges: &mut Vec<BidiVisualRange>,
gap: std::ops::Range<usize>,
fallback_direction: ResolvedBidiDirection,
) {
if let Some(range) = ranges.iter_mut().find(|range| range.range.start == gap.end) {
range.range.start = gap.start;
return;
}
if let Some(range) = ranges.iter_mut().find(|range| range.range.end == gap.start) {
range.range.end = gap.end;
return;
}
let Some((index, before)) = nearest_visual_range_for_gap(ranges, &gap) else {
ranges.push(BidiVisualRange {
range: gap,
direction: fallback_direction,
});
return;
};
let direction = ranges[index].direction;
if before {
ranges.insert(
index,
BidiVisualRange {
range: gap,
direction,
},
);
} else {
ranges.insert(
index + 1,
BidiVisualRange {
range: gap,
direction,
},
);
}
}
pub(in crate::layout) fn nearest_visual_range_for_gap(
ranges: &[BidiVisualRange],
gap: &std::ops::Range<usize>,
) -> Option<(usize, bool)> {
ranges
.iter()
.enumerate()
.map(|(index, range)| {
let before_distance = range.range.start.abs_diff(gap.end);
let after_distance = range.range.end.abs_diff(gap.start);
if before_distance <= after_distance {
(index, true, before_distance)
} else {
(index, false, after_distance)
}
})
.min_by_key(|(_, _, distance)| *distance)
.map(|(index, before, _)| (index, before))
}
pub(in crate::layout) fn mixed_inline_item_starts_with_suppressed_line_start_punctuation(
item: &InlineLineItem,
) -> bool {
let InlineLineItem::Fragment(fragment) = item else {
return false;
};
let Some(character) = fragment
.text()
.chars()
.find(|character| !is_css_collapsible_whitespace(*character))
else {
return false;
};
character_is_hangable_stop_or_comma(character)
|| character_is_last_hangable_punctuation(character)
}
#[cfg(test)]
mod tests {
use super::*;
fn bidi_control_item(
text: &str,
style: ComputedStyle,
source: InlineTextSource,
) -> MeasuredInlineItem {
MeasuredInlineItem::new(
InlineLineItem::Fragment(InlineFragment::new(
text,
style,
0.0,
None,
true,
source,
false,
InlineHangingEdges::default(),
Vec::new(),
)),
0.0,
None,
)
}
#[test]
fn selected_real_scope_end_replaces_matching_virtual_suffix_only() {
let mut outer = ComputedStyle::initial();
outer.unicode_bidi = UnicodeBidi::Isolate;
let mut inner = outer.clone();
inner.direction = Direction::Rtl;
let continuations = BidiLineScopeContinuations {
prefix_parent_context: "\u{200e}".to_owned(),
prefix: "\u{2066}\u{2067}".to_owned(),
suffix: "\u{2069}\u{2069}".to_owned(),
trailing_line_edge_context: "\u{200e}".to_owned(),
suffix_parent_context: "\u{200e}".to_owned(),
};
let effective = bidi_scope_continuations_after_selected_controls(
&[bidi_control_item(
"\u{2069}",
inner,
InlineTextSource::BidiControl,
)],
&continuations,
);
assert_eq!(effective.prefix, "\u{2066}\u{2067}");
assert_eq!(effective.suffix, "\u{2069}");
assert_eq!(effective.trailing_line_edge_context, "\u{200e}");
assert_eq!(effective.suffix_parent_context, "\u{200e}");
let closed = bidi_scope_continuations_after_selected_controls(
&[bidi_control_item(
"\u{2069}",
outer,
InlineTextSource::BidiControl,
)],
&effective,
);
assert!(closed.suffix.is_empty());
assert!(closed.suffix_parent_context.is_empty());
}
#[test]
fn selected_authored_scope_end_replaces_matching_virtual_suffix() {
let continuations = BidiLineScopeContinuations {
prefix: "\u{2068}".to_owned(),
suffix: "\u{2069}".to_owned(),
suffix_parent_context: "\u{200e}".to_owned(),
..BidiLineScopeContinuations::default()
};
let effective = bidi_scope_continuations_after_selected_controls(
&[bidi_control_item(
"\u{2069}",
ComputedStyle::initial(),
InlineTextSource::Normal,
)],
&continuations,
);
assert_eq!(effective.prefix, "\u{2068}");
assert!(effective.suffix.is_empty());
assert!(effective.suffix_parent_context.is_empty());
}
#[test]
fn visual_slice_retains_join_controls_owned_by_its_fragment() {
let text = "\u{200c}ع\u{200c}";
let owner = 20..(20 + text.len());
let letter_start = owner.start + '\u{200c}'.len_utf8();
let letter_end = letter_start + 'ع'.len_utf8();
assert_eq!(
expand_visual_slice_with_owned_join_controls(
text,
owner.clone(),
letter_start..letter_end,
),
owner
);
}
#[test]
fn visual_slice_does_not_cross_its_fragment_for_join_controls() {
let text = "ع\u{200c}";
let owner = 8..(8 + text.len());
let letter_end = owner.start + 'ع'.len_utf8();
assert_eq!(
expand_visual_slice_with_owned_join_controls(text, owner, 8..letter_end),
8..(8 + text.len())
);
}
#[test]
fn autospace_marker_uses_the_following_visual_boundary() {
let style = ComputedStyle::initial();
let item = MeasuredInlineItem::new(
InlineLineItem::Atom(InlineAtom::new(
InlineAtomContent::InlineEdge(InlineEdgeRole::TextAutospace(
InlineTextBoundarySpacing::new(layout_pt(1.0)),
)),
style,
None,
InlineSize::new(1.0, 0.0),
0.0,
0.0,
None,
None,
)),
1.0,
None,
);
assert_eq!(
transparent_inline_edge_precedes_visual_content(&item, ResolvedBidiDirection::Ltr),
Some(true)
);
assert_eq!(
transparent_inline_edge_precedes_visual_content(&item, ResolvedBidiDirection::Rtl),
Some(false)
);
}
#[test]
fn structural_positioning_markers_are_not_bidi_replacement_objects() {
let style = ComputedStyle::initial();
let atom = |content| {
InlineAtom::new(
content,
style.clone(),
None,
InlineSize::new(0.0, style.line_height),
style.font_size,
0.0,
None,
None,
)
};
let edge = atom(InlineAtomContent::InlineEdge(InlineEdgeRole::BoxEdge(
InlineBoxEdgeFragment {
logical_edge: InlineLogicalEdge::Start,
physical_side: PhysicalSide::Left,
positioning_containing_block_id: Some(InlinePositioningContainingBlockId(3)),
advance: 0.0,
paint_extent: 0.0,
},
)));
let hypothetical = atom(InlineAtomContent::StaticPositionHypothetical {
source: InlineStaticPositionSourceId::Block,
boundary: StaticPositionHypotheticalBoundary::Transparent,
});
let canvas = atom(InlineAtomContent::Canvas);
assert!(!mixed_inline_atom_participates_in_bidi_ordering(&edge));
assert!(!mixed_inline_atom_participates_in_bidi_ordering(
&hypothetical
));
assert!(mixed_inline_atom_participates_in_bidi_ordering(&canvas));
}
}