"),
+ _ => format!("
", class),
+ };
+ self.div_stack.push(class.to_string());
+ format!("{}\n", html)
+ }
+
+ /// Handles the end of an admonition block.
+ ///
+ /// # Returns
+ ///
+ /// A `String` containing the closing HTML div tag for the admonition.
+ fn handle_admonition_end(&mut self) -> String {
+ if self.div_stack.pop().is_some() {
+ "
\n".to_string()
+ } else {
+ String::from(":::\n")
+ }
+ }
+
+ /// Handles the start of a code block.
+ ///
+ /// # Returns
+ ///
+ /// An empty `String` as the code block start is not directly output.
+ fn handle_code_start(&mut self, is_display: bool) -> String {
+ self.eval_stack = true;
+ self.is_rhai_display = is_display;
+ self.contents.clear(); // Clear any previous contents
+ String::new()
+ }
+
+ /// Handles the end of a code block.
+ ///
+ /// # Returns
+ ///
+ /// A `String` containing the evaluated code output wrapped in HTML.
+ fn handle_code_end(&mut self) -> String {
+ if self.eval_stack {
+ self.eval_stack = false;
+ if !self.contents.is_empty() {
+ let code = self.contents.join("\n");
+ let results = Self::process_lambda(&self.rhai_engine, &mut self.rhai_scope, &code);
+ self.contents.clear();
+
+ if self.is_rhai_display {
+ if results.trim().is_empty() {
+ return String::new();
+ } else {
+ format!(
+ "
\n```rust\n{}\n```\n
\n```\n{}\n```\n
\n
\n",
+ code, results
+ )
+ }
+ } else {
+ return String::new();
+ }
+ } else {
+ String::new()
+ }
+ } else {
+ String::new()
+ }
+ }
+
+ /// Handles a regular line of text.
+ ///
+ /// # Arguments
+ ///
+ /// * `line` - A string slice that holds the line to be processed.
+ ///
+ /// # Returns
+ ///
+ /// A `String` containing the processed line.
+ fn handle_regular_line(&mut self, line: &str) -> String {
+ if self.eval_stack {
+ self.contents.push(line.to_string());
+ String::new() // Return an empty string when in eval_stack mode
+ } else {
+ let mut result = String::new();
+ let mut last_end = 0;
+ let mut scope = self.rhai_scope.clone();
+ let engine = &self.rhai_engine;
+
+ for cap in self.lambda_regex.captures_iter(line) {
+ let whole_match = cap.get(0).unwrap();
+ let captured = &cap[1];
+ result.push_str(&line[last_end..whole_match.start()]);
+ result.push_str(&Self::process_lambda(engine, &mut scope, captured));
+ last_end = whole_match.end();
+ }
+ result.push_str(&line[last_end..]);
+
+ // Update the main scope with any changes from the cloned scope
+ self.rhai_scope = scope;
+
+ if result.trim().is_empty() {
+ "\n".to_string() // Always return a newline for empty lines
+ } else {
+ format!("{}\n", result) // Add a newline after each non-empty line
+ }
+ }
+ }
+}