Added layout properties

src/elements/code.rs

@@ -325,7 +325,7 @@ impl CodeRule {
 				)
 				.unwrap(),
 			],
-			properties: PropertyParser::new(props),
+			properties: PropertyParser{ properties: props },
 		}
 	}
 }

src/elements/graphviz.rs

@@ -39,7 +39,6 @@ struct Graphviz {
 	pub dot: String,
 	pub layout: Layout,
 	pub width: String,
-	pub caption: Option<String>,
 }
 
 fn layout_from_str(value: &str) -> Result<Layout, String> {
@@ -100,6 +99,7 @@ impl Cached for Graphviz {
 	fn key(&self) -> <Self as Cached>::Key {
 		let mut hasher = Sha512::new();
 		hasher.input((self.layout as usize).to_be_bytes().as_slice());
+		hasher.input(self.width.as_bytes());
 		hasher.input(self.dot.as_bytes());
 
 		hasher.result_str()
@@ -179,7 +179,7 @@ impl GraphRule {
 				r"\[graph\](?:\[((?:\\.|[^\[\]\\])*?)\])?(?:((?:\\.|[^\\\\])*?)\[/graph\])?",
 			)
 			.unwrap()],
-			properties: PropertyParser::new(props),
+			properties: PropertyParser{ properties: props },
 		}
 	}
 }
@@ -354,8 +354,6 @@ impl RegexRule for GraphRule {
 			},
 		};
 
-		// TODO: Caption
-
 		parser.push(
 			document,
 			Box::new(Graphviz {
@@ -363,7 +361,6 @@ impl RegexRule for GraphRule {
 				dot: graph_content,
 				layout: graph_layout,
 				width: graph_width,
-				caption: None,
 			}),
 		);
 

src/elements/layout.rs

@@ -0,0 +1,617 @@
+use crate::compiler::compiler::Compiler;
+use crate::compiler::compiler::Target;
+use crate::document::document::Document;
+use crate::document::element::ElemKind;
+use crate::document::element::Element;
+use crate::parser::parser::Parser;
+use crate::parser::parser::ReportColors;
+use crate::parser::rule::RegexRule;
+use crate::parser::source::Source;
+use crate::parser::source::Token;
+use crate::parser::state::Scope;
+use crate::parser::state::State;
+use crate::parser::util::process_escaped;
+use ariadne::Fmt;
+use ariadne::Label;
+use ariadne::Report;
+use ariadne::ReportKind;
+use lazy_static::lazy_static;
+use mlua::Function;
+use mlua::Lua;
+use regex::Captures;
+use regex::Match;
+use regex::Regex;
+use std::any::Any;
+use std::cell::RefCell;
+use std::collections::HashMap;
+use std::ops::Range;
+use std::rc::Rc;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum LayoutToken {
+	BEGIN,
+	NEXT,
+	END,
+}
+
+/// Represents the type of a layout
+pub trait LayoutType: core::fmt::Debug {
+	/// Name of the layout
+	fn name(&self) -> &'static str;
+
+	/// Parses layout properties
+	fn parse_properties(&self, properties: &str) -> Result<Option<Box<dyn Any>>, String>;
+
+	/// Expected number of blocks
+	fn expects(&self) -> Range<usize>;
+
+	/// Compile layout
+	fn compile(
+		&self,
+		token: LayoutToken,
+		id: usize,
+		properties: &Option<Box<dyn Any>>,
+		compiler: &Compiler,
+		document: &dyn Document,
+	) -> Result<String, String>;
+}
+
+mod default_layouts {
+	use std::any::Any;
+
+	use crate::parser::util::Property;
+	use crate::parser::util::PropertyParser;
+
+	use super::*;
+
+	#[derive(Debug, Default)]
+	pub struct Centered;
+
+	impl LayoutType for Centered {
+		fn name(&self) -> &'static str { "Centered" }
+
+		fn expects(&self) -> Range<usize> { 1..1 }
+
+		fn parse_properties(&self, properties: &str) -> Result<Option<Box<dyn Any>>, String> {
+			if !properties.is_empty() {
+				return Err(format!("Layout {} excepts no properties", self.name()));
+			}
+			Ok(None)
+		}
+
+		fn compile(
+			&self,
+			token: LayoutToken,
+			_id: usize,
+			_properties: &Option<Box<dyn Any>>,
+			compiler: &Compiler,
+			_document: &dyn Document,
+		) -> Result<String, String> {
+			match compiler.target() {
+				Target::HTML => match token {
+					LayoutToken::BEGIN => Ok(r#"<div class="centered">"#.to_string()),
+					LayoutToken::NEXT => panic!(),
+					LayoutToken::END => Ok(r#"</div>"#.to_string()),
+				},
+				_ => todo!(""),
+			}
+		}
+	}
+
+	#[derive(Debug)]
+	pub struct Split {
+		properties: PropertyParser,
+	}
+
+	impl Default for Split {
+		fn default() -> Self {
+			let mut properties = HashMap::new();
+			properties.insert(
+				"style".to_string(),
+				Property::new(
+					true,
+					"Additional style for the split".to_string(),
+					Some("".to_string()),
+				),
+			);
+
+			Self {
+				properties: PropertyParser { properties },
+			}
+		}
+	}
+
+	impl LayoutType for Split {
+		fn name(&self) -> &'static str { "Split" }
+
+		fn expects(&self) -> Range<usize> { 2..usize::MAX }
+
+		fn parse_properties(&self, properties: &str) -> Result<Option<Box<dyn Any>>, String> {
+			let props = if properties.is_empty() {
+				self.properties.default()
+			} else {
+				self.properties.parse(properties)
+			}
+			.map_err(|err| {
+				format!(
+					"Failed to parse properties for layout {}: {err}",
+					self.name()
+				)
+			})?;
+
+			let style = props
+				.get("style", |_, value| -> Result<String, ()> {
+					Ok(value.clone())
+				})
+				.map_err(|err| format!("Failed to parse style: {err:#?}"))
+				.map(|(_, value)| value)?;
+
+			Ok(Some(Box::new(style)))
+		}
+
+		fn compile(
+			&self,
+			token: LayoutToken,
+			_id: usize,
+			properties: &Option<Box<dyn Any>>,
+			compiler: &Compiler,
+			_document: &dyn Document,
+		) -> Result<String, String> {
+			match compiler.target() {
+				Target::HTML => {
+					let style = match properties
+						.as_ref()
+						.unwrap()
+						.downcast_ref::<String>()
+						.unwrap().as_str()
+						{
+							"" => "".to_string(),
+							str => format!(r#" style={}"#, Compiler::sanitize(compiler.target(), str))
+						};
+					match token {
+						LayoutToken::BEGIN => Ok(format!(
+							r#"<div class="split-container"><div class="split"{style}>"#
+						)),
+						LayoutToken::NEXT => Ok(format!(r#"</div><div class="split"{style}>"#)),
+						LayoutToken::END => Ok(r#"</div></div>"#.to_string()),
+					}
+				}
+				_ => todo!(""),
+			}
+		}
+	}
+}
+
+#[derive(Debug)]
+struct Layout {
+	pub(self) location: Token,
+	pub(self) layout: Rc<dyn LayoutType>,
+	pub(self) id: usize,
+	pub(self) token: LayoutToken,
+	pub(self) properties: Option<Box<dyn Any>>,
+}
+
+impl Element for Layout {
+	fn location(&self) -> &Token { &self.location }
+	fn kind(&self) -> ElemKind { ElemKind::Block }
+	fn element_name(&self) -> &'static str { "Layout" }
+	fn to_string(&self) -> String { format!("{self:#?}") }
+	fn compile(&self, compiler: &Compiler, document: &dyn Document) -> Result<String, String> {
+		self.layout
+			.compile(self.token, self.id, &self.properties, compiler, document)
+	}
+}
+
+struct LayoutState {
+	/// The layout stack
+	pub(self) stack: Vec<(Vec<Token>, Rc<dyn LayoutType>)>,
+}
+
+impl State for LayoutState {
+	fn scope(&self) -> Scope { Scope::DOCUMENT }
+
+	fn on_remove<'a>(
+		&self,
+		parser: &dyn Parser,
+		document: &dyn Document,
+	) -> Vec<Report<'a, (Rc<dyn Source>, Range<usize>)>> {
+		let mut reports = vec![];
+
+		let doc_borrow = document.content().borrow();
+		let at = doc_borrow.last().unwrap().location();
+
+		for (tokens, layout_type) in &self.stack {
+			let start = tokens.first().unwrap();
+			reports.push(
+				Report::build(ReportKind::Error, start.source(), start.start())
+					.with_message("Unterminated Layout")
+					//.with_label(
+					//	Label::new((document.source(), active_range.clone()))
+					//	.with_order(0)
+					//	.with_message(format!("Style {} is not terminated before the end of paragraph",
+					//	name.fg(parser.colors().info)))
+					//	.with_color(parser.colors().error))
+					.with_label(
+						Label::new((start.source(), start.range.start + 1..start.range.end))
+							.with_order(1)
+							.with_message(format!(
+								"Layout {} stars here",
+								layout_type.name().fg(parser.colors().info)
+							))
+							.with_color(parser.colors().error),
+					)
+					.with_label(
+						Label::new((at.source(), at.range.clone()))
+							.with_order(2)
+							.with_message("Document ends here".to_string())
+							.with_color(parser.colors().error),
+					)
+					.finish(),
+			);
+		}
+
+		return reports;
+	}
+}
+
+pub struct LayoutRule {
+	re: [Regex; 3],
+	layouts: HashMap<String, Rc<dyn LayoutType>>,
+}
+
+impl LayoutRule {
+	pub fn new() -> Self {
+		let mut layouts: HashMap<String, Rc<dyn LayoutType>> = HashMap::new();
+
+		let layout_centered = default_layouts::Centered::default();
+		layouts.insert(layout_centered.name().to_string(), Rc::new(layout_centered));
+
+		let layout_split = default_layouts::Split::default();
+		layouts.insert(layout_split.name().to_string(), Rc::new(layout_split));
+
+		Self {
+			re: [
+				Regex::new(r"(?:^|\n)#\+LAYOUT_BEGIN(?:\[((?:\\.|[^\\\\])*?)\])?(.*)").unwrap(),
+				Regex::new(r"(?:^|\n)#\+LAYOUT_NEXT(?:\[((?:\\.|[^\\\\])*?)\])?(?:$|\n)").unwrap(),
+				Regex::new(r"(?:^|\n)#\+LAYOUT_END(?:\[((?:\\.|[^\\\\])*?)\])?(?:$|\n)").unwrap(),
+			],
+			layouts,
+		}
+	}
+
+	pub fn parse_properties<'a>(
+		colors: &ReportColors,
+		token: &Token,
+		layout_type: Rc<dyn LayoutType>,
+		properties: Option<Match>,
+	) -> Result<Option<Box<dyn Any>>, Report<'a, (Rc<dyn Source>, Range<usize>)>> {
+		match properties {
+			None => match layout_type.parse_properties("") {
+				Ok(props) => Ok(props),
+				Err(err) => Err(
+					Report::build(ReportKind::Error, token.source(), token.start())
+						.with_message("Unable to parse layout properties")
+						.with_label(
+							Label::new((token.source(), token.range.clone()))
+								.with_message(err)
+								.with_color(colors.error),
+						)
+						.finish(),
+				),
+			},
+			Some(props) => {
+				let trimmed = props.as_str().trim_start().trim_end();
+				let content = process_escaped('\\', "]", trimmed);
+				match layout_type.parse_properties(content.as_str()) {
+					Ok(props) => Ok(props),
+					Err(err) => {
+						Err(
+							Report::build(ReportKind::Error, token.source(), props.start())
+								.with_message("Unable to parse layout properties")
+								.with_label(
+									Label::new((token.source(), props.range()))
+										.with_message(err)
+										.with_color(colors.error),
+								)
+								.finish(),
+						)
+					}
+				}
+			}
+		}
+	}
+}
+
+lazy_static! {
+	static ref STATE_NAME: String = "elements.layout".to_string();
+}
+
+impl RegexRule for LayoutRule {
+	fn name(&self) -> &'static str { "Layout" }
+
+	fn regexes(&self) -> &[regex::Regex] { &self.re }
+
+	fn on_regex_match(
+		&self,
+		index: usize,
+		parser: &dyn Parser,
+		document: &dyn Document,
+		token: Token,
+		matches: Captures,
+	) -> Vec<Report<(Rc<dyn Source>, Range<usize>)>> {
+		let mut reports = vec![];
+
+		let query = parser.state().query(&STATE_NAME);
+		let state = match query {
+			Some(state) => state,
+			None => {
+				// Insert as a new state
+				match parser.state_mut().insert(
+					STATE_NAME.clone(),
+					Rc::new(RefCell::new(LayoutState { stack: vec![] })),
+				) {
+					Err(_) => panic!("Unknown error"),
+					Ok(state) => state,
+				}
+			}
+		};
+
+		if index == 0
+		// BEGIN_LAYOUT
+		{
+			match matches.get(2) {
+				None => {
+					reports.push(
+						Report::build(ReportKind::Error, token.source(), token.start())
+							.with_message("Missing Layout Name")
+							.with_label(
+								Label::new((token.source(), token.range.clone()))
+									.with_message(format!(
+										"Missing layout name after `{}`",
+										"#+BEGIN_LAYOUT".fg(parser.colors().highlight)
+									))
+									.with_color(parser.colors().error),
+							)
+							.finish(),
+					);
+					return reports;
+				}
+				Some(name) => {
+					let trimmed = name.as_str().trim_start().trim_end();
+					if name.as_str().is_empty() || trimmed.is_empty()
+					// Empty name
+					{
+						reports.push(
+							Report::build(ReportKind::Error, token.source(), name.start())
+								.with_message("Empty Layout Name")
+								.with_label(
+									Label::new((token.source(), token.range.clone()))
+										.with_message(format!(
+											"Empty layout name after `{}`",
+											"#+BEGIN_LAYOUT".fg(parser.colors().highlight)
+										))
+										.with_color(parser.colors().error),
+								)
+								.finish(),
+						);
+						return reports;
+					} else if !name.as_str().chars().next().unwrap().is_whitespace()
+					// Missing space
+					{
+						reports.push(
+							Report::build(ReportKind::Error, token.source(), name.start())
+								.with_message("Invalid Layout Name")
+								.with_label(
+									Label::new((token.source(), name.range()))
+										.with_message(format!(
+											"Missing a space before layout name `{}`",
+											name.as_str().fg(parser.colors().highlight)
+										))
+										.with_color(parser.colors().error),
+								)
+								.finish(),
+						);
+						return reports;
+					}
+
+					// Get layout
+					let layout_type = match self.layouts.get(trimmed) {
+						None => {
+							reports.push(
+								Report::build(ReportKind::Error, token.source(), name.start())
+									.with_message("Unknown Layout")
+									.with_label(
+										Label::new((token.source(), name.range()))
+											.with_message(format!(
+												"Cannot find layout `{}`",
+												trimmed.fg(parser.colors().highlight)
+											))
+											.with_color(parser.colors().error),
+									)
+									.finish(),
+							);
+							return reports;
+						}
+						Some(layout_type) => layout_type,
+					};
+
+					// Parse properties
+					let properties = match LayoutRule::parse_properties(
+						parser.colors(),
+						&token,
+						layout_type.clone(),
+						matches.get(1),
+					) {
+						Ok(props) => props,
+						Err(rep) => {
+							reports.push(rep);
+							return reports;
+						}
+					};
+
+					parser.push(
+						document,
+						Box::new(Layout {
+							location: token.clone(),
+							layout: layout_type.clone(),
+							id: 0,
+							token: LayoutToken::BEGIN,
+							properties,
+						}),
+					);
+
+					state
+						.borrow_mut()
+						.downcast_mut::<LayoutState>()
+						.map_or_else(
+							|| panic!("Invalid state at: `{}`", STATE_NAME.as_str()),
+							|s| s.stack.push((vec![token.clone()], layout_type.clone())),
+						);
+				}
+			};
+			return reports;
+		}
+
+		let (id, token_type, layout_type, properties) = if index == 1
+		// LAYOUT_NEXT
+		{
+			let mut state_borrow = state.borrow_mut();
+			let state = state_borrow.downcast_mut::<LayoutState>().unwrap();
+
+			let (tokens, layout_type) = match state.stack.last_mut() {
+				None => {
+					reports.push(
+						Report::build(ReportKind::Error, token.source(), token.start())
+							.with_message("Invalid #+LAYOUT_NEXT")
+							.with_label(
+								Label::new((token.source(), token.range.clone()))
+									.with_message("No active layout found".to_string())
+									.with_color(parser.colors().error),
+							)
+							.finish(),
+					);
+					return reports;
+				}
+				Some(last) => last,
+			};
+
+			if layout_type.expects().end < tokens.len()
+			// Too many blocks
+			{
+				reports.push(
+					Report::build(ReportKind::Error, token.source(), token.start())
+						.with_message("Unexpected #+LAYOUT_NEXT")
+						.with_label(
+							Label::new((token.source(), token.range.clone()))
+								.with_message(format!(
+									"Layout expects a maximum of {} blocks, currently at {}",
+									layout_type.expects().end.fg(parser.colors().info),
+									tokens.len().fg(parser.colors().info),
+								))
+								.with_color(parser.colors().error),
+						)
+						.finish(),
+				);
+				return reports;
+			}
+
+			// Parse properties
+			let properties = match LayoutRule::parse_properties(
+				parser.colors(),
+				&token,
+				layout_type.clone(),
+				matches.get(1),
+			) {
+				Ok(props) => props,
+				Err(rep) => {
+					reports.push(rep);
+					return reports;
+				}
+			};
+
+			tokens.push(token.clone());
+			(
+				tokens.len() - 1,
+				LayoutToken::NEXT,
+				layout_type.clone(),
+				properties,
+			)
+		} else {
+			// LAYOUT_END
+			let mut state_borrow = state.borrow_mut();
+			let state = state_borrow.downcast_mut::<LayoutState>().unwrap();
+
+			let (tokens, layout_type) = match state.stack.last_mut() {
+				None => {
+					reports.push(
+						Report::build(ReportKind::Error, token.source(), token.start())
+							.with_message("Invalid #+LAYOUT_END")
+							.with_label(
+								Label::new((token.source(), token.range.clone()))
+									.with_message("No active layout found".to_string())
+									.with_color(parser.colors().error),
+							)
+							.finish(),
+					);
+					return reports;
+				}
+				Some(last) => last,
+			};
+
+			if layout_type.expects().start > tokens.len()
+			// Not enough blocks
+			{
+				reports.push(
+					Report::build(ReportKind::Error, token.source(), token.start())
+						.with_message("Unexpected #+LAYOUT_END")
+						.with_label(
+							Label::new((token.source(), token.range.clone()))
+								.with_message(format!(
+									"Layout expects a minimum of {} blocks, currently at {}",
+									layout_type.expects().start.fg(parser.colors().info),
+									tokens.len().fg(parser.colors().info),
+								))
+								.with_color(parser.colors().error),
+						)
+						.finish(),
+				);
+				return reports;
+			}
+
+			// Parse properties
+			let properties = match LayoutRule::parse_properties(
+				parser.colors(),
+				&token,
+				layout_type.clone(),
+				matches.get(1),
+			) {
+				Ok(props) => props,
+				Err(rep) => {
+					reports.push(rep);
+					return reports;
+				}
+			};
+
+			let layout_type = layout_type.clone();
+			let id = tokens.len();
+			state.stack.pop();
+			(id, LayoutToken::END, layout_type, properties)
+		};
+
+		parser.push(
+			document,
+			Box::new(Layout {
+				location: token,
+				layout: layout_type,
+				id,
+				token: token_type,
+				properties,
+			}),
+		);
+
+		return reports;
+	}
+
+	// TODO
+	fn lua_bindings<'lua>(&self, _lua: &'lua Lua) -> Option<Vec<(String, Function<'lua>)>> { None }
+}

src/elements/media.rs

@@ -258,7 +258,7 @@ impl MediaRule {
 			.multi_line(true)
 			.build()
 			.unwrap()],
-			properties: PropertyParser::new(props),
+			properties: PropertyParser{ properties: props },
 		}
 	}
 

src/elements/mod.rs

@@ -1,17 +1,18 @@
-pub mod registrar;
-pub mod text;
-pub mod comment;
-pub mod paragraph;
-pub mod variable;
-pub mod import;
-pub mod script;
-pub mod list;
-pub mod style;
-pub mod section;
-pub mod link;
 pub mod code;
-pub mod tex;
+pub mod comment;
 pub mod graphviz;
-pub mod raw;
+pub mod import;
+pub mod layout;
+pub mod link;
+pub mod list;
 pub mod media;
+pub mod paragraph;
+pub mod raw;
 pub mod reference;
+pub mod registrar;
+pub mod script;
+pub mod section;
+pub mod style;
+pub mod tex;
+pub mod text;
+pub mod variable;

src/elements/raw.rs

@@ -33,16 +33,6 @@ struct Raw {
 	pub(self) content: String,
 }
 
-impl Raw {
-	fn new(location: Token, kind: ElemKind, content: String) -> Self {
-		Self {
-			location,
-			kind,
-			content,
-		}
-	}
-}
-
 impl Element for Raw {
 	fn location(&self) -> &Token { &self.location }
 	fn kind(&self) -> ElemKind { self.kind.clone() }
@@ -77,7 +67,7 @@ impl RawRule {
 				Regex::new(r"\{\?(?:\[((?:\\.|[^\[\]\\])*?)\])?(?:((?:\\.|[^\\\\])*?)(\?\}))?")
 					.unwrap(),
 			],
-			properties: PropertyParser::new(props),
+			properties: PropertyParser{ properties: props },
 		}
 	}
 }

src/elements/reference.rs

@@ -84,7 +84,7 @@ impl ReferenceRule {
 		);
 		Self {
 			re: [Regex::new(r"§\{(.*)\}(\[((?:\\.|[^\\\\])*?)\])?").unwrap()],
-			properties: PropertyParser::new(props),
+			properties: PropertyParser{ properties: props },
 		}
 	}
 

src/elements/registrar.rs

@@ -4,6 +4,7 @@ use super::code::CodeRule;
 use super::comment::CommentRule;
 use super::graphviz::GraphRule;
 use super::import::ImportRule;
+use super::layout::LayoutRule;
 use super::link::LinkRule;
 use super::list::ListRule;
 use super::media::MediaRule;
@@ -31,6 +32,7 @@ pub fn register<P: Parser>(parser: &mut P) {
 	parser.add_rule(Box::new(TexRule::new()), None).unwrap();
 	parser.add_rule(Box::new(GraphRule::new()), None).unwrap();
 	parser.add_rule(Box::new(MediaRule::new()), None).unwrap();
+	parser.add_rule(Box::new(LayoutRule::new()), None).unwrap();
 
 	parser.add_rule(Box::new(StyleRule::new()), None).unwrap();
 	parser.add_rule(Box::new(SectionRule::new()), None).unwrap();

src/elements/style.rs

@@ -1,10 +1,27 @@
-use mlua::{Function, Lua};
-use regex::{Captures, Regex};
-use crate::{compiler::compiler::{Compiler, Target}, document::{document::{DocumentAccessors, Document}, element::{ElemKind, Element}}, parser::{parser::Parser, rule::RegexRule, source::{Source, Token}, state::State}};
-use ariadne::{Fmt, Label, Report, ReportKind};
+use crate::compiler::compiler::Compiler;
+use crate::compiler::compiler::Target;
+use crate::document::document::Document;
+use crate::document::document::DocumentAccessors;
+use crate::document::element::ElemKind;
+use crate::document::element::Element;
+use crate::parser::parser::Parser;
+use crate::parser::rule::RegexRule;
+use crate::parser::source::Source;
+use crate::parser::source::Token;
 use crate::parser::state::Scope;
-use std::{cell::RefCell, ops::Range, rc::Rc};
+use crate::parser::state::State;
+use ariadne::Fmt;
+use ariadne::Label;
+use ariadne::Report;
+use ariadne::ReportKind;
 use lazy_static::lazy_static;
+use mlua::Function;
+use mlua::Lua;
+use regex::Captures;
+use regex::Regex;
+use std::cell::RefCell;
+use std::ops::Range;
+use std::rc::Rc;
 
 use super::paragraph::Paragraph;
 
@@ -15,64 +32,69 @@ pub struct Style {
 	close: bool,
 }
 
-impl Style
-{
+impl Style {
 	pub fn new(location: Token, kind: usize, close: bool) -> Self {
-		Self { location, kind, close }
+		Self {
+			location,
+			kind,
+			close,
+		}
 	}
 }
 
-impl Element for Style
-{
+impl Element for Style {
 	fn location(&self) -> &Token { &self.location }
 	fn kind(&self) -> ElemKind { ElemKind::Inline }
 	fn element_name(&self) -> &'static str { "Section" }
 	fn to_string(&self) -> String { format!("{self:#?}") }
 	fn compile(&self, compiler: &Compiler, _document: &dyn Document) -> Result<String, String> {
-		match compiler.target()
-		{
+		match compiler.target() {
 			Target::HTML => {
 				Ok([
 					// Bold
-					"<b>", "</b>",
-					// Italic
-					"<i>", "</i>",
-					// Underline
-					"<u>", "</u>",
-					// Code
+					"<b>", "</b>", // Italic
+					"<i>", "</i>", // Underline
+					"<u>", "</u>", // Code
 					"<em>", "</em>",
-				][self.kind*2 + self.close as usize].to_string())
+				][self.kind * 2 + self.close as usize]
+					.to_string())
 			}
-			Target::LATEX => Err("Unimplemented compiler".to_string())
+			Target::LATEX => Err("Unimplemented compiler".to_string()),
 		}
 	}
 }
 
-struct StyleState
-{
-	toggled: [Option<Token>; 4]
+struct StyleState {
+	toggled: [Option<Token>; 4],
 }
 
 impl StyleState {
 	const NAMES: [&'static str; 4] = ["Bold", "Italic", "Underline", "Code"];
 
 	fn new() -> Self {
-		Self { toggled: [None, None, None, None] }
+		Self {
+			toggled: [None, None, None, None],
+		}
 	}
 }
 
-impl State for StyleState
-{
+impl State for StyleState {
 	fn scope(&self) -> Scope { Scope::PARAGRAPH }
 
-	fn on_remove<'a>(&self, parser: &dyn Parser, document: &dyn Document) -> Vec<Report<'a, (Rc<dyn Source>, Range<usize>)>> {
-		let mut result = Vec::new();
+	fn on_remove<'a>(
+		&self,
+		parser: &dyn Parser,
+		document: &dyn Document,
+	) -> Vec<Report<'a, (Rc<dyn Source>, Range<usize>)>> {
+		let mut reports = vec![];
+
 		self.toggled
 			.iter()
 			.zip(StyleState::NAMES)
-			.for_each(|(token, name)|
-		{
-			if token.is_none() { return } // Style not enabled
+			.for_each(|(token, name)| {
+				if token.is_none() {
+					return;
+				} // Style not enabled
 				let token = token.as_ref().unwrap();
 
 				//let range = range.as_ref().unwrap();
@@ -80,12 +102,19 @@ impl State for StyleState
 				//let active_range = range.start .. paragraph.location().end()-1;
 
 				let paragraph = document.last_element::<Paragraph>().unwrap();
-			let paragraph_end = paragraph.content.last()
-				.and_then(|last| Some((last.location().source(), last.location().end()-1 .. last.location().end())))
+				let paragraph_end = paragraph
+					.content
+					.last()
+					.and_then(|last| {
+						Some((
+							last.location().source(),
+							last.location().end() - 1..last.location().end(),
+						))
+					})
 					.unwrap();
 
 				// TODO: Allow style to span multiple documents if they don't break paragraph.
-			result.push(
+				reports.push(
 					Report::build(ReportKind::Error, token.source(), token.start())
 						.with_message("Unterminated style")
 						//.with_label(
@@ -97,19 +126,24 @@ impl State for StyleState
 						.with_label(
 							Label::new((token.source(), token.range.clone()))
 								.with_order(1)
-					.with_message(format!("Style {} starts here",
-					name.fg(parser.colors().info)))
-					.with_color(parser.colors().info))
+								.with_message(format!(
+									"Style {} starts here",
+									name.fg(parser.colors().info)
+								))
+								.with_color(parser.colors().info),
+						)
 						.with_label(
 							Label::new(paragraph_end)
 								.with_order(1)
 								.with_message(format!("Paragraph ends here"))
-					.with_color(parser.colors().info))
+								.with_color(parser.colors().info),
+						)
 						.with_note("Styles cannot span multiple documents (i.e @import)")
-				.finish());
+						.finish(),
+				);
 			});
 
-		return result;
+		return reports;
 	}
 }
 
@@ -128,8 +162,8 @@ impl StyleRule {
 				// Underline
 				Regex::new(r"__").unwrap(),
 				// Code
-				Regex::new(r"`").unwrap()
-			]
+				Regex::new(r"`").unwrap(),
+			],
 		}
 	}
 }
@@ -138,21 +172,27 @@ lazy_static! {
 	static ref STATE_NAME: String = "elements.style".to_string();
 }
 
-impl RegexRule for StyleRule
-{
+impl RegexRule for StyleRule {
 	fn name(&self) -> &'static str { "Style" }
 
 	fn regexes(&self) -> &[regex::Regex] { &self.re }
 
-	fn on_regex_match(&self, index: usize, parser: &dyn Parser, document: &dyn Document, token: Token, _matches: Captures) -> Vec<Report<(Rc<dyn Source>, Range<usize>)>> {
-		let result = vec![];
-
+	fn on_regex_match(
+		&self,
+		index: usize,
+		parser: &dyn Parser,
+		document: &dyn Document,
+		token: Token,
+		_matches: Captures,
+	) -> Vec<Report<(Rc<dyn Source>, Range<usize>)>> {
 		let query = parser.state().query(&STATE_NAME);
-		let state = match query
-		{
+		let state = match query {
 			Some(state) => state,
-			None => { // Insert as a new state
-				match parser.state_mut().insert(STATE_NAME.clone(), Rc::new(RefCell::new(StyleState::new())))
+			None => {
+				// Insert as a new state
+				match parser
+					.state_mut()
+					.insert(STATE_NAME.clone(), Rc::new(RefCell::new(StyleState::new())))
 				{
 					Err(_) => panic!("Unknown error"),
 					Ok(state) => state,
@@ -160,26 +200,23 @@ impl RegexRule for StyleRule
 			}
 		};
 
-		if let Some(style_state) = state
-			.borrow_mut()
-			.as_any_mut()
-			.downcast_mut::<StyleState>()
-		{
-			style_state.toggled[index] = style_state.toggled[index].clone().map_or(Some(token.clone()), |_| None);
-			parser.push(document, Box::new(
-				Style::new(
+		if let Some(style_state) = state.borrow_mut().as_any_mut().downcast_mut::<StyleState>() {
+			style_state.toggled[index] = style_state.toggled[index]
+				.clone()
+				.map_or(Some(token.clone()), |_| None);
+			parser.push(
+				document,
+				Box::new(Style::new(
 					token.clone(),
 					index,
-					!style_state.toggled[index].is_some()
-				)
-			));
-		}
-		else
-		{
+					!style_state.toggled[index].is_some(),
+				)),
+			);
+		} else {
 			panic!("Invalid state at `{}`", STATE_NAME.as_str());
 		}
 
-		return result;
+		return vec![];
 	}
 
 	// TODO

src/elements/tex.rs

@@ -189,7 +189,7 @@ impl Element for Tex {
 					Tex::format_latex(&fontsize, &preamble, &format!("{prepend}{}", self.tex))
 				};
 
-				let mut result = if let Some(mut con) = compiler.cache() {
+				let result = if let Some(mut con) = compiler.cache() {
 					match latex.cached(&mut con, |s| s.latex_to_svg(&exec, &fontsize)) {
 						Ok(s) => Ok(s),
 						Err(e) => match e {
@@ -253,7 +253,7 @@ impl TexRule {
 					.unwrap(),
 				Regex::new(r"\$(?:\[((?:\\.|[^\\\\])*?)\])?(?:((?:\\.|[^\\\\])*?)\$)?").unwrap(),
 			],
-			properties: PropertyParser::new(props),
+			properties: PropertyParser{ properties: props },
 		}
 	}
 
@@ -387,7 +387,7 @@ impl RegexRule for TexRule {
 					);
 					return reports;
 				}
-				PropertyMapError::NotFoundError(err) => {
+				PropertyMapError::NotFoundError(_) => {
 					if index == 1 {
 						TexKind::Inline
 					} else {

src/main.rs

@@ -199,7 +199,7 @@ fn main() -> ExitCode {
 	let input_meta = match std::fs::metadata(&input) {
 		Ok(meta) => meta,
 		Err(e) => {
-			eprintln!("Unable to get metadata for input: `{input}`");
+			eprintln!("Unable to get metadata for input `{input}`: {e}");
 			return ExitCode::FAILURE;
 		}
 	};
@@ -218,7 +218,7 @@ fn main() -> ExitCode {
 		match std::fs::metadata(&output) {
 			Ok(_) => {}
 			Err(e) => {
-				eprintln!("Unable to get metadata for output: `{output}`");
+				eprintln!("Unable to get metadata for output `{output}`: {e}");
 				return ExitCode::FAILURE;
 			}
 		}
@@ -226,7 +226,7 @@ fn main() -> ExitCode {
 		let output_meta = match std::fs::metadata(&output) {
 			Ok(meta) => meta,
 			Err(e) => {
-				eprintln!("Unable to get metadata for output: `{output}`");
+				eprintln!("Unable to get metadata for output `{output}`: {e}");
 				return ExitCode::FAILURE;
 			}
 		};
@@ -302,7 +302,7 @@ fn main() -> ExitCode {
 					}
 				}
 				Err(e) => {
-					eprintln!("Faield to get metadata for `{entry:#?}`");
+					eprintln!("Faield to get metadata for `{entry:#?}`: {e}");
 					return ExitCode::FAILURE;
 				}
 			}

src/parser/util.rs

@@ -229,13 +229,12 @@ impl<'a> PropertyMap<'a> {
 	}
 }
 
+#[derive(Debug)]
 pub struct PropertyParser {
-	properties: HashMap<String, Property>,
+	pub properties: HashMap<String, Property>,
 }
 
 impl PropertyParser {
-	pub fn new(properties: HashMap<String, Property>) -> Self { Self { properties } }
-
 	/// Attempts to build a default propertymap
 	///
 	/// Returns an error if at least one [`Property`] is required and doesn't provide a default
@@ -271,7 +270,7 @@ impl PropertyParser {
 	/// properties.insert("width".to_string(),
 	/// 	Property::new(true, "Width of the element in em".to_string(), None));
 	///
-	/// let parser = PropertyParser::new(properties);
+	/// let parser = PropertyParser { properties };
 	/// let pm = parser.parse("width=15").unwrap();
 	///
 	/// assert_eq!(pm.get("width", |_, s| s.parse::<i32>()).unwrap().1, 15);
@@ -491,7 +490,7 @@ mod tests {
 			Property::new(false, "Weight in %".to_string(), Some("0.42".to_string())),
 		);
 
-		let parser = PropertyParser::new(properties);
+		let parser = PropertyParser { properties };
 		let pm = parser.parse("width=15,length=-10").unwrap();
 
 		// Ok

style.css

@@ -17,6 +17,24 @@ body {
 	width: 100%;
 }
 
+/* Layouts */
+div.centered {
+	text-align: center;
+}
+
+div.split-container {
+	display: flex;
+	width: 100%;
+}
+
+div.split-container > div.split {
+	flex: 1;
+	flex-shrink: 0;
+	overflow-x: auto;
+
+	margin: 0.5em;
+}
+
 /* Styles */
 em {
 	padding-left: .1em;
@@ -126,11 +144,10 @@ div.code-block-title {
 }
 
 div.code-block-content {
-	max-height: 20em;
+	max-height: 38em;
 	margin-bottom: 0.2em;
-	width: auto;
 
-	overflow: auto;
+	overflow: scroll;
 
 	background-color: #0f141a;
 }
@@ -143,6 +160,7 @@ div.code-block-content td {
 div.code-block-content pre {
 	border: 0;
 	margin: 0;
+	tab-size: 4;
 }
 
 div.code-block-content .code-block-gutter {