diff --git a/src-pdfrs/pdf/src/content.rs b/src-pdfrs/pdf/src/content.rs
index 7acf38d..e831e53 100644
--- a/src-pdfrs/pdf/src/content.rs
+++ b/src-pdfrs/pdf/src/content.rs
@@ -1,17 +1,17 @@
+use datasize::DataSize;
+use istring::SmallString;
+use itertools::Itertools;
+use std::cmp::Ordering;
 /// PDF content streams.
 use std::fmt::{self, Display};
-use std::cmp::Ordering;
-use itertools::Itertools;
-use istring::SmallString;
-use datasize::DataSize;
 use std::sync::Arc;
 
+use crate as pdf;
+use crate::enc::StreamFilter;
 use crate::error::*;
 use crate::object::*;
-use crate::parser::{Lexer, parse_with_lexer, ParseFlags};
+use crate::parser::{parse_with_lexer, Lexer, ParseFlags};
 use crate::primitive::*;
-use crate::enc::StreamFilter;
-use crate as pdf;
 
 /// Represents a PDF content stream - a `Vec` of `Operator`s
 #[derive(Debug, Clone, DataSize)]
@@ -41,7 +41,7 @@ pub fn parse_raw(data: &[u8]) -> Result<Vec<String>> {
     let mut result = vec![];
     while let Ok(next) = lexer.next() {
         result.push(next.to_string());
-    };
+    }
     Ok(result)
 }
 
@@ -66,41 +66,51 @@ macro_rules! points {
         )*
     )
 }
-fn name(args: &mut impl Iterator<Item=Primitive>) -> Result<Name> {
+fn name(args: &mut impl Iterator<Item = Primitive>) -> Result<Name> {
     args.next().ok_or(PdfError::NoOpArg)?.into_name()
 }
-fn number(args: &mut impl Iterator<Item=Primitive>) -> Result<f32> {
+fn number(args: &mut impl Iterator<Item = Primitive>) -> Result<f32> {
     args.next().ok_or(PdfError::NoOpArg)?.as_number()
 }
-fn string(args: &mut impl Iterator<Item=Primitive>) -> Result<PdfString> {
+fn string(args: &mut impl Iterator<Item = Primitive>) -> Result<PdfString> {
     args.next().ok_or(PdfError::NoOpArg)?.into_string()
 }
-fn point(args: &mut impl Iterator<Item=Primitive>) -> Result<Point> {
+fn point(args: &mut impl Iterator<Item = Primitive>) -> Result<Point> {
     let x = args.next().ok_or(PdfError::NoOpArg)?.as_number()?;
     let y = args.next().ok_or(PdfError::NoOpArg)?.as_number()?;
     Ok(Point { x, y })
 }
-fn rect(args: &mut impl Iterator<Item=Primitive>) -> Result<ViewRect> {
+fn rect(args: &mut impl Iterator<Item = Primitive>) -> Result<ViewRect> {
     let x = args.next().ok_or(PdfError::NoOpArg)?.as_number()?;
     let y = args.next().ok_or(PdfError::NoOpArg)?.as_number()?;
     let width = args.next().ok_or(PdfError::NoOpArg)?.as_number()?;
     let height = args.next().ok_or(PdfError::NoOpArg)?.as_number()?;
-    Ok(ViewRect { x, y, width, height })
+    Ok(ViewRect {
+        x,
+        y,
+        width,
+        height,
+    })
 }
-fn rgb(args: &mut impl Iterator<Item=Primitive>) -> Result<Rgb> {
+fn rgb(args: &mut impl Iterator<Item = Primitive>) -> Result<Rgb> {
     let red = args.next().ok_or(PdfError::NoOpArg)?.as_number()?;
     let green = args.next().ok_or(PdfError::NoOpArg)?.as_number()?;
     let blue = args.next().ok_or(PdfError::NoOpArg)?.as_number()?;
     Ok(Rgb { red, green, blue })
 }
-fn cmyk(args: &mut impl Iterator<Item=Primitive>) -> Result<Cmyk> {
+fn cmyk(args: &mut impl Iterator<Item = Primitive>) -> Result<Cmyk> {
     let cyan = args.next().ok_or(PdfError::NoOpArg)?.as_number()?;
     let magenta = args.next().ok_or(PdfError::NoOpArg)?.as_number()?;
     let yellow = args.next().ok_or(PdfError::NoOpArg)?.as_number()?;
     let key = args.next().ok_or(PdfError::NoOpArg)?.as_number()?;
-    Ok(Cmyk { cyan, magenta, yellow, key })
+    Ok(Cmyk {
+        cyan,
+        magenta,
+        yellow,
+        key,
+    })
 }
-fn matrix(args: &mut impl Iterator<Item=Primitive>) -> Result<Matrix> {
+fn matrix(args: &mut impl Iterator<Item = Primitive>) -> Result<Matrix> {
     Ok(Matrix {
         a: number(args)?,
         b: number(args)?,
@@ -110,11 +120,11 @@ fn matrix(args: &mut impl Iterator<Item=Primitive>) -> Result<Matrix> {
         f: number(args)?,
     })
 }
-fn array(args: &mut impl Iterator<Item=Primitive>) -> Result<Vec<Primitive>> {
+fn array(args: &mut impl Iterator<Item = Primitive>) -> Result<Vec<Primitive>> {
     match args.next() {
         Some(Primitive::Array(arr)) => Ok(arr),
         None => Ok(vec![]),
-        _ => Err(PdfError::NoOpArg)
+        _ => Err(PdfError::NoOpArg),
     }
 }
 
@@ -129,8 +139,10 @@ fn expand_abbr_name(name: SmallString, alt: &[(&str, &str)]) -> SmallString {
 fn expand_abbr(p: Primitive, alt: &[(&str, &str)]) -> Primitive {
     match p {
         Primitive::Name(name) => Primitive::Name(expand_abbr_name(name, alt)),
-        Primitive::Array(items) => Primitive::Array(items.into_iter().map(|p| expand_abbr(p, alt)).collect()),
-        p => p
+        Primitive::Array(items) => {
+            Primitive::Array(items.into_iter().map(|p| expand_abbr(p, alt)).collect())
+        }
+        p => p,
     }
 }
 
@@ -146,19 +158,22 @@ fn inline_image(lexer: &mut Lexer, resolve: &impl Resolve) -> Result<Arc<ImageXO
                 lexer.set_pos(backup_pos);
                 break;
             }
-            Ok(_) => bail!("invalid key type")
+            Ok(_) => bail!("invalid key type"),
         };
-        let key = expand_abbr_name(key, &[
-            ("BPC", "BitsPerComponent"),
-            ("CS", "ColorSpace"),
-            ("D", "Decode"),
-            ("DP", "DecodeParms"),
-            ("F", "Filter"),
-            ("H", "Height"),
-            ("IM", "ImageMask"),
-            ("I", "Interpolate"),
-            ("W", "Width"),
-        ]);
+        let key = expand_abbr_name(
+            key,
+            &[
+                ("BPC", "BitsPerComponent"),
+                ("CS", "ColorSpace"),
+                ("D", "Decode"),
+                ("DP", "DecodeParms"),
+                ("F", "Filter"),
+                ("H", "Height"),
+                ("IM", "ImageMask"),
+                ("I", "Interpolate"),
+                ("W", "Width"),
+            ],
+        );
         let val = parse_with_lexer(lexer, &NoResolve, ParseFlags::ANY)?;
         dict.insert(key, val);
     }
@@ -168,45 +183,87 @@ fn inline_image(lexer: &mut Lexer, resolve: &impl Resolve) -> Result<Arc<ImageXO
     // find the end before try parsing.
     if lexer.seek_substr("\nEI").is_none() {
         bail!("inline image exceeds expected data range");
-    }    
+    }
     let data_end = lexer.get_pos() - 3;
 
     // ugh
-    let bits_per_component = dict.get("BitsPerComponent").map(|p| p.as_integer()).transpose()?;
-    let color_space = dict.get("ColorSpace").map(|p| ColorSpace::from_primitive(expand_abbr(p.clone(), 
-        &[
-            ("G", "DeviceGray"),
-            ("RGB", "DeviceRGB"),
-            ("CMYK", "DeviceCMYK"),
-            ("I", "Indexed")
-        ]
-    ), resolve)).transpose()?;
-    let decode = dict.get("Decode").map(|p| Object::from_primitive(p.clone(), resolve)).transpose()?;
-    let decode_parms = dict.get("DecodeParms").map(|p| p.clone().resolve(resolve)?.into_dictionary()).transpose()?.unwrap_or_default();
-    let filter = dict.remove("Filter").map(|p| expand_abbr(p,
-        &[
-            ("AHx", "ASCIIHexDecode"),
-            ("A85", "ASCII85Decode"),
-            ("LZW", "LZWDecode"),
-            ("Fl", "FlateDecode"),
-            ("RL", "RunLengthDecode"),
-            ("CCF", "CCITTFaxDecode"),
-            ("DCT", "DCTDecode"),
-        ]
-    ));
+    let bits_per_component = dict
+        .get("BitsPerComponent")
+        .map(|p| p.as_integer())
+        .transpose()?;
+    let color_space = dict
+        .get("ColorSpace")
+        .map(|p| {
+            ColorSpace::from_primitive(
+                expand_abbr(
+                    p.clone(),
+                    &[
+                        ("G", "DeviceGray"),
+                        ("RGB", "DeviceRGB"),
+                        ("CMYK", "DeviceCMYK"),
+                        ("I", "Indexed"),
+                    ],
+                ),
+                resolve,
+            )
+        })
+        .transpose()?;
+    let decode = dict
+        .get("Decode")
+        .map(|p| Object::from_primitive(p.clone(), resolve))
+        .transpose()?;
+    let decode_parms = dict
+        .get("DecodeParms")
+        .map(|p| p.clone().resolve(resolve)?.into_dictionary())
+        .transpose()?
+        .unwrap_or_default();
+    let filter = dict.remove("Filter").map(|p| {
+        expand_abbr(
+            p,
+            &[
+                ("AHx", "ASCIIHexDecode"),
+                ("A85", "ASCII85Decode"),
+                ("LZW", "LZWDecode"),
+                ("Fl", "FlateDecode"),
+                ("RL", "RunLengthDecode"),
+                ("CCF", "CCITTFaxDecode"),
+                ("DCT", "DCTDecode"),
+            ],
+        )
+    });
     let filters = match filter {
-        Some(Primitive::Array(parts)) => parts.into_iter()
-            .map(|p| p.as_name().and_then(|kind| StreamFilter::from_kind_and_params(kind, decode_parms.clone(), resolve)))
+        Some(Primitive::Array(parts)) => parts
+            .into_iter()
+            .map(|p| {
+                p.as_name().and_then(|kind| {
+                    StreamFilter::from_kind_and_params(kind, decode_parms.clone(), resolve)
+                })
+            })
             .collect::<Result<_>>()?,
-        Some(Primitive::Name(kind)) => vec![StreamFilter::from_kind_and_params(&kind, decode_parms, resolve)?],
+        Some(Primitive::Name(kind)) => vec![StreamFilter::from_kind_and_params(
+            &kind,
+            decode_parms,
+            resolve,
+        )?],
         None => vec![],
-        _ => bail!("invalid filter")
+        _ => bail!("invalid filter"),
     };
-    
+
     let height = dict.require("InlineImage", "Height")?.as_u32()?;
-    let image_mask = dict.get("ImageMask").map(|p| p.as_bool()).transpose()?.unwrap_or(false);
-    let intent = dict.remove("Intent").map(|p| RenderingIntent::from_primitive(p, &NoResolve)).transpose()?;
-    let interpolate = dict.get("Interpolate").map(|p| p.as_bool()).transpose()?.unwrap_or(false);
+    let image_mask = dict
+        .get("ImageMask")
+        .map(|p| p.as_bool())
+        .transpose()?
+        .unwrap_or(false);
+    let intent = dict
+        .remove("Intent")
+        .map(|p| RenderingIntent::from_primitive(p, &NoResolve))
+        .transpose()?;
+    let interpolate = dict
+        .get("Interpolate")
+        .map(|p| p.as_bool())
+        .transpose()?
+        .unwrap_or(false);
     let width = dict.require("InlineImage", "Width")?.as_u32()?;
 
     let image_dict = ImageDict {
@@ -225,22 +282,24 @@ fn inline_image(lexer: &mut Lexer, resolve: &impl Resolve) -> Result<Arc<ImageXO
         other: dict,
     };
 
-    let data = lexer.new_substr(data_start .. data_end).to_vec();
+    let data = lexer.new_substr(data_start..data_end).to_vec();
 
-    Ok(Arc::new(ImageXObject { inner: Stream::from_compressed(image_dict, data, filters) }))
+    Ok(Arc::new(ImageXObject {
+        inner: Stream::from_compressed(image_dict, data, filters),
+    }))
 }
 
 struct OpBuilder {
     last: Point,
     compability_section: bool,
-    ops: Vec<Op>
+    ops: Vec<Op>,
 }
 impl OpBuilder {
     fn new() -> Self {
         OpBuilder {
             last: Point { x: 0., y: 0. },
             compability_section: false,
-            ops: Vec::new()
+            ops: Vec::new(),
         }
     }
     fn parse(&mut self, data: &[u8], resolve: &impl Resolve) -> Result<()> {
@@ -264,10 +323,10 @@ impl OpBuilder {
                     let op = t!(lexer.next());
                     let operator = t!(op.as_str(), op);
                     match self.add(operator, buffer.drain(..), &mut lexer, resolve) {
-                        Ok(()) => {},
+                        Ok(()) => {}
                         Err(e) if resolve.options().allow_invalid_ops => {
                             warn!("OP Err: {:?}", e);
-                        },
+                        }
                         Err(e) => return Err(e),
                     }
                 }
@@ -275,162 +334,208 @@ impl OpBuilder {
             match lexer.get_pos().cmp(&data.len()) {
                 Ordering::Greater => err!(PdfError::ContentReadPastBoundary),
                 Ordering::Less => (),
-                Ordering::Equal => break
+                Ordering::Equal => break,
             }
         }
         Ok(())
     }
-    fn add(&mut self, op: &str, mut args: impl Iterator<Item=Primitive>, lexer: &mut Lexer, resolve: &impl Resolve) -> Result<()> {
+    fn add(
+        &mut self,
+        op: &str,
+        mut args: impl Iterator<Item = Primitive>,
+        lexer: &mut Lexer,
+        resolve: &impl Resolve,
+    ) -> Result<()> {
         use Winding::*;
 
         let ops = &mut self.ops;
         let mut push = move |op| ops.push(op);
 
         match op {
-            "b"   => {
+            "b" => {
                 push(Op::Close);
                 push(Op::FillAndStroke { winding: NonZero });
-            },
-            "B"   => push(Op::FillAndStroke { winding: NonZero }),
-            "b*"  => {
+            }
+            "B" => push(Op::FillAndStroke { winding: NonZero }),
+            "b*" => {
                 push(Op::Close);
                 push(Op::FillAndStroke { winding: EvenOdd });
             }
-            "B*"  => push(Op::FillAndStroke { winding: EvenOdd }),
+            "B*" => push(Op::FillAndStroke { winding: EvenOdd }),
             "BDC" => push(Op::BeginMarkedContent {
                 tag: name(&mut args)?,
-                properties: Some(args.next().ok_or(PdfError::NoOpArg)?)
+                properties: Some(args.next().ok_or(PdfError::NoOpArg)?),
+            }),
+            "BI" => push(Op::InlineImage {
+                image: inline_image(lexer, resolve)?,
             }),
-            "BI"  => push(Op::InlineImage { image: inline_image(lexer, resolve)? }),
             "BMC" => push(Op::BeginMarkedContent {
                 tag: name(&mut args)?,
-                properties: None
+                properties: None,
             }),
-            "BT"  => push(Op::BeginText),
-            "BX"  => self.compability_section = true,
-            "c"   => {
+            "BT" => push(Op::BeginText),
+            "BX" => self.compability_section = true,
+            "c" => {
                 points!(args, c1, c2, p);
                 push(Op::CurveTo { c1, c2, p });
                 self.last = p;
             }
-            "cm"  => {
+            "cm" => {
                 numbers!(args, a, b, c, d, e, f);
-                push(Op::Transform { matrix: Matrix { a, b, c, d, e, f }});
+                push(Op::Transform {
+                    matrix: Matrix { a, b, c, d, e, f },
+                });
             }
-            "CS"  => {
+            "CS" => {
                 names!(args, name);
                 push(Op::StrokeColorSpace { name });
             }
-            "cs"  => {
+            "cs" => {
                 names!(args, name);
                 push(Op::FillColorSpace { name });
             }
-            "d"  => {
+            "d" => {
                 let p = args.next().ok_or(PdfError::NoOpArg)?;
-                let pattern = p.as_array()?.iter().map(|p| p.as_number()).collect::<Result<Vec<f32>, PdfError>>()?;
+                let pattern = p
+                    .as_array()?
+                    .iter()
+                    .map(|p| p.as_number())
+                    .collect::<Result<Vec<f32>, PdfError>>()?;
                 let phase = args.next().ok_or(PdfError::NoOpArg)?.as_number()?;
                 push(Op::Dash { pattern, phase });
             }
-            "d0"  => {}
-            "d1"  => {}
+            "d0" => {}
+            "d1" => {}
             "Do" | "Do0" => {
                 names!(args, name);
                 push(Op::XObject { name });
             }
-            "DP"  => push(Op::MarkedContentPoint {
+            "DP" => push(Op::MarkedContentPoint {
                 tag: name(&mut args)?,
-                properties: Some(args.next().ok_or(PdfError::NoOpArg)?)
+                properties: Some(args.next().ok_or(PdfError::NoOpArg)?),
             }),
-            "EI"  => bail!("Parse Error. Unexpected 'EI'"),
+            "EI" => bail!("Parse Error. Unexpected 'EI'"),
             "EMC" => push(Op::EndMarkedContent),
-            "ET"  => push(Op::EndText),
-            "EX"  => self.compability_section = false,
-            "f" |
-            "F"   => push(Op::Fill { winding: NonZero }),
-            "f*"  => push(Op::Fill { winding: EvenOdd }),
-            "G"   => push(Op::StrokeColor { color: Color::Gray(number(&mut args)?) }),
-            "g"   => push(Op::FillColor { color: Color::Gray(number(&mut args)?) }),
-            "gs"  => push(Op::GraphicsState { name: name(&mut args)? }),
-            "h"   => push(Op::Close),
-            "i"   => push(Op::Flatness { tolerance: number(&mut args)? }),
-            "ID"  => bail!("Parse Error. Unexpected 'ID'"),
-            "j"   => {
+            "ET" => push(Op::EndText),
+            "EX" => self.compability_section = false,
+            "f" | "F" => push(Op::Fill { winding: NonZero }),
+            "f*" => push(Op::Fill { winding: EvenOdd }),
+            "G" => push(Op::StrokeColor {
+                color: Color::Gray(number(&mut args)?),
+            }),
+            "g" => push(Op::FillColor {
+                color: Color::Gray(number(&mut args)?),
+            }),
+            "gs" => push(Op::GraphicsState {
+                name: name(&mut args)?,
+            }),
+            "h" => push(Op::Close),
+            "i" => push(Op::Flatness {
+                tolerance: number(&mut args)?,
+            }),
+            "ID" => bail!("Parse Error. Unexpected 'ID'"),
+            "j" => {
                 let n = args.next().ok_or(PdfError::NoOpArg)?.as_integer()?;
                 let join = match n {
                     0 => LineJoin::Miter,
                     1 => LineJoin::Round,
                     2 => LineJoin::Bevel,
-                    _ => bail!("invalid line join {}", n)
+                    _ => bail!("invalid line join {}", n),
                 };
                 push(Op::LineJoin { join });
             }
-            "J"   => {
+            "J" => {
                 let n = args.next().ok_or(PdfError::NoOpArg)?.as_integer()?;
                 let cap = match n {
                     0 => LineCap::Butt,
                     1 => LineCap::Round,
                     2 => LineCap::Square,
-                    _ => bail!("invalid line cap {}", n)
+                    _ => bail!("invalid line cap {}", n),
                 };
                 push(Op::LineCap { cap });
             }
-            "K"   => {
+            "K" => {
                 let color = Color::Cmyk(cmyk(&mut args)?);
                 push(Op::StrokeColor { color });
             }
-            "k"   => {
+            "k" => {
                 let color = Color::Cmyk(cmyk(&mut args)?);
                 push(Op::FillColor { color });
             }
-            "l"   => {
+            "l" => {
                 let p = point(&mut args)?;
                 push(Op::LineTo { p });
                 self.last = p;
             }
-            "m"   => {
+            "m" => {
                 let p = point(&mut args)?;
                 push(Op::MoveTo { p });
                 self.last = p;
             }
-            "M"   => push(Op::MiterLimit { limit: number(&mut args)? }),
-            "MP"  => push(Op::MarkedContentPoint { tag: name(&mut args)?, properties: None }),
-            "n"   => push(Op::EndPath),
-            "q"   => push(Op::Save),
-            "Q"   => push(Op::Restore),
-            "re"  => push(Op::Rect { rect: rect(&mut args)? }),
-            "RG"  => push(Op::StrokeColor { color: Color::Rgb(rgb(&mut args)?) }),
-            "rg"  => push(Op::FillColor { color: Color::Rgb(rgb(&mut args)?) }),
-            "ri"  => {
+            "M" => push(Op::MiterLimit {
+                limit: number(&mut args)?,
+            }),
+            "MP" => push(Op::MarkedContentPoint {
+                tag: name(&mut args)?,
+                properties: None,
+            }),
+            "n" => push(Op::EndPath),
+            "q" => push(Op::Save),
+            "Q" => push(Op::Restore),
+            "re" => push(Op::Rect {
+                rect: rect(&mut args)?,
+            }),
+            "RG" => push(Op::StrokeColor {
+                color: Color::Rgb(rgb(&mut args)?),
+            }),
+            "rg" => push(Op::FillColor {
+                color: Color::Rgb(rgb(&mut args)?),
+            }),
+            "ri" => {
                 let s = name(&mut args)?;
-                let intent = RenderingIntent::from_str(&s)
-                    .ok_or_else(|| PdfError::Other { msg: format!("invalid rendering intent {}", s) })?;
+                let intent = RenderingIntent::from_str(&s).ok_or_else(|| PdfError::Other {
+                    msg: format!("invalid rendering intent {}", s),
+                })?;
                 push(Op::RenderingIntent { intent });
-            },
-            "s"   => {
+            }
+            "s" => {
                 push(Op::Close);
                 push(Op::Stroke);
             }
-            "S"   => push(Op::Stroke),
+            "S" => push(Op::Stroke),
             "SC" | "SCN" => {
-                push(Op::StrokeColor { color: Color::Other(args.collect()) });
+                push(Op::StrokeColor {
+                    color: Color::Other(args.collect()),
+                });
             }
             "sc" | "scn" => {
-                push(Op::FillColor { color: Color::Other(args.collect()) });
+                push(Op::FillColor {
+                    color: Color::Other(args.collect()),
+                });
             }
-            "sh"  => {
-
-            }
-            "T*"  => push(Op::TextNewline),
-            "Tc"  => push(Op::CharSpacing { char_space: number(&mut args)? }),
-            "Td"  => push(Op::MoveTextPosition { translation: point(&mut args)? }),
-            "TD"  => {
+            "sh" => {}
+            "T*" => push(Op::TextNewline),
+            "Tc" => push(Op::CharSpacing {
+                char_space: number(&mut args)?,
+            }),
+            "Td" => push(Op::MoveTextPosition {
+                translation: point(&mut args)?,
+            }),
+            "TD" => {
                 let translation = point(&mut args)?;
-                push(Op::Leading { leading: -translation.y });
+                push(Op::Leading {
+                    leading: -translation.y,
+                });
                 push(Op::MoveTextPosition { translation });
             }
-            "Tf"  => push(Op::TextFont { name: name(&mut args)?, size: number(&mut args)? }),
-            "Tj"  => push(Op::TextDraw { text: string(&mut args)? }),
-            "TJ"  => {
+            "Tf" => push(Op::TextFont {
+                name: name(&mut args)?,
+                size: number(&mut args)?,
+            }),
+            "Tj" => push(Op::TextDraw {
+                text: string(&mut args)?,
+            }),
+            "TJ" => {
                 let mut result = Vec::<TextDrawAdjusted>::new();
 
                 for spacing_or_text in array(&mut args)?.into_iter() {
@@ -438,7 +543,7 @@ impl OpBuilder {
                         Primitive::Integer(i) => TextDrawAdjusted::Spacing(i as f32),
                         Primitive::Number(f) => TextDrawAdjusted::Spacing(f),
                         Primitive::String(text) => TextDrawAdjusted::Text(text),
-                        p => bail!("invalid primitive in TJ operator: {:?}", p)
+                        p => bail!("invalid primitive in TJ operator: {:?}", p),
                     };
 
                     result.push(spacing_or_text);
@@ -446,9 +551,13 @@ impl OpBuilder {
 
                 push(Op::TextDrawAdjusted { array: result })
             }
-            "TL"  => push(Op::Leading { leading: number(&mut args)? }),
-            "Tm"  => push(Op::SetTextMatrix { matrix: matrix(&mut args)? }), 
-            "Tr"  => {
+            "TL" => push(Op::Leading {
+                leading: number(&mut args)?,
+            }),
+            "Tm" => push(Op::SetTextMatrix {
+                matrix: matrix(&mut args)?,
+            }),
+            "Tr" => {
                 use TextMode::*;
 
                 let n = args.next().ok_or(PdfError::NoOpArg)?.as_integer()?;
@@ -465,35 +574,55 @@ impl OpBuilder {
                 };
                 push(Op::TextRenderMode { mode });
             }
-            "Ts"  => push(Op::TextRise { rise: number(&mut args)? }),
-            "Tw"  => push(Op::WordSpacing { word_space: number(&mut args)? }),
-            "Tz"  => push(Op::TextScaling { horiz_scale: number(&mut args)? }),
-            "v"   => {
+            "Ts" => push(Op::TextRise {
+                rise: number(&mut args)?,
+            }),
+            "Tw" => push(Op::WordSpacing {
+                word_space: number(&mut args)?,
+            }),
+            "Tz" => push(Op::TextScaling {
+                horiz_scale: number(&mut args)?,
+            }),
+            "v" => {
                 points!(args, c2, p);
-                push(Op::CurveTo { c1: self.last, c2, p });
+                push(Op::CurveTo {
+                    c1: self.last,
+                    c2,
+                    p,
+                });
                 self.last = p;
             }
-            "w"   => push(Op::LineWidth { width: number(&mut args)? }),
-            "W"   => push(Op::Clip { winding: NonZero }),
-            "W*"  => push(Op::Clip { winding: EvenOdd }),
-            "y"   => {
+            "w" => push(Op::LineWidth {
+                width: number(&mut args)?,
+            }),
+            "W" => push(Op::Clip { winding: NonZero }),
+            "W*" => push(Op::Clip { winding: EvenOdd }),
+            "y" => {
                 points!(args, c1, p);
                 push(Op::CurveTo { c1, c2: p, p });
                 self.last = p;
             }
-            "'"   => {
+            "'" => {
                 push(Op::TextNewline);
-                push(Op::TextDraw { text: string(&mut args)? });
+                push(Op::TextDraw {
+                    text: string(&mut args)?,
+                });
             }
-            "\""  => {
-                push(Op::WordSpacing { word_space: number(&mut args)? });
-                push(Op::CharSpacing { char_space: number(&mut args)? });
+            "\"" => {
+                push(Op::WordSpacing {
+                    word_space: number(&mut args)?,
+                });
+                push(Op::CharSpacing {
+                    char_space: number(&mut args)?,
+                });
                 push(Op::TextNewline);
-                push(Op::TextDraw { text: string(&mut args)? });
+                push(Op::TextDraw {
+                    text: string(&mut args)?,
+                });
             }
             o if !self.compability_section => {
                 bail!("invalid operator {}", o)
-            },
+            }
             _ => {}
         }
         Ok(())
@@ -513,7 +642,9 @@ impl Object for Content {
                     parts.push(part);
                 }
             }
-            Primitive::Reference(r) => return Self::from_primitive(t!(resolve.resolve(r)), resolve),
+            Primitive::Reference(r) => {
+                return Self::from_primitive(t!(resolve.resolve(r)), resolve)
+            }
             p => {
                 let part = t!(ContentStream::from_primitive(p, resolve));
                 parts.push(part);
@@ -543,9 +674,7 @@ impl Object for FormXObject {
     /// Convert primitive to Self
     fn from_primitive(p: Primitive, resolve: &impl Resolve) -> Result<Self> {
         let stream = t!(Stream::<FormDict>::from_primitive(p, resolve));
-        Ok(FormXObject {
-            stream,
-        })
+        Ok(FormXObject { stream })
     }
 }
 impl ObjectWrite for FormXObject {
@@ -584,39 +713,55 @@ pub fn display_ops(mut ops: &[Op]) -> Result<Vec<String>> {
     while ops.len() > 0 {
         let mut advance = 1;
         match ops[0] {
-            Op::BeginMarkedContent { ref tag, properties: Some(ref name) } => {
+            Op::BeginMarkedContent {
+                ref tag,
+                properties: Some(ref name),
+            } => {
                 write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} {} BDC", tag, name)?;
                 marked_depth += 1;
             }
-            Op::BeginMarkedContent { ref tag, properties: None } => {
+            Op::BeginMarkedContent {
+                ref tag,
+                properties: None,
+            } => {
                 write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} BMC", tag)?;
-                marked_depth += 1;
+                marked_depth = marked_depth.saturating_add(1);
             }
-            Op::MarkedContentPoint { ref tag, properties: Some(ref name) } => {
+            Op::MarkedContentPoint {
+                ref tag,
+                properties: Some(ref name),
+            } => {
                 write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} {} DP", tag, tag)?;
             }
-            Op::MarkedContentPoint { ref tag, properties: None } => {
+            Op::MarkedContentPoint {
+                ref tag,
+                properties: None,
+            } => {
                 write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} MP", tag)?;
             }
             Op::EndMarkedContent => {
-                marked_depth -= 1;
+                marked_depth = marked_depth.saturating_sub(1);
                 write_ln_indented!(f, marked_depth, q_depth, t_depth, "EMC")?;
-            },
+            }
             Op::Close => match ops.get(1) {
                 Some(Op::Stroke) => {
                     write_ln_indented!(f, marked_depth, q_depth, t_depth, "s")?;
                     advance += 1;
                 }
-                Some(Op::FillAndStroke { winding: Winding::NonZero }) => {
+                Some(Op::FillAndStroke {
+                    winding: Winding::NonZero,
+                }) => {
                     write_ln_indented!(f, marked_depth, q_depth, t_depth, "b")?;
                     advance += 1;
                 }
-                Some(Op::FillAndStroke { winding: Winding::EvenOdd }) => {
+                Some(Op::FillAndStroke {
+                    winding: Winding::EvenOdd,
+                }) => {
                     write_ln_indented!(f, marked_depth, q_depth, t_depth, "b*")?;
                     advance += 1;
                 }
                 _ => write_ln_indented!(f, marked_depth, q_depth, t_depth, "h")?,
-            }
+            },
             Op::MoveTo { p } => {
                 write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} m", p)?;
                 current_point = Some(p);
@@ -624,7 +769,7 @@ pub fn display_ops(mut ops: &[Op]) -> Result<Vec<String>> {
             Op::LineTo { p } => {
                 write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} l", p)?;
                 current_point = Some(p);
-            },
+            }
             Op::CurveTo { c1, c2, p } => {
                 if Some(c1) == current_point {
                     write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} {} v", c2, p)?;
@@ -634,105 +779,243 @@ pub fn display_ops(mut ops: &[Op]) -> Result<Vec<String>> {
                     write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} {} {} c", c1, c2, p)?;
                 }
                 current_point = Some(p);
-            },
-            Op::Rect { rect } => write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} re", rect)?,
+            }
+            Op::Rect { rect } => {
+                write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} re", rect)?
+            }
             Op::EndPath => write_ln_indented!(f, marked_depth, q_depth, t_depth, "n")?,
             Op::Stroke => write_ln_indented!(f, marked_depth, q_depth, t_depth, "S")?,
-            Op::FillAndStroke { winding: Winding::NonZero } => write_ln_indented!(f, marked_depth, q_depth, t_depth, "B")?,
-            Op::FillAndStroke { winding: Winding::EvenOdd } => write_ln_indented!(f, marked_depth, q_depth, t_depth, "B*")?,
-            Op::Fill { winding: Winding::NonZero } => write_ln_indented!(f, marked_depth, q_depth, t_depth, "f")?,
-            Op::Fill { winding: Winding::EvenOdd } => write_ln_indented!(f, marked_depth, q_depth, t_depth, "f*")?,
-            Op::Shade { ref name } => write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} sh", name)?,
-            Op::Clip { winding: Winding::NonZero } => write_ln_indented!(f, marked_depth, q_depth, t_depth, "W")?,
-            Op::Clip { winding: Winding::EvenOdd } => write_ln_indented!(f, marked_depth, q_depth, t_depth, "W*")?,
+            Op::FillAndStroke {
+                winding: Winding::NonZero,
+            } => write_ln_indented!(f, marked_depth, q_depth, t_depth, "B")?,
+            Op::FillAndStroke {
+                winding: Winding::EvenOdd,
+            } => write_ln_indented!(f, marked_depth, q_depth, t_depth, "B*")?,
+            Op::Fill {
+                winding: Winding::NonZero,
+            } => write_ln_indented!(f, marked_depth, q_depth, t_depth, "f")?,
+            Op::Fill {
+                winding: Winding::EvenOdd,
+            } => write_ln_indented!(f, marked_depth, q_depth, t_depth, "f*")?,
+            Op::Shade { ref name } => {
+                write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} sh", name)?
+            }
+            Op::Clip {
+                winding: Winding::NonZero,
+            } => write_ln_indented!(f, marked_depth, q_depth, t_depth, "W")?,
+            Op::Clip {
+                winding: Winding::EvenOdd,
+            } => write_ln_indented!(f, marked_depth, q_depth, t_depth, "W*")?,
             Op::Save => {
                 write_ln_indented!(f, marked_depth, q_depth, t_depth, "q")?;
                 q_depth += 1;
-            },
+            }
             Op::Restore => {
                 q_depth = q_depth.saturating_sub(1);
                 write_ln_indented!(f, marked_depth, q_depth, t_depth, "Q")?;
-            },
-            Op::Transform { matrix } => write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} cm", matrix)?,
-            Op::LineWidth { width } => write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} w", width)?,
-            Op::Dash { ref pattern, phase } => write_ln_indented!(f, marked_depth, q_depth, t_depth, "[{}] {} d", pattern.iter().format(" "), phase)?,
-            Op::LineJoin { join } => write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} j", join as u8)?,
-            Op::LineCap { cap } => write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} J", cap as u8)?,
-            Op::MiterLimit { limit } => write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} M", limit)?,
-            Op::Flatness { tolerance } => write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} i", tolerance)?,
-            Op::GraphicsState { ref name } => write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} gs", name)?,
-            Op::StrokeColor { color: Color::Gray(g) } => write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} G", g)?,
-            Op::StrokeColor { color: Color::Rgb(rgb) } => write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} RG", rgb)?,
-            Op::StrokeColor { color: Color::Cmyk(cmyk) } => write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} K", cmyk)?,
-            Op::StrokeColor { color: Color::Other(ref args) } => {
-                let args_str = args.iter().map(|p| format!("{}", p)).collect::<Vec<String>>().join(" ");
+            }
+            Op::Transform { matrix } => {
+                write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} cm", matrix)?
+            }
+            Op::LineWidth { width } => {
+                write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} w", width)?
+            }
+            Op::Dash { ref pattern, phase } => write_ln_indented!(
+                f,
+                marked_depth,
+                q_depth,
+                t_depth,
+                "[{}] {} d",
+                pattern.iter().format(" "),
+                phase
+            )?,
+            Op::LineJoin { join } => {
+                write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} j", join as u8)?
+            }
+            Op::LineCap { cap } => {
+                write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} J", cap as u8)?
+            }
+            Op::MiterLimit { limit } => {
+                write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} M", limit)?
+            }
+            Op::Flatness { tolerance } => {
+                write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} i", tolerance)?
+            }
+            Op::GraphicsState { ref name } => {
+                write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} gs", name)?
+            }
+            Op::StrokeColor {
+                color: Color::Gray(g),
+            } => write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} G", g)?,
+            Op::StrokeColor {
+                color: Color::Rgb(rgb),
+            } => write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} RG", rgb)?,
+            Op::StrokeColor {
+                color: Color::Cmyk(cmyk),
+            } => write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} K", cmyk)?,
+            Op::StrokeColor {
+                color: Color::Other(ref args),
+            } => {
+                let args_str = args
+                    .iter()
+                    .map(|p| format!("{}", p))
+                    .collect::<Vec<String>>()
+                    .join(" ");
                 write_ln_indented!(f, marked_depth, q_depth, t_depth, "{}{} SCN", args_str, " ")?;
             }
-            Op::FillColor { color: Color::Gray(g) } => write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} g", g)?,
-            Op::FillColor { color: Color::Rgb(rgb) } => write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} rg", rgb)?,
-            Op::FillColor { color: Color::Cmyk(cmyk) } => write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} k", cmyk)?,
-            Op::FillColor { color: Color::Other(ref args) } => {
-                let args_str = args.iter().map(|p| format!("{}", p)).collect::<Vec<String>>().join(" ");
+            Op::FillColor {
+                color: Color::Gray(g),
+            } => write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} g", g)?,
+            Op::FillColor {
+                color: Color::Rgb(rgb),
+            } => write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} rg", rgb)?,
+            Op::FillColor {
+                color: Color::Cmyk(cmyk),
+            } => write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} k", cmyk)?,
+            Op::FillColor {
+                color: Color::Other(ref args),
+            } => {
+                let args_str = args
+                    .iter()
+                    .map(|p| format!("{}", p))
+                    .collect::<Vec<String>>()
+                    .join(" ");
                 write_ln_indented!(f, marked_depth, q_depth, t_depth, "{}{} scn", args_str, " ")?;
             }
-            Op::FillColorSpace { ref name } => write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} cs", name)?,
-            Op::StrokeColorSpace { ref name } => write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} CS", name)?,
-            Op::RenderingIntent { intent } => write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} ri", intent.to_str())?,
-            Op::BeginText => {write_ln_indented!(f, marked_depth, q_depth, t_depth, "BT")?; t_depth = t_depth.saturating_add(1)},
-            Op::EndText => {t_depth = t_depth.saturating_sub(1); write_ln_indented!(f, marked_depth, q_depth, t_depth, "ET")?;},
-            Op::CharSpacing { char_space } => write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} Tc", char_space)?,
+            Op::FillColorSpace { ref name } => {
+                write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} cs", name)?
+            }
+            Op::StrokeColorSpace { ref name } => {
+                write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} CS", name)?
+            }
+            Op::RenderingIntent { intent } => {
+                write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} ri", intent.to_str())?
+            }
+            Op::BeginText => {
+                write_ln_indented!(f, marked_depth, q_depth, t_depth, "BT")?;
+                t_depth = t_depth.saturating_add(1)
+            }
+            Op::EndText => {
+                t_depth = t_depth.saturating_sub(1);
+                write_ln_indented!(f, marked_depth, q_depth, t_depth, "ET")?;
+            }
+            Op::CharSpacing { char_space } => {
+                write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} Tc", char_space)?
+            }
             Op::WordSpacing { word_space } => {
-                if let [Op::CharSpacing { char_space }, Op::TextNewline, Op::TextDraw { ref text }, ..] = ops[1..] {
-                    write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} {} {:} \"", word_space, char_space, format_text(text)?)?;
+                if let [Op::CharSpacing { char_space }, Op::TextNewline, Op::TextDraw { ref text }, ..] =
+                    ops[1..]
+                {
+                    write_ln_indented!(
+                        f,
+                        marked_depth,
+                        q_depth,
+                        t_depth,
+                        "{} {} {:} \"",
+                        word_space,
+                        char_space,
+                        format_text(text)?
+                    )?;
                     advance += 3;
                 } else {
                     write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} Tw", word_space)?;
                 }
             }
-            Op::TextScaling { horiz_scale } => write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} Tz", horiz_scale)?,
+            Op::TextScaling { horiz_scale } => {
+                write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} Tz", horiz_scale)?
+            }
             Op::Leading { leading } => match ops[1..] {
                 [Op::MoveTextPosition { translation }, ..] if leading == -translation.x => {
-                    write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} {} TD", translation.x, translation.y)?;
+                    write_ln_indented!(
+                        f,
+                        marked_depth,
+                        q_depth,
+                        t_depth,
+                        "{} {} TD",
+                        translation.x,
+                        translation.y
+                    )?;
                     advance += 1;
                 }
                 _ => write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} TL", leading)?,
+            },
+            Op::TextFont { ref name, ref size } => {
+                write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} {} Tf", name, size)?
+            }
+            Op::TextRenderMode { mode } => {
+                write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} Tr", mode as u8)?
+            }
+            Op::TextRise { rise } => {
+                write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} Ts", rise)?
+            }
+            Op::MoveTextPosition { translation } => write_ln_indented!(
+                f,
+                marked_depth,
+                q_depth,
+                t_depth,
+                "{} {} Td",
+                translation.x,
+                translation.y
+            )?,
+            Op::SetTextMatrix { matrix } => {
+                write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} Tm", matrix)?
             }
-            Op::TextFont { ref name, ref size } => write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} {} Tf", name, size)?,
-            Op::TextRenderMode { mode } => write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} Tr", mode as u8)?,
-            Op::TextRise { rise } => write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} Ts", rise)?,
-            Op::MoveTextPosition { translation } => write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} {} Td", translation.x, translation.y)?,
-            Op::SetTextMatrix { matrix } => write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} Tm", matrix)?,
             Op::TextNewline => {
                 if let [Op::TextDraw { ref text }, ..] = ops[1..] {
-                    write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} '", format_text(text)?)?;
+                    write_ln_indented!(
+                        f,
+                        marked_depth,
+                        q_depth,
+                        t_depth,
+                        "{} '",
+                        format_text(text)?
+                    )?;
                     advance += 1;
                 } else {
                     write_ln_indented!(f, marked_depth, q_depth, t_depth, "T*")?;
                 }
-            },
+            }
             Op::TextDraw { ref text } => {
-                write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} Tj", format_text(text)?)?;
-            },
+                write_ln_indented!(
+                    f,
+                    marked_depth,
+                    q_depth,
+                    t_depth,
+                    "{} Tj",
+                    format_text(text)?
+                )?;
+            }
             Op::TextDrawAdjusted { ref array } => {
-                let content = array.iter().enumerate()
+                let content = array
+                    .iter()
+                    .enumerate()
                     .map(|(i, val)| match val {
                         TextDrawAdjusted::Spacing(s) => s.to_string(),
-                        TextDrawAdjusted::Text(data) => format_text(data).unwrap_or(String::from("!!!")),
+                        TextDrawAdjusted::Text(data) => {
+                            format_text(data).unwrap_or(String::from("!!!"))
+                        }
                     })
                     .collect::<Vec<_>>()
                     .join(" ");
                 write_ln_indented!(f, marked_depth, q_depth, t_depth, "[{}] TJ", content)?;
-            },
-            Op::InlineImage { image: _ } => write_ln_indented!(f, marked_depth, q_depth, t_depth, "Inline image is not implemented yet!")?,
-            Op::XObject { ref name } => write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} Do", name)?,
+            }
+            Op::InlineImage { image: _ } => write_ln_indented!(
+                f,
+                marked_depth,
+                q_depth,
+                t_depth,
+                "Inline image is not implemented yet!"
+            )?,
+            Op::XObject { ref name } => {
+                write_ln_indented!(f, marked_depth, q_depth, t_depth, "{} Do", name)?
+            }
         }
         ops = &ops[advance..];
     }
     Ok(data)
 }
 
-
-#[allow(clippy::float_cmp)]  // TODO
+#[allow(clippy::float_cmp)] // TODO
 pub fn serialize_ops(mut ops: &[Op]) -> Result<Vec<u8>> {
     use std::io::Write;
 
@@ -743,23 +1026,35 @@ pub fn serialize_ops(mut ops: &[Op]) -> Result<Vec<u8>> {
     while ops.len() > 0 {
         let mut advance = 1;
         match ops[0] {
-            Op::BeginMarkedContent { ref tag, properties: Some(ref name) } => {
+            Op::BeginMarkedContent {
+                ref tag,
+                properties: Some(ref name),
+            } => {
                 serialize_name(tag, f)?;
                 write!(f, " ")?;
                 name.serialize(f)?;
                 writeln!(f, " BDC")?;
             }
-            Op::BeginMarkedContent { ref tag, properties: None } => {
+            Op::BeginMarkedContent {
+                ref tag,
+                properties: None,
+            } => {
                 serialize_name(tag, f)?;
                 writeln!(f, " BMC")?;
             }
-            Op::MarkedContentPoint { ref tag, properties: Some(ref name) } => {
+            Op::MarkedContentPoint {
+                ref tag,
+                properties: Some(ref name),
+            } => {
                 serialize_name(tag, f)?;
                 write!(f, " ")?;
                 name.serialize(f)?;
                 writeln!(f, " DP")?;
             }
-            Op::MarkedContentPoint { ref tag, properties: None } => {
+            Op::MarkedContentPoint {
+                ref tag,
+                properties: None,
+            } => {
                 serialize_name(tag, f)?;
                 writeln!(f, " MP")?;
             }
@@ -769,16 +1064,20 @@ pub fn serialize_ops(mut ops: &[Op]) -> Result<Vec<u8>> {
                     writeln!(f, "s")?;
                     advance += 1;
                 }
-                Some(Op::FillAndStroke { winding: Winding::NonZero }) => {
+                Some(Op::FillAndStroke {
+                    winding: Winding::NonZero,
+                }) => {
                     writeln!(f, "b")?;
                     advance += 1;
                 }
-                Some(Op::FillAndStroke { winding: Winding::EvenOdd }) => {
+                Some(Op::FillAndStroke {
+                    winding: Winding::EvenOdd,
+                }) => {
                     writeln!(f, "b*")?;
                     advance += 1;
                 }
                 _ => writeln!(f, "h")?,
-            }
+            },
             Op::MoveTo { p } => {
                 writeln!(f, "{} m", p)?;
                 current_point = Some(p);
@@ -786,7 +1085,7 @@ pub fn serialize_ops(mut ops: &[Op]) -> Result<Vec<u8>> {
             Op::LineTo { p } => {
                 writeln!(f, "{} l", p)?;
                 current_point = Some(p);
-            },
+            }
             Op::CurveTo { c1, c2, p } => {
                 if Some(c1) == current_point {
                     writeln!(f, "{} {} v", c2, p)?;
@@ -796,25 +1095,39 @@ pub fn serialize_ops(mut ops: &[Op]) -> Result<Vec<u8>> {
                     writeln!(f, "{} {} {} c", c1, c2, p)?;
                 }
                 current_point = Some(p);
-            },
+            }
             Op::Rect { rect } => writeln!(f, "{} re", rect)?,
             Op::EndPath => writeln!(f, "n")?,
             Op::Stroke => writeln!(f, "S")?,
-            Op::FillAndStroke { winding: Winding::NonZero } => writeln!(f, "B")?,
-            Op::FillAndStroke { winding: Winding::EvenOdd } => writeln!(f, "B*")?,
-            Op::Fill { winding: Winding::NonZero } => writeln!(f, "f")?,
-            Op::Fill { winding: Winding::EvenOdd } => writeln!(f, "f*")?,
+            Op::FillAndStroke {
+                winding: Winding::NonZero,
+            } => writeln!(f, "B")?,
+            Op::FillAndStroke {
+                winding: Winding::EvenOdd,
+            } => writeln!(f, "B*")?,
+            Op::Fill {
+                winding: Winding::NonZero,
+            } => writeln!(f, "f")?,
+            Op::Fill {
+                winding: Winding::EvenOdd,
+            } => writeln!(f, "f*")?,
             Op::Shade { ref name } => {
                 serialize_name(name, f)?;
                 writeln!(f, " sh")?;
-            },
-            Op::Clip { winding: Winding::NonZero } => writeln!(f, "W")?,
-            Op::Clip { winding: Winding::EvenOdd } => writeln!(f, "W*")?,
+            }
+            Op::Clip {
+                winding: Winding::NonZero,
+            } => writeln!(f, "W")?,
+            Op::Clip {
+                winding: Winding::EvenOdd,
+            } => writeln!(f, "W*")?,
             Op::Save => writeln!(f, "q")?,
             Op::Restore => writeln!(f, "Q")?,
             Op::Transform { matrix } => writeln!(f, "{} cm", matrix)?,
             Op::LineWidth { width } => writeln!(f, "{} w", width)?,
-            Op::Dash { ref pattern, phase } => writeln!(f, "[{}] {} d", pattern.iter().format(" "), phase)?,
+            Op::Dash { ref pattern, phase } => {
+                writeln!(f, "[{}] {} d", pattern.iter().format(" "), phase)?
+            }
             Op::LineJoin { join } => writeln!(f, "{} j", join as u8)?,
             Op::LineCap { cap } => writeln!(f, "{} J", cap as u8)?,
             Op::MiterLimit { limit } => writeln!(f, "{} M", limit)?,
@@ -822,21 +1135,37 @@ pub fn serialize_ops(mut ops: &[Op]) -> Result<Vec<u8>> {
             Op::GraphicsState { ref name } => {
                 serialize_name(name, f)?;
                 writeln!(f, " gs")?;
-            },
-            Op::StrokeColor { color: Color::Gray(g) } => writeln!(f, "{} G", g)?,
-            Op::StrokeColor { color: Color::Rgb(rgb) } => writeln!(f, "{} RG", rgb)?,
-            Op::StrokeColor { color: Color::Cmyk(cmyk) } => writeln!(f, "{} K", cmyk)?,
-            Op::StrokeColor { color: Color::Other(ref args) } =>  {
+            }
+            Op::StrokeColor {
+                color: Color::Gray(g),
+            } => writeln!(f, "{} G", g)?,
+            Op::StrokeColor {
+                color: Color::Rgb(rgb),
+            } => writeln!(f, "{} RG", rgb)?,
+            Op::StrokeColor {
+                color: Color::Cmyk(cmyk),
+            } => writeln!(f, "{} K", cmyk)?,
+            Op::StrokeColor {
+                color: Color::Other(ref args),
+            } => {
                 for p in args {
                     p.serialize(f)?;
                     write!(f, " ")?;
                 }
                 writeln!(f, "SCN")?;
             }
-            Op::FillColor { color: Color::Gray(g) } => writeln!(f, "{} g", g)?,
-            Op::FillColor { color: Color::Rgb(rgb) } => writeln!(f, "{} rg", rgb)?,
-            Op::FillColor { color: Color::Cmyk(cmyk) } => writeln!(f, "{} k", cmyk)?,
-            Op::FillColor { color: Color::Other(ref args) } => {
+            Op::FillColor {
+                color: Color::Gray(g),
+            } => writeln!(f, "{} g", g)?,
+            Op::FillColor {
+                color: Color::Rgb(rgb),
+            } => writeln!(f, "{} rg", rgb)?,
+            Op::FillColor {
+                color: Color::Cmyk(cmyk),
+            } => writeln!(f, "{} k", cmyk)?,
+            Op::FillColor {
+                color: Color::Other(ref args),
+            } => {
                 for p in args {
                     p.serialize(f)?;
                     write!(f, " ")?;
@@ -846,23 +1175,20 @@ pub fn serialize_ops(mut ops: &[Op]) -> Result<Vec<u8>> {
             Op::FillColorSpace { ref name } => {
                 serialize_name(name, f)?;
                 writeln!(f, " cs")?;
-            },
+            }
             Op::StrokeColorSpace { ref name } => {
                 serialize_name(name, f)?;
                 writeln!(f, " CS")?;
-            },
+            }
 
             Op::RenderingIntent { intent } => writeln!(f, "{} ri", intent.to_str())?,
             Op::BeginText => writeln!(f, "BT")?,
             Op::EndText => writeln!(f, "ET")?,
             Op::CharSpacing { char_space } => writeln!(f, "{} Tc", char_space)?,
             Op::WordSpacing { word_space } => {
-                if let [
-                    Op::CharSpacing { char_space },
-                    Op::TextNewline,
-                    Op::TextDraw { ref text },
-                    ..
-                ] = ops[1..] {
+                if let [Op::CharSpacing { char_space }, Op::TextNewline, Op::TextDraw { ref text }, ..] =
+                    ops[1..]
+                {
                     write!(f, "{} {} ", word_space, char_space)?;
                     text.serialize(f)?;
                     writeln!(f, " \"")?;
@@ -880,14 +1206,16 @@ pub fn serialize_ops(mut ops: &[Op]) -> Result<Vec<u8>> {
                 _ => {
                     writeln!(f, "{} TL", leading)?;
                 }
-            }
+            },
             Op::TextFont { ref name, ref size } => {
                 serialize_name(name, f)?;
                 writeln!(f, " {} Tf", size)?;
-            },
+            }
             Op::TextRenderMode { mode } => writeln!(f, "{} Tr", mode as u8)?,
             Op::TextRise { rise } => writeln!(f, "{} Ts", rise)?,
-            Op::MoveTextPosition { translation } => writeln!(f, "{} {} Td", translation.x, translation.y)?,
+            Op::MoveTextPosition { translation } => {
+                writeln!(f, "{} {} Td", translation.x, translation.y)?
+            }
             Op::SetTextMatrix { matrix } => writeln!(f, "{} Tm", matrix)?,
             Op::TextNewline => {
                 if let [Op::TextDraw { ref text }, ..] = ops[1..] {
@@ -897,11 +1225,11 @@ pub fn serialize_ops(mut ops: &[Op]) -> Result<Vec<u8>> {
                 } else {
                     writeln!(f, "T*")?;
                 }
-            },
+            }
             Op::TextDraw { ref text } => {
                 text.serialize(f)?;
                 writeln!(f, " Tj")?;
-            },
+            }
             Op::TextDrawAdjusted { ref array } => {
                 write!(f, "[")?;
                 for (i, val) in array.iter().enumerate() {
@@ -914,12 +1242,12 @@ pub fn serialize_ops(mut ops: &[Op]) -> Result<Vec<u8>> {
                     }
                 }
                 writeln!(f, "] TJ")?;
-            },
+            }
             Op::InlineImage { image: _ } => unimplemented!(),
             Op::XObject { ref name } => {
                 serialize_name(name, f)?;
                 writeln!(f, " Do")?;
-            },
+            }
         }
         ops = &ops[advance..];
     }
@@ -930,7 +1258,7 @@ impl Content {
     pub fn from_ops(operations: Vec<Op>) -> Self {
         let data = serialize_ops(&operations).unwrap();
         Content {
-            parts: vec![Stream::new((), data)]
+            parts: vec![Stream::new((), data)],
         }
     }
 }
@@ -949,7 +1277,7 @@ impl ObjectWrite for Content {
 #[derive(Debug, Copy, Clone, PartialEq, DataSize)]
 pub enum Winding {
     EvenOdd,
-    NonZero
+    NonZero,
 }
 
 #[derive(Debug, Copy, Clone, PartialEq, DataSize)]
@@ -973,7 +1301,7 @@ pub struct PdfSpace();
 #[repr(C, align(8))]
 pub struct Point {
     pub x: f32,
-    pub y: f32
+    pub y: f32,
 }
 impl Display for Point {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
@@ -1038,24 +1366,39 @@ impl Display for ViewRect {
 #[cfg(feature = "euclid")]
 impl Into<euclid::Box2D<f32, PdfSpace>> for ViewRect {
     fn into(self) -> euclid::Box2D<f32, PdfSpace> {
-        let ViewRect { x, y, width, height } = self;
+        let ViewRect {
+            x,
+            y,
+            width,
+            height,
+        } = self;
 
         assert!(width > 0.0);
         assert!(height > 0.0);
 
-        euclid::Box2D::new(euclid::Point2D::new(x, y), euclid::Point2D::new(x + width, y + height))
+        euclid::Box2D::new(
+            euclid::Point2D::new(x, y),
+            euclid::Point2D::new(x + width, y + height),
+        )
     }
 }
 #[cfg(feature = "euclid")]
 impl From<euclid::Box2D<f32, PdfSpace>> for ViewRect {
     fn from(from: euclid::Box2D<f32, PdfSpace>) -> Self {
-        let euclid::Box2D { min: euclid::Point2D { x, y, .. }, max: euclid::Point2D { x: x2, y: y2, .. }, .. } = from;
+        let euclid::Box2D {
+            min: euclid::Point2D { x, y, .. },
+            max: euclid::Point2D { x: x2, y: y2, .. },
+            ..
+        } = from;
 
         assert!(x < x2);
         assert!(y < y2);
 
         ViewRect {
-            x, y, width: x2 - x, height: y2 - y
+            x,
+            y,
+            width: x2 - x,
+            height: y2 - y,
         }
     }
 }
@@ -1072,7 +1415,11 @@ pub struct Matrix {
 }
 impl Display for Matrix {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{} {} {} {} {} {}", self.a, self.b, self.c, self.d, self.e, self.f)
+        write!(
+            f,
+            "{} {} {} {} {} {}",
+            self.a, self.b, self.c, self.d, self.e, self.f
+        )
     }
 }
 impl Default for Matrix {
@@ -1101,7 +1448,7 @@ impl ObjectWrite for Matrix {
 #[cfg(feature = "euclid")]
 impl Into<euclid::Transform2D<f32, PdfSpace, PdfSpace>> for Matrix {
     fn into(self) -> euclid::Transform2D<f32, PdfSpace, PdfSpace> {
-        let Matrix { a, b, c, d, e, f} = self;
+        let Matrix { a, b, c, d, e, f } = self;
 
         euclid::Transform2D::new(a, b, c, d, e, f)
     }
@@ -1109,11 +1456,17 @@ impl Into<euclid::Transform2D<f32, PdfSpace, PdfSpace>> for Matrix {
 #[cfg(feature = "euclid")]
 impl From<euclid::Transform2D<f32, PdfSpace, PdfSpace>> for Matrix {
     fn from(from: euclid::Transform2D<f32, PdfSpace, PdfSpace>) -> Self {
-        let euclid::Transform2D { m11: a, m12: b, m21: c, m22: d, m31: e, m32: f, .. } = from;
+        let euclid::Transform2D {
+            m11: a,
+            m12: b,
+            m21: c,
+            m22: d,
+            m31: e,
+            m32: f,
+            ..
+        } = from;
 
-        Matrix {
-            a, b, c, d, e, f
-        }
+        Matrix { a, b, c, d, e, f }
     }
 }
 
@@ -1132,7 +1485,7 @@ pub enum TextMode {
     FillThenStroke,
     Invisible,
     FillAndClip,
-    StrokeAndClip
+    StrokeAndClip,
 }
 
 #[derive(Debug, Copy, Clone, PartialEq, DataSize)]
@@ -1156,7 +1509,11 @@ pub struct Cmyk {
 }
 impl Display for Cmyk {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{} {} {} {}", self.cyan, self.magenta, self.yellow, self.key)
+        write!(
+            f,
+            "{} {} {} {}",
+            self.cyan, self.magenta, self.yellow, self.key
+        )
     }
 }
 
@@ -1176,146 +1533,241 @@ impl Display for TextDrawAdjusted {
 }
 
 /// Graphics Operator
-/// 
+///
 /// See PDF32000 A.2
 #[derive(Debug, Clone, DataSize)]
 pub enum Op {
     /// Begin a marked comtent sequence
-    /// 
+    ///
     /// Pairs with the following EndMarkedContent.
-    /// 
+    ///
     /// generated by operators `BMC` and `BDC`
-    BeginMarkedContent { tag: Name, properties: Option<Primitive> },
+    BeginMarkedContent {
+        tag: Name,
+        properties: Option<Primitive>,
+    },
 
     /// End a marked content sequence.
-    /// 
+    ///
     /// Pairs with the previous BeginMarkedContent.
-    /// 
+    ///
     /// generated by operator `EMC`
     EndMarkedContent,
 
     /// A marked content point.
-    /// 
+    ///
     /// generated by operators `MP` and `DP`.
-    MarkedContentPoint { tag: Name, properties: Option<Primitive> },
-
+    MarkedContentPoint {
+        tag: Name,
+        properties: Option<Primitive>,
+    },
 
     Close,
-    MoveTo { p: Point },
-    LineTo { p: Point },
-    CurveTo { c1: Point, c2: Point, p: Point },
-    Rect { rect: ViewRect },
+    MoveTo {
+        p: Point,
+    },
+    LineTo {
+        p: Point,
+    },
+    CurveTo {
+        c1: Point,
+        c2: Point,
+        p: Point,
+    },
+    Rect {
+        rect: ViewRect,
+    },
     EndPath,
 
     Stroke,
 
     /// Fill and Stroke operation
-    /// 
+    ///
     /// generated by operators `b`, `B`, `b*`, `B*`
     /// `close` indicates whether the path should be closed first
-    FillAndStroke { winding: Winding },
+    FillAndStroke {
+        winding: Winding,
+    },
 
-
-    Fill { winding: Winding },
+    Fill {
+        winding: Winding,
+    },
 
     /// Fill using the named shading pattern
-    /// 
+    ///
     /// operator: `sh`
-    Shade { name: Name },
+    Shade {
+        name: Name,
+    },
 
-    Clip { winding: Winding },
+    Clip {
+        winding: Winding,
+    },
 
     Save,
     Restore,
 
-    Transform { matrix: Matrix },
+    Transform {
+        matrix: Matrix,
+    },
 
-    LineWidth { width: f32 },
-    Dash { pattern: Vec<f32>, phase: f32 },
-    LineJoin { join: LineJoin },
-    LineCap { cap: LineCap },
-    MiterLimit { limit: f32 },
-    Flatness { tolerance: f32 },
+    LineWidth {
+        width: f32,
+    },
+    Dash {
+        pattern: Vec<f32>,
+        phase: f32,
+    },
+    LineJoin {
+        join: LineJoin,
+    },
+    LineCap {
+        cap: LineCap,
+    },
+    MiterLimit {
+        limit: f32,
+    },
+    Flatness {
+        tolerance: f32,
+    },
 
-    GraphicsState { name: Name },
+    GraphicsState {
+        name: Name,
+    },
 
-    StrokeColor { color: Color },
-    FillColor { color: Color },
+    StrokeColor {
+        color: Color,
+    },
+    FillColor {
+        color: Color,
+    },
 
-    FillColorSpace { name: Name },
-    StrokeColorSpace { name: Name },
+    FillColorSpace {
+        name: Name,
+    },
+    StrokeColorSpace {
+        name: Name,
+    },
 
-    RenderingIntent { intent: RenderingIntent },
+    RenderingIntent {
+        intent: RenderingIntent,
+    },
 
     BeginText,
     EndText,
 
-    CharSpacing { char_space: f32 },
-    WordSpacing { word_space: f32 },
-    TextScaling { horiz_scale: f32 },
-    Leading { leading: f32 },
-    TextFont { name: Name, size: f32 },
-    TextRenderMode { mode: TextMode },
+    CharSpacing {
+        char_space: f32,
+    },
+    WordSpacing {
+        word_space: f32,
+    },
+    TextScaling {
+        horiz_scale: f32,
+    },
+    Leading {
+        leading: f32,
+    },
+    TextFont {
+        name: Name,
+        size: f32,
+    },
+    TextRenderMode {
+        mode: TextMode,
+    },
 
     /// `Ts`
-    TextRise { rise: f32 },
+    TextRise {
+        rise: f32,
+    },
 
     /// `Td`, `TD`
-    MoveTextPosition { translation: Point },
+    MoveTextPosition {
+        translation: Point,
+    },
 
     /// `Tm`
-    SetTextMatrix { matrix: Matrix },
+    SetTextMatrix {
+        matrix: Matrix,
+    },
 
     /// `T*`
     TextNewline,
 
     /// `Tj`
-    TextDraw { text: PdfString },
+    TextDraw {
+        text: PdfString,
+    },
 
-    TextDrawAdjusted { array: Vec<TextDrawAdjusted> },
+    TextDrawAdjusted {
+        array: Vec<TextDrawAdjusted>,
+    },
 
-    XObject { name: Name },
+    XObject {
+        name: Name,
+    },
 
-    InlineImage { image: Arc<ImageXObject> },
+    InlineImage {
+        image: Arc<ImageXObject>,
+    },
 }
 
-pub fn deep_clone_op(op: &Op, cloner: &mut impl Cloner, old_resources: &Resources, resources: &mut Resources) -> Result<Op> {
+pub fn deep_clone_op(
+    op: &Op,
+    cloner: &mut impl Cloner,
+    old_resources: &Resources,
+    resources: &mut Resources,
+) -> Result<Op> {
     match *op {
         Op::GraphicsState { ref name } => {
             if !resources.graphics_states.contains_key(name) {
                 if let Some(gs) = old_resources.graphics_states.get(name) {
-                    resources.graphics_states.insert(name.clone(), gs.deep_clone(cloner)?);
+                    resources
+                        .graphics_states
+                        .insert(name.clone(), gs.deep_clone(cloner)?);
                 }
             }
             Ok(Op::GraphicsState { name: name.clone() })
         }
-        Op::MarkedContentPoint { ref tag, ref properties } => {
-            Ok(Op::MarkedContentPoint { tag: tag.clone(), properties: properties.deep_clone(cloner)? })
-        }
-        Op::BeginMarkedContent { ref tag, ref properties } => {
-            Ok(Op::BeginMarkedContent { tag: tag.clone(), properties: properties.deep_clone(cloner)? })
-        }
+        Op::MarkedContentPoint {
+            ref tag,
+            ref properties,
+        } => Ok(Op::MarkedContentPoint {
+            tag: tag.clone(),
+            properties: properties.deep_clone(cloner)?,
+        }),
+        Op::BeginMarkedContent {
+            ref tag,
+            ref properties,
+        } => Ok(Op::BeginMarkedContent {
+            tag: tag.clone(),
+            properties: properties.deep_clone(cloner)?,
+        }),
         Op::TextFont { ref name, size } => {
             if !resources.fonts.contains_key(name) {
                 if let Some(f) = old_resources.fonts.get(name) {
                     resources.fonts.insert(name.clone(), f.deep_clone(cloner)?);
                 }
             }
-            Ok(Op::TextFont { name: name.clone(), size })
+            Ok(Op::TextFont {
+                name: name.clone(),
+                size,
+            })
         }
         Op::XObject { ref name } => {
             if !resources.xobjects.contains_key(name) {
                 if let Some(xo) = old_resources.xobjects.get(name) {
-                    resources.xobjects.insert(name.clone(), xo.deep_clone(cloner)?);
+                    resources
+                        .xobjects
+                        .insert(name.clone(), xo.deep_clone(cloner)?);
                 }
             }
             Ok(Op::XObject { name: name.clone() })
         }
-        ref op => Ok(op.clone())
+        ref op => Ok(op.clone()),
     }
 }
 
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -1334,6 +1786,6 @@ Gb"0F_%"1&#XD6"#B1qiGGG^V6GZ#ZkijB5'RjB4S^5I61&$Ni:Xh=4S_9KYN;c9MUZPn/h,c]oCLUmg
 EI
 "###;
         let mut lexer = Lexer::new(data);
-        assert!(inline_image(&mut lexer, &NoResolve).is_ok()); 
+        assert!(inline_image(&mut lexer, &NoResolve).is_ok());
     }
 }
diff --git a/src-pdfrs/pdf/src/primitive.rs b/src-pdfrs/pdf/src/primitive.rs
index 00b51bd..275ddba 100644
--- a/src-pdfrs/pdf/src/primitive.rs
+++ b/src-pdfrs/pdf/src/primitive.rs
@@ -249,7 +249,7 @@ impl<'a> IntoIterator for &'a Dictionary {
 #[derive(Clone, Debug, PartialEq, DataSize)]
 pub struct PdfStream {
     pub info: Dictionary,
-    pub (crate) inner: StreamInner,
+    pub inner: StreamInner,
 }
 
 #[derive(Clone, Debug, PartialEq, DataSize)]
diff --git a/src-tauri/Cargo.lock b/src-tauri/Cargo.lock
index c04a5c6..2d2f658 100644
--- a/src-tauri/Cargo.lock
+++ b/src-tauri/Cargo.lock
@@ -1011,6 +1011,12 @@ version = "0.3.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "04d2cd9c18b9f454ed67da600630b021a8a80bf33f8c95896ab33aaf1c26b728"
 
+[[package]]
+name = "data-encoding"
+version = "2.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "575f75dfd25738df5b91b8e43e14d44bda14637a58fae779fd2b064f8bf3e010"
+
 [[package]]
 name = "datasize"
 version = "0.2.15"
@@ -3681,6 +3687,7 @@ name = "pdf-forge"
 version = "0.1.0"
 dependencies = [
  "image 0.25.5",
+ "indexmap 1.9.3",
  "lazy_static",
  "pathfinder_geometry",
  "pathfinder_rasterize",
@@ -3694,6 +3701,7 @@ dependencies = [
  "tauri-plugin-dialog",
  "tauri-plugin-fs",
  "tauri-plugin-opener",
+ "tauri-plugin-websocket",
  "uuid",
 ]
 
@@ -4811,6 +4819,17 @@ dependencies = [
  "stable_deref_trait",
 ]
 
+[[package]]
+name = "sha1"
+version = "0.10.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3bf829a2d51ab4a5ddf1352d8470c140cadc8301b2ae1789db023f01cedd6ba"
+dependencies = [
+ "cfg-if 1.0.0",
+ "cpufeatures",
+ "digest",
+]
+
 [[package]]
 name = "sha2"
 version = "0.10.8"
@@ -5350,6 +5369,25 @@ dependencies = [
  "zbus",
 ]
 
+[[package]]
+name = "tauri-plugin-websocket"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af3ac71aec5fb0ae5441e830cd075b1cbed49ac3d39cb975a4894ea8fa2e62b9"
+dependencies = [
+ "futures-util",
+ "http",
+ "log",
+ "rand 0.8.5",
+ "serde",
+ "serde_json",
+ "tauri",
+ "tauri-plugin",
+ "thiserror 2.0.11",
+ "tokio",
+ "tokio-tungstenite",
+]
+
 [[package]]
 name = "tauri-runtime"
 version = "2.3.0"
@@ -5607,6 +5645,22 @@ dependencies = [
  "tokio",
 ]
 
+[[package]]
+name = "tokio-tungstenite"
+version = "0.26.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be4bf6fecd69fcdede0ec680aaf474cdab988f9de6bc73d3758f0160e3b7025a"
+dependencies = [
+ "futures-util",
+ "log",
+ "rustls",
+ "rustls-pki-types",
+ "tokio",
+ "tokio-rustls",
+ "tungstenite",
+ "webpki-roots",
+]
+
 [[package]]
 name = "tokio-util"
 version = "0.7.13"
@@ -5775,6 +5829,26 @@ version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b"
 
+[[package]]
+name = "tungstenite"
+version = "0.26.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "413083a99c579593656008130e29255e54dcaae495be556cc26888f211648c24"
+dependencies = [
+ "byteorder",
+ "bytes",
+ "data-encoding",
+ "http",
+ "httparse",
+ "log",
+ "rand 0.8.5",
+ "rustls",
+ "rustls-pki-types",
+ "sha1",
+ "thiserror 2.0.11",
+ "utf-8",
+]
+
 [[package]]
 name = "tuple"
 version = "0.5.2"
diff --git a/src-tauri/Cargo.toml b/src-tauri/Cargo.toml
index 5ed0d78..0f27e34 100644
--- a/src-tauri/Cargo.toml
+++ b/src-tauri/Cargo.toml
@@ -33,3 +33,5 @@ image = { version = "0.25.5", features = ["jpeg"] }
 pdf_render = { path = "../../pdf-render/render" }
 pathfinder_rasterize = { git = "https://github.com/s3bk/pathfinder_rasterizer" }
 pathfinder_geometry = { git = "https://github.com/servo/pathfinder" }
+indexmap = "1.9.3"
+tauri-plugin-websocket = "2"
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
index 7a3a4d6..364c59b 100644
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@@ -11,14 +11,13 @@ use crate::render::Renderer;
 use image::DynamicImage;
 use lazy_static::lazy_static;
 use pdf::file::{File, FileOptions, NoLog, ObjectCache, StreamCache};
-use pdf::object::{Object, PlainRef};
+use pdf::object::{Object, PlainRef, Stream, Updater};
 use pdf::primitive::{Dictionary, Primitive};
 use pdf::xref::XRef;
 use regex::Regex;
 use retrieval::{get_prim_by_path_with_file, get_stream_data_by_path_with_file};
 use serde::{Deserialize, Serialize};
 use std::collections::{HashMap, VecDeque};
-use std::ops::DerefMut;
 use std::path::Path;
 use std::sync::{Arc, RwLock};
 use tauri::ipc::{InvokeResponseBody, Response};
@@ -26,7 +25,6 @@ use tauri::{Manager, State};
 use uuid::Uuid;
 
 type CosFile = File<Vec<u8>, ObjectCache, StreamCache, NoLog>;
-
 #[derive(Serialize, Debug, Clone)]
 pub struct XRefTableModel {
     pub size: usize,
@@ -113,7 +111,7 @@ fn get_all_files(session: State<Session>) -> Vec<PdfFile> {
     session
         .get_all_files()
         .iter()
-        .map(|s| s.pdf_file.clone())
+        .map(|s| s.read().unwrap().pdf_file.clone())
         .collect()
 }
 
@@ -129,7 +127,9 @@ fn close_file(id: &str, session: State<Session>) {
 
 #[tauri::command]
 fn get_file_by_id(id: &str, session: State<Session>) -> Result<PdfFile, String> {
-    session.get_file(id).map(|file| file.pdf_file.clone())
+    let lock = session.get_file(id)?;
+    let file = lock.read().unwrap();
+    Ok(file.pdf_file.clone())
 }
 
 #[tauri::command]
@@ -183,7 +183,8 @@ fn to_pdf_file(path: &str, file: &CosFile) -> Result<PdfFile, String> {
 
 #[tauri::command]
 fn get_contents(id: &str, path: &str, session: State<Session>) -> Result<ContentsModel, String> {
-    let file = session.get_file(id)?;
+    let lock = session.get_file(id)?;
+    let file = lock.read().unwrap();
 
     let (_, page_prim, _) = get_prim_by_path_with_file(path, &file.cos_file)?;
     let resolver = file.cos_file.resolver();
@@ -208,11 +209,30 @@ fn get_stream_data_as_string(
     path: &str,
     session: State<Session>,
 ) -> Result<String, String> {
-    let file = session.get_file(id)?;
+    let lock = session.get_file(id)?;
+    let file = lock.read().unwrap();
     let data = get_stream_data_by_path_with_file(path, &file.cos_file)?;
     Ok(String::from_utf8_lossy(&data).into_owned())
 }
 
+#[tauri::command]
+async fn update_stream_data_as_string(
+    id: &str,
+    path: &str,
+    new_data: &str,
+    session: State<'_, Session>,
+) -> Result<(), String> {
+    let lock = session.get_file(id)?;
+    let mut file = lock.write().unwrap();
+    let (_, _, trace) = get_prim_by_path_with_file(path, &file.cos_file)?;
+    let i = trace.len() - 1;
+    let id = t!(trace[i].last_jump.parse::<u64>());
+    let plain_ref = PlainRef { id, gen: 0 };
+    let stream = Stream::new((), new_data.as_bytes());
+    let _ = t!(file.cos_file.update(plain_ref, stream));
+    Ok(())
+}
+
 fn format_img_as_response(img: DynamicImage) -> Result<Response, String> {
     use std::mem;
 
@@ -248,7 +268,8 @@ async fn get_stream_data_as_image(
     path: &str,
     session: State<'_, Session>,
 ) -> Result<Response, String> {
-    let file = session.get_file(id)?;
+    let lock = session.get_file(id)?;
+    let file = lock.read().unwrap();
     let img = retrieval::get_image_by_path(path, &file.cos_file)?;
     format_img_as_response(img)
 }
@@ -259,21 +280,39 @@ async fn get_page_by_num(
     num: u32,
     session: State<'_, Session>,
 ) -> Result<Response, String> {
-    let file = session.get_file(id)?;
+    render_page_by_path(id, &format!("Page{}", num), session).await
+}
+
+#[tauri::command]
+async fn render_page_by_path(
+    id: &str,
+    path: &str,
+    session: State<'_, Session>,
+) -> Result<Response, String> {
+    let lock = session.get_file(id)?;
+    let file = lock.read().unwrap();
+    let page = get_page_by_path(path, &file.cos_file)?;
     let mut renderer = Renderer::new(&file.cos_file, 150);
-    let img = renderer.render(num)?;
+    let img = renderer.render(&page)?;
 
     format_img_as_response(img)
 }
 
+fn get_page_by_path(path: &str, file: &CosFile) -> Result<pdf::object::Page, String> {
+    let resolver = file.resolver();
+    let (_, page_prim, _) = get_prim_by_path_with_file(path, file)?;
+    let page = t!(pdf::object::Page::from_primitive(page_prim, &resolver));
+    Ok(page)
+}
+
 #[tauri::command]
 fn get_prim_by_path(
     id: &str,
     path: &str,
     session: State<Session>,
 ) -> Result<PrimitiveModel, String> {
-    let file = session.get_file(id)?;
-
+    let lock = session.get_file(id)?;
+    let file = lock.read().unwrap();
     get_prim_model_by_path_with_file(path, &file.cos_file)
 }
 
@@ -313,7 +352,8 @@ fn get_prim_tree_by_path(
     paths: Vec<TreeViewRequest>,
     session: State<Session>,
 ) -> Result<Vec<PrimitiveTreeView>, String> {
-    let file = session.get_file(id)?;
+    let lock = session.get_file(id)?;
+    let file = lock.read().unwrap();
 
     let results = paths
         .into_iter()
@@ -659,9 +699,11 @@ impl PrimitiveTreeView {
 }
 #[tauri::command]
 fn get_xref_table(id: &str, session: State<Session>) -> Result<XRefTableModel, String> {
-    let file = session.get_file(id)?;
+    let lock = session.get_file(id)?;
+    let file = lock.read().unwrap();
     get_xref_table_model_with_file(&file.cos_file)
 }
+
 fn get_xref_table_model_with_file(file: &CosFile) -> Result<XRefTableModel, String> {
     let resolver = file.resolver();
     let x_ref_table = file.get_xref();
@@ -719,7 +761,7 @@ fn get_xref_table_model_with_file(file: &CosFile) -> Result<XRefTableModel, Stri
 }
 
 struct Session {
-    files: RwLock<HashMap<String, Arc<SessionFile>>>,
+    files: RwLock<HashMap<String, Arc<RwLock<SessionFile>>>>,
 }
 
 struct SessionFile {
@@ -734,20 +776,15 @@ impl Session {
         }
     }
 
-    fn get_file(&self, id: &str) -> Result<Arc<SessionFile>, String> {
+    fn get_file(&self, id: &str) -> Result<Arc<RwLock<SessionFile>>, String> {
         let lock = self.files.read().unwrap();
         lock.get(id)
             .cloned()
             .ok_or(format!(" File {} not found!", id))
     }
 
-    fn get_all_files(&self) -> Vec<Arc<SessionFile>> {
-        self.files
-            .read()
-            .unwrap()
-            .values()
-            .map(|f| f.clone())
-            .collect()
+    fn get_all_files(&self) -> Vec<Arc<RwLock<SessionFile>>> {
+        self.files.read().unwrap().values().cloned().collect()
     }
 
     fn get_all_file_ids(&self) -> Vec<String> {
@@ -763,10 +800,10 @@ impl Session {
         if let Ok(mut files) = self.files.write() {
             return match files.insert(
                 pdf_file.id.clone(),
-                Arc::new(SessionFile {
+                Arc::new(RwLock::new(SessionFile {
                     pdf_file: pdf_file,
                     cos_file: cos_file,
-                }),
+                })),
             ) {
                 Some(_) => Err("File could not be uploaded!".to_string()),
                 None => Ok(()),
@@ -802,7 +839,8 @@ pub fn run() {
             get_contents,
             get_stream_data_as_string,
             get_stream_data_as_image,
-            get_page_by_num
+            get_page_by_num,
+            update_stream_data_as_string
         ])
         .run(tauri::generate_context!())
         .expect("error while running tauri application");
diff --git a/src-tauri/src/render.rs b/src-tauri/src/render.rs
index ff5c21d..cc7e4f8 100644
--- a/src-tauri/src/render.rs
+++ b/src-tauri/src/render.rs
@@ -5,6 +5,7 @@ use crate::{t, CosFile};
 use image::{DynamicImage, RgbaImage};
 use pathfinder_geometry::transform2d::Transform2F;
 use pathfinder_rasterize::Rasterizer;
+use pdf::object::Page;
 use pdf_render::{render_page, Cache, SceneBackend};
 
 pub struct Renderer<'a> {
@@ -22,9 +23,8 @@ impl<'a> Renderer<'a> {
         }
     }
 
-    pub fn render(&mut self, page_num: u32) -> Result<DynamicImage, String> {
+    pub fn render(&mut self, page: &Page) -> Result<DynamicImage, String> {
         let resolver = self.file.resolver();
-        let page = t!(self.file.get_page(page_num - 1));
         let mut backend = SceneBackend::new(&mut self.cache);
         t!(render_page(&mut backend, &resolver, &page, self.transform));
         let scene = backend.finish();
diff --git a/src/components/App.svelte b/src/components/App.svelte
index df48bb1..c185d5e 100644
--- a/src/components/App.svelte
+++ b/src/components/App.svelte
@@ -97,6 +97,7 @@
             closeTab={closeFile}
             openTab={upload}
             selectTab={(state) => (fState = state)}
+            reload={() => fState?.reload()}
         ></TitleBar>
     </div>
     <div class="fileview_container" style="height: {fileViewHeight}px">
diff --git a/src/components/PageView.svelte b/src/components/PageView.svelte
index bc83ce6..688092c 100644
--- a/src/components/PageView.svelte
+++ b/src/components/PageView.svelte
@@ -1,6 +1,4 @@
 <script lang="ts">
-
-    import ContentsView from "./ContentsView.svelte";
     import RenderedPageView from "./RenderedPageView.svelte";
     import {Pane, Splitpanes} from "svelte-splitpanes";
     import {PageViewState} from "../models/PageViewState.svelte";
@@ -8,30 +6,14 @@
     import StreamEditor from "./StreamEditor.svelte";
 
     let {fState, height}: {fState: FileViewState, height: number} = $props();
-
-    let states: PageViewState[] = [];
-    let state: PageViewState | undefined = $state(undefined);
-
-    $effect(() => {
-        if (!(fState.container_prim && fState.container_prim.isPage())) return;
-
-        let page_num = fState.container_prim.getPageNumber();
-
-        if (state && state.file_id == fState.file.id && state.page_num === page_num) return;
-
-        state = states.find(s => s.file_id === fState.file.id && s.page_num == page_num)
-        if (!state) {
-            state = new PageViewState(fState.file.id, page_num, (m) => fState.logError(m));
-            states.push(state);
-        }
-    })
+    let state: PageViewState | undefined = $derived(fState.pageViewState);
 
 </script>
-{#if fState.container_prim && fState.container_prim.isPage() && state}
+{#if state}
     <Splitpanes theme="forge-movable">
         <Pane minSize={1}>
             <div class="overflow-hidden">
-                <StreamEditor stream_data={state.contents} height={height - 1}></StreamEditor>
+                <StreamEditor save={state.handleSave} stream_data={state.contents.toDisplay()} height={height - 1}></StreamEditor>
             </div>
         </Pane>
         <Pane minSize={1}>
diff --git a/src/components/PrimitiveView.svelte b/src/components/PrimitiveView.svelte
index d108799..fed77a3 100644
--- a/src/components/PrimitiveView.svelte
+++ b/src/components/PrimitiveView.svelte
@@ -2,12 +2,12 @@
     import type FileViewState from "../models/FileViewState.svelte";
     import type Primitive from "../models/Primitive.svelte";
     import PrimitiveIcon from "./PrimitiveIcon.svelte";
-    import {Pane, Splitpanes} from "svelte-splitpanes";
+    import { Pane, Splitpanes } from "svelte-splitpanes";
     import StreamDataView from "./StreamDataView.svelte";
 
     const cellH = 29;
     const headerOffset = 24;
-    let {fState, height}: { fState: FileViewState; height: number } =
+    let { fState, height }: { fState: FileViewState; height: number } =
         $props();
     let fillerHeight: number = $state(0);
     let firstEntry = $state(0);
@@ -20,9 +20,6 @@
     let tableHeight = $derived(prim ? prim.children.length * cellH : 0);
 
     let bodyHeight = $derived(height);
-    let editorHeight = $derived(
-        Math.max(800, bodyHeight - tableHeight - headerOffset),
-    );
 
     let locallySelected: Primitive | undefined = $state(undefined);
     $effect(() => {
@@ -50,53 +47,65 @@
         fState.selectPath(_path);
     }
 </script>
-<Splitpanes  theme="forge-movable">
+
+<Splitpanes theme="forge-movable">
     <Pane minSize={1}>
         {#if prim && prim.children && prim.children.length > 0}
             <div
-                    class="overflow-auto"
-                    onscroll={handleScroll}
-                    style="height: {bodyHeight}px"
+                class="overflow-auto"
+                onscroll={handleScroll}
+                style="height: {bodyHeight}px"
             >
                 <div class="w-[851px]">
                     <table style="position: relative; top: {scrollY}px">
                         <thead>
-                        <tr>
-                            <td class="page-cell t-header border-forge-prim">Key
-                            </td
-                            >
-                            <td class="ref-cell t-header border-forge-prim">Type
-                            </td
-                            >
-                            <td class="cell t-header border-forge-sec">Value</td>
-                        </tr>
+                            <tr>
+                                <td class="page-cell t-header border-forge-prim"
+                                    >Key
+                                </td>
+                                <td class="ref-cell t-header border-forge-prim"
+                                    >Type
+                                </td>
+                                <td class="cell t-header border-forge-sec"
+                                    >Value</td
+                                >
+                            </tr>
                         </thead>
                     </table>
                     <div class="container" style="height: {tableHeight}px">
                         <table>
                             <tbody>
-                            <tr class="filler" style="height: {fillerHeight}px"
-                            ></tr>
-                            {#each entriesToDisplay as entry}
                                 <tr
+                                    class="filler"
+                                    style="height: {fillerHeight}px"
+                                ></tr>
+                                {#each entriesToDisplay as entry}
+                                    <tr
                                         class:selected={entry.key ===
-                                    locallySelected?.key}
+                                            locallySelected?.key}
                                         class="row"
                                         onclick={() => handlePrimClick(entry)}
-                                        ondblclick={() => handlePrimDbLClick(entry)}
-                                >
-                                    <td class="page-cell t-data">
-                                        <div class="key-field">
-                                            <PrimitiveIcon ptype={entry.ptype}/>
-                                            <p class="text-left">
-                                                {entry.key}
-                                            </p>
-                                        </div>
-                                    </td>
-                                    <td class="ref-cell t-data">{entry.ptype}</td>
-                                    <td class="cell t-data">{entry.value}</td>
-                                </tr>
-                            {/each}
+                                        ondblclick={() =>
+                                            handlePrimDbLClick(entry)}
+                                    >
+                                        <td class="page-cell t-data">
+                                            <div class="key-field">
+                                                <PrimitiveIcon
+                                                    ptype={entry.ptype}
+                                                />
+                                                <p class="text-left">
+                                                    {entry.key}
+                                                </p>
+                                            </div>
+                                        </td>
+                                        <td class="ref-cell t-data"
+                                            >{entry.ptype}</td
+                                        >
+                                        <td class="cell t-data"
+                                            >{entry.value}</td
+                                        >
+                                    </tr>
+                                {/each}
                             </tbody>
                         </table>
                     </div>
@@ -105,17 +114,18 @@
         {/if}
     </Pane>
     <Pane
-            size={fState.container_prim?.stream_data ? 50 : 0}
-            minSize={fState.container_prim?.stream_data ? 1 : 0}
-            maxSize={fState.container_prim?.stream_data ? 100 : 0}
+        size={fState.container_prim?.stream_data ? 50 : 0}
+        minSize={fState.container_prim?.stream_data ? 1 : 0}
+        maxSize={fState.container_prim?.stream_data ? 100 : 0}
     >
-        <div style:height={height} class="bg-forge-dark">
+        <div style:height class="bg-forge-dark">
             {#if fState.container_prim?.stream_data}
                 <StreamDataView {fState} {height}></StreamDataView>
             {/if}
         </div>
     </Pane>
 </Splitpanes>
+
 <style lang="postcss">
     .key-field {
         display: flex;
diff --git a/src/components/StreamDataView.svelte b/src/components/StreamDataView.svelte
index 39162a7..522e581 100644
--- a/src/components/StreamDataView.svelte
+++ b/src/components/StreamDataView.svelte
@@ -1,29 +1,33 @@
 <script lang="ts">
-
     import type FileViewState from "../models/FileViewState.svelte";
     import StreamEditor from "./StreamEditor.svelte";
-    import type {StreamData} from "../models/StreamData.svelte";
+    import type { StreamData } from "../models/StreamData.svelte";
     import RenderedPageView from "./RenderedPageView.svelte";
 
-    let {fState, height}: { fState: FileViewState, height: number } = $props()
-    let streamData: StreamData | undefined = $derived(fState.container_prim?.stream_data);
-
-
+    let {
+        fState,
+        height,
+    }: {
+        fState: FileViewState;
+        height: number;
+    } = $props();
+    let streamData: StreamData | undefined = $derived(
+        fState.container_prim?.stream_data,
+    );
 </script>
+
 {#if streamData}
     {#if streamData.type === "Image"}
-        <RenderedPageView img={streamData.imageData} {height}></RenderedPageView>
-    {:else}
-        {#if streamData.textData}
-            <StreamEditor
-                    stream_data={streamData.textData}
-                    {height}
-            ></StreamEditor>
-        {/if}
+        <RenderedPageView img={streamData.imageData} {height}
+        ></RenderedPageView>
+    {:else if streamData.textData}
+        <StreamEditor
+            stream_data={streamData.textData}
+            {height}
+            save={(updated_data) => fState.saveStreamData(updated_data)}
+        ></StreamEditor>
     {/if}
 {/if}
 
 <style lang="postcss">
-
-
-</style>
\ No newline at end of file
+</style>
diff --git a/src/components/StreamEditor.svelte b/src/components/StreamEditor.svelte
index 7285517..e9308c6 100644
--- a/src/components/StreamEditor.svelte
+++ b/src/components/StreamEditor.svelte
@@ -1,20 +1,32 @@
 <script lang="ts">
     import { onMount } from "svelte";
+    import { UploadOutline } from "flowbite-svelte-icons";
     import * as monaco from "monaco-editor";
 
-    monaco.editor.defineTheme('forge-dark', {
+    monaco.editor.defineTheme("forge-dark", {
         base: "vs-dark",
         inherit: true,
         rules: [],
         colors: {
-            "editor.background": '#1E1F22FF'
-        }
+            "editor.background": "#1E1F22FF",
+        },
     });
-    let { stream_data, height }: { stream_data: string; height: number } =
-        $props();
+    let {
+        stream_data,
+        height,
+        save,
+    }: {
+        stream_data: string;
+        height: number;
+        save: (updated_data: string) => void;
+    } = $props();
 
     let editorContainer: HTMLElement;
     let editor: monaco.editor.IStandaloneCodeEditor;
+
+    let isEdited = $state(false);
+    let last_data: string | undefined = $state(undefined);
+
     onMount(() => {
         editor = monaco.editor.create(editorContainer, {
             value: "",
@@ -26,6 +38,27 @@
             automaticLayout: true,
         });
 
+        loadContents(stream_data);
+
+        editor.onDidChangeModelContent(() => {
+            isEdited = editor.getValue() !== stream_data;
+        });
+
+        editor.addCommand(
+            monaco.KeyMod.CtrlCmd | monaco.KeyCode.KeyS,
+            (context, args) => {
+                if (isEdited) {
+                    save(editor.getValue());
+                }
+            },
+        );
+
+        window.addEventListener("keydown", (event) => {
+            if ((event.ctrlKey || event.metaKey) && event.key === "s") {
+                event.preventDefault();
+            }
+        });
+
         return () => {
             editor.dispose();
         };
@@ -38,11 +71,36 @@
     function loadContents(stream_data: string | undefined) {
         if (!stream_data || !editor) return;
 
+        if (last_data === stream_data) {
+            return;
+        }
+
+        isEdited = false;
+        last_data = stream_data;
         editor.setValue(stream_data);
     }
 </script>
 
-<div bind:this={editorContainer} style:height = {height - 1 + "px"}></div>
+<div class="relative">
+    <div bind:this={editorContainer} style:height={height + "px"}></div>
+    {#if isEdited}
+        <button onclick={() => save(editor.getValue())} class="save-button">
+            <UploadOutline size="xl" />
+        </button>
+    {/if}
+</div>
 
 <style lang="postcss">
+    .save-button {
+        @apply p-2 bg-forge-sec text-forge-text border-t border-forge-bound cursor-pointer;
+        position: absolute;
+        right: 2em;
+        bottom: 0px;
+        width: 48px;
+        height: 48px;
+    }
+
+    .save-button:hover {
+        background-color: #3c3d41;
+    }
 </style>
diff --git a/src/components/TitleBar.svelte b/src/components/TitleBar.svelte
index a5b8c2e..05cfcbc 100644
--- a/src/components/TitleBar.svelte
+++ b/src/components/TitleBar.svelte
@@ -6,6 +6,7 @@
         CaretDownOutline,
         PlusOutline,
         FilePdfSolid,
+        ArrowsRepeatOutline,
     } from "flowbite-svelte-icons";
     import { getCurrentWindow } from "@tauri-apps/api/window";
     import { homeDir } from "@tauri-apps/api/path";
@@ -21,12 +22,14 @@
         selectTab,
         closeTab,
         openTab: newFile,
+        reload
     }: {
         fStates: FileViewState[];
         fState: FileViewState | undefined;
         selectTab: (arg0: FileViewState) => void;
         closeTab: (arg0: FileViewState) => void;
         openTab: () => void;
+        reload: () => void;
     } = $props();
 
     let dropdownVisible = $state(false);
@@ -167,7 +170,15 @@
         {/if}
     </div>
 
+
     <div class="titlebar-button-group">
+        <button
+                onclick={reload}
+                class="titlebar-button"
+                id="titlebar-maximize"
+        >
+            <ArrowsRepeatOutline            />
+        </button>
         <button
             onclick={minimize}
             class="titlebar-button"
diff --git a/src/components/TreeView.svelte b/src/components/TreeView.svelte
index af83e3a..ec6685c 100644
--- a/src/components/TreeView.svelte
+++ b/src/components/TreeView.svelte
@@ -5,7 +5,6 @@
     import type {TreeViewModel} from "../models/TreeViewModel";
     import TreeViewEntry from "./TreeViewEntry.svelte";
 
-    const rowHeight = 24;
     let {
         fState,
         height,
@@ -17,54 +16,36 @@
     const file_id = $derived(fState.file.id);
 
     let scrollY = $state(0);
-    let scrollContainer: HTMLElement;
-    let fillerHeight: number = $state(0);
-    let states: TreeViewState[] = [];
 
-    let treeState: TreeViewState | undefined = $state(undefined);
+    let treeState: TreeViewState | undefined = $state(fState.treeState);
 
-    let totalHeight: number = $state(100);
-    let entries: TreeViewModel[] = $state([]);
-    let stickies: TreeViewModel[] = $state([]);
+    let fillerHeight: number = $derived(
+        treeState ? treeState.filler_height : 0,
+    );
+    let totalHeight: number = $derived(treeState ? treeState.total_height : 0);
+    let entries: TreeViewModel[] = $derived(treeState ? treeState.entries : []);
+    let stickies: TreeViewModel[] = $derived(
+        treeState ? treeState.stickies : [],
+    );
 
     $effect(() => {
-        treeState = states.find((state) => state.file_id === file_id);
-        updateTreeView();
-    });
-
-
-    async function updateTreeView() {
-        if (!treeState || treeState.file_id !== file_id) {
-            let newState = new TreeViewState(file_id, fState);
-            await newState.loadTreeView();
-            states.push(newState);
-            treeState = newState;
-            totalHeight = treeState.getEntryCount() * rowHeight;
+            treeState?.loadTreeView(scrollY, height);
         }
-        scrollY = scrollContainer.scrollTop;
-        let firstEntry = Math.floor(scrollY / rowHeight);
-        let lastEntry = Math.ceil((scrollY + height) / rowHeight);
-        let entryCount = treeState?.getEntryCount();
-        totalHeight = Math.max(entryCount * rowHeight, 0);
-        fillerHeight = firstEntry * rowHeight;
-        let entriesAndStickies = treeState.getEntries(firstEntry, lastEntry);
-        entries = entriesAndStickies[0];
-        stickies = entriesAndStickies[1];
-    }
+    )
 
     function handleSelect(prim: TreeViewModel) {
         if (prim.expanded && prim.container) {
             treeState
                 ?.collapseTree(prim.path.map((path) => path.key))
                 .then(() => {
-                    updateTreeView();
+                    treeState?.loadTreeView(scrollY, height);
                 });
             return;
         } else if (prim.container) {
             treeState
                 ?.expandTree(prim.path.map((path) => path.key))
                 .then(() => {
-                    updateTreeView();
+                    treeState?.loadTreeView(scrollY, height);
                 });
         }
         fState.selectPathHandler(
@@ -73,19 +54,22 @@
                 prim.path.map((path) => path.key),
             ),
         );
-        updateTreeView();
+        treeState?.loadTreeView(scrollY, height);
     }
 
     function handleScroll(event: Event & { currentTarget: HTMLElement }) {
-        updateTreeView();
+        scrollY = event.currentTarget.scrollTop;
+        treeState?.loadTreeView(scrollY, height);
     }
-
 </script>
 
-<div bind:this={scrollContainer}  onscroll={handleScroll}  class="overflow-auto" style="height: {height}px">
+<div onscroll={handleScroll} class="overflow-auto" style="height: {height}px">
     {#if entries}
         <div style="height: {totalHeight}px; width: 100%">
-            <table class="border-b-2 border-forge-bound bg-forge-prim" style="position: relative; top: {scrollY}px">
+            <table
+                    class="border-b-2 border-forge-bound bg-forge-prim"
+                    style="position: relative; top: {scrollY}px"
+            >
                 <thead>
                 <tr>
                     {#each stickies as entry}
@@ -99,8 +83,9 @@
                 </tr>
                 </thead>
             </table>
-            <div class="filler"
-                 style="height: {fillerHeight}px; width: 100%"
+            <div
+                    class="filler"
+                    style="height: {fillerHeight}px; width: 100%"
             ></div>
             <div>
                 {#each entries as entry}
diff --git a/src/models/ContentModel.svelte.ts b/src/models/ContentModel.svelte.ts
index 0e4ad99..4390886 100644
--- a/src/models/ContentModel.svelte.ts
+++ b/src/models/ContentModel.svelte.ts
@@ -1,3 +1,42 @@
-export default interface ContentModel {
-    readonly parts: string[][];
+const EOF: string = "\n%-------------------% EOF %-------------------%\n\n";
+const CONTENTS: string = "%----------------% Contents[%d] %--------------%\n\n";
+const CONTENTS_PATTERN = /%----------------% Contents\[\d+] %--------------%\n\n([\s\S]*?)(?=%-------------------% EOF %-------------------%|$)/gm;
+export default class ContentModel {
+    parts: string[][];
+    constructor(parts: string[][]) {
+        this.parts = parts;
+    }
+
+    public toDisplay(): string {
+
+        let text = "";
+        if (this.parts.length > 1) {
+            let i = 0;
+            for (let part of this.parts) {
+                text += CONTENTS.replace("%d", i.toString());
+                for (let line of part) {
+                    text += "  " + line + "\n";
+                }
+                text += EOF;
+                i++;
+            }
+        } else if (this.parts.length == 1) {
+            text = this.parts[0].join("\n");
+        }
+        return text;
+    }
+
+    public fromDisplay(display: string): ContentModel {
+        const parts: string[][] = [];
+        let match;
+        while ((match = CONTENTS_PATTERN.exec(display)) !== null) {
+            const lines = match[1].split("\n").map(line => line.trim()).filter(line => line !== "");
+            parts.push(lines);
+        }
+
+        if (parts.length === 0) {
+            parts.push(display.split("\n").map(line => line.trim()));
+        }
+        return new ContentModel(parts);
+    }
 }
\ No newline at end of file
diff --git a/src/models/FileViewState.svelte.ts b/src/models/FileViewState.svelte.ts
index 9b84132..ccb7c05 100644
--- a/src/models/FileViewState.svelte.ts
+++ b/src/models/FileViewState.svelte.ts
@@ -9,6 +9,8 @@ import {StreamData} from "./StreamData.svelte";
 import {ForgeNotification} from "./ForgeNotification.svelte";
 import {Mutex} from 'async-mutex';
 import {RawImageData} from "./RawImageData";
+import TreeViewState from "./TreeViewState.svelte";
+import {PageViewState} from "./PageViewState.svelte";
 
 export default class FileViewState {
     public file: PdfFile;
@@ -24,6 +26,10 @@ export default class FileViewState {
     public selected_leaf_prim: Primitive | undefined = $state();
     public xref_entries: XRefEntry[] = $state([]);
 
+    public treeState: TreeViewState | undefined = $state();
+    pageViewStates: Map<number, PageViewState> = new Map();
+    public pageViewState: PageViewState | undefined = $state();
+
     public notifications: ForgeNotification[] = $state([]);
     notificationMutex = new Mutex();
 
@@ -33,6 +39,7 @@ export default class FileViewState {
         this.selectPath(this.path);
         this.loadXrefEntries()
         this.notificationMutex = new Mutex();
+        this.treeState = new TreeViewState(this);
     }
 
     getLastJump(): string | number | undefined {
@@ -43,6 +50,31 @@ export default class FileViewState {
         return this.container_prim?.getFirstJump()
     }
 
+    public saveStreamData(updated_data: string) {
+        if (!this.selected_leaf_prim) return;
+        if (!this.container_prim?.stream_data) return;
+        invoke("update_stream_data_as_string", {
+            id: this.file.id,
+            path: this.formatPaths(this.path),
+            newData: updated_data
+        })
+            .then(() => {
+                console.log("saved");
+                this.reload();
+                this.container_prim?.stream_data?.setData(updated_data);
+            })
+            .catch(err => this.logError(err));
+    }
+
+    public reload() {
+        this.container_prim = undefined;
+        this.selected_leaf_prim = undefined;
+        this.loadXrefEntries();
+        this.selectPath(this.path);
+        this.treeState?.reload();
+        this.reloadPageState();
+    }
+
     public logError(message: string) {
         this.notificationMutex.acquire().then(release => {
             try {
@@ -54,6 +86,10 @@ export default class FileViewState {
         });
     }
 
+    public setTreeViewState(state: TreeViewState) {
+        this.treeState = state;
+    }
+
     public async deleteNotification(timestamp: number) {
         const release = await this.notificationMutex.acquire();
         try {
@@ -95,6 +131,7 @@ export default class FileViewState {
         if (newPrim.isContainer()) {
             this.container_prim = newPrim;
             this.path = newPath
+            this.loadPageState().catch(err => this.logError(err));
             return;
         }
         this.selected_leaf_prim = newPrim;
@@ -174,4 +211,21 @@ export default class FileViewState {
     }
 
 
+    private async reloadPageState() {
+        this.pageViewState = undefined;
+        this.pageViewStates = new Map();
+    }
+
+    private async loadPageState() {
+        if (!(this.container_prim && this.container_prim.isPage())) return;
+        let page_num = this.container_prim.getPageNumber();
+
+        if (this.pageViewState && this.pageViewState.page_num === page_num) return;
+
+        this.pageViewState = this.pageViewStates.get(page_num);
+        if (!this.pageViewState) {
+            this.pageViewState = new PageViewState(page_num, this);
+            this.pageViewStates.set(page_num, this.pageViewState);
+        }
+    }
 }
\ No newline at end of file
diff --git a/src/models/PageViewState.svelte.ts b/src/models/PageViewState.svelte.ts
index bd2d359..d99fbb5 100644
--- a/src/models/PageViewState.svelte.ts
+++ b/src/models/PageViewState.svelte.ts
@@ -1,62 +1,55 @@
-import type ContentModel from "./ContentModel.svelte";
+import ContentModel from "./ContentModel.svelte";
 import {invoke} from "@tauri-apps/api/core";
 import {RawImageData} from "./RawImageData";
+import type FileViewState from "./FileViewState.svelte";
 
 export class PageViewState {
     file_id: string;
     page_num: number;
-    errorHandler: (arg0: string) => void;
+    fState: FileViewState;
 
     img_data: RawImageData | undefined = $state();
-    contents: string = $state("");
+    contents: ContentModel = $state(new ContentModel([]));
 
-    constructor(file_id: string, page_num: number, errorHandler: (arg0: string) => void) {
-        this.file_id = file_id;
+    constructor(page_num: number, fState: FileViewState) {
+        this.file_id = fState.file.id;
         this.page_num = page_num;
-        this.errorHandler = errorHandler;
-        this.load();
+        this.fState = fState;
+
+        this.load(page_num);
     }
 
-    public async load() {
-        invoke<ContentModel>("get_contents", {id: this.file_id, path: "Page" + this.page_num})
+    private logError(err: string) {
+        this.fState.logError(err);
+    }
+
+    public async load(page_num: number) {
+        invoke<ContentModel>("get_contents", {id: this.file_id, path: "Page" + page_num})
             .then((result) => {
-                this.contents = this.mapToString(result);
-                this.loadImage();
+                this.page_num = page_num;
+                this.contents = new ContentModel(result.parts);
+                this.loadImage(page_num);
             })
-            .catch((err) => this.errorHandler(err));
+            .catch(this.logError);
     }
 
-    public async loadImage() {
+    public async loadImage(page_num: number) {
         let result = await invoke<ArrayBuffer>("get_page_by_num", {
             id: this.file_id,
-            num: this.page_num,
-        }).catch(err => this.errorHandler(err));
+            num: page_num,
+        })
+        .catch(this.logError);
         if (result) {
             this.img_data = new RawImageData(result);
         }
     }
 
-    private mapToString(model: ContentModel | undefined): string {
-        if (!model) return "";
-
-        let text = "";
-        if (model.parts.length > 1) {
-            let i = 0;
-            for (let part of model.parts) {
-                text +=
-                    "%----------------% Contents[" +
-                    i +
-                    "] %--------------%\n\n";
-                for (let line of part) {
-                    text += "  " + line + "\n";
-                }
-                text +=
-                    "\n%-------------------% EOF %-------------------%\n\n";
-                i++;
-            }
-        } else {
-            text = model.parts[0].join("\n");
-        }
-        return text;
+    public handleSave(newData: string) {
+        invoke("update_contents", {id: this.file_id, path: "Page" + this.page_num, newData: newData})
+            .then((_) => {
+                this.loadImage(this.page_num);
+            })
+            .catch(this.logError);
     }
+
 }
\ No newline at end of file
diff --git a/src/models/TreeViewState.svelte.ts b/src/models/TreeViewState.svelte.ts
index 91c75cb..a8626b3 100644
--- a/src/models/TreeViewState.svelte.ts
+++ b/src/models/TreeViewState.svelte.ts
@@ -4,21 +4,29 @@ import {TreeViewModel} from "./TreeViewModel";
 import type {Trace} from "./Primitive.svelte";
 import type FileViewState from "./FileViewState.svelte";
 
+const ROW_HEIGHT = 24;
 const MAX_STICKIES: number = 5;
 export default class TreeViewState {
 
     private initialRequest: TreeViewRequest[];
-    private activeRequest: Map<string, TreeViewRequest> = $state(new Map());
-    private activeEntries: Map<string, TreeViewModel[]> = $state(new Map());
-    scrollY: number = 0;
+    private activeRequest: Map<string, TreeViewRequest> = new Map();
+    private activeEntries: Map<string, TreeViewModel[]> = new Map();
+
+    public total_height: number = $state(100);
+    public filler_height: number = $state(0);
+    public entries: TreeViewModel[] = $state([]);
+    public stickies: TreeViewModel[] = $state([]);
+
+    private scrollY = 0;
+    private height = 100;
     file_id: string;
 
-    constructor(file_id: string, fState: FileViewState) {
+    constructor(fState: FileViewState) {
 
         this.initialRequest = [TreeViewRequest.TRAILER];
         this.initialRequest = this.initialRequest.concat(TreeViewRequest.fromPageCount(+fState.file.page_count));
         this.activeRequest.set(this.initialRequest[0].key, this.initialRequest[0]);
-        this.file_id = file_id;
+        this.file_id = fState.file.id;
     }
 
     public getEntryCount() {
@@ -106,9 +114,22 @@ export default class TreeViewState {
         );
     }
 
-    public async loadTreeView() {
+    public async reload() {
+        await this.loadTreeView(this.scrollY, this.height);
+    }
+
+    public async loadTreeView(scrollY: number, height: number) {
         const activeRequests = Array.from(this.activeRequest.values());
         await this.updateTreeViewRequest(activeRequests);
+        let firstEntry = Math.floor(scrollY / ROW_HEIGHT);
+        let lastEntry = Math.ceil((scrollY + height) / ROW_HEIGHT);
+        this.total_height = this.getEntryCount() * ROW_HEIGHT;
+        this.filler_height = firstEntry * ROW_HEIGHT;
+        let entriesAndStickies = this.getEntries(firstEntry, lastEntry);
+        this.entries = entriesAndStickies[0];
+        this.stickies = entriesAndStickies[1];
+        this.scrollY = scrollY;
+        this.height = height;
     }
 
     public getRoot(): TreeViewRequest[] {