| {
if index > 0 {
printer.docs.close(part);
let between = printer.docs.part();
match separator {
Some(separator) => printer.separator(separator),
None => printer.docs.line(),
}
printer.docs.close(between);
part = printer.docs.part();
}
printer.bytes(piece);
};
if parent.has(Flags::IS_WHITESPACE_SENSITIVE) {
if parent.has(Flags::IS_INDENTATION_SENSITIVE) {
for (index, line) in strings::split(value, b"\n").enumerate() {
write(self, index, line, Some(Separator::Literal));
}
} else {
let dedented = dedent_string(html_trim_preserve_indentation(value));
for (index, line) in strings::split(&dedented, b"\n").enumerate() {
write(self, index, line, Some(Separator::Hard));
}
}
} else {
for (index, word) in html_split(value).enumerate() {
write(self, index, word, None);
}
}
self.marker(|tags, out| tags.closing_tag_suffix(id, out));
self.docs.close(part);
self.docs.close(fill);
}
// ───────────────────────────── `print/children.js` ─────────────────────────────
/// `getEndLocation`
fn end_location(&self, id: Id) -> u32 {
let node = &self.tree[id];
let end = node.span.end;
if node.kind == Kind::Element
&& node.end_span().is_none()
&& let Some(last) = self.tree.last_child(id)
{
return end.max(self.end_location(last));
}
end
}
fn print_child(&mut self, id: Id) {
if !self.tree.has_prettier_ignore(id) {
return self.print_nested(id);
}
let tags = self.tags();
let node = &self.tree[id];
let mut start = node.span.start as usize;
if self
.tree
.prev(id)
.is_some_and(|prev| tags.needs_to_borrow_next_opening_tag_start_marker(prev))
{
start += tags.len_of(|tags, out| tags.opening_tag_start_marker(id, out));
}
let mut end = self.end_location(id) as usize;
if self.tree.next(id).is_some_and(|next| tags.needs_to_borrow_prev_closing_tag_end_marker(next))
{
end -= tags.len_of(|tags, out| tags.closing_tag_end_marker(id, out));
}
let text = self.options.original_text.get(start..end).unwrap_or_default();
let text = strings::trim_html_whitespace_end(text);
self.marker(|tags, out| tags.opening_tag_prefix(id, out));
self.lines(text, Separator::Literal);
self.marker(|tags, out| tags.closing_tag_suffix(id, out));
}
fn between(&self, prev: Id, next: Id) -> Between {
let tags = self.tags();
let (before, after) = (&self.tree[prev], &self.tree[next]);
let hard_leading = self.tree.prefer_hardline_as_leading_spaces(next, self.options);
if is_text_like(before) && is_text_like(after) {
if before.has(Flags::IS_TRAILING_SPACE_SENSITIVE) {
if before.has(Flags::HAS_TRAILING_SPACES) {
return if hard_leading { Between::Hard } else { Between::Line };
}
return Between::None;
}
return if hard_leading { Between::Hard } else { Between::Soft };
}
if (tags.needs_to_borrow_next_opening_tag_start_marker(prev)
&& (self.tree.has_prettier_ignore(next)
|| self.tree.first_child(next).is_some()
|| after.has(Flags::IS_SELF_CLOSING)
|| (after.kind == Kind::Element && after.has_attrs())))
|| (before.kind == Kind::Element
&& before.has(Flags::IS_SELF_CLOSING)
&& tags.needs_to_borrow_prev_closing_tag_end_marker(next))
{
return Between::None;
}
if after.kind == Kind::Comment
&& after.has(Flags::IS_LEADING_SPACE_SENSITIVE)
&& !after.has(Flags::HAS_LEADING_SPACES)
{
return Between::Soft;
}
let borrows_deep = || {
tags.needs_to_borrow_prev_closing_tag_end_marker(next)
&& self.tree.last_child(prev).is_some_and(|last| {
tags.needs_to_borrow_parent_closing_tag_start_marker(last)
&& self
.tree
.last_child(last)
.is_some_and(|deep| tags.needs_to_borrow_parent_closing_tag_start_marker(deep))
})
};
if !after.has(Flags::IS_LEADING_SPACE_SENSITIVE) || hard_leading || borrows_deep() {
return Between::Hard;
}
if after.has(Flags::HAS_LEADING_SPACES) { Between::Line } else { Between::Soft }
}
fn emit_between(&mut self, between: Between) {
match between {
Between::None => {}
Between::Hard => self.docs.hardline(),
Between::Line => self.docs.line(),
Between::Soft => self.docs.softline(),
}
}
fn print_children(&mut self, id: Id) {
if self.tree.force_break_children(id) {
self.docs.break_parent();
let mut next = self.tree.first_child(id);
while let Some(child) = next {
next = self.tree.next(child);
if let Some(prev) = self.tree.prev(child) {
let between = self.between(prev, child);
if between != Between::None {
self.emit_between(between);
if self.tree.force_next_empty_line(prev, self.options) {
self.docs.hardline();
}
}
}
self.print_child(child);
}
return;
}
// The group of the previous child, which `ifBreak` looks at.
let mut previous = None;
let mut next = self.tree.first_child(id);
while let Some(child) = next {
next = self.tree.next(child);
let prev = self.tree.prev(child);
let group = self.docs.group_id();
let current = previous.replace(group);
if is_text_like(&self.tree[child]) {
if let Some(prev) = prev.filter(|&prev| is_text_like(&self.tree[prev])) {
let between = self.between(prev, child);
if between != Between::None {
if self.tree.force_next_empty_line(prev, self.options) {
self.docs.hardline();
self.docs.hardline();
} else {
self.emit_between(between);
}
}
}
self.print_child(child);
continue;
}
let mut before = 0;
let mut leading = Leading::None;
let mut trailing = Between::None;
let mut after = 0;
if let Some(prev) = prev {
let between = self.between(prev, child);
if between != Between::None {
if self.tree.force_next_empty_line(prev, self.options) {
before = 2;
} else if between == Between::Hard {
before = 1;
} else if is_text_like(&self.tree[prev]) {
leading = Leading::Line(between);
} else {
leading = Leading::Soft;
}
}
}
if let Some(next) = next {
let between = self.between(child, next);
if between != Between::None {
let next_is_text = is_text_like(&self.tree[next]);
if self.tree.force_next_empty_line(child, self.options) {
after = if next_is_text { 2 } else { 0 };
} else if between == Between::Hard {
after = usize::from(next_is_text);
} else {
trailing = between;
}
}
}
for _ in 0..before {
self.docs.hardline();
}
let outer = self.docs.group();
match leading {
Leading::None => {}
Leading::Line(between) => self.emit_between(between),
Leading::Soft => {
let flat = self.docs.if_break(Branch::Flat, current);
self.docs.softline();
self.docs.close(flat);
}
}
let inner = self.docs.group_with(Some(group), false);
self.print_child(child);
self.emit_between(trailing);
self.docs.close(inner);
self.docs.close(outer);
for _ in 0..after {
self.docs.hardline();
}
}
}
// ───────────────────────────── `print/element.js` ─────────────────────────────
fn print_element(&mut self, id: Id) {
let tags = self.tags();
let node = &self.tree[id];
if node.has(Flags::PRESERVES_CONTENT) {
// The tags already print the markers that they borrow, and Prettier prints those again around them:
// `a>`. A whitespace-only `` or `