use anyhow::Result;use mdbook::book::{Book, BookItem};use mdbook::errors::Error;use mdbook::preprocess::{Preprocessor, PreprocessorContext as MdBookContext};use settings::KeymapFile;use std::sync::Arc;use util::asset_str; mod templates; use templates::{ActionTemplate, KeybindingTemplate, Template}; pub struct PreprocessorContext {    macos_keymap: Arc<KeymapFile>,    linux_keymap: Arc<KeymapFile>,} impl PreprocessorContext {    pub fn new() -> Result<Self> {        let macos_keymap = Arc::new(load_keymap("keymaps/default-macos.json")?);        let linux_keymap = Arc::new(load_keymap("keymaps/default-linux.json")?);        Ok(Self {            macos_keymap,            linux_keymap,        })    }     pub fn find_binding(&self, os: &str, action: &str) -> Option<String> {        let keymap = match os {            "macos" => &self.macos_keymap,            "linux" => &self.linux_keymap,            _ => return None,        };         // Find the binding in reverse order, as the last binding takes precedence.        keymap.sections().rev().find_map(|section| {            section.bindings().rev().find_map(|(keystroke, a)| {                if a.to_string() == action {                    Some(keystroke.to_string())                } else {                    None                }            })        })    }} fn load_keymap(asset_path: &str) -> Result<KeymapFile> {    let content = asset_str::<settings::SettingsAssets>(asset_path);    KeymapFile::parse(content.as_ref())} pub struct ZedDocsPreprocessor {    context: PreprocessorContext,    templates: Vec<Box<dyn Template>>,} impl ZedDocsPreprocessor {    pub fn new() -> Result<Self> {        let context = PreprocessorContext::new()?;        let templates: Vec<Box<dyn Template>> = vec![            Box::new(KeybindingTemplate::new()),            Box::new(ActionTemplate::new()),        ];        Ok(Self { context, templates })    }     fn process_content(&self, content: &str) -> String {        let mut processed = content.to_string();        for template in &self.templates {            processed = template.process(&self.context, &processed);        }        processed    }} impl Preprocessor for ZedDocsPreprocessor {    fn name(&self) -> &str {        "zed-docs-preprocessor"    }     fn run(&self, _ctx: &MdBookContext, mut book: Book) -> Result<Book, Error> {        book.for_each_mut(|item| {            if let BookItem::Chapter(chapter) = item {                chapter.content = self.process_content(&chapter.content);            }        });        Ok(book)    }     fn supports_renderer(&self, renderer: &str) -> bool {        renderer != "not-supported"    }}