katex - Rust bindings to KaTeX

katex-rs This crate offers Rust bindings to KaTeX. This allows you to render LaTeX equations to HTML. Documentation https://docs.rs/katex Usage Add th

Information

Category: Rust / Math
Watchers: 2
Star: 60
Fork: 6
Last update: May 13, 2022

Resource links

https://docs.rs/katex

https://github.com/xu-cheng/katex-rs

katex-rs

This crate offers Rust bindings to KaTeX. This allows you to render LaTeX equations to HTML.

Documentation

https://docs.rs/katex

Usage

Add this to your Cargo.toml:

[dependencies]
katex = "0.2"

Examples

let html = katex::render("E = mc^2").unwrap();

let opts = katex::Opts::builder().display_mode(true).build().unwrap();
let html_in_display_mode = katex::render_with_opts("E = mc^2", opts).unwrap();

License

^{Licensed under either of Apache License, Version 2.0 or MIT license at your option.}
_{Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in this crate by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.}

1 Open More issues

Closed

Failed to build libquickjs on Windows

   Compiling libquickjs-sys v0.4.0
error: failed to run custom build command for `libquickjs-sys v0.4.0`

Caused by:
  process didn't exit successfully: `D:\Rust\katex-rs\target\debug\build\libquickjs-sys-41555e9664b161d9\build-script-build` (exit code: 101)
--- stderr
Applying patches...
Applying "js-tobigint64-overflow.patch"...
thread 'main' panicked at 'Could not apply patches: Os { code: 2, kind: NotFound, message: "The system cannot find the file specified." }', C:\Users\Aster\.cargo\registry\src\github.com-1ecc6299db9ec823\libquickjs-sys-0.4.0\build.rs:100:22
stack backtrace:
   0: backtrace::backtrace::trace_unsynchronized
             at C:\Users\VssAdministrator\.cargo\registry\src\github.com-1ecc6299db9ec823\backtrace-0.3.44\src\backtrace\mod.rs:66
   1: std::sys_common::backtrace::_print_fmt
             at /rustc/433aae93e4ef866a1fdfefad136b32ed89acd3e7\/src\libstd\sys_common\backtrace.rs:78
   2: std::sys_common::backtrace::_print::{{impl}}::fmt
             at /rustc/433aae93e4ef866a1fdfefad136b32ed89acd3e7\/src\libstd\sys_common\backtrace.rs:59
   3: core::fmt::write
             at /rustc/433aae93e4ef866a1fdfefad136b32ed89acd3e7\/src\libcore\fmt\mod.rs:1052
   4: std::io::Write::write_fmt<std::sys::windows::stdio::Stderr>
             at /rustc/433aae93e4ef866a1fdfefad136b32ed89acd3e7\/src\libstd\io\mod.rs:1428
   5: std::sys_common::backtrace::_print
             at /rustc/433aae93e4ef866a1fdfefad136b32ed89acd3e7\/src\libstd\sys_common\backtrace.rs:62
   6: std::sys_common::backtrace::print
             at /rustc/433aae93e4ef866a1fdfefad136b32ed89acd3e7\/src\libstd\sys_common\backtrace.rs:49
   7: std::panicking::default_hook::{{closure}}
             at /rustc/433aae93e4ef866a1fdfefad136b32ed89acd3e7\/src\libstd\panicking.rs:204
   8: std::panicking::default_hook
             at /rustc/433aae93e4ef866a1fdfefad136b32ed89acd3e7\/src\libstd\panicking.rs:224
   9: std::panicking::rust_panic_with_hook
             at /rustc/433aae93e4ef866a1fdfefad136b32ed89acd3e7\/src\libstd\panicking.rs:470
  10: std::panicking::begin_panic_handler
             at /rustc/433aae93e4ef866a1fdfefad136b32ed89acd3e7\/src\libstd\panicking.rs:378
  11: core::panicking::panic_fmt
             at /rustc/433aae93e4ef866a1fdfefad136b32ed89acd3e7\/src\libcore\panicking.rs:85
  12: core::option::expect_none_failed
             at /rustc/433aae93e4ef866a1fdfefad136b32ed89acd3e7\/src\libcore\option.rs:1211
  13: core::result::Result<std::process::Child, std::io::error::Error>::expect<std::process::Child,std::io::error::Error>
             at /rustc/433aae93e4ef866a1fdfefad136b32ed89acd3e7\src\libcore\result.rs:961
  14: build_script_build::apply_patches
             at .\build.rs:100
  15: build_script_build::main
             at .\build.rs:70
  16: std::rt::lang_start::{{closure}}<()>
             at /rustc/433aae93e4ef866a1fdfefad136b32ed89acd3e7\src\libstd\rt.rs:67
  17: std::rt::lang_start_internal::{{closure}}
             at /rustc/433aae93e4ef866a1fdfefad136b32ed89acd3e7\/src\libstd\rt.rs:52
  18: std::panicking::try::do_call<closure-0,i32>
             at /rustc/433aae93e4ef866a1fdfefad136b32ed89acd3e7\/src\libstd\panicking.rs:303
  19: panic_unwind::__rust_maybe_catch_panic
             at /rustc/433aae93e4ef866a1fdfefad136b32ed89acd3e7\/src\libpanic_unwind\lib.rs:86
  20: std::panicking::try
             at /rustc/433aae93e4ef866a1fdfefad136b32ed89acd3e7\/src\libstd\panicking.rs:281
  21: std::panic::catch_unwind
             at /rustc/433aae93e4ef866a1fdfefad136b32ed89acd3e7\/src\libstd\panic.rs:394
  22: std::rt::lang_start_internal
             at /rustc/433aae93e4ef866a1fdfefad136b32ed89acd3e7\/src\libstd\rt.rs:51
  23: std::rt::lang_start<()>
             at /rustc/433aae93e4ef866a1fdfefad136b32ed89acd3e7\src\libstd\rt.rs:67
  24: main
  25: invoke_main
             at d:\agent\_work\3\s\src\vctools\crt\vcstartup\src\startup\exe_common.inl:78
  26: __scrt_common_main_seh
             at d:\agent\_work\3\s\src\vctools\crt\vcstartup\src\startup\exe_common.inl:288
  27: BaseThreadInitThunk
  28: RtlUserThreadStart
note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace.


Process finished with exit code 101

upstream

opened Feb 16, 2020 by oovm 5

Closed

add duktabe JS engine

duktabe is nice because it is way smaller than quickJS and probably easier to build on Windows & Co.

We probably should still figure out how features should work and how to wire this thing up into the CI.

TBH I had a bit of trouble making this work w/ the current engine abstraction layer, since it assumes that values are freestanding and not bound to the engine in any way which I don't believe is true for any engine (e.g. you cannot create one engine, get some complex value out of it and use it in a second engine). Also creating values out of thin air (aka w/o having an engine running) is kinda a problem (hence the dual representation of the value and the lazy conversation from Rust to ducc).

BTW: I've named the feature after the engine, not after the binding crate because I found it unlikely that we would ever support multiple bindings for the same engine and our users most likely don't care which binding crate we use.

Ref #6.

opened Sep 3, 2021 by crepererum 4

Closed

feat: add support for chemical equations (\ce) by contrib/mhchem.min.js

opened Dec 1, 2020 by srevinsaju 3

Closed

Unable to use katex Opts when trait Sync is required

First of all, thanks for this great crate.

I am encountering an error when using this where Sync is also required.

Detailed stacktrace:

| impl ParseBlock for EquationBlock {
|      ^^^^^^^^^^ `(dyn for<'r> std::ops::Fn(katex::TrustContext<'r>) -> bool + std::panic::RefUnwindSafe + 'static)` cannot be sent between threads safely
| 
::: ~/.cargo/registry/src/github.com-1ecc6299db9ec823/liquid-core-0.21.2/src/parser/block.rs:32:30
|
32 | pub trait ParseBlock: Send + Sync + ParseBlockClone {
|                              ---- required by this bound in `liquid_core::parser::block::ParseBlock`
|
= help: the trait `std::marker::Send` is not implemented for `(dyn for<'r> std::ops::Fn(katex::TrustContext<'r>) -> bool + std::panic::RefUnwindSafe + 'static)`
= note: required because of the requirements on the impl of `std::marker::Sync` for `std::sync::Arc<(dyn for<'r> std::ops::Fn(katex::TrustContext<'r>) -> bool + std::panic::RefUnwindSafe + 'static)>`
= note: required because it appears within the type `katex::TrustCallback`
= note: required because it appears within the type `std::option::Option<katex::TrustCallback>`
= note: required because it appears within the type `katex::Opts`
= note: required because it appears within the type `equation_block::EquationBlock`

error[E0277]: `(dyn for<'r> std::ops::Fn(katex::TrustContext<'r>) -> bool + std::panic::RefUnwindSafe + 'static)` cannot be shared between threads safely
--> src/equation_block.rs:56:6
|
56 | impl ParseBlock for EquationBlock {
|      ^^^^^^^^^^ `(dyn for<'r> std::ops::Fn(katex::TrustContext<'r>) -> bool + std::panic::RefUnwindSafe + 'static)` cannot be shared between threads safely
|
::: ~/.cargo/registry/src/github.com-1ecc6299db9ec823/liquid-core-0.21.2/src/parser/block.rs:32:30
|
32 | pub trait ParseBlock: Send + Sync + ParseBlockClone {
|                              ---- required by this bound in `liquid_core::parser::block::ParseBlock`
|
= help: the trait `std::marker::Sync` is not implemented for `(dyn for<'r> std::ops::Fn(katex::TrustContext<'r>) -> bool + std::panic::RefUnwindSafe + 'static)`
= note: required because of the requirements on the impl of `std::marker::Sync` for `std::sync::Arc<(dyn for<'r> std::ops::Fn(katex::TrustContext<'r>) -> bool + std::panic::RefUnwindSafe + 'static)>`
= note: required because it appears within the type `katex::TrustCallback`
= note: required because it appears within the type `std::option::Option<katex::TrustCallback>`

opened Mar 14, 2021 by deep110 2

Closed

Update quickjs-rs version

This PR updates quickjs-rs in order to import the fix for https://github.com/theduke/quickjs-rs/issues/93

Thanks in advance for your review! :)

opened Feb 4, 2021 by Luni-4 2

Closed

Pass macros / Opts as references

Hello,

Since the OptsBuilder takes ownership of the macros hashmap, the hashmap needs to be cloned every time a new equation is rendered.

I think it is a common use case to render multiple equations with the same set of macros / with the same opts. Wouldn't it be more convenient / faster to pass the macros as a &HashMap reference?

Or, maybe even better, to pass an &Opts reference to render_with_ops?

Right now I have to clone macros and create a new Opts object every time I render a new equation. It looks like this

for item in items_to_render {
    let cloned_macros = macros.clone();
    let ops = katex::Opts::builder()
         .display_mode(display)
         .output_type(katex::OutputType::Html)
         .macros(cloned_macros)
         .build()
         .unwrap();
    let result = katex::render_with_opts(&item, ops);
    ...
}

Which could be replaced by

let ops = katex::Opts::builder()
    .display_mode(display)
    .output_type(katex::OutputType::Html)
    .macros(macros)
    .build()
    .unwrap();
for item in items_to_render {
    let result = katex::render_with_opts(&item, &ops);
    ...
}

Let me know if I'm missing something!

opened Nov 19, 2020 by lzanini 1

Open

Investigate Alternative JS Engine

This crate requires an embedded JS engine to execute katex. Currently, this is done using quickjs and its rust binding. However, it has certain shortages:

No support on native windows using MSVC. (https://github.com/theduke/quickjs-rs/issues/72)
No support on WASM environment. (https://github.com/theduke/quickjs-rs/issues/73)
The development activity of quickjs is low.

As such, we may want to find an alternative JS engine. Since this crate never exposes the types from the underlying JS engine, changing it will not create any breaking changes. Ideally, the alternatives need supporting all the current used features, addressing the above problems, being small to be embedded, and being well maintained.

Some candidates:

boa, a JS engine written in pure Rust. But currently, it is experimental with many basic JS features not being implemented.
rusty_v8, Rust bindings to V8 engine. This engine may be too big to be embedded.
rust-mozjs, JS engine from servo. It doesn’t seem to be well maintained. Its crate hasn’t been updated for 2 years.

help wanted

opened Feb 5, 2021 by xu-cheng 13

0.4.4(May 7, 2022)

Update KaTeX to 0.15.3.
Use named feature in Cargo.toml.

Source code(tar.gz)
Source code(zip)

0.4.3(Jan 13, 2022)

Update KaTeX to 0.15.2.

Source code(tar.gz)
Source code(zip)

0.4.2(Nov 1, 2021)

Update KaTeX to 0.15.1.

Source code(tar.gz)
Source code(zip)

0.4.1(Sep 6, 2021)

Support Node.js in wasm-js backend.

Source code(tar.gz)
Source code(zip)

0.4.0(Sep 5, 2021)

Update KaTeX to 0.13.18.
Support multiple JS backends. You can choose appropriate backend based on your environment.
- quick-js: Enable by default. Use quick-js as the JS backend.
- duktape: Use duktape as the JS backend. You need to disable the default features to enable this backend as shown in the below example.
```
katex = { version = "0.4.0", default-features = false, features = ["duktape"] }
```
- wasm-js: Use wasm-bindgen and js-sys as the JS backend. You need to disable the default features to enable this backend as shown in the below example. Currently, it only supports browser environment. Node.js is unsupported.
```
katex = { version = "0.4.0", default-features = false, features = ["wasm-js"] }
```

Source code(tar.gz)
Source code(zip)

0.4.0-alpha.3(Sep 5, 2021)

Source code(tar.gz)
Source code(zip)

Display math in TeX with KaTeX and ReactJS

vue-katex - Simple plugin for math typsetting using KaTeX in Vue.js

qml-rust — QML bindings.

qml - Safe QML bindings for Rust

Fast math typesetting for the web.

Tiny cross-platform webview library for C/C++/Golang. Uses WebKit (Gtk/Cocoa) and Edge (Windows)

High-quality JavaScript bindings for OCaml

opencv-rust — Rust bindings for OpenCV

rust-htslib - This library provides HTSlib bindings and a high level Rust API for reading and writing BAM files

rust-bindgen dtolnayC++ rust-lang/rust-bindgen — A Rust bindings generator dtolnay/cxx — Safe interop between Rust and C++

rust-sdl — SDL1 bindings

leveldb — LevelDB bindings

rust-sciter — Sciter bindings

rust_hawktracer - Rust bindings for hawktracer profiling library

JVMTI Bindings for Rust. ( All for simplicity! )

rust-sdl2 — SDL2 bindings

sdl2_mixer - SDL2_mixer bindings for Rust

Up-to-date Go bindings for SFML, the Simple and Fast Multimedia Library.

Low-level Python CFFI Bindings for Argon2

Rust ZeroMQ bindings.

Share this repo

Related Repos

Math

Static Linear Algebra System

SLAS Static Linear Algebra System Provides statically allocated vector, matrix and tensor types, for interfacing with blas/blis, in a performant manor

Math

Rule evaluation sidecar

RuES - Expression Evaluation as Service RuES is a minimal JMES expression evaluation side-car, that uses JMESPath and it can handle arbitrary JSON. Wh

Math

Powerful math lib for Vector, Matrix and Quaternion operations

An opinionated, powerful math lib for Vector2, Vector3, Matrix and Quaternion operations Vector2 Add, Sub, Div, Mul, Eq Distance Move towards target a

Math

Fast and easy zero-dep random number generation.

A zero-dependency crate for fast number generation, with a focus on ease of use (no more passing &mut rng everywhere!).

Math

Atomic Physics Library

Iridium Atomic Physics Library Attempt at making a atomic database. Uses Nubase2020, ENSDF for decay chains, atomic masses, and half-lives. Nubase2020

Math

Linear Algebra Hand Notes

Linear Algebra Pamphlet This is a repository containing my pamphlet regarding Linear Algebra course held by Prof. Gilbert Strang at MIT. I wrote this

Math

2.6k

Linear algebra library for Rust.

Linear algebra library for the Rust programming language.

Math

148

Super-fast float parser in Rust

This crate provides a super-fast decimal number parser from strings into floats.

Math

171

Scientific Computing in Rust

Math

linxal - Linear Algebra package with rust-ndarray interface

linxal Status Description linxal is a linear algebra package for rust. linxal uses LAPACK as a backend, (specifically with the lapack package) to exec

Math

glm - GLSL mathematics for Rust

GLSL Mathematics for Rust. Another Rust mathematics library for graphics applications. Inspired by the great GLM library for C++, glm-rs implements th

Math

334

num-bigint - Big integer implementation for Rust

num-bigint Big integer types for Rust, BigInt and BigUint. Usage Add this to your Cargo.toml: [dependencies] num-bigint = "0.3" Features The std crate

Math

algebra - Abstract algebra for Rust

Abstract algebra for Rust |(• ◡•)|ノ〵(❍ᴥ❍⋃) - "ALGEBRAIC!!!" Abstract algebra organises organises a wide range of structures into a logically cons

Math

katex - Rust bindings to KaTeX

katex-rs This crate offers Rust bindings to KaTeX. This allows you to render LaTeX equations to HTML. Documentation https://docs.rs/katex Usage Add th

Math

nightly coord - A simple, ergonomic vector mathematics crate

coord is deprecated. I recommend using vek, a project with near-identical aims instead. Coord Description Coord is a simple, ergonomic vector mathemat