panache-cli 3.4.0__tar.gz → 3.5.0__tar.gz

{panache_cli-3.4.0 → panache_cli-3.5.0}/Cargo.lock

@@ -992,9 +992,9 @@ checksum = "3eaf3ede3fee6db1a4c2ee091bf8a8b4dccdc6d17f656fb07896ee72867612f2"
 
 [[package]]
 name = "libredox"
-version = "0.1.19"
+version = "0.1.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2026a5056764a10b2bf5d56488cba40da507f5493a6a429340e2004d9ed085fa"
+checksum = "28d0a00925a9f930d679b6789b721e3a7f9ed110f41b86d2497caa780c3a070a"
 dependencies = [
  "libc",
 ]
@@ -1203,7 +1203,7 @@ checksum = "1a80800c0488c3a21695ea981a54918fbb37abf04f4d0720c453632255e2ff0e"
 
 [[package]]
 name = "panache"
-version = "3.4.0"
+version = "3.5.0"
 dependencies = [
  "annotate-snippets",
  "assert_cmd",
@@ -1223,6 +1223,7 @@ dependencies = [
  "log",
  "lsp-server",
  "lsp-types",
+ "memchr",
  "num_cpus",
  "panache-formatter",
  "panache-parser",
@@ -1235,7 +1236,7 @@ dependencies = [
  "schemars",
  "serde",
  "serde_json",
- "similar 3.1.2",
+ "similar 3.2.0",
  "similar-asserts",
  "tempfile",
  "toml",
@@ -1247,7 +1248,7 @@ dependencies = [
 
 [[package]]
 name = "panache-formatter"
-version = "0.21.0"
+version = "0.21.1"
 dependencies = [
  "insta",
  "log",
@@ -1265,7 +1266,7 @@ dependencies = [
 
 [[package]]
 name = "panache-parser"
-version = "0.26.0"
+version = "0.27.0"
 dependencies = [
  "entities",
  "insta",
@@ -1791,9 +1792,9 @@ checksum = "bbbb5d9659141646ae647b42fe094daf6c6192d1620870b449d9557f748b2daa"
 
 [[package]]
 name = "similar"
-version = "3.1.2"
+version = "3.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "85ee016af5d736b69fc89e19254540fa4b5f5492853fb5503920f084011c78b6"
+checksum = "4f66ca1f7aca2474dc10c942eb22feffc897735f54cd1db90138c2fddb490987"
 dependencies = [
  "bstr",
  "unicode-segmentation",
@@ -1806,7 +1807,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "997e6ca38e97437973fc9f7f50a50d1274cacd874341a4960fea90067291038c"
 dependencies = [
  "console",
- "similar 3.1.2",
+ "similar 3.2.0",
 ]
 
 [[package]]
@@ -2062,9 +2063,9 @@ checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
 
 [[package]]
 name = "uuid"
-version = "1.24.0"
+version = "1.24.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bf3923a6f5c4c6382e0b653c4117f48d631ea17f38ed86e2a828e6f7412f5239"
+checksum = "2cefc03fd367c0c6d4305de1b312cf00248c4114f4a0418ce6a6af769e3b0bd9"
 dependencies = [
  "getrandom 0.4.3",
  "js-sys",

{panache_cli-3.4.0 → panache_cli-3.5.0}/Cargo.toml

@@ -10,7 +10,7 @@ authors = ["Johan Larsson <johan@jolars.co>"]
 
 [package]
 name = "panache"
-version = "3.4.0"
+version = "3.5.0"
 edition.workspace = true
 rust-version.workspace = true
 # `distill_quarto_schema` is a dev-only vendoring bin (src/bin/); keep bare
@@ -52,8 +52,8 @@ path = "src/main.rs"
 required-features = ["cli"]
 
 [dependencies]
-panache-formatter = { path = "crates/panache-formatter", version = "0.21.0" }
-panache-parser = { path = "crates/panache-parser", version = "0.26.0", features = [
+panache-formatter = { path = "crates/panache-formatter", version = "0.21.1" }
+panache-parser = { path = "crates/panache-parser", version = "0.27.0", features = [
     "serde",
     "schema",
 ] }
@@ -69,6 +69,7 @@ ignore = { version = "0.4.29", optional = true }
 log = { version = "0.4.31", features = ["release_max_level_debug"] }
 lsp-server = { version = "0.10.0", optional = true }
 lsp-types = { version = "0.97.0", optional = true }
+memchr = "2.8.3"
 num_cpus = { version = "1.17.0", optional = true }
 percent-encoding = { version = "2.3.2", optional = true }
 regex = "1.12.2"

{panache_cli-3.4.0 → panache_cli-3.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: panache-cli
-Version: 3.4.0
+Version: 3.5.0
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers

{panache_cli-3.4.0 → panache_cli-3.5.0}/crates/panache-formatter/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## [0.21.1](https://github.com/jolars/panache/compare/panache-formatter-v0.21.0...panache-formatter-v0.21.1) (2026-08-17)
+
+### Bug Fixes
+- **parser:** anchor yaml metadata delimiters at column 0 ([`55e3999`](https://github.com/jolars/panache/commit/55e3999730d4987bc37f369733ed0f420d9e6c40))
+- gate heading auto-ids on `auto_identifiers` ([`efd4ae0`](https://github.com/jolars/panache/commit/efd4ae053acdad06f0f559ffdff803fd77348bf8))
+- **formatter:** stop trimming heading content hashes ([`cee2dbf`](https://github.com/jolars/panache/commit/cee2dbfe3efa3a240b838aa5dbd4e1f2dba3d1d6))
+- **formatter:** keep a load-bearing heading `#` run ([`be48179`](https://github.com/jolars/panache/commit/be481798358fc2722da2a3dbb1241bdb4d27bb80))
+- **parser:** fold whitespace into a backslash line break ([`eaf42a0`](https://github.com/jolars/panache/commit/eaf42a00e77fe3bfda14a01e1568605f5b9c2785))
+- **formatter:** drop trailing whitespace under `wrap = preserve` ([`d3fdd9f`](https://github.com/jolars/panache/commit/d3fdd9fc1e259112462709cbad91e3135010eb63)), closes [#496](https://github.com/jolars/panache/issues/496)
+
+### Dependencies
+- updated crates/panache-parser to v0.27.0
+
 ## [0.21.0](https://github.com/jolars/panache/compare/panache-formatter-v0.20.5...panache-formatter-v0.21.0) (2026-08-14)
 
 ### Features

{panache_cli-3.4.0 → panache_cli-3.5.0}/crates/panache-formatter/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "panache-formatter"
-version = "0.21.0"
+version = "0.21.1"
 edition.workspace = true
 rust-version.workspace = true
 include = [
@@ -19,7 +19,7 @@ keywords = ["quarto", "pandoc", "markdown", "formatter"]
 categories = ["text-processing"]
 
 [dependencies]
-panache-parser = { path = "../panache-parser", version = "0.26.0" }
+panache-parser = { path = "../panache-parser", version = "0.27.0" }
 log = { version = "0.4.31", features = ["release_max_level_debug"] }
 rowan = "0.17.0"
 serde = { version = "1.0.228", features = ["derive"], optional = true }

{panache_cli-3.4.0 → panache_cli-3.5.0}/crates/panache-formatter/src/config.rs

@@ -98,6 +98,7 @@ pub enum BlankLines {
 
 #[derive(Debug, Clone, PartialEq)]
 pub struct FormatterExtensions {
+    pub auto_identifiers: bool,
     pub blank_before_header: bool,
     pub bookdown_references: bool,
     pub east_asian_line_breaks: bool,
@@ -120,6 +121,7 @@ impl FormatterExtensions {
         let smart_default = matches!(flavor, Flavor::Pandoc | Flavor::Quarto | Flavor::RMarkdown);
 
         Self {
+            auto_identifiers: parser_defaults.auto_identifiers,
             blank_before_header: parser_defaults.blank_before_header,
             bookdown_references: parser_defaults.bookdown_references,
             east_asian_line_breaks: parser_defaults.east_asian_line_breaks,
@@ -177,6 +179,7 @@ macro_rules! known_formatter_extensions {
 }
 
 known_formatter_extensions! {
+    "auto-identifiers" => auto_identifiers,
     "blank-before-header" => blank_before_header,
     "bookdown-references" => bookdown_references,
     "east-asian-line-breaks" => east_asian_line_breaks,

{panache_cli-3.4.0 → panache_cli-3.5.0}/crates/panache-formatter/src/formatter/core.rs

@@ -14,6 +14,7 @@ use super::headings;
 use super::inline;
 use super::inline_layout;
 use super::paragraphs;
+use super::preserve::{preserve_lines, preserve_lines_unprefixed};
 use super::smart::normalize_smart_punctuation;
 use super::tables;
 use super::utils::{is_block_element, is_structural_block};
@@ -1041,19 +1042,20 @@ impl Formatter {
                             let available_width =
                                 self.config.line_width.saturating_sub(child_indent);
                             let lines = match wrap_mode {
-                                WrapMode::Preserve => child
-                                    .text()
+                                WrapMode::Preserve => preserve_lines(
+                                    child,
+                                    self.config.formatter_extensions.escaped_line_breaks,
+                                )
+                                .iter()
+                                .map(|line| {
+                                    normalize_smart_punctuation(
+                                        line.trim_start_matches([' ', '\t']),
+                                        self.config.formatter_extensions.smart,
+                                        self.config.formatter_extensions.smart_quotes,
+                                    )
                                     .to_string()
-                                    .lines()
-                                    .map(|line| {
-                                        normalize_smart_punctuation(
-                                            line.trim_start_matches([' ', '\t']),
-                                            self.config.formatter_extensions.smart,
-                                            self.config.formatter_extensions.smart_quotes,
-                                        )
-                                        .to_string()
-                                    })
-                                    .collect(),
+                                })
+                                .collect(),
                                 WrapMode::Reflow => {
                                     self.wrapped_lines_for_paragraph(child, available_width)
                                 }
@@ -1148,19 +1150,20 @@ impl Formatter {
                                 self.config.line_width.saturating_sub(child_indent);
                             let widths = [first_line_space, available_width];
                             let lines = match wrap_mode {
-                                WrapMode::Preserve => {
-                                    let text = child.text().to_string();
-                                    text.lines()
-                                        .map(|line| {
-                                            normalize_smart_punctuation(
-                                                line,
-                                                self.config.formatter_extensions.smart,
-                                                self.config.formatter_extensions.smart_quotes,
-                                            )
-                                            .to_string()
-                                        })
-                                        .collect()
-                                }
+                                WrapMode::Preserve => preserve_lines(
+                                    child,
+                                    self.config.formatter_extensions.escaped_line_breaks,
+                                )
+                                .iter()
+                                .map(|line| {
+                                    normalize_smart_punctuation(
+                                        line,
+                                        self.config.formatter_extensions.smart,
+                                        self.config.formatter_extensions.smart_quotes,
+                                    )
+                                    .to_string()
+                                })
+                                .collect(),
                                 WrapMode::Reflow => {
                                     self.wrapped_lines_for_paragraph_with_widths(child, &widths)
                                 }
@@ -1229,8 +1232,9 @@ impl Formatter {
 
                             match wrap_mode {
                                 WrapMode::Preserve => {
-                                    let text = child.text().to_string();
-                                    for line in text.lines() {
+                                    let escaped =
+                                        self.config.formatter_extensions.escaped_line_breaks;
+                                    for line in preserve_lines(child, escaped) {
                                         self.output.push_str(&" ".repeat(child_indent));
                                         self.output.push_str(
                                             normalize_smart_punctuation(
@@ -1500,28 +1504,21 @@ impl Formatter {
                             let para_start = self.output.len();
                             match wrap_mode {
                                 WrapMode::Preserve => {
-                                    // Build paragraph text while skipping BlockQuoteMarker tokens
-                                    // (they're in the tree for losslessness but we add prefixes dynamically)
-                                    let mut lines_text = String::new();
-                                    for item in child.children_with_tokens() {
-                                        match item {
-                                            NodeOrToken::Token(t)
-                                                if t.kind() == SyntaxKind::LINE_PREFIX =>
-                                            {
-                                                // Container prefix — re-added dynamically.
-                                            }
-                                            NodeOrToken::Token(t) => {
-                                                lines_text.push_str(t.text());
-                                            }
-                                            NodeOrToken::Node(n) => {
-                                                lines_text.push_str(&n.text().to_string());
-                                            }
+                                    // We write `content_prefix` on every line
+                                    // ourselves, so the tree's own LINE_PREFIX
+                                    // tokens have to come back out.
+                                    let escaped =
+                                        self.config.formatter_extensions.escaped_line_breaks;
+                                    for line in preserve_lines_unprefixed(child, escaped) {
+                                        // An empty quoted line takes the bare
+                                        // marker, so the prefix does not become
+                                        // trailing whitespace itself.
+                                        if line.is_empty() {
+                                            self.output.push_str(content_prefix.trim_end());
+                                        } else {
+                                            self.output.push_str(&content_prefix);
+                                            self.output.push_str(&line);
                                         }
-                                    }
-
-                                    for line in lines_text.lines() {
-                                        self.output.push_str(&content_prefix);
-                                        self.output.push_str(line);
                                         self.output.push('\n');
                                     }
                                 }
@@ -1566,10 +1563,17 @@ impl Formatter {
                                 match alert_child.kind() {
                                     SyntaxKind::PARAGRAPH => match wrap_mode {
                                         WrapMode::Preserve => {
-                                            let text = alert_child.text().to_string();
-                                            for line in text.lines() {
-                                                self.output.push_str(&content_prefix);
-                                                self.output.push_str(line);
+                                            let escaped = self
+                                                .config
+                                                .formatter_extensions
+                                                .escaped_line_breaks;
+                                            for line in preserve_lines(&alert_child, escaped) {
+                                                if line.is_empty() {
+                                                    self.output.push_str(content_prefix.trim_end());
+                                                } else {
+                                                    self.output.push_str(&content_prefix);
+                                                    self.output.push_str(&line);
+                                                }
                                                 self.output.push('\n');
                                             }
                                         }
@@ -1952,25 +1956,17 @@ impl Formatter {
                 match wrap_mode {
                     WrapMode::Preserve => {
                         log::trace!("Preserving paragraph line breaks");
-                        if indent > 0 {
-                            for (i, line) in text.lines().enumerate() {
-                                if i > 0 {
-                                    self.output.push('\n');
-                                }
+                        let escaped = self.config.formatter_extensions.escaped_line_breaks;
+                        for (i, line) in preserve_lines(node, escaped).iter().enumerate() {
+                            if i > 0 {
+                                self.output.push('\n');
+                            }
+                            if indent > 0 {
                                 self.output.push_str(&paragraph_indent);
-                                self.output.push_str(
-                                    normalize_smart_punctuation(
-                                        line.trim_start(),
-                                        self.config.formatter_extensions.smart,
-                                        self.config.formatter_extensions.smart_quotes,
-                                    )
-                                    .as_ref(),
-                                );
                             }
-                        } else {
                             self.output.push_str(
                                 normalize_smart_punctuation(
-                                    &text,
+                                    if indent > 0 { line.trim_start() } else { line },
                                     self.config.formatter_extensions.smart,
                                     self.config.formatter_extensions.smart_quotes,
                                 )
@@ -2051,32 +2047,32 @@ impl Formatter {
                     && !self.output.ends_with(":   ");
                 match wrap_mode {
                     WrapMode::Preserve => {
-                        if needs_indent {
-                            for line in text.lines() {
+                        let escaped = self.config.formatter_extensions.escaped_line_breaks;
+                        for (i, line) in preserve_lines(node, escaped).iter().enumerate() {
+                            if needs_indent {
                                 self.output.push_str(&" ".repeat(indent));
-                                self.output.push_str(
-                                    normalize_smart_punctuation(
-                                        line.trim_start(),
-                                        self.config.formatter_extensions.smart,
-                                        self.config.formatter_extensions.smart_quotes,
-                                    )
-                                    .as_ref(),
-                                );
+                            } else if i > 0 {
                                 self.output.push('\n');
                             }
-                        } else {
                             self.output.push_str(
                                 normalize_smart_punctuation(
-                                    &text,
+                                    if needs_indent {
+                                        line.trim_start()
+                                    } else {
+                                        line
+                                    },
                                     self.config.formatter_extensions.smart,
                                     self.config.formatter_extensions.smart_quotes,
                                 )
                                 .as_ref(),
                             );
-                            if !self.output.ends_with('\n') {
+                            if needs_indent {
                                 self.output.push('\n');
                             }
                         }
+                        if !self.output.ends_with('\n') {
+                            self.output.push('\n');
+                        }
                     }
                     WrapMode::Reflow => {
                         log::trace!("Reflowing Plain block to {} width", line_width);
@@ -2545,10 +2541,12 @@ impl Formatter {
                                         let widths = [first_line_space, available_width];
 
                                         let lines = match wrap_mode {
-                                            WrapMode::Preserve => {
-                                                let text = n.text().to_string();
-                                                text.lines().map(|line| line.to_string()).collect()
-                                            }
+                                            WrapMode::Preserve => preserve_lines(
+                                                n,
+                                                self.config
+                                                    .formatter_extensions
+                                                    .escaped_line_breaks,
+                                            ),
                                             WrapMode::Reflow => self
                                                 .wrapped_lines_for_paragraph_with_widths(
                                                     n, &widths,

{panache_cli-3.4.0 → panache_cli-3.5.0}/crates/panache-formatter/src/formatter/headings.rs

@@ -1,3 +1,4 @@
+use panache_parser::parser::blocks::headings::content_reads_as_decoration;
 use rowan::NodeOrToken;
 
 use super::core::normalize_attribute_text;
@@ -65,16 +66,27 @@ pub(super) fn format_heading(node: &SyntaxNode, config: &Config) -> String {
         }
     }
 
-    // Trim trailing closing hashes and surrounding whitespace (`# Title #`).
-    let content = content
-        .trim_end_matches(|c: char| c == '#' || c.is_whitespace())
-        .trim_start();
+    // The parser splits the closing run off into its own marker token, so
+    // whatever is left is content; only surrounding whitespace goes.
+    let content = content.trim();
 
     let mut out = "#".repeat(level);
     if !content.is_empty() {
         out.push(' ');
         out.push_str(content);
     }
+    // A closing run is decoration and normally dropped --- except when it is
+    // load-bearing, i.e. when the content it leaves in front of the line ending
+    // would read back as decoration itself. pandoc reads a heading's attribute
+    // block only *after* the run, so the run is what keeps a trailing `{...}`
+    // in the content out of the attributes: `# foo {#id} #` is `Header 1
+    // (foo-id) [Str "foo", Space, Str "{#id}"]`, and dropping the run would
+    // rewrite the id to `id`. A content hash at the end of the line is the same
+    // story one level down: the `#` in `# foo # #` is content, but alone on the
+    // line it closes the heading instead.
+    if content_reads_as_decoration(content, &config.parser_options()) {
+        out.push_str(" #");
+    }
     if !attributes.is_empty() {
         out.push(' ');
         out.push_str(&attributes);

{panache_cli-3.4.0 → panache_cli-3.5.0}/crates/panache-formatter/src/formatter/inline.rs

@@ -657,7 +657,9 @@ pub(super) fn format_inline_node(node: &SyntaxNode, config: &Config) -> String {
             if config.formatter_extensions.escaped_line_breaks {
                 "\\\n".to_string()
             } else {
-                node.text().to_string()
+                let text = node.text().to_string();
+                let ending = text.find(['\r', '\n']).map_or("", |at| &text[at..]);
+                format!("{}{ending}", crate::utils::hard_break_marker(&text))
             }
         }
         SyntaxKind::NONBREAKING_SPACE => "\\ ".to_string(),

{panache_cli-3.4.0 → panache_cli-3.5.0}/crates/panache-formatter/src/formatter/inline_layout.rs

@@ -965,7 +965,7 @@ fn process_node_recursive(
                     let marker = if config.formatter_extensions.escaped_line_breaks {
                         "\\"
                     } else {
-                        t.text().trim_end_matches(['\r', '\n'])
+                        crate::utils::hard_break_marker(t.text())
                     };
                     sink.push_hard_line_break(marker);
                 }

{panache_cli-3.4.0 → panache_cli-3.5.0}/crates/panache-formatter/src/formatter/lists.rs

@@ -7,6 +7,7 @@ use panache_parser::parser::blocks::definition_lists::try_parse_definition_marke
 use rowan::NodeOrToken;
 
 use super::Formatter;
+use super::preserve;
 
 impl Formatter {
     fn is_marker_only_blockquote_continuation(node: &SyntaxNode) -> bool {
@@ -247,7 +248,6 @@ impl Formatter {
     /// Format a paragraph that is a continuation of a list item.
     /// Strips existing indentation from the text and applies the correct list item indentation.
     pub(super) fn format_list_continuation_paragraph(&mut self, node: &SyntaxNode, indent: usize) {
-        let text = node.text().to_string();
         let line_width = self.config.line_width.saturating_sub(indent);
         let wrap_mode = self.config.wrap.clone().unwrap_or(WrapMode::Reflow);
         // This arm emits the paragraph's lines itself rather than going through
@@ -257,7 +257,8 @@ impl Formatter {
         match wrap_mode {
             WrapMode::Preserve => {
                 // Strip existing indentation and apply list item indentation
-                for line in text.lines() {
+                let escaped = self.config.formatter_extensions.escaped_line_breaks;
+                for line in preserve::preserve_lines(node, escaped) {
                     self.output.push_str(&" ".repeat(indent));
                     self.output.push_str(line.trim_start());
                     self.output.push('\n');
@@ -1004,12 +1005,16 @@ impl Formatter {
 
         let preserve_lines = match wrap_mode {
             WrapMode::Preserve => {
-                let source = content_node
-                    .as_ref()
-                    .map(|content| content.text().to_string())
-                    .unwrap_or_default();
-                Some(source.lines().map(ToString::to_string).collect::<Vec<_>>())
+                let escaped = self.config.formatter_extensions.escaped_line_breaks;
+                Some(
+                    content_node
+                        .as_ref()
+                        .map(|content| preserve::preserve_lines(content, escaped))
+                        .unwrap_or_default(),
+                )
             }
+            // A format-off directive means "leave these bytes alone", trailing
+            // whitespace included, so this path deliberately does not trim.
             _ if content_has_format_directive => {
                 let source = content_node
                     .as_ref()

panache_cli-3.5.0/crates/panache-formatter/src/formatter/preserve.rs

@@ -0,0 +1,103 @@
+//! Line emission for `wrap = preserve`.
+//!
+//! Every other wrap mode re-renders inlines and so drops the padding at the
+//! end of a source line as a side effect of rebuilding it. Preserve mode
+//! copies bytes instead, which is what keeps the line breaks intact -- but it
+//! also carried the trailing whitespace straight into the output (issue #496).
+//! This module is the one place that turns a block's tokens into preserve-mode
+//! lines, so the two concerns stay separated: line breaks preserved, padding
+//! dropped.
+
+use crate::syntax::{SyntaxKind, SyntaxNode};
+use rowan::NodeOrToken;
+
+/// Split a block into the lines `wrap = preserve` should emit, with trailing
+/// whitespace removed and hard breaks normalized.
+///
+/// Only `NEWLINE` and `HARD_LINE_BREAK` tokens end a line. Newlines inside
+/// verbatim constructs never reach us as either kind -- a code span keeps its
+/// whole body in one `INLINE_CODE_CONTENT` token, math uses `MATH_NEWLINE`, and
+/// inline HTML uses `WHITESPACE` -- so their bytes are copied untouched and
+/// this stays a prose-only trim.
+///
+/// A trailing run that genuinely *is* a hard break becomes `\` when
+/// `escaped_line_breaks` is on, matching what the inline formatter emits for
+/// every other wrap mode. Otherwise the original whitespace run is kept, since
+/// it is the only thing carrying the break.
+///
+/// Container `LINE_PREFIX` tokens are kept, since most callers emit the
+/// block's own source indentation. Callers that rebuild the prefix themselves
+/// want [`preserve_lines_unprefixed`] instead.
+pub(super) fn preserve_lines(node: &SyntaxNode, escaped_line_breaks: bool) -> Vec<String> {
+    lines_with_prefix(node, escaped_line_breaks, LinePrefix::Keep)
+}
+
+/// Like [`preserve_lines`], but drops the container `LINE_PREFIX` tokens. They
+/// are in the tree for losslessness; a caller that writes its own prefix on
+/// every line would otherwise emit them twice.
+pub(super) fn preserve_lines_unprefixed(
+    node: &SyntaxNode,
+    escaped_line_breaks: bool,
+) -> Vec<String> {
+    lines_with_prefix(node, escaped_line_breaks, LinePrefix::Drop)
+}
+
+#[derive(Clone, Copy, PartialEq)]
+enum LinePrefix {
+    Keep,
+    Drop,
+}
+
+fn lines_with_prefix(
+    node: &SyntaxNode,
+    escaped_line_breaks: bool,
+    prefix: LinePrefix,
+) -> Vec<String> {
+    let mut lines = Vec::new();
+    let mut current = String::new();
+    collect(node, escaped_line_breaks, prefix, &mut lines, &mut current);
+
+    // Mirror `str::lines`: a block ending in a newline has no empty final line.
+    if !current.is_empty() {
+        lines.push(trim_padding(&current));
+    }
+    lines
+}
+
+fn collect(
+    node: &SyntaxNode,
+    escaped_line_breaks: bool,
+    prefix: LinePrefix,
+    lines: &mut Vec<String>,
+    current: &mut String,
+) {
+    for item in node.children_with_tokens() {
+        match item {
+            NodeOrToken::Node(child) => {
+                collect(&child, escaped_line_breaks, prefix, lines, current)
+            }
+            NodeOrToken::Token(token) => match token.kind() {
+                SyntaxKind::LINE_PREFIX if prefix == LinePrefix::Drop => {}
+                SyntaxKind::NEWLINE => {
+                    lines.push(trim_padding(current));
+                    current.clear();
+                }
+                SyntaxKind::HARD_LINE_BREAK => {
+                    if escaped_line_breaks {
+                        current.push('\\');
+                    } else {
+                        current.push_str(crate::utils::hard_break_marker(token.text()));
+                    }
+                    lines.push(std::mem::take(current));
+                }
+                _ => current.push_str(token.text()),
+            },
+        }
+    }
+}
+
+/// Trim only ASCII spaces and tabs. `str::trim_end` would also eat a
+/// non-breaking space, which is content.
+fn trim_padding(line: &str) -> String {
+    line.trim_end_matches([' ', '\t']).to_string()
+}

{panache_cli-3.4.0 → panache_cli-3.5.0}/crates/panache-formatter/src/formatter.rs

@@ -13,6 +13,7 @@ mod inline_layout;
 mod lists;
 mod metadata;
 mod paragraphs;
+mod preserve;
 mod sentence_wrap;
 mod shortcodes;
 mod smart;