BlueGit

timfa posprint

Files

posprint / src / escpos.rs

escpos.rs

escpos.rs 23.9 KiB Download Raw
1use std::path::Path;
2
3use image::GrayImage;
4
5use crate::bitmap_font::{self, MixedSeg};
6use crate::dsl::{
7 Align, BarcodeMode, BarcodeSymbology, Block, Document, ImageWidth, Inline, QrEcc, QrMode,
8};
9use crate::io::PosMetadata;
10use crate::raster::{self, RasterError};
11use crate::text_wrap::{self, TextWrapStyle};
12
13#[derive(Debug)]
14pub enum EscPosError {
15 Image(String),
16 Barcode(String),
17 Raster(RasterError),
18 Io(String),
19}
20
21pub struct EscPosEncoder {
22 buffer: Vec<u8>,
23 metadata: PosMetadata,
24 base_dir: Option<std::path::PathBuf>,
25}
26
27impl EscPosEncoder {
28 pub fn new(metadata: PosMetadata) -> Self {
29 Self {
30 buffer: Vec::new(),
31 metadata,
32 base_dir: None,
33 }
34 }
35
36 pub fn with_base_dir(mut self, base_dir: impl AsRef<Path>) -> Self {
37 self.base_dir = Some(base_dir.as_ref().to_path_buf());
38 self
39 }
40
41 pub fn encode_document(&mut self, document: &Document) -> Result<&[u8], EscPosError> {
42 self.buffer.clear();
43 self.init();
44 for block in &document.blocks {
45 self.encode_block(block)?;
46 }
47 Ok(&self.buffer)
48 }
49
50 pub fn into_bytes(self) -> Vec<u8> {
51 self.buffer
52 }
53
54 fn init(&mut self) {
55 self.buffer.extend_from_slice(&[0x1B, b'@']);
56 self.buffer.extend_from_slice(&[0x1B, b't', 0]);
57 }
58
59 fn encode_block(&mut self, block: &Block) -> Result<(), EscPosError> {
60 match block {
61 Block::Paragraph { align, inlines } => {
62 self.set_align(*align);
63 let cols = text_wrap::wrap_cols(&self.metadata, TextWrapStyle::Normal);
64 if bitmap_font::inlines_have_checkbox(inlines) {
65 self.encode_mixed_inlines(inlines, cols, "", "")?;
66 } else {
67 let line = inlines_to_plain(inlines);
68 for part in text_wrap::wrap_text(&line, cols) {
69 self.writeln(&part);
70 }
71 }
72 }
73 Block::List { align, items } => {
74 self.set_align(*align);
75 let cols = text_wrap::wrap_cols(&self.metadata, TextWrapStyle::Normal);
76 for item in items {
77 if bitmap_font::inlines_have_checkbox(item) {
78 self.encode_mixed_inlines(
79 item,
80 cols,
81 text_wrap::BULLET_FIRST_PREFIX,
82 text_wrap::BULLET_NEXT_PREFIX,
83 )?;
84 } else {
85 let line = inlines_to_plain(item);
86 for part in text_wrap::wrap_bullet_item(&line, cols) {
87 self.writeln(&part);
88 }
89 }
90 }
91 }
92 Block::Heading { level, align, inlines } => {
93 self.set_align(*align);
94 let wrap_style = if *level == 1 {
95 TextWrapStyle::Heading1
96 } else {
97 TextWrapStyle::Heading2
98 };
99 let cols = text_wrap::wrap_cols(&self.metadata, wrap_style);
100 if bitmap_font::inlines_have_checkbox(inlines) {
101 if *level == 1 {
102 self.buffer.extend_from_slice(&[0x1D, b'!', 0x11]);
103 } else {
104 self.buffer.extend_from_slice(&[0x1B, b'E', 1]);
105 }
106 self.encode_mixed_inlines(inlines, cols, "", "")?;
107 if *level == 1 {
108 self.buffer.extend_from_slice(&[0x1D, b'!', 0x00]);
109 } else {
110 self.buffer.extend_from_slice(&[0x1B, b'E', 0]);
111 }
112 } else {
113 let wrapped = text_wrap::wrap_text(&inlines_to_plain(inlines), cols);
114 if *level == 1 {
115 self.buffer.extend_from_slice(&[0x1D, b'!', 0x11]);
116 } else {
117 self.buffer.extend_from_slice(&[0x1B, b'E', 1]);
118 }
119 for part in &wrapped {
120 self.writeln(part);
121 }
122 if *level == 1 {
123 self.buffer.extend_from_slice(&[0x1D, b'!', 0x00]);
124 } else {
125 self.buffer.extend_from_slice(&[0x1B, b'E', 0]);
126 }
127 }
128 }
129 Block::Rule => {
130 let width = self.metadata.chars_per_line() as usize;
131 self.writeln(&"-".repeat(width));
132 }
133 Block::Feed(n) => self.feed(*n),
134 Block::Cut => self.cut(),
135 Block::Image { path, width, align } => {
136 self.set_align(*align);
137 self.encode_image(path, *width)?;
138 }
139 Block::Barcode {
140 mode,
141 symbology,
142 data,
143 height,
144 align,
145 show_text,
146 } => {
147 self.set_align(*align);
148 match mode {
149 BarcodeMode::Native => {
150 self.encode_barcode_native(*symbology, data, *height, *show_text)?;
151 }
152 BarcodeMode::Raster => {
153 let img = raster::render_barcode(*symbology, data, *height as u32)
154 .map_err(EscPosError::Raster)?;
155 let target = self.metadata.printable_dots() as u32;
156 let img = raster::scale_gray_to_print_width(img, target);
157 self.encode_gray_raster(&img, ImageWidth::Default)?;
158 }
159 }
160 }
161 Block::Qr {
162 mode,
163 data,
164 size,
165 ecc,
166 version,
167 align,
168 } => {
169 self.set_align(*align);
170 match mode {
171 QrMode::Native => self.encode_qr_native(data, *size, *ecc)?,
172 QrMode::Raster => {
173 let img = raster::render_qr(data, *version, *ecc, *size as u32)
174 .map_err(EscPosError::Raster)?;
175 self.encode_gray_raster(&img, ImageWidth::Default)?;
176 }
177 }
178 }
179 Block::Date { format, align } => {
180 self.set_align(*align);
181 let text = crate::datetime::format_date(format.as_deref());
182 let cols = text_wrap::wrap_cols(&self.metadata, TextWrapStyle::Normal);
183 for part in text_wrap::wrap_text(&text, cols) {
184 self.writeln(&part);
185 }
186 }
187 Block::Time { format, align } => {
188 self.set_align(*align);
189 let text = crate::datetime::format_time(*format);
190 let cols = text_wrap::wrap_cols(&self.metadata, TextWrapStyle::Normal);
191 for part in text_wrap::wrap_text(&text, cols) {
192 self.writeln(&part);
193 }
194 }
195 }
196 Ok(())
197 }
198
199 fn set_align(&mut self, align: Align) {
200 let n = match align {
201 Align::Left => 0,
202 Align::Center => 1,
203 Align::Right => 2,
204 };
205 self.buffer.extend_from_slice(&[0x1B, b'a', n]);
206 }
207
208 fn writeln(&mut self, text: &str) {
209 self.buffer.extend_from_slice(text.as_bytes());
210 self.buffer.push(b'\n');
211 }
212
213 fn encode_mixed_inlines(
214 &mut self,
215 inlines: &[Inline],
216 cols: usize,
217 first_prefix: &str,
218 next_prefix: &str,
219 ) -> Result<(), EscPosError> {
220 let segs = bitmap_font::segments_from_inlines(inlines);
221 let lines = if first_prefix.is_empty() && next_prefix.is_empty() {
222 bitmap_font::wrap_segments(&segs, cols)
223 } else {
224 bitmap_font::wrap_segments_hanging(&segs, cols, first_prefix, next_prefix)
225 };
226 for line in lines {
227 self.encode_mixed_line(&line)?;
228 }
229 Ok(())
230 }
231
232 fn encode_mixed_line(&mut self, segs: &[MixedSeg]) -> Result<(), EscPosError> {
233 // Native printer font for text; only the checkbox is a bit-image glyph.
234 for seg in segs {
235 match seg {
236 MixedSeg::Text(t) => self.buffer.extend_from_slice(t.as_bytes()),
237 MixedSeg::Checkbox { checked } => self.write_checkbox_bit_image(*checked),
238 }
239 }
240 self.buffer.push(b'\n');
241 Ok(())
242 }
243
244 /// ESC * m=33 — 24-dot double-density bit image, mixes with text in the print buffer.
245 fn write_checkbox_bit_image(&mut self, checked: bool) {
246 let img = bitmap_font::render_checkbox(checked);
247 let w = img.width();
248 let h = img.height().min(24);
249 let n_l = (w & 0xFF) as u8;
250 let n_h = ((w >> 8) & 0xFF) as u8;
251 self.buffer.extend_from_slice(&[0x1B, b'*', 33, n_l, n_h]);
252 for x in 0..w {
253 let mut bytes = [0u8; 3];
254 for y in 0..h {
255 if img.get_pixel(x, y).0[0] < 128 {
256 let byte_idx = (y / 8) as usize;
257 let bit = 7 - (y % 8);
258 bytes[byte_idx] |= 1 << bit;
259 }
260 }
261 self.buffer.extend_from_slice(&bytes);
262 }
263 }
264
265 fn feed(&mut self, lines: u8) {
266 if lines == 0 {
267 return;
268 }
269 // ESC d — reliable paper feed after raster graphics (print-bridge uses this too).
270 self.buffer.extend_from_slice(&[0x1B, b'd', lines]);
271 }
272
273 fn cut(&mut self) {
274 self.buffer.extend_from_slice(&[0x1D, b'V', 66, 0]);
275 }
276
277 fn encode_barcode_native(
278 &mut self,
279 symbology: BarcodeSymbology,
280 data: &str,
281 height: u8,
282 show_text: bool,
283 ) -> Result<(), EscPosError> {
284 self.buffer.extend_from_slice(&[0x1D, b'h', height]);
285 self.buffer.extend_from_slice(&[0x1D, b'H', if show_text { 2 } else { 0 }]);
286 // Widest module width (GS w 6) for easier scanning.
287 self.buffer.extend_from_slice(&[0x1D, b'w', 6]);
288 match symbology {
289 BarcodeSymbology::Code128 => {
290 let bytes = data.as_bytes();
291 self.buffer.extend_from_slice(&[0x1D, b'k', 73, bytes.len() as u8]);
292 self.buffer.extend_from_slice(bytes);
293 }
294 BarcodeSymbology::UpcA => {
295 if data.len() != 11 && data.len() != 12 {
296 return Err(EscPosError::Barcode("UPC-A requires 11-12 digits".into()));
297 }
298 self.buffer.extend_from_slice(&[0x1D, b'k', 65, data.len() as u8]);
299 self.buffer.extend_from_slice(data.as_bytes());
300 }
301 BarcodeSymbology::UpcE => {
302 if data.len() != 6 && data.len() != 7 && data.len() != 8 {
303 return Err(EscPosError::Barcode("UPC-E requires 6-8 digits".into()));
304 }
305 self.buffer.extend_from_slice(&[0x1D, b'k', 66, data.len() as u8]);
306 self.buffer.extend_from_slice(data.as_bytes());
307 }
308 BarcodeSymbology::Ean13 => {
309 if data.len() != 12 && data.len() != 13 {
310 return Err(EscPosError::Barcode("EAN13 requires 12-13 digits".into()));
311 }
312 self.buffer.extend_from_slice(&[0x1D, b'k', 67, data.len() as u8]);
313 self.buffer.extend_from_slice(data.as_bytes());
314 }
315 BarcodeSymbology::Ean8 => {
316 if data.len() != 7 && data.len() != 8 {
317 return Err(EscPosError::Barcode("EAN8 requires 7-8 digits".into()));
318 }
319 self.buffer.extend_from_slice(&[0x1D, b'k', 68, data.len() as u8]);
320 self.buffer.extend_from_slice(data.as_bytes());
321 }
322 BarcodeSymbology::Code39 => {
323 self.buffer.extend_from_slice(&[0x1D, b'k', 69, data.len() as u8]);
324 self.buffer.extend_from_slice(data.as_bytes());
325 }
326 BarcodeSymbology::Itf => {
327 if data.len() % 2 != 0 {
328 return Err(EscPosError::Barcode("ITF requires even digit count".into()));
329 }
330 self.buffer.extend_from_slice(&[0x1D, b'k', 70, data.len() as u8]);
331 self.buffer.extend_from_slice(data.as_bytes());
332 }
333 BarcodeSymbology::Codabar => {
334 self.buffer.extend_from_slice(&[0x1D, b'k', 71, data.len() as u8]);
335 self.buffer.extend_from_slice(data.as_bytes());
336 }
337 BarcodeSymbology::Code93 | BarcodeSymbology::Code11 => {
338 return Err(EscPosError::Barcode(format!(
339 "{} requires RASTER mode",
340 symbology.as_str()
341 )));
342 }
343 }
344 self.buffer.push(b'\n');
345 Ok(())
346 }
347
348 fn encode_qr_native(&mut self, data: &str, size: u8, ecc: QrEcc) -> Result<(), EscPosError> {
349 let ecc_level = match ecc {
350 QrEcc::L => 48,
351 QrEcc::M => 49,
352 QrEcc::Q => 50,
353 QrEcc::H => 51,
354 };
355 let store = data.as_bytes();
356 let len = store.len() + 3;
357 let p_l = (len & 0xFF) as u8;
358 let p_h = ((len >> 8) & 0xFF) as u8;
359
360 self.buffer.extend_from_slice(&[0x1D, 0x28, b'k', 4, 0, 49, 65, 50, 0]);
361 self.buffer.extend_from_slice(&[0x1D, 0x28, b'k', 3, 0, 49, 67, size]);
362 self.buffer.extend_from_slice(&[0x1D, 0x28, b'k', 3, 0, 49, 69, ecc_level]);
363 self.buffer.extend_from_slice(&[0x1D, 0x28, b'k', p_l, p_h, 49, 80, 48]);
364 self.buffer.extend_from_slice(store);
365 self.buffer.extend_from_slice(&[0x1D, 0x28, b'k', 3, 0, 49, 81, 48]);
366 self.buffer.push(b'\n');
367 Ok(())
368 }
369
370 fn encode_image(&mut self, path: &str, width: ImageWidth) -> Result<(), EscPosError> {
371 let resolved = resolve_image_path(path, self.base_dir.as_deref());
372 let img = image::open(&resolved).map_err(|e| EscPosError::Image(e.to_string()))?;
373 self.encode_gray_raster(&img.to_luma8(), width)
374 }
375
376 fn encode_gray_raster(&mut self, gray: &GrayImage, width: ImageWidth) -> Result<(), EscPosError> {
377 let (w, h) = gray.dimensions();
378 let target_width = match width {
379 ImageWidth::Percent(pct) => {
380 (self.metadata.printable_dots() as u32 * pct as u32 / 100) as u32
381 }
382 ImageWidth::Dots(d) => d as u32,
383 ImageWidth::Default => self.metadata.printable_dots() as u32,
384 };
385 let new_w = target_width.min(w).max(1);
386 let new_h = ((h as f32) * (new_w as f32 / w as f32)).max(1.0) as u32;
387 let resized = image::imageops::resize(
388 gray,
389 new_w,
390 new_h,
391 image::imageops::FilterType::Nearest,
392 );
393 let bytes_per_row = ((new_w + 7) / 8) as usize;
394 let mut raster = vec![0u8; bytes_per_row * new_h as usize];
395 for y in 0..new_h {
396 for x in 0..new_w {
397 let pixel = resized.get_pixel(x, y).0[0];
398 if pixel < 128 {
399 let byte_index = (y as usize * bytes_per_row) + (x as usize / 8);
400 let bit = 7 - (x % 8);
401 raster[byte_index] |= 1 << bit;
402 }
403 }
404 }
405 let x_l = (bytes_per_row & 0xFF) as u8;
406 let x_h = ((bytes_per_row >> 8) & 0xFF) as u8;
407 let y_l = (new_h & 0xFF) as u8;
408 let y_h = ((new_h >> 8) & 0xFF) as u8;
409 // GS v 0 normal raster — same header as print-bridge / node-escpos:
410 // 1D 76 30 00, xL xH (bytes/row), yL yH (dots), then bitmap bytes.
411 self.buffer
412 .extend_from_slice(&[0x1D, b'v', 0x30, 0x00, x_l, x_h, y_l, y_h]);
413 self.buffer.extend_from_slice(&raster);
414 // LF prints/flushes the raster; without it the next graphic can butt against this one.
415 self.buffer.push(b'\n');
416 Ok(())
417 }
418}
419
420fn resolve_image_path(path: &str, base_dir: Option<&Path>) -> std::path::PathBuf {
421 let p = Path::new(path);
422 if p.is_absolute() {
423 p.to_path_buf()
424 } else if let Some(base) = base_dir {
425 base.join(p)
426 } else {
427 p.to_path_buf()
428 }
429}
430
431fn inlines_to_plain(inlines: &[Inline]) -> String {
432 let mut out = String::new();
433 for inline in inlines {
434 match inline {
435 Inline::Text(t) => out.push_str(t),
436 Inline::Param(t) => out.push_str(t),
437 Inline::Checkbox { checked } => out.push_str(crate::dsl::checkbox_glyph(*checked)),
438 }
439 }
440 out
441}
442
443#[cfg(test)]
444mod tests {
445 use super::*;
446 use crate::dsl::{parse, Block};
447
448 #[test]
449 fn heading_wraps_like_preview_on_narrow_paper() {
450 let doc = parse("# Proof of Transfer").unwrap();
451 let mut enc = EscPosEncoder::new(PosMetadata {
452 page_width_mm: 53.0,
453 ..Default::default()
454 });
455 let bytes = enc.encode_document(&doc).unwrap();
456 let text = String::from_utf8_lossy(bytes);
457 assert!(
458 text.contains("Proof of\n"),
459 "expected word wrap before Transfer, got: {text}"
460 );
461 assert!(
462 text.contains("Transfer\n"),
463 "expected wrapped second line, got: {text}"
464 );
465 }
466
467 #[test]
468 fn encodes_bullet_list_with_hanging_indent() {
469 let doc = parse("- this is a long line").unwrap();
470 let meta = PosMetadata {
471 chars_per_line: Some(15),
472 ..Default::default()
473 };
474 let mut enc = EscPosEncoder::new(meta);
475 let bytes = enc.encode_document(&doc).unwrap();
476 let text = String::from_utf8_lossy(bytes);
477 assert!(text.contains("* this is a\n"));
478 assert!(text.contains(" long line\n"));
479 }
480
481 #[test]
482 fn encodes_inline_checkboxes_as_bit_image() {
483 let doc = parse("[] hello [x]").unwrap();
484 let mut enc = EscPosEncoder::new(PosMetadata::default());
485 let bytes = enc.encode_document(&doc).unwrap();
486 assert!(
487 bytes.windows(3).any(|w| w == [0x1B, b'*', 33]),
488 "checkbox should use ESC * 24-dot bit image"
489 );
490 assert!(
491 bytes.windows(5).any(|w| w == b"hello"),
492 "surrounding text should stay as native font bytes"
493 );
494 assert!(
495 !bytes.windows(4).any(|w| w == [0x1D, b'v', 0x30, 0x00]),
496 "checkbox lines must not rasterize the whole line with GS v 0"
497 );
498 }
499
500 #[test]
501 fn encodes_init_and_text() {
502 let doc = parse("Hello").unwrap();
503 let mut enc = EscPosEncoder::new(PosMetadata::default());
504 let bytes = enc.encode_document(&doc).unwrap();
505 assert_eq!(&bytes[0..2], &[0x1B, b'@']);
506 assert!(bytes.windows(5).any(|w| w == b"Hello"));
507 }
508
509 #[test]
510 fn encodes_raster_barcode() {
511 let doc = parse("@barcode RASTER CODE128 TEST").unwrap();
512 let mut enc = EscPosEncoder::new(PosMetadata::default());
513 let bytes = enc.encode_document(&doc).unwrap();
514 assert!(
515 bytes.windows(4).any(|w| w == [0x1D, b'v', 0x30, 0x00]),
516 "expected GS v 0 raster header"
517 );
518 }
519
520 #[test]
521 fn raster_header_matches_print_bridge_format() {
522 let doc = parse("@barcode RASTER CODE128 X").unwrap();
523 let meta = PosMetadata {
524 page_width_mm: 58.0,
525 ..Default::default()
526 };
527 let mut enc = EscPosEncoder::new(meta.clone());
528 let bytes = enc.encode_document(&doc).unwrap();
529 let pos = bytes
530 .windows(4)
531 .position(|w| w == [0x1D, b'v', 0x30, 0x00])
532 .expect("raster header");
533 assert_eq!(&bytes[pos..pos + 4], &[0x1D, b'v', 0x30, 0x00]);
534 let x_bytes = u16::from_le_bytes([bytes[pos + 4], bytes[pos + 5]]);
535 let expected_bytes = ((meta.printable_dots() as u32 + 7) / 8) as u16;
536 assert_eq!(
537 x_bytes, expected_bytes,
538 "barcode raster should span full printable width"
539 );
540 let y_dots = u16::from_le_bytes([bytes[pos + 6], bytes[pos + 7]]);
541 assert!(y_dots > 0);
542 }
543
544 #[test]
545 fn encodes_centered_heading() {
546 let doc = parse(":center:\n# Hello").unwrap();
547 let mut enc = EscPosEncoder::new(PosMetadata::default());
548 let bytes = enc.encode_document(&doc).unwrap();
549 assert!(bytes.windows(3).any(|w| w == [0x1B, b'a', 1]));
550 assert!(bytes.windows(5).any(|w| w == b"Hello"));
551 }
552
553 #[test]
554 fn encodes_date_directive() {
555 let doc = parse("@date DD-YYYY-MM").unwrap();
556 let mut enc = EscPosEncoder::new(PosMetadata::default());
557 let bytes = enc.encode_document(&doc).unwrap();
558 let text = String::from_utf8_lossy(bytes);
559 assert!(text.contains('-'));
560 }
561
562 #[test]
563 fn encodes_cut_directive() {
564 let doc = parse("@cut").unwrap();
565 let mut enc = EscPosEncoder::new(PosMetadata::default());
566 let bytes = enc.encode_document(&doc).unwrap();
567 assert!(bytes.windows(3).any(|w| w == [0x1D, b'V', 66]));
568 }
569
570 #[test]
571 fn feed_uses_esc_d_for_blank_lines() {
572 let doc = parse("A\n\nB").unwrap();
573 let mut enc = EscPosEncoder::new(PosMetadata::default());
574 let bytes = enc.encode_document(&doc).unwrap();
575 assert!(bytes.windows(3).any(|w| w == [0x1B, b'd', 1]));
576 }
577
578 #[test]
579 fn blank_line_between_barcode_and_qr_is_ordered_feed() {
580 let doc = parse("@barcode RASTER CODE128 X\n\n:center:@qr RASTER Y scale=4").unwrap();
581 assert!(matches!(
582 doc.blocks.as_slice(),
583 [
584 Block::Barcode { .. },
585 Block::Feed(1),
586 Block::Qr { .. },
587 ]
588 ));
589 }
590
591 #[test]
592 fn blank_line_between_graphics_feeds_on_print() {
593 let doc = parse("@barcode RASTER CODE128 X\n\n@qr RASTER Y scale=4").unwrap();
594 let mut enc = EscPosEncoder::new(PosMetadata {
595 page_width_mm: 53.0,
596 ..Default::default()
597 });
598 let bytes = enc.encode_document(&doc).unwrap();
599 let raster_positions: Vec<_> = bytes
600 .windows(4)
601 .enumerate()
602 .filter(|(_, w)| *w == [0x1D, b'v', 0x30, 0x00])
603 .map(|(i, _)| i)
604 .collect();
605 assert_eq!(raster_positions.len(), 2);
606 let between = &bytes[raster_positions[0]..raster_positions[1]];
607 assert!(
608 between.windows(3).any(|w| w == [0x1B, b'd', 1]),
609 "expected ESC d feed between raster graphics, got {} bytes",
610 between.len()
611 );
612 }
613
614 #[test]
615 fn raster_graphic_ends_with_line_feed() {
616 let doc = parse("@barcode RASTER CODE128 X").unwrap();
617 let mut enc = EscPosEncoder::new(PosMetadata::default());
618 let bytes = enc.encode_document(&doc).unwrap();
619 let raster_start = bytes
620 .windows(4)
621 .position(|w| w == [0x1D, b'v', 0x30, 0x00])
622 .expect("raster header");
623 assert!(
624 bytes[raster_start..].contains(&b'\n'),
625 "expected LF after raster data"
626 );
627 }
628
629 #[test]
630 fn does_not_auto_cut_without_directive() {
631 let doc = parse("x").unwrap();
632 let mut enc = EscPosEncoder::new(PosMetadata::default());
633 let bytes = enc.encode_document(&doc).unwrap();
634 assert!(!bytes.windows(3).any(|w| w == [0x1D, b'V', 66]));
635 }
636}