From 5db08cea39d5e8d45e6dab50d4b260e8a8372131 Mon Sep 17 00:00:00 2001
From: OrangeX4 <34951714+OrangeX4@users.noreply.github.com>
Date: Thu, 25 Apr 2024 17:48:43 +0800
Subject: [PATCH] feat(converter): support figure and tabular environments
 (#154)

* dev: clean code

* dev: more convert functions

* dev: update itemcmd

* dev: minor improvements

* test(convert): refactor tests

* dev: add converter.rs

* fix: make ci happy

* dev: add convert_env

* dev: simplify \label for env

* feat: add quote and abstract envs

* dev: support caption for figure

* fix: fix figure env bug

* test: use assert_snapshot

* test: update tests

* fix: make insta test happy

* fix: make ci happy

* fix: fix bug of commands

* feat: add support for \includegraphics

* feat: add convert_env_figure

* feat: support basic tabular

* fix: make ci happy

* feat: support \toprule,
\midrule, and \bottomrule

* dev: merge main branch

* dev: update

* fix: fix bug of glob env

* fix: fix bug of Glob

* fix: add pattern for Glob

* docs: update README
---
 README.md                                 |   1 +
 assets/artifacts                          |   2 +-
 crates/mitex-parser/src/arg_match.rs      |   2 +-
 crates/mitex-parser/tests/ast.rs          |   6 +
 crates/mitex-parser/tests/ast/figure.rs   | 180 ++++++++
 crates/mitex-parser/tests/ast/tabular.rs  |  76 +++
 crates/mitex-spec/src/lib.rs              |  11 +-
 crates/mitex-spec/src/preludes.rs         |  16 +-
 crates/mitex-spec/src/query.rs            |  21 +-
 crates/mitex/src/converter.rs             | 537 ++++++++++++++++++----
 crates/mitex/tests/cvt.rs                 |   9 +
 crates/mitex/tests/cvt/basic_text_mode.rs |  20 +
 crates/mitex/tests/cvt/figure.rs          |  52 +++
 crates/mitex/tests/cvt/simple_env.rs      |  13 +
 crates/mitex/tests/cvt/tabular.rs         |  25 +
 crates/mitex/tests/cvt/trivia.rs          |  12 +-
 packages/mitex/examples/example.typ       |  18 +-
 packages/mitex/specs/latex/standard.typ   |  27 +-
 packages/mitex/specs/prelude.typ          |   9 +
 19 files changed, 921 insertions(+), 116 deletions(-)
 create mode 100644 crates/mitex-parser/tests/ast/figure.rs
 create mode 100644 crates/mitex-parser/tests/ast/tabular.rs
 create mode 100644 crates/mitex/tests/cvt/figure.rs
 create mode 100644 crates/mitex/tests/cvt/simple_env.rs
 create mode 100644 crates/mitex/tests/cvt/tabular.rs

diff --git a/README.md b/README.md
index d89fb98..33bbb15 100644
--- a/README.md
+++ b/README.md
@@ -97,6 +97,7 @@ https://github.com/mitex-rs/mitex/assets/34951714/0ce77a2c-0a7d-445f-b26d-e139f3
   - [x] Inline and block math equations.
   - [x] `\ref`, `\eqref` and `\label`.
   - [x] `itemize` and `enumerate` environments.
+  - [x] `figure`, `table` and `tabular` environments.
 
 ## Features to Implement
 
diff --git a/assets/artifacts b/assets/artifacts
index c6b397d..6dd2b1a 160000
--- a/assets/artifacts
+++ b/assets/artifacts
@@ -1 +1 @@
-Subproject commit c6b397df9ad621920d65fdf740d9e5ce88e8ec92
+Subproject commit 6dd2b1a3f60e511c87e121034136b298109a2277
diff --git a/crates/mitex-parser/src/arg_match.rs b/crates/mitex-parser/src/arg_match.rs
index c5ca313..7496297 100644
--- a/crates/mitex-parser/src/arg_match.rs
+++ b/crates/mitex-parser/src/arg_match.rs
@@ -99,7 +99,7 @@ impl ArgMatcherBuilder {
                 }
             }
             ArgPattern::Greedy => ArgMatcher::Greedy,
-            ArgPattern::Glob(re) => ArgMatcher::Glob {
+            ArgPattern::Glob { pattern: re } => ArgMatcher::Glob {
                 re: re.clone(),
                 prefix: String::new(),
             },
diff --git a/crates/mitex-parser/tests/ast.rs b/crates/mitex-parser/tests/ast.rs
index d8f4e3a..122e4f4 100644
--- a/crates/mitex-parser/tests/ast.rs
+++ b/crates/mitex-parser/tests/ast.rs
@@ -38,6 +38,12 @@ mod ast {
     #[cfg(test)]
     mod trivia;
 
+    #[cfg(test)]
+    mod figure;
+
+    #[cfg(test)]
+    mod tabular;
+
     /// Convenient function to launch/debug a test case
     #[test]
     fn bug_playground() {}
diff --git a/crates/mitex-parser/tests/ast/figure.rs b/crates/mitex-parser/tests/ast/figure.rs
new file mode 100644
index 0000000..f6a5ee1
--- /dev/null
+++ b/crates/mitex-parser/tests/ast/figure.rs
@@ -0,0 +1,180 @@
+use super::prelude::*;
+
+#[test]
+fn figure() {
+    assert_debug_snapshot!(parse(r###"
+    \begin{figure}[ht]
+        \centering
+        \includegraphics[width=0.5\textwidth]{example-image}
+        \caption{This is an example image.}
+        \label{fig:example}
+    \end{figure}
+    "###), @r###"
+    root
+    |br'("\n")
+    |space'("    ")
+    |env
+    ||begin
+    |||sym'("figure")
+    |||args
+    ||||bracket
+    |||||lbracket'("[")
+    |||||text(word'("ht"))
+    |||||rbracket'("]")
+    ||br'("\n")
+    ||space'("        ")
+    ||cmd(cmd-name("\\centering"))
+    ||br'("\n")
+    ||space'("        ")
+    ||cmd
+    |||cmd-name("\\includegraphics")
+    |||args
+    ||||bracket
+    |||||lbracket'("[")
+    |||||text(word'("width=0.5"))
+    |||||cmd(cmd-name("\\textwidth"))
+    |||||rbracket'("]")
+    |||args
+    ||||curly
+    |||||lbrace'("{")
+    |||||text(word'("example-image"))
+    |||||rbrace'("}")
+    ||br'("\n")
+    ||space'("        ")
+    ||cmd
+    |||cmd-name("\\caption")
+    |||args
+    ||||curly
+    |||||lbrace'("{")
+    |||||text(word'("This"),space'(" "),word'("is"),space'(" "),word'("an"),space'(" "),word'("example"),space'(" "),word'("image."))
+    |||||rbrace'("}")
+    ||br'("\n")
+    ||space'("        ")
+    ||cmd
+    |||cmd-name("\\label")
+    |||args
+    ||||curly
+    |||||lbrace'("{")
+    |||||text(word'("fig:example"))
+    |||||rbrace'("}")
+    ||br'("\n")
+    ||space'("    ")
+    ||end(sym'("figure"))
+    |br'("\n")
+    |space'("    ")
+    "###);
+}
+
+#[test]
+fn table() {
+    assert_debug_snapshot!(parse(r###"
+    \begin{table}[ht]
+        \centering
+        \begin{tabular}{|c|c|}
+            \hline
+            \textbf{Name} & \textbf{Age} \\
+            \hline
+            John & 25 \\
+            Jane & 22 \\
+            \hline
+        \end{tabular}
+        \caption{This is an example table.}
+        \label{tab:example}
+    \end{table}
+    "###), @r###"
+    root
+    |br'("\n")
+    |space'("    ")
+    |env
+    ||begin
+    |||sym'("table")
+    |||args
+    ||||bracket
+    |||||lbracket'("[")
+    |||||text(word'("ht"))
+    |||||rbracket'("]")
+    ||br'("\n")
+    ||space'("        ")
+    ||cmd(cmd-name("\\centering"))
+    ||br'("\n")
+    ||space'("        ")
+    ||env
+    |||begin
+    ||||sym'("tabular")
+    ||||args
+    |||||curly
+    ||||||lbrace'("{")
+    ||||||text(word'("|c|c|"))
+    ||||||rbrace'("}")
+    |||br'("\n")
+    |||space'("            ")
+    |||cmd(cmd-name("\\hline"))
+    |||br'("\n")
+    |||space'("            ")
+    |||cmd
+    ||||cmd-name("\\textbf")
+    ||||args
+    |||||curly
+    ||||||lbrace'("{")
+    ||||||text(word'("Name"))
+    ||||||rbrace'("}")
+    |||space'(" ")
+    |||ampersand'("&")
+    |||space'(" ")
+    |||cmd
+    ||||cmd-name("\\textbf")
+    ||||args
+    |||||curly
+    ||||||lbrace'("{")
+    ||||||text(word'("Age"))
+    ||||||rbrace'("}")
+    |||space'(" ")
+    |||newline("\\\\")
+    |||br'("\n")
+    |||space'("            ")
+    |||cmd(cmd-name("\\hline"))
+    |||br'("\n")
+    |||space'("            ")
+    |||text(word'("John"),space'(" "))
+    |||ampersand'("&")
+    |||space'(" ")
+    |||text(word'("25"),space'(" "))
+    |||newline("\\\\")
+    |||br'("\n")
+    |||space'("            ")
+    |||text(word'("Jane"),space'(" "))
+    |||ampersand'("&")
+    |||space'(" ")
+    |||text(word'("22"),space'(" "))
+    |||newline("\\\\")
+    |||br'("\n")
+    |||space'("            ")
+    |||cmd(cmd-name("\\hline"))
+    |||br'("\n")
+    |||space'("        ")
+    |||end(sym'("tabular"))
+    ||br'("\n")
+    ||space'("        ")
+    ||cmd
+    |||cmd-name("\\caption")
+    |||args
+    ||||curly
+    |||||lbrace'("{")
+    |||||text(word'("This"),space'(" "),word'("is"),space'(" "),word'("an"),space'(" "),word'("example"),space'(" "),word'("table."))
+    |||||rbrace'("}")
+    ||br'("\n")
+    ||space'("        ")
+    ||cmd
+    |||cmd-name("\\label")
+    |||args
+    ||||curly
+    |||||lbrace'("{")
+    |||||text(word'("tab:example"))
+    |||||rbrace'("}")
+    ||br'("\n")
+    ||space'("    ")
+    ||end(sym'("table"))
+    |br'("\n")
+    |space'("    ")
+    "###);
+}
diff --git a/crates/mitex-parser/tests/ast/tabular.rs b/crates/mitex-parser/tests/ast/tabular.rs
new file mode 100644
index 0000000..d883818
--- /dev/null
+++ b/crates/mitex-parser/tests/ast/tabular.rs
@@ -0,0 +1,76 @@
+use super::prelude::*;
+
+#[test]
+fn tabular() {
+    assert_debug_snapshot!(parse(r###"
+    \begin{tabular}{|c|c|}
+        \hline
+        \textbf{Name} & \textbf{Age} \\
+        \hline
+        John & 25 \\
+        Jane & 22 \\
+        \hline
+    \end{tabular}
+    "###), @r###"
+    root
+    |br'("\n")
+    |space'("    ")
+    |env
+    ||begin
+    |||sym'("tabular")
+    |||args
+    ||||curly
+    |||||lbrace'("{")
+    |||||text(word'("|c|c|"))
+    |||||rbrace'("}")
+    ||br'("\n")
+    ||space'("        ")
+    ||cmd(cmd-name("\\hline"))
+    ||br'("\n")
+    ||space'("        ")
+    ||cmd
+    |||cmd-name("\\textbf")
+    |||args
+    ||||curly
+    |||||lbrace'("{")
+    |||||text(word'("Name"))
+    |||||rbrace'("}")
+    ||space'(" ")
+    ||ampersand'("&")
+    ||space'(" ")
+    ||cmd
+    |||cmd-name("\\textbf")
+    |||args
+    ||||curly
+    |||||lbrace'("{")
+    |||||text(word'("Age"))
+    |||||rbrace'("}")
+    ||space'(" ")
+    ||newline("\\\\")
+    ||br'("\n")
+    ||space'("        ")
+    ||cmd(cmd-name("\\hline"))
+    ||br'("\n")
+    ||space'("        ")
+    ||text(word'("John"),space'(" "))
+    ||ampersand'("&")
+    ||space'(" ")
+    ||text(word'("25"),space'(" "))
+    ||newline("\\\\")
+    ||br'("\n")
+    ||space'("        ")
+    ||text(word'("Jane"),space'(" "))
+    ||ampersand'("&")
+    ||space'(" ")
+    ||text(word'("22"),space'(" "))
+    ||newline("\\\\")
+    ||br'("\n")
+    ||space'("        ")
+    ||cmd(cmd-name("\\hline"))
+    ||br'("\n")
+    ||space'("    ")
+    ||end(sym'("tabular"))
+    |br'("\n")
+    |space'("    ")
+    "###);
+}
diff --git a/crates/mitex-spec/src/lib.rs b/crates/mitex-spec/src/lib.rs
index d461670..7c28872 100644
--- a/crates/mitex-spec/src/lib.rs
+++ b/crates/mitex-spec/src/lib.rs
@@ -278,7 +278,10 @@ pub enum ArgPattern {
     /// - {,b}: first, it matches a bracket option, e.g. `\sqrt[3]`
     /// - t: it then matches a single term, e.g. `\sqrt[3]{a}` or `\sqrt{a}`
     #[cfg_attr(feature = "serde", serde(rename = "glob"))]
-    Glob(GlobStr),
+    Glob {
+        /// The glob pattern to match the arguments
+        pattern: GlobStr,
+    },
 }
 
 // struct ArgShape(ArgPattern, Direction);
@@ -336,6 +339,12 @@ pub enum ContextFeature {
     /// Parse content like cases
     #[cfg_attr(feature = "serde", serde(rename = "is-cases"))]
     IsCases,
+    /// Parse content like figure
+    #[cfg_attr(feature = "serde", serde(rename = "is-figure"))]
+    IsFigure,
+    /// Parse content like table
+    #[cfg_attr(feature = "serde", serde(rename = "is-table"))]
+    IsTable,
     /// Parse content like itemize
     #[cfg_attr(feature = "serde", serde(rename = "is-itemize"))]
     IsItemize,
diff --git a/crates/mitex-spec/src/preludes.rs b/crates/mitex-spec/src/preludes.rs
index b149230..c1c923d 100644
--- a/crates/mitex-spec/src/preludes.rs
+++ b/crates/mitex-spec/src/preludes.rs
@@ -2,7 +2,7 @@
 #![allow(missing_docs)]
 
 pub mod command {
-    use crate::{ArgShape, CommandSpecItem};
+    use crate::{ArgShape, CommandSpecItem, ContextFeature};
 
     pub fn define_command(len: u8) -> CommandSpecItem {
         CommandSpecItem::Cmd(crate::CmdShape {
@@ -16,12 +16,24 @@ pub mod command {
     pub fn define_glob_command(reg: &str, alias: &str) -> CommandSpecItem {
         CommandSpecItem::Cmd(crate::CmdShape {
             args: crate::ArgShape::Right {
-                pattern: crate::ArgPattern::Glob(reg.into()),
+                pattern: crate::ArgPattern::Glob {
+                    pattern: reg.into(),
+                },
             },
             alias: Some(alias.to_owned()),
         })
     }
 
+    pub fn define_glob_env(reg: &str, alias: &str, ctx_feature: ContextFeature) -> CommandSpecItem {
+        CommandSpecItem::Env(crate::EnvShape {
+            args: crate::ArgPattern::Glob {
+                pattern: reg.into(),
+            },
+            ctx_feature,
+            alias: Some(alias.to_owned()),
+        })
+    }
+
     pub fn define_symbol(alias: &str) -> CommandSpecItem {
         CommandSpecItem::Cmd(crate::CmdShape {
             args: crate::ArgShape::Right {
diff --git a/crates/mitex-spec/src/query.rs b/crates/mitex-spec/src/query.rs
index 131d88f..91cc9df 100644
--- a/crates/mitex-spec/src/query.rs
+++ b/crates/mitex-spec/src/query.rs
@@ -5,7 +5,7 @@ use std::{collections::HashMap, sync::Arc};
 
 use serde::{Deserialize, Serialize};
 
-use crate::{CmdShape, EnvShape};
+use crate::{CmdShape, ContextFeature, EnvShape};
 
 /// A package specification.
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -57,6 +57,16 @@ pub enum CommandSpecItem {
     /// A command that takes no argument and is a normal environment.
     #[serde(rename = "normal-env")]
     EnvNormal,
+    /// A command that has a glob argument pattern and is an environment.
+    #[serde(rename = "glob-env")]
+    EnvGlob {
+        /// The glob pattern of the command.
+        pattern: String,
+        /// The aliasing typst handle of the command.
+        alias: String,
+        /// The context feature of the command.
+        ctx_feature: ContextFeature,
+    },
 
     /// A command that is aliased to a Typst symbol.
     #[serde(rename = "alias-sym")]
@@ -70,15 +80,15 @@ pub enum CommandSpecItem {
         /// The aliasing typst handle of the command.
         alias: String,
     },
-    #[serde(rename = "infix-cmd")]
     /// A command that is an infix operator and is aliased to a Typst handler.
+    #[serde(rename = "infix-cmd")]
     CmdInfix {
         /// The aliasing typst handle of the command.
         alias: String,
     },
-    #[serde(rename = "glob-cmd")]
     /// A command that has a glob argument pattern and is aliased to a Typst
     /// handler.
+    #[serde(rename = "glob-cmd")]
     CmdGlob {
         /// The glob pattern of the command.
         pattern: String,
@@ -100,6 +110,11 @@ impl From<CommandSpecItem> for crate::CommandSpecItem {
             CommandSpecItem::CmdLeft1 => TEX_LEFT1_OPEARTOR,
             CommandSpecItem::EnvMatrix => TEX_MATRIX_ENV,
             CommandSpecItem::EnvNormal => TEX_NORMAL_ENV,
+            CommandSpecItem::EnvGlob {
+                pattern,
+                alias,
+                ctx_feature,
+            } => define_glob_env(&pattern, &alias, ctx_feature),
             CommandSpecItem::SymAlias { alias } => define_symbol(&alias),
             CommandSpecItem::CmdGreedy { alias } => define_greedy_command(&alias),
             CommandSpecItem::CmdInfix { alias } => crate::CommandSpecItem::Cmd(crate::CmdShape {
diff --git a/crates/mitex/src/converter.rs b/crates/mitex/src/converter.rs
index 216a35d..7418cb2 100644
--- a/crates/mitex/src/converter.rs
+++ b/crates/mitex/src/converter.rs
@@ -24,6 +24,8 @@ enum LaTeXEnv {
     #[default]
     // Text mode
     None,
+    Figure,
+    Table,
     Itemize,
     Enumerate,
     // Math mode
@@ -269,105 +271,16 @@ impl Converter {
                     "label" => {
                         self.convert_command_label(f, &cmd)?;
                     }
+                    "includegraphics" => {
+                        self.convert_command_includegraphics(f, &cmd)?;
+                    }
                     _ => {
                         self.convert_normal_command(f, elem, spec)?;
                     }
                 }
             }
             ItemEnv => {
-                let env = EnvItem::cast(elem.as_node().unwrap().clone()).unwrap();
-                let name = env
-                    .name_tok()
-                    .expect("environment name must be non-empty")
-                    .text()
-                    .to_string();
-                let name = name.trim();
-                let args = env.arguments();
-                // todo: handle options
-
-                let env_shape = spec
-                    .get_env(name)
-                    .ok_or_else(|| format!("unknown environment: \\{}", name))?;
-                let typst_name = env_shape.alias.as_deref().unwrap_or(name);
-
-                let env_kind = match env_shape.ctx_feature {
-                    ContextFeature::None => LaTeXEnv::None,
-                    ContextFeature::IsMath => LaTeXEnv::Math,
-                    ContextFeature::IsMatrix => LaTeXEnv::Matrix,
-                    ContextFeature::IsCases => LaTeXEnv::Cases,
-                    ContextFeature::IsItemize => LaTeXEnv::Itemize,
-                    ContextFeature::IsEnumerate => LaTeXEnv::Enumerate,
-                };
-
-                // hack for itemize and enumerate
-                if matches!(env_kind, LaTeXEnv::Itemize | LaTeXEnv::Enumerate) {
-                    let prev = self.enter_env(env_kind);
-
-                    for child in elem.as_node().unwrap().children_with_tokens() {
-                        if matches!(child.kind(), ItemBegin | ItemEnd) {
-                            continue;
-                        }
-
-                        self.convert(f, child, spec)?;
-                    }
-
-                    self.exit_env(prev);
-
-                    return Ok(());
-                }
-
-                // text mode to math mode with $ ... $
-                let is_need_dollar = matches!(self.mode, LaTeXMode::Text)
-                    && !matches!(
-                        env_kind,
-                        LaTeXEnv::None | LaTeXEnv::Itemize | LaTeXEnv::Enumerate
-                    );
-                let prev = self.enter_env(env_kind);
-                let mut prev_mode = LaTeXMode::Text;
-                if is_need_dollar {
-                    f.write_str("$ ")?;
-                    prev_mode = self.enter_mode(LaTeXMode::Math);
-                }
-
-                // environment name
-                f.write_str(typst_name)?;
-                f.write_char('(')?;
-                // named args
-                for (index, arg) in args.enumerate() {
-                    f.write_str(format!("arg{}: ", index).as_str())?;
-                    self.convert(f, rowan::NodeOrToken::Node(arg), spec)?;
-                    f.write_char(',')?;
-                }
-
-                for child in elem.as_node().unwrap().children_with_tokens() {
-                    if matches!(child.kind(), ItemBegin | ItemEnd) {
-                        continue;
-                    }
-
-                    self.convert(f, child, spec)?;
-                }
-
-                f.write_char(')')?;
-
-                self.exit_env(prev);
-
-                if is_need_dollar {
-                    f.write_str(" $")?;
-                    self.exit_mode(prev_mode);
-                }
-
-                // handle label
-                if matches!(
-                    self.env,
-                    LaTeXEnv::None | LaTeXEnv::Itemize | LaTeXEnv::Enumerate
-                ) {
-                    if let Some(label) = self.label.take() {
-                        f.write_char('<')?;
-                        f.write_str(label.as_str())?;
-                        f.write_char('>')?;
-                        self.label = None;
-                    }
-                }
+                self.convert_env(f, elem, spec)?;
             }
             ItemTypstCode => {
                 write!(f, "{}", elem.as_node().unwrap().text())?;
@@ -599,6 +512,80 @@ impl Converter {
         Ok(())
     }
 
+    /// Convert command `\includegraphics[width=0.5\textwidth]{example-image}`
+    fn convert_command_includegraphics(
+        &mut self,
+        f: &mut fmt::Formatter<'_>,
+        cmd: &CmdItem,
+    ) -> Result<(), ConvertError> {
+        let opt_arg = cmd.arguments().find(|arg| {
+            matches!(
+                arg.first_child().unwrap().kind(),
+                LatexSyntaxKind::ItemBracket
+            )
+        });
+        let arg = cmd
+            .arguments()
+            .find(|arg| {
+                matches!(
+                    arg.first_child().unwrap().kind(),
+                    LatexSyntaxKind::ItemCurly
+                )
+            })
+            .expect("\\includegraphics command must have one argument");
+        // remove { and } then trim
+        let body = arg.text().to_string();
+        let body = &body[1..(body.len() - 1)];
+        let body = body.trim();
+        f.write_str("#image(")?;
+        // optional arguments
+        if let Some(opt_arg) = opt_arg {
+            let arg_text = opt_arg.text().to_string();
+            let arg_text = &arg_text[1..(arg_text.len() - 1)];
+            let arg_text = arg_text.trim();
+            // example: \includegraphics[width=0.5\textwidth, height=3cm,
+            // angle=45]{example-image} split by comma and convert
+            // to key-value pairs
+            let args = arg_text.split(',').collect::<Vec<_>>();
+            let args = args
+                .iter()
+                .map(|arg| {
+                    let arg = arg.trim();
+                    let arg = arg.split('=').collect::<Vec<_>>();
+                    let key = arg[0].trim();
+                    let value = if arg.len() == 2 { arg[1].trim() } else { "" };
+                    (key, value)
+                })
+                .collect::<Vec<_>>();
+            for (key, value) in args.iter() {
+                if matches!(key, &"width" | &"height") {
+                    f.write_str(key)?;
+                    f.write_char(':')?;
+                    f.write_char(' ')?;
+                    if value.ends_with("\\textwidth") {
+                        let value = value.trim_end_matches("\\textwidth");
+                        f.write_str(value)?;
+                        f.write_str(" * 100%")?;
+                    } else if value.ends_with("\\textheight") {
+                        let value = value.trim_end_matches("\\textheight");
+                        f.write_str(value)?;
+                        f.write_str(" * 100%")?;
+                    } else {
+                        f.write_str(value)?;
+                    }
+                    f.write_char(',')?;
+                    f.write_char(' ')?;
+                }
+            }
+        }
+        // image path
+        f.write_char('"')?;
+        f.write_str(body)?;
+        f.write_char('"')?;
+        f.write_char(')')?;
+        Ok(())
+    }
+
     /// Convert normal command
     fn convert_normal_command(
         &mut self,
@@ -701,8 +688,8 @@ impl Converter {
                     self.exit_mode(prev_mode);
                     f.write_char(']')?;
                 }
-                f.write_char(';')?;
             }
+            f.write_char(';')?;
         }
 
         // hack for \substack{abc \\ bcd}
@@ -712,6 +699,368 @@ impl Converter {
 
         Ok(())
     }
+
+    /// Convert environments
+    fn convert_env(
+        &mut self,
+        f: &mut fmt::Formatter<'_>,
+        elem: LatexSyntaxElem,
+        spec: &CommandSpec,
+    ) -> Result<(), ConvertError> {
+        let env = EnvItem::cast(elem.as_node().unwrap().clone()).unwrap();
+        let name = env
+            .name_tok()
+            .expect("environment name must be non-empty")
+            .text()
+            .to_string();
+        let name = name.trim();
+        let args = env.arguments();
+
+        let env_shape = spec
+            .get_env(name)
+            .ok_or_else(|| format!("unknown environment: \\{}", name))?;
+        let typst_name = env_shape.alias.as_deref().unwrap_or(name);
+
+        let env_kind = match env_shape.ctx_feature {
+            ContextFeature::None => LaTeXEnv::None,
+            ContextFeature::IsMath => LaTeXEnv::Math,
+            ContextFeature::IsMatrix => LaTeXEnv::Matrix,
+            ContextFeature::IsCases => LaTeXEnv::Cases,
+            ContextFeature::IsFigure => LaTeXEnv::Figure,
+            ContextFeature::IsTable => LaTeXEnv::Table,
+            ContextFeature::IsItemize => LaTeXEnv::Itemize,
+            ContextFeature::IsEnumerate => LaTeXEnv::Enumerate,
+        };
+
+        // hack for itemize and enumerate
+        if matches!(env_kind, LaTeXEnv::Itemize | LaTeXEnv::Enumerate) {
+            let prev = self.enter_env(env_kind);
+
+            for child in elem.as_node().unwrap().children_with_tokens() {
+                if matches!(
+                    child.kind(),
+                    LatexSyntaxKind::ItemBegin | LatexSyntaxKind::ItemEnd
+                ) {
+                    continue;
+                }
+
+                self.convert(f, child, spec)?;
+            }
+
+            self.exit_env(prev);
+
+            return Ok(());
+        }
+
+        // is environment for math
+        let is_math_env = matches!(
+            env_kind,
+            // math environments
+            LaTeXEnv::Math
+                | LaTeXEnv::Matrix
+                | LaTeXEnv::Cases
+                | LaTeXEnv::SubStack
+                | LaTeXEnv::MathCurlyGroup
+        );
+
+        // convert math environments into functions like `mat(a, b; c, d)`
+        if is_math_env {
+            // text mode to math mode with $ ... $
+            let with_dollar = matches!(self.mode, LaTeXMode::Text) && is_math_env;
+            let prev = self.enter_env(env_kind);
+            let prev_mode = self.enter_mode(LaTeXMode::Math);
+            if with_dollar {
+                f.write_str("$ ")?;
+            }
+
+            // environment name
+            f.write_str(typst_name)?;
+
+            f.write_char('(')?;
+            // named args
+            for (index, arg) in args.enumerate() {
+                f.write_str(format!("arg{}: ", index).as_str())?;
+                self.convert(f, rowan::NodeOrToken::Node(arg), spec)?;
+                f.write_char(',')?;
+            }
+
+            for child in elem.as_node().unwrap().children_with_tokens() {
+                // skip \begin and \end commands
+                if matches!(
+                    child.kind(),
+                    LatexSyntaxKind::ItemBegin | LatexSyntaxKind::ItemEnd
+                ) {
+                    continue;
+                }
+                self.convert(f, child, spec)?;
+            }
+
+            f.write_char(')')?;
+
+            self.exit_env(prev);
+
+            if with_dollar {
+                f.write_str(" $")?;
+                self.exit_mode(prev_mode);
+            }
+        } else {
+            // convert text environments
+            // 1. \begin{quote}xxx\end{quote} -> #quote(block: true)[xxx]
+            //    \begin{abstract}xxx\end{abstract} -> #quote(block: true)[xxx]
+            // 2. \begin{figure}xxx\end{figure} -> #figure(image(), caption: [])
+            //    \begin{table}xxx\end{table} -> #figure(table(), caption: [])
+            // 3. \begin{tabular}xxx\end{tabular}
+            // environment name
+            match env_kind {
+                LaTeXEnv::Figure => {
+                    self.convert_env_figure(f, elem, spec, env_kind, typst_name)?;
+                }
+                LaTeXEnv::Table => {
+                    self.convert_env_table(f, elem, spec, env_kind, typst_name)?;
+                }
+                _ => {
+                    // normal environment
+                    let prev = self.enter_env(env_kind);
+                    f.write_char('#')?;
+                    f.write_str(typst_name)?;
+                    f.write_char('[')?;
+                    for child in elem.as_node().unwrap().children_with_tokens() {
+                        // skip \begin and \end commands
+                        if matches!(
+                            child.kind(),
+                            LatexSyntaxKind::ItemBegin | LatexSyntaxKind::ItemEnd
+                        ) {
+                            continue;
+                        }
+                        self.convert(f, child, spec)?;
+                    }
+                    f.write_str("];")?;
+                    self.exit_env(prev);
+                }
+            }
+        }
+
+        // handle label, only add <label> for text mode
+        if matches!(self.mode, LaTeXMode::Text) {
+            if let Some(label) = self.label.take() {
+                f.write_char('<')?;
+                f.write_str(label.as_str())?;
+                f.write_char('>')?;
+                self.label = None;
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Convert figure environment
+    fn convert_env_figure(
+        &mut self,
+        f: &mut fmt::Formatter<'_>,
+        elem: LatexSyntaxElem,
+        spec: &CommandSpec,
+        env_kind: LaTeXEnv,
+        typst_name: &str,
+    ) -> Result<(), ConvertError> {
+        fn is_named_arg(child: &LatexSyntaxElem) -> bool {
+            matches!(
+                child.kind(),
+                LatexSyntaxKind::ItemCmd
+                    if matches!(
+                        CmdItem::cast(child.as_node().unwrap().clone())
+                            .unwrap()
+                            .name_tok()
+                            .unwrap()
+                            .text(),
+                        "\\caption" | "\\centering"
+                    )
+            )
+        }
+        // collect named args
+        let mut caption = None;
+        for child in elem.as_node().unwrap().children_with_tokens() {
+            if is_named_arg(&child) {
+                let cmd = CmdItem::cast(child.as_node().unwrap().clone()).unwrap();
+                let name = cmd.name_tok().unwrap();
+                let name = name.text();
+                // remove prefix \
+                let name = &name[1..];
+                if name == "caption" {
+                    let arg = cmd
+                        .arguments()
+                        .next()
+                        .expect("\\caption command must have one argument");
+                    caption = Some(arg);
+                }
+            }
+        }
+        // convert to #figure
+        let prev = self.enter_env(env_kind);
+        f.write_char('#')?;
+        f.write_str(typst_name)?;
+        f.write_char('(')?;
+        if let Some(caption) = caption {
+            f.write_str("caption: [")?;
+            self.convert(f, caption.into(), spec)?;
+            f.write_str("],")?;
+        }
+        f.write_str(")[")?;
+        for child in elem.as_node().unwrap().children_with_tokens() {
+            // skip \begin and \end commands
+            if matches!(
+                child.kind(),
+                LatexSyntaxKind::ItemBegin | LatexSyntaxKind::ItemEnd
+            ) || matches!(child.kind(), LatexSyntaxKind::ItemCmd) && is_named_arg(&child)
+            {
+                continue;
+            }
+            self.convert(f, child, spec)?;
+        }
+        f.write_str("];")?;
+        self.exit_env(prev);
+
+        Ok(())
+    }
+
+    /// Convert tabular environment
+    fn convert_env_table(
+        &mut self,
+        f: &mut fmt::Formatter<'_>,
+        elem: LatexSyntaxElem,
+        spec: &CommandSpec,
+        env_kind: LaTeXEnv,
+        typst_name: &str,
+    ) -> Result<(), ConvertError> {
+        let env = EnvItem::cast(elem.as_node().unwrap().clone()).unwrap();
+        let arg = env
+            .arguments()
+            .next()
+            .expect("tabular environment must have one argument");
+        let arg = arg.text().to_string();
+        // remove { and } then trim
+        let arg = &arg[1..(arg.len() - 1)];
+        let arg = arg.trim();
+        // split arg to get alignments and vertical lines
+        let mut alignments: Vec<char> = vec![];
+        let mut vlines: Vec<usize> = vec![];
+        let mut index = 0;
+        for ch in arg.chars() {
+            match ch {
+                'l' | 'c' | 'r' => {
+                    alignments.push(ch);
+                    index += 1;
+                }
+                '|' => {
+                    vlines.push(index);
+                }
+                _ => {
+                    // unknown character
+                    Err(format!("unknown alignment: {}", ch))?;
+                }
+            }
+        }
+        // convert to #figure
+        let prev = self.enter_env(env_kind);
+        f.write_char('#')?;
+        f.write_str(typst_name)?;
+        f.write_char('(')?;
+        // stroke: none,
+        f.write_str("stroke: none,\n")?;
+        // columns: 2,
+        f.write_str(format!("columns: {},\n", alignments.len()).as_str())?;
+        // align: (left, center, right, ),
+        f.write_str("align: (")?;
+        for align in alignments {
+            match align {
+                'l' => f.write_str("left, ")?,
+                'c' => f.write_str("center, ")?,
+                'r' => f.write_str("right, ")?,
+                _ => {}
+            }
+        }
+        f.write_str("),\n")?;
+        // table.vline(x: 1),
+        for vline in vlines {
+            f.write_str(format!("table.vline(stroke: .5pt, x: {}), ", vline).as_str())?;
+        }
+        f.write_str("\n")?;
+        let mut exterior = true;
+        for child in elem.as_node().unwrap().children_with_tokens() {
+            // skip \begin and \end commands
+            if matches!(
+                child.kind(),
+                LatexSyntaxKind::ItemBegin | LatexSyntaxKind::ItemEnd
+            ) {
+                continue;
+            }
+            // preprocess if exterior
+            if exterior {
+                match child.kind() {
+                    LatexSyntaxKind::TokenWhiteSpace | LatexSyntaxKind::TokenLineBreak => {}
+                    LatexSyntaxKind::TokenAmpersand => {
+                        // write `[],` for empty exterior when encountering &
+                        f.write_str("[], ")?;
+                    }
+                    LatexSyntaxKind::ItemNewLine => {
+                        // write `[],\n` for empty exterior when encountering //
+                        f.write_str("[],\n")?;
+                    }
+                    LatexSyntaxKind::ItemCmd => {
+                        let cmd_name = CmdItem::cast(child.as_node().unwrap().clone())
+                            .unwrap()
+                            .name_tok()
+                            .unwrap();
+                        let cmd_name = &cmd_name.text()[1..];
+                        match cmd_name {
+                            "hline" => {
+                                f.write_str("table.hline(stroke: .5pt),\n")?;
+                            }
+                            "toprule" => {
+                                f.write_str("table.hline(stroke: 1pt),\n")?;
+                            }
+                            "midrule" => {
+                                f.write_str("table.hline(stroke: .5pt),\n")?;
+                            }
+                            "bottomrule" => {
+                                f.write_str("table.hline(stroke: 1pt),\n")?;
+                            }
+                            _ => {
+                                // enter interior for normal commands
+                                exterior = false;
+                                f.write_char('[')?;
+                            }
+                        }
+                    }
+                    _ => {
+                        // enter interior for normal text
+                        exterior = false;
+                        f.write_char('[')?;
+                    }
+                }
+            }
+            // process if interior
+            if !exterior {
+                match child.kind() {
+                    LatexSyntaxKind::TokenAmpersand => {
+                        // write `[],` when encountering &
+                        f.write_str("], ")?;
+                        exterior = true;
+                    }
+                    LatexSyntaxKind::ItemNewLine => {
+                        // write `[],\n` when encountering //
+                        f.write_str("],\n")?;
+                        exterior = true;
+                    }
+                    _ => {
+                        self.convert(f, child, spec)?;
+                    }
+                }
+            }
+        }
+        f.write_str(");")?;
+        self.exit_env(prev);
+        Ok(())
+    }
 }
 
 struct TypstRepr {
diff --git a/crates/mitex/tests/cvt.rs b/crates/mitex/tests/cvt.rs
index 955c543..7c492d8 100644
--- a/crates/mitex/tests/cvt.rs
+++ b/crates/mitex/tests/cvt.rs
@@ -46,9 +46,18 @@ mod cvt {
     #[cfg(test)]
     mod left_right;
 
+    #[cfg(test)]
+    mod simple_env;
+
     #[cfg(test)]
     mod trivia;
 
+    #[cfg(test)]
+    mod figure;
+
+    #[cfg(test)]
+    mod tabular;
+
     #[cfg(test)]
     mod misc;
     /// Convenient function to launch/debug a test case
diff --git a/crates/mitex/tests/cvt/basic_text_mode.rs b/crates/mitex/tests/cvt/basic_text_mode.rs
index c2cdf74..b3125a2 100644
--- a/crates/mitex/tests/cvt/basic_text_mode.rs
+++ b/crates/mitex/tests/cvt/basic_text_mode.rs
@@ -5,4 +5,24 @@ fn test_convert_text_mode() {
     assert_snapshot!(convert_text(r#"abc"#).unwrap(), @"abc");
     assert_snapshot!(convert_text(r#"\section{Title}"#).unwrap(), @"#heading(level: 1)[Title];");
     assert_snapshot!(convert_text(r#"a \textbf{strong} text"#).unwrap(), @"a #strong[strong]; text");
+    assert_snapshot!(convert_text(r###"\section{Title}
+
+    A \textbf{strong} text, a \emph{emph} text and inline equation $x + y$.
+    
+    Also block \eqref{eq:pythagoras}.
+  
+    \begin{equation}
+      a^2 + b^2 = c^2 \label{eq:pythagoras}
+    \end{equation}"###).unwrap(), @r###"
+
+    #heading(level: 1)[Title];
+
+    A #strong[strong]; text\, a #emph[emph]; text and inline equation #math.equation(block: false, $x  +  y $);.
+
+    Also block #mitexref[eq:pythagoras];.
+
+    $ aligned(
+    a ^(2 ) +  b ^(2 ) =  c ^(2 ) 
+    ) $<eq:pythagoras>
+    "###);
 }
diff --git a/crates/mitex/tests/cvt/figure.rs b/crates/mitex/tests/cvt/figure.rs
new file mode 100644
index 0000000..2fa006b
--- /dev/null
+++ b/crates/mitex/tests/cvt/figure.rs
@@ -0,0 +1,52 @@
+use super::prelude::*;
+
+#[test]
+fn figure() {
+    assert_snapshot!(convert_text(r###"\begin{figure}[ht]
+        \centering
+        \includegraphics[width=0.5\textwidth, height=3cm, angle=45]{example-image.png}
+        \caption{This is an example image.}
+        \label{fig:example}
+    \end{figure}"###).unwrap(), @r###"
+    #figure(caption: [This is an example image.],)[
+
+    #image(width: 0.5 * 100%, height: 3cm, "example-image.png")
+
+
+    ];<fig:example>
+    "###);
+}
+
+#[test]
+fn table() {
+    assert_snapshot!(convert_text(r###"\begin{table}[ht]
+        \centering
+        \begin{tabular}{|c|c|}
+            \hline
+            \textbf{Name} & \textbf{Age} \\
+            \hline
+            John & 25 \\
+            Jane & 22 \\
+            \hline
+        \end{tabular}
+        \caption{This is an example table.}
+        \label{tab:example}
+    \end{table}"###).unwrap(), @r###"
+    #figure(caption: [This is an example table.],)[
+
+    #table(stroke: none,
+    columns: 2,
+    align: (center, center, ),
+    table.vline(stroke: .5pt, x: 0), table.vline(stroke: .5pt, x: 1), table.vline(stroke: .5pt, x: 2), 
+    table.hline(stroke: .5pt),
+    [#strong[Name]; ], [#strong[Age]; ],
+    table.hline(stroke: .5pt),
+    [John ], [25 ],
+    [Jane ], [22 ],
+    table.hline(stroke: .5pt),
+    );
+
+
+    ];<tab:example>
+    "###);
+}
diff --git a/crates/mitex/tests/cvt/simple_env.rs b/crates/mitex/tests/cvt/simple_env.rs
new file mode 100644
index 0000000..4f40323
--- /dev/null
+++ b/crates/mitex/tests/cvt/simple_env.rs
@@ -0,0 +1,13 @@
+use super::prelude::*;
+
+#[test]
+fn quote() {
+    assert_snapshot!(convert_text(r#"\begin{quote}\end{quote}"#).unwrap(), @"#quote(block: true)[];");
+    assert_snapshot!(convert_text(r#"\begin{quote}yes\end{quote}"#).unwrap(), @"#quote(block: true)[yes];");
+}
+
+#[test]
+fn test_abstract() {
+    assert_snapshot!(convert_text(r#"\begin{abstract}\end{abstract}"#).unwrap(), @"#quote(block: true)[];");
+    assert_snapshot!(convert_text(r#"\begin{abstract}yes\end{abstract}"#).unwrap(), @"#quote(block: true)[yes];");
+}
diff --git a/crates/mitex/tests/cvt/tabular.rs b/crates/mitex/tests/cvt/tabular.rs
new file mode 100644
index 0000000..7a47283
--- /dev/null
+++ b/crates/mitex/tests/cvt/tabular.rs
@@ -0,0 +1,25 @@
+use super::prelude::*;
+
+#[test]
+fn tabular() {
+    assert_snapshot!(convert_text(r###"\begin{tabular}{|c|c|}
+        \hline
+        \textbf{Name} & \textbf{Age} \\
+        \hline
+        John & 25 \\
+        Jane & 22 \\
+        \hline
+    \end{tabular}"###).unwrap(), @r###"
+    #table(stroke: none,
+    columns: 2,
+    align: (center, center, ),
+    table.vline(stroke: .5pt, x: 0), table.vline(stroke: .5pt, x: 1), table.vline(stroke: .5pt, x: 2), 
+    table.hline(stroke: .5pt),
+    [#strong[Name]; ], [#strong[Age]; ],
+    table.hline(stroke: .5pt),
+    [John ], [25 ],
+    [Jane ], [22 ],
+    table.hline(stroke: .5pt),
+    );
+    "###);
+}
diff --git a/crates/mitex/tests/cvt/trivia.rs b/crates/mitex/tests/cvt/trivia.rs
index 49f164e..2830c15 100644
--- a/crates/mitex/tests/cvt/trivia.rs
+++ b/crates/mitex/tests/cvt/trivia.rs
@@ -2,18 +2,18 @@ use super::prelude::*;
 
 #[test]
 fn curly_group() {
-    assert_snapshot!(convert_text(r#"a \mathbf{strong} text"#).unwrap(), @"a mitexmathbf[strong]; text");
+    assert_snapshot!(convert_math(r#"a \mathbf{strong} text"#).unwrap(), @"a  mitexmathbf(s t r o n g ) t e x t ");
 }
 
 #[test]
 fn arguments() {
-    assert_snapshot!(convert_text(r#"\frac { 1 } { 2 }"#).unwrap(), @"frac[ 1 ];[ 2 ];");
+    assert_snapshot!(convert_math(r#"\frac { 1 } { 2 }"#).unwrap(), @"frac( 1  , 2  )");
 }
 
 #[test]
 fn greedy_trivia() {
-    assert_snapshot!(convert_text(r#"a {\displaystyle text } b"#).unwrap(), @"a mitexdisplay( text ) b");
-    assert_snapshot!(convert_text(r#"\displaystyle text "#).unwrap(), @"mitexdisplay( text )");
-    assert_snapshot!(convert_text(r#"\displaystyle {text} "#).unwrap(), @"mitexdisplay( text, )");
-    assert_snapshot!(convert_text(r#"\displaystyle {\mathrm {text}} "#).unwrap(), @"mitexdisplay( upright[text];, )");
+    assert_snapshot!(convert_math(r#"a {\displaystyle text } b"#).unwrap(), @"a  mitexdisplay( t e x t  ) b ");
+    assert_snapshot!(convert_math(r#"\displaystyle text "#).unwrap(), @"mitexdisplay( t e x t  )");
+    assert_snapshot!(convert_math(r#"\displaystyle {text} "#).unwrap(), @"mitexdisplay( t e x t , )");
+    assert_snapshot!(convert_math(r#"\displaystyle {\mathrm {text}} "#).unwrap(), @"mitexdisplay( upright(t e x t ), )");
 }
diff --git a/packages/mitex/examples/example.typ b/packages/mitex/examples/example.typ
index 18f0124..021eda3 100644
--- a/packages/mitex/examples/example.typ
+++ b/packages/mitex/examples/example.typ
@@ -19,16 +19,30 @@ We also support text mode (in development):
 
 #mitext(`
   \iftypst
-    #set math.equation(numbering: "(1)", supplement: "equation")
+    #set math.equation(numbering: "(1)", supplement: "Equation")
   \fi
 
   \section{Title}
 
   A \textbf{strong} text, a \emph{emph} text and inline equation $x + y$.
   
-  Also block \eqref{eq:pythagoras}.
+  Also block \eqref{eq:pythagoras} and \ref{tab:example}.
 
   \begin{equation}
     a^2 + b^2 = c^2 \label{eq:pythagoras}
   \end{equation}
+
+  \begin{table}[ht]
+      \centering
+      \begin{tabular}{|c|c|}
+          \hline
+          \textbf{Name} & \textbf{Age} \\
+          \hline
+          John & 25 \\
+          Jane & 22 \\
+          \hline
+      \end{tabular}
+      \caption{This is an example table.}
+      \label{tab:example}
+  \end{table}
 `)
diff --git a/packages/mitex/specs/latex/standard.typ b/packages/mitex/specs/latex/standard.typ
index 68254c1..a31cdfd 100644
--- a/packages/mitex/specs/latex/standard.typ
+++ b/packages/mitex/specs/latex/standard.typ
@@ -41,7 +41,7 @@
 #let limits-handle(alias, wrap) = define-cmd(1, alias: alias, handle: (it) => math.limits(wrap(it)))
 #let matrix-handle(delim: none, handle: none) = define-env(none, kind: "is-matrix", alias: none, handle: math.mat.with(delim: delim))
 #let call-or-ignore(fn) = (..args) => if args.pos().len() > 0 { fn(..args) } else { math.zws }
-#let ignore-me = it => {}
+#let ignore-me = (..args) => {}
 #let ignore-sym = define-sym("")
 
 // 2. Standard package definitions, generate specs and scopes,
@@ -54,13 +54,30 @@
   footnote: define-cmd(1, alias: "#footnote"),
   cite: define-cmd(1, alias: "#mitexcite", handle: it => cite(label(get-tex-str(it)))),
   emph: define-cmd(1, alias: "#emph"),
-  item: ignore-sym,
-  itemize: define-env(none, kind: "is-itemize"),
-  enumerate: define-env(none, kind: "is-enumerate"),
   label: define-cmd(1, alias: "mitexlabel", handle: ignore-me),
   tag: define-cmd(1, alias: "mitexlabel", handle: ignore-me),
   ref: define-cmd(1, alias: "#mitexref", handle: it => ref(label(get-tex-str(it)))),
   eqref: define-cmd(1, alias: "#mitexref"),
+  item: ignore-sym,
+  // environments for text mode
+  itemize: define-env(none, kind: "is-itemize"),
+  enumerate: define-env(none, kind: "is-enumerate"),
+  quote: define-env(none, alias: "quote(block: true)"),
+  abstract: define-env(none, alias: "quote(block: true)"),
+  figure: define-glob-env("{,b}", kind: "is-figure", alias: "figure"),
+  table: define-glob-env("{,b}", kind: "is-figure", alias: "figure"),
+  tabular: define-env(1, kind: "is-table", alias: "table"),
+  // commands for figure
+  centering: ignore-sym,
+  textwidth: sym,
+  caption: define-cmd(1, alias: "mitexcaption", handle: ignore-me),
+  includegraphics: define-glob-cmd("{,b}t", "#miteximage", handle: ignore-me),
+  // commands for tabular
+  toprule: define-glob-cmd("{,b}", "toprule"),
+  midrule: define-glob-cmd("{,b}", "midrule"),
+  bottomrule: define-glob-cmd("{,b}", "bottomrule"),
+  hline: ignore-sym,
+  vline: ignore-sym,
   // Spaces: \! \, \> \: \; \ \quad \qquad
   "!": define-sym("negthinspace", sym: h(-(3/18) * 1em)),
   negthinspace: of-sym(h(-(3/18) * 1em)),
@@ -1002,8 +1019,6 @@
   relax: ignore-sym,
   cr: ignore-sym,
   expandafter: ignore-sym,
-  hline: ignore-sym,
-  vline: ignore-sym,
   hskip: ignore-sym,
   mskip: ignore-sym,
   kern: ignore-sym,
diff --git a/packages/mitex/specs/prelude.typ b/packages/mitex/specs/prelude.typ
index 5a9e04a..7488285 100644
--- a/packages/mitex/specs/prelude.typ
+++ b/packages/mitex/specs/prelude.typ
@@ -107,6 +107,15 @@
   ), if handle != none { (alias: alias, handle: handle) } else { none })
 }
 
+#let define-glob-env(pat, kind: "none", alias: none, handle: none) = {
+  ((
+    kind: "glob-env",
+    pattern: pat,
+    ctx_feature: ( kind: kind ),
+    alias: alias,
+  ), if handle != none { (alias: alias, handle: handle) } else { none })
+}
+
 /// Define a symbol without alias and without handler function, like \alpha => alpha
 /// 
 /// Return: A spec item and no scope item (none for no scope item)