Add more fonts

.cargo/config.toml

@@ -1,2 +0,0 @@
-[target.wasm32-unknown-unknown]
-rustflags = ['--cfg', 'getrandom_backend="wasm_js"']

Cargo.lock

@@ -953,11 +953,9 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "73fea8450eea4bac3940448fb7ae50d91f034f941199fcd9d909a5a07aa455f0"
 dependencies = [
  "cfg-if",
- "js-sys",
  "libc",
  "r-efi",
  "wasi 0.14.2+wasi-0.2.4",
- "wasm-bindgen",
 ]
 
 [[package]]
@@ -1352,7 +1350,6 @@ dependencies = [
  "egui_glow 0.31.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "env_logger",
  "eyre",
- "getrandom 0.3.2",
  "half",
  "insta",
  "log",
@@ -1360,7 +1357,6 @@ dependencies = [
  "rfd",
  "serde",
  "wasm-bindgen-futures",
- "web-sys",
  "zerocopy 0.8.25",
 ]
 

Cargo.toml

@@ -30,12 +30,9 @@ base64 = "0.22.1"
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 env_logger = "0.11.8"
-rand = "0.9.1"
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
-getrandom = { version = "0.3", features = ["wasm_js"] }
 wasm-bindgen-futures = "0.4.50"
-web-sys = "0.3.77"
 
 [patch.crates-io]
 egui =   { git = "https://github.com/emilk/egui", rev = "f2ce6424f3a32f47308fb9871d540c01377b2cd9" }

src/app.rs

@@ -2,6 +2,7 @@ use std::{
     fs,
     path::PathBuf,
     sync::{Arc, mpsc},
+    thread,
 };
 
 use crate::{file_editor::FileEditor, preferences::Preferences, util::GuiSender};
@@ -203,10 +204,9 @@ impl eframe::App for App {
                         self.open_tab(Tab::File(file));
                     }
 
-                    #[cfg(not(target_arch = "wasm32"))]
                     if ui.button("Open File").clicked() {
                         let actions_tx = self.actions_tx(ui.ctx());
-                        std::thread::spawn(move || {
+                        thread::spawn(move || {
                             let file = rfd::FileDialog::new().pick_file();
 
                             let Some(file_path) = file else { return };
@@ -263,7 +263,6 @@ impl eframe::App for App {
                         }
                     }
 
-                    #[cfg(not(target_arch = "wasm32"))]
                     if ui
                         .add_enabled(open_file.is_some(), Button::new("Save As"))
                         .clicked()

src/easy_mark/easy_mark_highlighter.rs

@@ -0,0 +1,243 @@
+use egui::text::{CCursorRange, LayoutJob};
+
+use crate::easy_mark::easy_mark_parser;
+
+/// Highlight easymark, memoizing previous output to save CPU.
+///
+/// In practice, the highlighter is fast enough not to need any caching.
+#[derive(Default)]
+pub struct MemoizedHighlighter {
+    style: egui::Style,
+    code: String,
+    output: LayoutJob,
+}
+
+impl MemoizedHighlighter {
+    pub fn highlight(
+        &mut self,
+        egui_style: &egui::Style,
+        code: &str,
+        cursor: Option<CCursorRange>,
+    ) -> LayoutJob {
+        if (&self.style, self.code.as_str()) != (egui_style, code) {
+            self.style = egui_style.clone();
+            code.clone_into(&mut self.code);
+            self.output = highlight_easymark(egui_style, code, cursor);
+        }
+        self.output.clone()
+    }
+}
+
+pub fn highlight_easymark(
+    egui_style: &egui::Style,
+    mut text: &str,
+
+    // TODO: hide special characters where cursor isn't
+    _cursor: Option<CCursorRange>,
+) -> LayoutJob {
+    let mut job = LayoutJob::default();
+    let mut style = easy_mark_parser::Style::default();
+    let mut start_of_line = true;
+
+    const CODE_INDENT: f32 = 10.0;
+
+    while !text.is_empty() {
+        if start_of_line && text.starts_with("```") {
+            let astyle = format_from_style(
+                egui_style,
+                &easy_mark_parser::Style {
+                    code: true,
+                    ..Default::default()
+                },
+            );
+
+            // Render the initial backticks as spaces
+            text = &text[3..];
+            job.append("   ", CODE_INDENT, astyle.clone());
+
+            match text.find("\n```") {
+                Some(n) => {
+                    for line in text[..n + 1].lines() {
+                        job.append(line, CODE_INDENT, astyle.clone());
+                        job.append("\n", 0.0, astyle.clone());
+                    }
+                    // Render the final backticks as spaces
+                    job.append("   ", CODE_INDENT, astyle);
+                    text = &text[n + 4..];
+                }
+                None => {
+                    job.append(text, 0.0, astyle.clone());
+                    text = "";
+                }
+            };
+            style = Default::default();
+            continue;
+        }
+
+        if text.starts_with('`') {
+            style.code = true;
+            let end = text[1..]
+                .find(&['`', '\n'][..])
+                .map_or_else(|| text.len(), |i| i + 2);
+            job.append(&text[..end], 0.0, format_from_style(egui_style, &style));
+            text = &text[end..];
+            style.code = false;
+            continue;
+        }
+
+        let skip;
+
+        // zero-width space
+        let _zws = "\u{200b}";
+
+        let mut apply_basic_style =
+            |text: &mut &str,
+             style: &mut easy_mark_parser::Style,
+             access: fn(&mut easy_mark_parser::Style) -> &mut bool| {
+                let skip = if *access(style) {
+                    // Include the character that is ending this style:
+                    job.append(&text[..1], 0.0, format_from_style(egui_style, style));
+                    *text = &text[1..];
+                    0
+                } else {
+                    1
+                };
+                *access(style) ^= true;
+                skip
+            };
+
+        if text.starts_with('*') {
+            skip = apply_basic_style(&mut text, &mut style, |style| &mut style.strong);
+        } else if text.starts_with('/') {
+            skip = apply_basic_style(&mut text, &mut style, |style| &mut style.italics);
+        } else if text.starts_with('_') {
+            skip = apply_basic_style(&mut text, &mut style, |style| &mut style.underline);
+        } else if text.starts_with('$') {
+            skip = apply_basic_style(&mut text, &mut style, |style| &mut style.small);
+        } else if text.starts_with('~') {
+            skip = apply_basic_style(&mut text, &mut style, |style| &mut style.strikethrough);
+        } else if text.starts_with('^') {
+            skip = apply_basic_style(&mut text, &mut style, |style| &mut style.raised);
+        } else if text.starts_with('\\') && text.len() >= 2 {
+            skip = 2;
+        } else if start_of_line && text.starts_with(' ') {
+            // we don't preview indentation, because it is confusing
+            skip = 1;
+        } else if start_of_line && text.starts_with("###### ") {
+            style.heading = true;
+            skip = 7;
+        } else if start_of_line && text.starts_with("##### ") {
+            style.heading = true;
+            skip = 6;
+        } else if start_of_line && text.starts_with("#### ") {
+            style.heading = true;
+            skip = 5;
+        } else if start_of_line && text.starts_with("### ") {
+            style.heading = true;
+            skip = 4;
+        } else if start_of_line && text.starts_with("## ") {
+            style.heading = true;
+            skip = 3;
+        } else if start_of_line && text.starts_with("# ") {
+            style.heading = true;
+            skip = 2;
+        } else if start_of_line && text.starts_with("> ") {
+            style.quoted = true;
+            skip = 2;
+            // we don't preview indentation, because it is confusing
+        } else if start_of_line && text.trim_start().starts_with("- ") {
+            job.append("• ", 0.0, format_from_style(egui_style, &style));
+            text = &text[2..];
+            skip = 0;
+            // we don't preview indentation, because it is confusing
+        } else {
+            skip = 0;
+        }
+        // Note: we don't preview underline, strikethrough and italics because it confuses things.
+
+        // Swallow everything up to the next special character:
+        let line_end = text[skip..]
+            .find('\n')
+            .map_or_else(|| text.len(), |i| (skip + i + 1));
+        let end = text[skip..]
+            .find(&['*', '`', '~', '_', '/', '$', '^', '\\', '<', '['][..])
+            .map_or_else(|| text.len(), |i| (skip + i).max(1));
+
+        if line_end <= end {
+            job.append(
+                &text[..line_end],
+                0.0,
+                format_from_style(egui_style, &style),
+            );
+            text = &text[line_end..];
+            start_of_line = true;
+            style = Default::default();
+        } else {
+            job.append(&text[..end], 0.0, format_from_style(egui_style, &style));
+            text = &text[end..];
+            start_of_line = false;
+        }
+    }
+
+    job
+}
+
+fn format_from_style(
+    egui_style: &egui::Style,
+    emark_style: &easy_mark_parser::Style,
+) -> egui::text::TextFormat {
+    use egui::{Align, Color32, Stroke, TextStyle};
+
+    let color = if emark_style.strong || emark_style.heading {
+        egui_style.visuals.strong_text_color()
+    } else if emark_style.quoted {
+        egui_style.visuals.weak_text_color()
+    } else {
+        egui_style.visuals.text_color()
+    };
+
+    let text_style = if emark_style.heading {
+        TextStyle::Heading
+    } else if emark_style.code {
+        TextStyle::Monospace
+    } else if emark_style.small | emark_style.raised {
+        TextStyle::Small
+    } else {
+        TextStyle::Body
+    };
+
+    let background = if emark_style.code {
+        egui_style.visuals.code_bg_color
+    } else {
+        Color32::TRANSPARENT
+    };
+
+    let underline = if emark_style.underline {
+        Stroke::new(1.0, color)
+    } else {
+        Stroke::NONE
+    };
+
+    let strikethrough = if emark_style.strikethrough {
+        Stroke::new(1.0, color)
+    } else {
+        Stroke::NONE
+    };
+
+    let valign = if emark_style.raised {
+        Align::TOP
+    } else {
+        Align::BOTTOM
+    };
+
+    egui::text::TextFormat {
+        font_id: text_style.resolve(egui_style),
+        color,
+        background,
+        italics: emark_style.italics,
+        underline,
+        strikethrough,
+        valign,
+        ..Default::default()
+    }
+}

src/easy_mark/easy_mark_parser.rs

@@ -0,0 +1,346 @@
+//! A parser for `EasyMark`: a very simple markup language.
+//!
+//! WARNING: `EasyMark` is subject to change.
+//
+//! # `EasyMark` design goals:
+//! 1. easy to parse
+//! 2. easy to learn
+//! 3. similar to markdown
+
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub enum Item<'a> {
+    /// `\n`
+    // TODO(emilk): add Style here so empty heading still uses up the right amount of space.
+    Newline,
+
+    /// Text
+    Text(Style, &'a str),
+
+    /// title, url
+    Hyperlink(Style, &'a str, &'a str),
+
+    /// leading space before e.g. a [`Self::BulletPoint`].
+    Indentation(usize),
+
+    /// >
+    QuoteIndent,
+
+    /// - a point well made.
+    BulletPoint,
+
+    /// 1. numbered list. The string is the number(s).
+    NumberedPoint(&'a str),
+
+    /// ---
+    Separator,
+
+    /// language, code
+    CodeBlock(&'a str, &'a str),
+}
+
+#[derive(Copy, Clone, Debug, Default, Eq, PartialEq)]
+pub struct Style {
+    /// # heading (large text)
+    pub heading: bool,
+
+    /// > quoted (slightly dimmer color or other font style)
+    pub quoted: bool,
+
+    /// `code` (monospace, some other color)
+    pub code: bool,
+
+    /// self.strong* (emphasized, e.g. bold)
+    pub strong: bool,
+
+    /// _underline_
+    pub underline: bool,
+
+    /// ~strikethrough~
+    pub strikethrough: bool,
+
+    /// /italics/
+    pub italics: bool,
+
+    /// $small$
+    pub small: bool,
+
+    /// ^raised^
+    pub raised: bool,
+}
+
+/// Parser for the `EasyMark` markup language.
+pub struct Parser<'a> {
+    /// The remainder of the input text
+    s: &'a str,
+
+    /// Are we at the start of a line?
+    start_of_line: bool,
+
+    /// Current self.style. Reset after a newline.
+    style: Style,
+}
+
+impl<'a> Parser<'a> {
+    pub fn new(s: &'a str) -> Self {
+        Self {
+            s,
+            start_of_line: true,
+            style: Style::default(),
+        }
+    }
+
+    /// `1. `, `42. ` etc.
+    fn numbered_list(&mut self) -> Option<Item<'a>> {
+        let n_digits = self.s.chars().take_while(|c| c.is_ascii_digit()).count();
+        if n_digits > 0 && self.s.chars().skip(n_digits).take(2).eq(". ".chars()) {
+            let number = &self.s[..n_digits];
+            self.s = &self.s[(n_digits + 2)..];
+            self.start_of_line = false;
+            return Some(Item::NumberedPoint(number));
+        }
+        None
+    }
+
+    // ```{language}\n{code}```
+    fn code_block(&mut self) -> Option<Item<'a>> {
+        if let Some(language_start) = self.s.strip_prefix("```") {
+            if let Some(newline) = language_start.find('\n') {
+                let language = &language_start[..newline];
+                let code_start = &language_start[newline + 1..];
+                if let Some(end) = code_start.find("\n```") {
+                    let code = &code_start[..end].trim();
+                    self.s = &code_start[end + 4..];
+                    self.start_of_line = false;
+                    return Some(Item::CodeBlock(language, code));
+                } else {
+                    self.s = "";
+                    return Some(Item::CodeBlock(language, code_start));
+                }
+            }
+        }
+        None
+    }
+
+    // `code`
+    fn inline_code(&mut self) -> Option<Item<'a>> {
+        if let Some(rest) = self.s.strip_prefix('`') {
+            self.s = rest;
+            self.start_of_line = false;
+            self.style.code = true;
+            let rest_of_line = &self.s[..self.s.find('\n').unwrap_or(self.s.len())];
+            if let Some(end) = rest_of_line.find('`') {
+                let item = Item::Text(self.style, &self.s[..end]);
+                self.s = &self.s[end + 1..];
+                self.style.code = false;
+                return Some(item);
+            } else {
+                let end = rest_of_line.len();
+                let item = Item::Text(self.style, rest_of_line);
+                self.s = &self.s[end..];
+                self.style.code = false;
+                return Some(item);
+            }
+        }
+        None
+    }
+
+    /// `<url>` or `[link](url)`
+    fn url(&mut self) -> Option<Item<'a>> {
+        if self.s.starts_with('<') {
+            let this_line = &self.s[..self.s.find('\n').unwrap_or(self.s.len())];
+            if let Some(url_end) = this_line.find('>') {
+                let url = &self.s[1..url_end];
+                self.s = &self.s[url_end + 1..];
+                self.start_of_line = false;
+                return Some(Item::Hyperlink(self.style, url, url));
+            }
+        }
+
+        // [text](url)
+        if self.s.starts_with('[') {
+            let this_line = &self.s[..self.s.find('\n').unwrap_or(self.s.len())];
+            if let Some(bracket_end) = this_line.find(']') {
+                let text = &this_line[1..bracket_end];
+                if this_line[bracket_end + 1..].starts_with('(') {
+                    if let Some(parens_end) = this_line[bracket_end + 2..].find(')') {
+                        let parens_end = bracket_end + 2 + parens_end;
+                        let url = &self.s[bracket_end + 2..parens_end];
+                        self.s = &self.s[parens_end + 1..];
+                        self.start_of_line = false;
+                        return Some(Item::Hyperlink(self.style, text, url));
+                    }
+                }
+            }
+        }
+        None
+    }
+}
+
+impl<'a> Iterator for Parser<'a> {
+    type Item = Item<'a>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        loop {
+            if self.s.is_empty() {
+                return None;
+            }
+
+            // \n
+            if self.s.starts_with('\n') {
+                self.s = &self.s[1..];
+                self.start_of_line = true;
+                self.style = Style::default();
+                return Some(Item::Newline);
+            }
+
+            // Ignore line break (continue on the same line)
+            if self.s.starts_with("\\\n") && self.s.len() >= 2 {
+                self.s = &self.s[2..];
+                self.start_of_line = false;
+                continue;
+            }
+
+            // \ escape (to show e.g. a backtick)
+            if self.s.starts_with('\\') && self.s.len() >= 2 {
+                let text = &self.s[1..2];
+                self.s = &self.s[2..];
+                self.start_of_line = false;
+                return Some(Item::Text(self.style, text));
+            }
+
+            if self.start_of_line {
+                // leading space (indentation)
+                if self.s.starts_with(' ') {
+                    let length = self.s.find(|c| c != ' ').unwrap_or(self.s.len());
+                    self.s = &self.s[length..];
+                    self.start_of_line = true; // indentation doesn't count
+                    return Some(Item::Indentation(length));
+                }
+
+                // # Heading
+                if let Some(after) = self.s.strip_prefix("# ") {
+                    self.s = after;
+                    self.start_of_line = false;
+                    self.style.heading = true;
+                    continue;
+                }
+
+                // > quote
+                if let Some(after) = self.s.strip_prefix("> ") {
+                    self.s = after;
+                    self.start_of_line = true; // quote indentation doesn't count
+                    self.style.quoted = true;
+                    return Some(Item::QuoteIndent);
+                }
+
+                // - bullet point
+                if self.s.starts_with("- ") {
+                    self.s = &self.s[2..];
+                    self.start_of_line = false;
+                    return Some(Item::BulletPoint);
+                }
+
+                // `1. `, `42. ` etc.
+                if let Some(item) = self.numbered_list() {
+                    return Some(item);
+                }
+
+                // --- separator
+                if let Some(after) = self.s.strip_prefix("---") {
+                    self.s = after.trim_start_matches('-'); // remove extra dashes
+                    self.s = self.s.strip_prefix('\n').unwrap_or(self.s); // remove trailing newline
+                    self.start_of_line = false;
+                    return Some(Item::Separator);
+                }
+
+                // ```{language}\n{code}```
+                if let Some(item) = self.code_block() {
+                    return Some(item);
+                }
+            }
+
+            // `code`
+            if let Some(item) = self.inline_code() {
+                return Some(item);
+            }
+
+            if let Some(rest) = self.s.strip_prefix('*') {
+                self.s = rest;
+                self.start_of_line = false;
+                self.style.strong = !self.style.strong;
+                continue;
+            }
+            if let Some(rest) = self.s.strip_prefix('_') {
+                self.s = rest;
+                self.start_of_line = false;
+                self.style.underline = !self.style.underline;
+                continue;
+            }
+            if let Some(rest) = self.s.strip_prefix('~') {
+                self.s = rest;
+                self.start_of_line = false;
+                self.style.strikethrough = !self.style.strikethrough;
+                continue;
+            }
+            if let Some(rest) = self.s.strip_prefix('/') {
+                self.s = rest;
+                self.start_of_line = false;
+                self.style.italics = !self.style.italics;
+                continue;
+            }
+            if let Some(rest) = self.s.strip_prefix('$') {
+                self.s = rest;
+                self.start_of_line = false;
+                self.style.small = !self.style.small;
+                continue;
+            }
+            if let Some(rest) = self.s.strip_prefix('^') {
+                self.s = rest;
+                self.start_of_line = false;
+                self.style.raised = !self.style.raised;
+                continue;
+            }
+
+            // `<url>` or `[link](url)`
+            if let Some(item) = self.url() {
+                return Some(item);
+            }
+
+            // Swallow everything up to the next special character:
+            let end = self
+                .s
+                .find(&['*', '`', '~', '_', '/', '$', '^', '\\', '<', '[', '\n'][..])
+                .map_or_else(|| self.s.len(), |special| special.max(1));
+
+            let item = Item::Text(self.style, &self.s[..end]);
+            self.s = &self.s[end..];
+            self.start_of_line = false;
+            return Some(item);
+        }
+    }
+}
+
+#[test]
+fn test_easy_mark_parser() {
+    let items: Vec<_> = Parser::new("~strikethrough `code`~").collect();
+    assert_eq!(
+        items,
+        vec![
+            Item::Text(
+                Style {
+                    strikethrough: true,
+                    ..Default::default()
+                },
+                "strikethrough "
+            ),
+            Item::Text(
+                Style {
+                    code: true,
+                    strikethrough: true,
+                    ..Default::default()
+                },
+                "code"
+            ),
+        ]
+    );
+}

src/easy_mark/mod.rs

@@ -0,0 +1,7 @@
+//! Experimental markup language
+
+mod easy_mark_highlighter;
+pub mod easy_mark_parser;
+
+pub use easy_mark_highlighter::{MemoizedHighlighter, highlight_easymark};
+pub use easy_mark_parser as parser;

src/lib.rs

@@ -3,8 +3,8 @@
 pub mod app;
 pub mod constants;
 pub mod custom_code_block;
+pub mod easy_mark;
 pub mod file_editor;
-pub mod markdown;
 pub mod painting;
 pub mod preferences;
 pub mod rasterizer;

src/main.rs

@@ -49,7 +49,7 @@ fn main() {
             .start(
                 canvas,
                 web_options,
-                Box::new(|cc| Ok(Box::new(inkr::App::new(cc)))),
+                Box::new(|cc| Ok(Box::new(eframe_template::TemplateApp::new(cc)))),
             )
             .await;
 

src/markdown/ast.rs

@@ -1,54 +0,0 @@
-use super::span::Span;
-
-#[derive(Copy, Clone, Debug, Eq, PartialEq)]
-pub enum Heading {
-    H1,
-    H2,
-    H3,
-    H4,
-    H5,
-    H6,
-}
-
-#[derive(Copy, Clone, Debug, Default, Eq, PartialEq)]
-pub struct Style {
-    /// # heading (large text)
-    pub heading: Option<Heading>,
-
-    /// > quoted (slightly dimmer color or other font style)
-    pub quoted: bool,
-
-    /// `code` (monospace, some other color)
-    pub code: bool,
-
-    /// self.strong* (emphasized, e.g. bold)
-    pub strong: bool,
-
-    /// _underline_
-    pub underline: bool,
-
-    /// ~strikethrough~
-    pub strikethrough: bool,
-
-    /// /italics/
-    pub italics: bool,
-
-    /// $small$
-    pub small: bool,
-
-    /// ^raised^
-    pub raised: bool,
-}
-
-pub enum MarkdownItem<'a> {
-    Text {
-        span: Span<'a>,
-        style: Style,
-    },
-
-    CodeBlock {
-        all: Span<'a>,
-        language: Span<'a>,
-        code: Span<'a>,
-    },
-}

src/markdown/grammar.lalrpop

@@ -1,10 +0,0 @@
-use std::str::FromStr;
-
-grammar;
-
-pub Term: i32 = {
-    <n:Num> => n,
-    "(" <t:Term> ")" => t,
-};
-
-Num: i32 = <s:r"[0-9]+"> => i32::from_str(s).unwrap();

src/markdown/highlighter.rs

@@ -1,268 +0,0 @@
-use egui::text::{CCursorRange, LayoutJob};
-
-use crate::markdown::{
-    span::Span,
-    tokenizer::{Heading, Token, TokenKind, tokenize},
-};
-
-/// Highlight markdown, caching previous output to save CPU.
-#[derive(Default)]
-pub struct MemoizedHighlighter {
-    style: egui::Style,
-    code: String,
-    output: LayoutJob,
-}
-
-#[derive(Copy, Clone, Debug, Default, Eq, PartialEq)]
-pub struct Style {
-    /// # heading (large text)
-    pub heading: Option<Heading>,
-
-    /// > quoted (slightly dimmer color or other font style)
-    pub quoted: bool,
-
-    /// `code` (monospace, some other color)
-    pub code: bool,
-
-    /// self.strong* (emphasized, e.g. bold)
-    pub strong: bool,
-
-    /// _underline_
-    pub underline: bool,
-
-    /// ~strikethrough~
-    pub strikethrough: bool,
-
-    /// /italics/
-    pub italics: bool,
-
-    /// $small$
-    pub small: bool,
-
-    /// ^raised^
-    pub raised: bool,
-}
-
-impl MemoizedHighlighter {
-    pub fn highlight(
-        &mut self,
-        egui_style: &egui::Style,
-        code: &str,
-        cursor: Option<CCursorRange>,
-    ) -> LayoutJob {
-        if (&self.style, self.code.as_str()) != (egui_style, code) {
-            self.style = egui_style.clone();
-            code.clone_into(&mut self.code);
-            self.output = highlight_markdown(egui_style, code, cursor);
-        }
-        self.output.clone()
-    }
-}
-
-pub fn highlight_markdown(
-    egui_style: &egui::Style,
-    text: &str,
-
-    // TODO: hide special characters where cursor isn't
-    _cursor: Option<CCursorRange>,
-) -> LayoutJob {
-    let mut job = LayoutJob::default();
-    let mut style = Style::default();
-
-    let mut prev = TokenKind::Newline;
-
-    let tokens: Vec<_> = tokenize(text).collect();
-    let mut tokens = &tokens[..];
-
-    const CODE_INDENT: f32 = 10.0;
-
-    while !tokens.is_empty() {
-        let token = tokens.first().unwrap();
-        tokens = &tokens[1..];
-
-        let start_of_line = prev == TokenKind::Newline;
-        prev = token.kind;
-
-        let mut basic_style: Option<fn(&mut Style) -> &mut bool> = None;
-
-        match token.kind {
-            TokenKind::CodeBlock if start_of_line => {
-                let span = collect_until(
-                    token,
-                    &mut tokens,
-                    series([TokenKind::Newline, TokenKind::CodeBlock]),
-                );
-
-                let code_style = format_from_style(
-                    egui_style,
-                    &Style {
-                        code: true,
-                        ..Default::default()
-                    },
-                );
-
-                job.append(&*span, CODE_INDENT, code_style.clone());
-                style = Default::default();
-                continue;
-            }
-
-            TokenKind::Newline => style = Style::default(),
-
-            TokenKind::Strong => basic_style = Some(|s| &mut s.strong),
-            TokenKind::Italic => basic_style = Some(|s| &mut s.italics),
-            TokenKind::Strikethrough => basic_style = Some(|s| &mut s.strikethrough),
-
-            TokenKind::CodeBlock | TokenKind::Mono => {
-                style.code = true;
-                let span = collect_until(
-                    token,
-                    &mut tokens,
-                    any_of([TokenKind::Mono, TokenKind::CodeBlock, TokenKind::Newline]),
-                );
-                job.append(&*span, 0.0, format_from_style(egui_style, &style));
-                style.code = false;
-                continue;
-            }
-
-            // TODO: different heading strengths
-            TokenKind::Heading(h) if start_of_line => style.heading = Some(h),
-            TokenKind::Quote if start_of_line => style.quoted = true,
-
-            // TODO: indented list entries
-            TokenKind::ListEntry if start_of_line => {
-                job.append("• ", 0.0, format_from_style(egui_style, &style));
-                continue;
-            }
-
-            TokenKind::Text
-            // the following tokens are only richly rendered if encountered e.g. at start_of_line.
-            | TokenKind::Indentation
-            | TokenKind::ListEntry
-            | TokenKind::Heading(..)
-            | TokenKind::Quote => {}
-        }
-
-        // if we encountered a marker for Bold, Italic, or Strikethrough, toggle that style and
-        // render the token with the style enabled.
-        if let Some(basic_style) = basic_style {
-            let mut tmp_style = style;
-            *basic_style(&mut tmp_style) = true;
-            *basic_style(&mut style) ^= true; // toggle
-            job.append(&token.span, 0.0, format_from_style(egui_style, &tmp_style));
-            continue;
-        }
-
-        job.append(&token.span, 0.0, format_from_style(egui_style, &style));
-    }
-
-    job
-}
-
-fn series<'a, const N: usize>(of: [TokenKind; N]) -> impl FnMut(&[Token<'a>; N]) -> bool {
-    move |token| {
-        of.iter()
-            .zip(token)
-            .all(|(kind, token)| kind == &token.kind)
-    }
-}
-
-fn any_of<'a, const N: usize>(these: [TokenKind; N]) -> impl FnMut(&[Token<'a>; 1]) -> bool {
-    move |[token]| these.contains(&token.kind)
-}
-
-/// Collect all tokens up to and including `pattern`, and merge them into a signle span.
-///
-/// `N` determines how many specific and consecutive tokens we are looking for.
-/// i.e. if we were looking for a [TokenKind::Newline] followed by a [TokenKind::Quote], `N`
-/// would equal `2`.
-///
-/// `pattern` is a function that accepts an array of `N` tokens and returns `true` if they match,
-/// i.e. if we should stop collecting. [any_of] and [series] can help to construct this function.
-///
-/// The collected tokens will be split off the head of the slice referred to by `tokens`.
-///
-/// # Panic
-/// Panics if `tokens` does not contain only consecutive adjacent spans.
-fn collect_until<'a, const N: usize>(
-    token: &Token<'a>,
-    tokens: &mut &[Token<'a>],
-    pattern: impl FnMut(&[Token<'a>; N]) -> bool,
-) -> Span<'a>
-where
-    for<'b> &'b [Token<'a>; N]: TryFrom<&'b [Token<'a>]>,
-{
-    let mut windows = tokens
-        .windows(N)
-        .map(|slice| <&[Token<'a>; N]>::try_from(slice).ok().unwrap());
-
-    let split_at = match windows.position(pattern) {
-        Some(i) => i + N,
-        None => tokens.len(), // consume everything
-    };
-
-    let (consume, keep) = tokens.split_at(split_at);
-    *tokens = keep;
-
-    consume
-        .iter()
-        .fold(token.span.clone(), |span: Span<'_>, token| {
-            span.try_merge(&token.span).unwrap()
-        })
-}
-
-fn format_from_style(egui_style: &egui::Style, emark_style: &Style) -> egui::text::TextFormat {
-    use egui::{Align, Color32, Stroke, TextStyle};
-
-    let color = if emark_style.strong || emark_style.heading.is_some() {
-        egui_style.visuals.strong_text_color()
-    } else if emark_style.quoted {
-        egui_style.visuals.weak_text_color()
-    } else {
-        egui_style.visuals.text_color()
-    };
-
-    let text_style = if emark_style.heading.is_some() {
-        TextStyle::Heading
-    } else if emark_style.code {
-        TextStyle::Monospace
-    } else if emark_style.small | emark_style.raised {
-        TextStyle::Small
-    } else {
-        TextStyle::Body
-    };
-
-    let background = if emark_style.code {
-        egui_style.visuals.code_bg_color
-    } else {
-        Color32::TRANSPARENT
-    };
-
-    let underline = if emark_style.underline {
-        Stroke::new(1.0, color)
-    } else {
-        Stroke::NONE
-    };
-
-    let strikethrough = if emark_style.strikethrough {
-        Stroke::new(1.0, color)
-    } else {
-        Stroke::NONE
-    };
-
-    let valign = if emark_style.raised {
-        Align::TOP
-    } else {
-        Align::BOTTOM
-    };
-
-    egui::text::TextFormat {
-        font_id: text_style.resolve(egui_style),
-        color,
-        background,
-        italics: emark_style.italics,
-        underline,
-        strikethrough,
-        valign,
-        ..Default::default()
-    }
-}

src/markdown/mod.rs

@@ -1,7 +0,0 @@
-mod highlighter;
-mod span;
-mod tokenizer;
-
-pub use highlighter::*;
-pub use span::*;
-pub use tokenizer::*;

src/markdown/snapshots/inkr__markdown__tokenizer__tests__tokenize.snap

@@ -1,46 +0,0 @@
----
-source: src/markdown/tokenizer.rs
-expression: examples
----
-- string: "just some normal text :D"
-  tokens:
-    - "Token { span: Span(0..24, \"just some normal text :D\"), kind: Text }"
-- string: normal *bold* normal
-  tokens:
-    - "Token { span: Span(0..7, \"normal \"), kind: Text }"
-    - "Token { span: Span(7..8, \"*\"), kind: Strong }"
-    - "Token { span: Span(8..12, \"bold\"), kind: Text }"
-    - "Token { span: Span(12..13, \"*\"), kind: Strong }"
-    - "Token { span: Span(13..20, \" normal\"), kind: Text }"
-- string: normal * maybe bold? * normal
-  tokens:
-    - "Token { span: Span(0..7, \"normal \"), kind: Text }"
-    - "Token { span: Span(7..8, \"*\"), kind: Strong }"
-    - "Token { span: Span(8..21, \" maybe bold? \"), kind: Text }"
-    - "Token { span: Span(21..22, \"*\"), kind: Strong }"
-    - "Token { span: Span(22..29, \" normal\"), kind: Text }"
-- string: "```lang\ncode code code\n```"
-  tokens:
-    - "Token { span: Span(0..3, \"```\"), kind: CodeBlock }"
-    - "Token { span: Span(3..7, \"lang\"), kind: Text }"
-    - "Token { span: Span(7..8, \"\\n\"), kind: Newline }"
-    - "Token { span: Span(8..22, \"code code code\"), kind: Text }"
-    - "Token { span: Span(22..23, \"\\n\"), kind: Newline }"
-    - "Token { span: Span(23..26, \"```\"), kind: CodeBlock }"
-- string: "*/``/*"
-  tokens:
-    - "Token { span: Span(0..1, \"*\"), kind: Strong }"
-    - "Token { span: Span(1..2, \"/\"), kind: Italic }"
-    - "Token { span: Span(2..3, \"`\"), kind: Mono }"
-    - "Token { span: Span(3..4, \"`\"), kind: Mono }"
-    - "Token { span: Span(4..5, \"/\"), kind: Italic }"
-    - "Token { span: Span(5..6, \"*\"), kind: Strong }"
-- string: "*/`*/*/"
-  tokens:
-    - "Token { span: Span(0..1, \"*\"), kind: Strong }"
-    - "Token { span: Span(1..2, \"/\"), kind: Italic }"
-    - "Token { span: Span(2..3, \"`\"), kind: Mono }"
-    - "Token { span: Span(3..4, \"*\"), kind: Strong }"
-    - "Token { span: Span(4..5, \"/\"), kind: Italic }"
-    - "Token { span: Span(5..6, \"*\"), kind: Strong }"
-    - "Token { span: Span(6..7, \"/\"), kind: Italic }"

src/markdown/span.rs

@@ -1,83 +0,0 @@
-use std::{
-    fmt,
-    ops::{Deref, Range},
-};
-
-#[derive(Clone, Eq, PartialEq)]
-pub struct Span<'a> {
-    complete_str: &'a str,
-    range: Range<usize>,
-}
-
-impl<'a> Span<'a> {
-    pub fn new(complete_str: &'a str) -> Self {
-        Self {
-            complete_str,
-            range: 0..complete_str.len(),
-        }
-    }
-
-    pub fn get(&self, slice: Range<usize>) -> Option<Self> {
-        let start = self.range.start.checked_add(slice.start)?;
-        let end = self.range.start.checked_add(slice.end)?;
-
-        if end > self.range.end || end < start {
-            return None;
-        }
-
-        Some(Self {
-            complete_str: self.complete_str,
-            range: Range { start, end },
-        })
-    }
-
-    pub fn complete_str(&self) -> Self {
-        Self::new(self.complete_str)
-    }
-
-    pub fn split_at(&self, i: usize) -> Option<(Self, Self)> {
-        let head = self.get(0..i)?;
-        let tail = self.get(i..self.range.len())?;
-        Some((head, tail))
-    }
-
-    /// Try to merge the spans.
-    ///
-    /// This only works if spans are pointing into the same backing buffer, and are adjacent.
-    pub fn try_merge(&self, other: &Self) -> Option<Self> {
-        if self.complete_str.as_ptr() != other.complete_str.as_ptr() {
-            return None;
-        }
-
-        if self.range.end == other.range.start {
-            Some(Self {
-                range: self.range.start..other.range.end,
-                ..*self
-            })
-        } else if self.range.start == other.range.end {
-            Some(Self {
-                range: other.range.start..self.range.end,
-                ..*self
-            })
-        } else {
-            None
-        }
-    }
-}
-
-impl Deref for Span<'_> {
-    type Target = str;
-
-    fn deref(&self) -> &Self::Target {
-        &self.complete_str[self.range.clone()]
-    }
-}
-
-impl<'a> fmt::Debug for Span<'a> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_tuple("Span")
-            .field(&self.range)
-            .field(&self.deref())
-            .finish()
-    }
-}

src/markdown/tokenizer.rs

@@ -1,156 +0,0 @@
-use std::iter;
-
-use super::span::Span;
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum Heading {
-    H6,
-    H5,
-    H4,
-    H3,
-    H2,
-    H1,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum TokenKind {
-    /// A newline that isn't a codeblock
-    Newline,
-
-    /// "#" to "######"
-    Heading(Heading),
-
-    /// A newline followed by three `
-    CodeBlock,
-
-    Mono,
-    Strong,
-    Italic,
-    Strikethrough,
-
-    /// ">"
-    Quote,
-
-    /// Two spaces
-    Indentation,
-
-    /// "- "
-    ListEntry,
-
-    /// Normal text
-    Text,
-}
-
-const TOKENS: &[(&'static str, TokenKind)] = &[
-    ("\n", TokenKind::Newline),
-    ("######", TokenKind::Heading(Heading::H6)),
-    ("#####", TokenKind::Heading(Heading::H5)),
-    ("####", TokenKind::Heading(Heading::H4)),
-    ("###", TokenKind::Heading(Heading::H3)),
-    ("##", TokenKind::Heading(Heading::H2)),
-    ("#", TokenKind::Heading(Heading::H1)),
-    ("```", TokenKind::CodeBlock),
-    ("`", TokenKind::Mono),
-    ("*", TokenKind::Strong),
-    ("_", TokenKind::Italic),
-    ("~", TokenKind::Strikethrough),
-    (">", TokenKind::Quote),
-    ("  ", TokenKind::Indentation),
-    ("- ", TokenKind::ListEntry),
-];
-
-#[derive(Debug)]
-pub struct Token<'a> {
-    pub span: Span<'a>,
-    pub kind: TokenKind,
-}
-
-pub fn tokenize<'a>(s: &'a str) -> impl Iterator<Item = Token<'a>> {
-    let mut s = Span::new(s);
-    let mut yield_n: usize = 0;
-
-    iter::from_fn(move || {
-        loop {
-            if s.is_empty() {
-                return None;
-            }
-
-            if yield_n == s.len() {
-                let (token, rest) = s.split_at(s.len()).unwrap();
-                let token = Token {
-                    span: token,
-                    kind: TokenKind::Text,
-                };
-                s = rest;
-                return Some(token);
-            }
-
-            let token = TOKENS.iter().find_map(|(token_str, token_kind)| {
-                s[yield_n..]
-                    .starts_with(token_str)
-                    .then(|| (*token_kind, token_str.len()))
-            });
-
-            let Some((kind, len)) = token else {
-                yield_n += s[yield_n..].chars().next().unwrap_or('\0').len_utf8();
-                continue;
-            };
-
-            if yield_n > 0 {
-                let (token, rest) = s.split_at(yield_n).unwrap();
-                let token = Token {
-                    span: token,
-                    kind: TokenKind::Text,
-                };
-                s = rest;
-                yield_n = 0;
-                return Some(token);
-            }
-
-            let (token, rest) = s.split_at(len).unwrap();
-            let token = Token { span: token, kind };
-            s = rest;
-            return Some(token);
-        }
-    })
-}
-
-#[cfg(test)]
-mod tests {
-    use serde::Serialize;
-
-    use super::tokenize;
-
-    #[test]
-    fn test_tokenize() {
-        let examples = [
-            "just some normal text :D",
-            "normal *bold* normal",
-            "normal * maybe bold? * normal",
-            "```lang\ncode code code\n```",
-            "*/``/*",
-            "*/`*/*/",
-        ];
-
-        #[derive(Serialize)]
-        struct Result {
-            pub string: &'static str,
-
-            /// Debug-printed tokens
-            pub tokens: Vec<String>,
-        }
-
-        let examples = examples
-            .into_iter()
-            .map(|string| {
-                let tokens = tokenize(string)
-                    .map(|tokens| format!("{tokens:?}"))
-                    .collect::<Vec<_>>();
-
-                Result { string, tokens }
-            })
-            .collect::<Vec<_>>();
-
-        insta::assert_yaml_snapshot!(examples);
-    }
-}

src/painting.rs

@@ -3,6 +3,7 @@ use std::{
     iter, mem,
     str::FromStr,
     sync::Arc,
+    time::Instant,
 };
 
 use base64::{Engine, prelude::BASE64_STANDARD};
@@ -435,8 +436,7 @@ impl Handwriting {
 
         self.refresh_texture = false;
 
-        #[cfg(not(target_arch = "wasm32"))]
-        let start_time = std::time::Instant::now();
+        let start_time = Instant::now();
 
         let mut tesselator = Tessellator::new(
             mesh_context.pixels_per_point,
@@ -468,12 +468,9 @@ impl Handwriting {
         self.image = rasterize::<StrokeBlendMode>(px_x, px_y, point_to_pixel, triangles);
         texture.set(self.image.clone(), Default::default());
 
-        #[cfg(not(target_arch = "wasm32"))]
-        {
         let elapsed = start_time.elapsed();
         println!("refreshed mesh in {:.3}s", elapsed.as_secs_f32());
     }
-    }
 
     pub fn ui(&mut self, style: &HandwritingStyle, ui: &mut Ui) {
         ui.vertical_centered_justified(|ui| {

src/snapshots/inkr__custom_code_block__test__iter_markdown-2.snap.new

@@ -1,44 +0,0 @@
----
-source: src/custom_code_block.rs
-assertion_line: 133
-expression: list
----
-[
-    Line(
-        "\n",
-    ),
-    Line(
-        "# Hello world\n",
-    ),
-    Line(
-        "## Subheader\n",
-    ),
-    Line(
-        "- 1\n",
-    ),
-    CodeBlock {
-        key: "foo",
-        content: "  whatever\n     some code\n Hi mom!",
-        span: "```foo\n  whatever\n     some code\n Hi mom!\n```",
-    },
-    Line(
-        " \n",
-    ),
-    Line(
-        "\n",
-    ),
-    CodeBlock {
-        key: "` # wrong number of ticks, but that's ok",
-        content: " ``` # indented ticks",
-        span: "```` # wrong number of ticks, but that's ok\n ``` # indented ticks\n```\n",
-    },
-    Line(
-        "\n",
-    ),
-    Line(
-        "``` # no closing ticks\n",
-    ),
-    Line(
-        "            ",
-    ),
-]

src/snapshots/inkr__painting__test__serialized handwriting.snap.new

@@ -1,8 +0,0 @@
----
-source: src/painting.rs
-assertion_line: 695
-expression: serialized
----
-```handwriting
-BQAAvAA8AEIAPABCAEIAPgBAAAAAAAQAAEIAQgC8ADwAAAAAAEIAPA==
-```

src/text_editor.rs

@@ -8,7 +8,7 @@ use egui::{
     Color32, InputState, Key, Modifiers, TextBuffer, TextEdit, Ui, Vec2, text::CCursorRange,
 };
 
-use crate::markdown::MemoizedHighlighter;
+use crate::easy_mark::MemoizedHighlighter;
 
 #[derive(Default, serde::Deserialize, serde::Serialize)]
 pub struct MdTextEdit {
@@ -46,8 +46,8 @@ impl MdTextEdit {
 
         let w = ui.available_width();
 
-        let mut layouter = |ui: &egui::Ui, markdown: &dyn TextBuffer, _wrap_width: f32| {
-            let mut layout_job = highlighter.highlight(ui.style(), markdown.as_str(), *cursor);
+        let mut layouter = |ui: &egui::Ui, easymark: &dyn TextBuffer, _wrap_width: f32| {
+            let mut layout_job = highlighter.highlight(ui.style(), easymark.as_str(), *cursor);
             layout_job.wrap.max_width = w - 10.0;
             ui.fonts(|f| f.layout_job(layout_job))
         };