If I get it correctly, for the time being, mitex only works as a WASM module and thus only works on the typst web app, but not for the CLI.

It would be better to provide a CLI program that runs like:

mitex -i foo.tex -o foo.typ

Then we can deal with the typst source with typst-cli.

Another benefit of this is that we can easily build a testset with a bunch of TeX sources, which will largely assure the quality and stability of mitex.

Scanned by script

• [x] \notag
• [x] \brack
• [x] \triangle
• [x] \impliedby
• [x] \LaTeX
• [x] \space
• [x] \lnot
• [x] \mathop
• [x] \vert
• [x] \middle
• [x] \lvert
• [x] \rvert
• [x] \lVert
• [x] \Bbb
• [x] \implies
• [x] \boxed
• [x] \checkmark
• [x] \substack
• [x] \dotsb
• [x] \dbinom
• [x] \*
• [x] \wedge
• [x] \subsetneqq
• [x] \emptyset
• [x] \pod
• [x] \lor
• [x] \cr
• [x] \tag
• [x] \varphi*
• [x] \brace
• [x] \begin{alignedat}

I am genuinely impressed with potential of this project and excited about the possibilities it offers. However, I've encountered a bit of a roadblock. As a new user, I'm unsure about the installation process, as the current README file doesn't include an installation section. This has made it challenging for me to get started with the project.

Could you please consider adding an installation guide to the README?

I copied the example from the README and pasted it to the web app. The code, which is below.

#import "@preview/mitex:0.1.0": *

#assert.eq(mitex-convert("\alpha x"), "alpha  x ")

Write inline equations like #mi("x") or #mi[y].

Also block equations (this case is from #text(blue.lighten(20%), link("https://katex.org/")[katex.org])):

#mitex(`
  \newcommand{\f}[2]{#1f(#2)}
  \f\relax{x} = \int_{-\infty}^\infty
    \f\hat\xi\,e^{2 \pi i \xi x}
    \,d\xi
`)

After trying to compile it I got "Plugin errored with error: error unknown command \f". Am I doing something wrong or is the library in the preview repository doesn't support the feature yet?

Though I prefer to writing documents in pure typst, I need to write several LaTeX documents for formal publications. Typst has delightful future but we have to admit that it cannot be used for writing that documents at least in next few months.

Now, I still want to fully make use of typst, So I want to have a MiTeX which converts at least main body part of TeX code to typst code for me. So that I can preview a LaTeX document locally without help of TeXLive or TeXStudio. I also want to have capability to embed typst content, e.g. cetz pictures into the document, so that I don't have to use tikz.

In conclusion, I feel it useful for partially supporting to convert entire TeX document into typst. With that you can:

• preview a TeX document instantly, without locally installed TeXLive or TeXStudio.
• keep document in TeX format (which is still needed for formal publication).
• export document by typst exporters, then we can share or distribute them informally.

Convert entire document into typst sounds crazy, but we still have a chance. We can support them with some limitation, since we are converting a user document.

• Less TeX Styles: We can show TeX content by typst rules. Therefore, we can throw most styles of a TeX document away, so that we won't touch typesetting things during convertion.
• Less TeX Macros: We can perform calcuation via typst scripting. Therefore, it is also not quite necessary to have a fully supported macros.

Idea follows.

• [x] support text mode.
• [x] convert commonly used text commands.
• partially support context-insensitive \input{chapterN} with help of mitex(read('chapterN.tex')).
• [x] add conditional macros, \iftypst, so that I can make hacks in my TeX document.
  • \iftypst expands only if the document is compiled by typst.
• [x] add limited macro support, e.g. only with context-insensitive \newcommand.
  • so that I can replace some harsh commands with help of binding to typst functions

Not quite hard, no much efforts, but looks perfect for typst users writing TeX documents!

Postscript here. I don't mention more complex things, such as tables, since I plan to do some hacks on them. Personally, I may read and process data by typst scripting, then I either

• render data by tablex.
• or export them via typst query, and use TeX's tables showing data processed by typst.

Currently, Lexer treats a single dollar sign and multiple dollar signs as the same token, so we can't distinguish between an inline equation and a block equation.

https://github.com/mitex-rs/mitex/blob/41a666c4e205549bd27c9a778b2c48b2fc706bdf/crates/mitex-lexer/src/lib.rs#L433-L434

• Add allocation profiling. I have carefully optimized it so it should not have a noticeable footprint.
• Remove setup cost from benchmarks. Previously benchmarks would include the cost of initializing a once_cell::sync::Lazy instance. This reduces benchmarked times by 100-400µs.

Example output:

simple                  fastest       │ slowest       │ median        │ mean          │ samples │ iters
├─ alpha_x_20000        1.975 ms      │ 2.168 ms      │ 1.99 ms       │ 1.995 ms      │ 100     │ 100
│                       alloc:        │               │               │               │         │
│                         12          │ 12            │ 12            │ 12            │         │
│                         960.8 KB    │ 960.8 KB      │ 960.8 KB      │ 960.8 KB      │         │
│                       dealloc:      │               │               │               │         │
│                         5           │ 5             │ 5             │ 5             │         │
│                         1.579 MB    │ 1.579 MB      │ 1.579 MB      │ 1.579 MB      │         │
│                       grow:         │               │               │               │         │
│                         18          │ 18            │ 18            │ 18            │         │
│                         1.578 MB    │ 1.578 MB      │ 1.578 MB      │ 1.578 MB      │         │
├─ alpha_x_20000_heavy  2.02 ms       │ 2.338 ms      │ 2.038 ms      │ 2.047 ms      │ 100     │ 100
│                       alloc:        │               │               │               │         │
│                         12          │ 12            │ 12            │ 12            │         │
│                         960.8 KB    │ 960.8 KB      │ 960.8 KB      │ 960.8 KB      │         │
│                       dealloc:      │               │               │               │         │
│                         5           │ 5             │ 5             │ 5             │         │
│                         1.579 MB    │ 1.579 MB      │ 1.579 MB      │ 1.579 MB      │         │
│                       grow:         │               │               │               │         │
│                         18          │ 18            │ 18            │ 18            │         │
│                         1.578 MB    │ 1.578 MB      │ 1.578 MB      │ 1.578 MB      │         │
├─ alpha_x_40000        4.013 ms      │ 4.396 ms      │ 4.044 ms      │ 4.061 ms      │ 100     │ 100
│                       alloc:        │               │               │               │         │
│                         12          │ 12            │ 12            │ 12            │         │
│                         1.92 MB     │ 1.92 MB       │ 1.92 MB       │ 1.92 MB       │         │
│                       dealloc:      │               │               │               │         │
│                         5           │ 5             │ 5             │ 5             │         │
│                         3.152 MB    │ 3.152 MB      │ 3.152 MB      │ 3.152 MB      │         │
│                       grow:         │               │               │               │         │
│                         19          │ 19            │ 19            │ 19            │         │
│                         3.151 MB    │ 3.151 MB      │ 3.151 MB      │ 3.151 MB      │         │
├─ alpha_x_40000_heavy  4.021 ms      │ 4.307 ms      │ 4.116 ms      │ 4.124 ms      │ 100     │ 100
│                       alloc:        │               │               │               │         │
│                         12          │ 12            │ 12            │ 12            │         │
│                         1.92 MB     │ 1.92 MB       │ 1.92 MB       │ 1.92 MB       │         │
│                       dealloc:      │               │               │               │         │
│                         5           │ 5             │ 5             │ 5             │         │
│                         3.152 MB    │ 3.152 MB      │ 3.152 MB      │ 3.152 MB      │         │
│                       grow:         │               │               │               │         │
│                         19          │ 19            │ 19            │ 19            │         │
│                         3.151 MB    │ 3.151 MB      │ 3.151 MB      │ 3.151 MB      │         │
├─ slice_word           2.275 ms      │ 2.707 ms      │ 2.292 ms      │ 2.299 ms      │ 100     │ 100
│                       alloc:        │               │               │               │         │
│                         12          │ 12            │ 12            │ 12            │         │
│                         960.9 KB    │ 960.9 KB      │ 960.9 KB      │ 960.9 KB      │         │
│                       dealloc:      │               │               │               │         │
│                         5           │ 5             │ 5             │ 5             │         │
│                         1.579 MB    │ 1.579 MB      │ 1.579 MB      │ 1.579 MB      │         │
│                       grow:         │               │               │               │         │
│                         18          │ 18            │ 18            │ 18            │         │
│                         1.578 MB    │ 1.578 MB      │ 1.578 MB      │ 1.578 MB      │         │
╰─ sqrt_pattern         1.598 ms      │ 1.752 ms      │ 1.609 ms      │ 1.615 ms      │ 100     │ 100
                        alloc:        │               │               │               │         │
                          7523        │ 7523          │ 7523          │ 7523          │         │
                          1.021 MB    │ 1.021 MB      │ 1.021 MB      │ 1.021 MB      │         │
                        dealloc:      │               │               │               │         │
                          8           │ 8             │ 8             │ 8             │         │
                          793 KB      │ 793 KB        │ 793 KB        │ 793 KB        │         │
                        grow:         │               │               │               │         │
                          17          │ 17            │ 17            │ 17            │         │
                          792 KB      │ 792 KB        │ 792 KB        │ 792 KB        │         │

• Add cli usage to readme.
• Use new text mode in compile command
• Restrict build constraints for mitex-cli, so that it doesn't always compile by cargo run --bin mitex.
• insert handler definitions in mitex-scope before the transpiled document. They look like:

  #import "@preview/mitex:0.1.0": *
  #let mitexarray = mitex-scope.at("mitexarray", default: none);
  #let mitexbold = mitex-scope.at("mitexbold", default: none);
  #let mitexcal = mitex-scope.at("mitexcal", default: none);
  ...
  

The key code is here

https://github.com/mitex-rs/mitex/blob/ed4a57cbe7ac9a7668ff4fc019a120633c63d76f/crates/mitex-spec-gen/build.rs#L10-L17

Three mode.

• if specified feature prebuilt, get spec by running copy_prebuilt.

• otherwise, if specified feature generate, get spec by running generate.

• otherwise, in default, if users have typst-cli installed, run generate, otherwise run copy_prebuilt.

  if which::which("typst").is_ok() { 
     generate 
  } else { 
    // fallback to prebuilt spec 
    copy_prebuilt 
  }
  

• [x] Basic text mode support, you can use it to write LaTeX drafts.
  • [x] \section, \textbf, \emph.
  • [x] Inline and block math equations.
  • [x] \ref, \eqref and \label.
  • [x] itemize and enumerate environments.

• Use mitex-convert to convert LaTeX code into Typst code in string.
• Use mi to embed an inline LaTeX equation into Typst.
• Use mitex(numbering: none, supplement: auto, ..) to embed a block LaTeX equation into Typst.
• Use mitext to embed a LaTeX text into Typst.

#import "@preview/mitex:0.1.0": *

#mitext(`
  \iftypst
    #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}.

  \begin{equation}
    a^2 + b^2 = c^2 \label{eq:pythagoras}
  \end{equation}
  
  \begin{enumerate}
    \item This is the first item
    \item This is the second item
    \begin{itemize}
      \item This is the first subitem
      \item This is the second subitem
    \end{itemize}
  \end{enumerate}
`)

No plan, but some direction:

• find a way of ignoring all box related commands, so that it just compiles in typst instead of really layout something.
• implement kern commands
• implement glue commands
• implement paragraph commands

Materials and ideas

• See ifdim
• See ifhbox
• See ifvbox
• See ifvoid
• See Box family in TUG.
• See Kern family in TUG.
• See Glue family in TUG.
• See Paragraph family in TUG.

Initial Idea is following.

• The boxes are allocated by converter.
• We may have infinite virtual box registers, since holding limit of 256 is just less meaningful but depends on implementation.
• We won't calculate any size of boxes, but converting them with typst scripting. That means, any failed conversions will just make MiTeX ignore layout request from TeX Code.
• For code converting layout, measure for box and box conditions:

  #locate(loc => layout(size => {
    // converted code here
  }))
  

Examples

Example 1 (paragraph):

\everypar{\setbox\parbox=
\vbox\bgroup\everypar{}%
\def\par{\endgraf\HandleLines
\egroup\box\parbox}}
\def\HandleLines{ ... \lastbox ... }

Example 2 (box):

\newbox\linebox \newbox\snapbox
\def\eatlines{
\setbox\linebox\lastbox % check the last line
\ifvoid\linebox
\else % if it's not empty
\unskip\unpenalty % take whatever is
{\eatlines} % above it;
% collapse the line
\setbox\snapbox\hbox{\unhcopy\linebox}
% depending on the difference
\ifdim\wd\snapbox<.98\wd\linebox
\box\snapbox % take the one or the other,
\else \box\linebox \fi
\fi}