tex2typst 0.2.9 → 0.2.12

package/dist/index.js

@@ -36,21 +36,15 @@ var symbolMap = new Map([
   ["pmb", "bold"],
   ["pm", "plus.minus"],
   ["mp", "minus.plus"],
-  ["oplus", "xor"],
   ["boxplus", "plus.square"],
   ["otimes", "times.circle"],
   ["boxtimes", "times.square"],
-  ["sim", "tilde"],
   ["approx", "approx"],
   ["cong", "tilde.equiv"],
   ["simeq", "tilde.eq"],
   ["asymp", "\u224D"],
   ["equiv", "equiv"],
   ["propto", "prop"],
-  ["lfloor", "\u230A"],
-  ["rfloor", "\u230B"],
-  ["lceil", "\u2308"],
-  ["rceil", "\u2309"],
   ["gets", "arrow.l"],
   ["hookleftarrow", "arrow.l.hook"],
   ["leftharpoonup", "harpoon.lt"],
@@ -62,7 +56,6 @@ var symbolMap = new Map([
   ["Longleftarrow", "arrow.l.double.long"],
   ["Longrightarrow", "arrow.r.double.long"],
   ["Longleftrightarrow", "arrow.l.r.double.long"],
-  ["longmapsto", "arrow.r.bar"],
   ["hookrightarrow", "arrow.r.hook"],
   ["rightharpoonup", "harpoon.rt"],
   ["rightharpoondown", "harpoon.rb"],
@@ -104,17 +97,13 @@ var symbolMap = new Map([
   ["angle", "angle"],
   ["approx", "approx"],
   ["approxeq", "approx.eq"],
-  ["ast", "ast"],
   ["beta", "beta"],
   ["bigcap", "sect.big"],
   ["bigcirc", "circle.big"],
   ["bigcup", "union.big"],
   ["bigodot", "dot.circle.big"],
-  ["bigoplus", "xor.big"],
   ["bigotimes", "times.circle.big"],
   ["bigsqcup", "union.sq.big"],
-  ["bigtriangledown", "triangle.b"],
-  ["bigtriangleup", "triangle.t"],
   ["biguplus", "union.plus.big"],
   ["bigvee", "or.big"],
   ["bigwedge", "and.big"],
@@ -156,7 +145,7 @@ var symbolMap = new Map([
   ["gg", "gt.double"],
   ["hbar", "planck.reduce"],
   ["imath", "dotless.i"],
-  ["iiiint", "intgral.quad"],
+  ["iiiint", "integral.quad"],
   ["iiint", "integral.triple"],
   ["iint", "integral.double"],
   ["in", "in"],
@@ -181,19 +170,15 @@ var symbolMap = new Map([
   ["leqslant", "lt.eq.slant"],
   ["lhd", "triangle.l"],
   ["ll", "lt.double"],
-  ["longmapsto", "arrow.bar.long"],
-  ["longrightarrow", "arrow.long"],
   ["lor", "or"],
   ["ltimes", "times.l"],
-  ["mapsto", "arrow.bar"],
   ["measuredangle", "angle.arc"],
   ["mid", "divides"],
   ["models", "models"],
   ["mp", "minus.plus"],
   ["mu", "mu"],
-  ["nRightarrow", "arrow.double.not"],
   ["nabla", "nabla"],
-  ["ncong", "tilde.nequiv"],
+  ["ncong", "tilde.equiv.not"],
   ["ne", "eq.not"],
   ["neg", "not"],
   ["neq", "eq.not"],
@@ -205,7 +190,6 @@ var symbolMap = new Map([
   ["ngeq", "gt.eq.not"],
   ["nmid", "divides.not"],
   ["notin", "in.not"],
-  ["nrightarrow", "arrow.not"],
   ["nsim", "tilde.not"],
   ["nsubseteq", "subset.eq.not"],
   ["nu", "nu"],
@@ -218,7 +202,6 @@ var symbolMap = new Map([
   ["oiiint", "integral.vol"],
   ["omega", "omega"],
   ["ominus", "minus.circle"],
-  ["oplus", "xor"],
   ["otimes", "times.circle"],
   ["parallel", "parallel"],
   ["partial", "diff"],
@@ -243,7 +226,7 @@ var symbolMap = new Map([
   ["rtimes", "times.r"],
   ["setminus", "without"],
   ["sigma", "sigma"],
-  ["sim", "tilde"],
+  ["sim", "tilde.op"],
   ["simeq", "tilde.eq"],
   ["slash", "slash"],
   ["smallsetminus", "without"],
@@ -252,7 +235,6 @@ var symbolMap = new Map([
   ["sqcup", "union.sq"],
   ["sqsubseteq", "subset.eq.sq"],
   ["sqsupseteq", "supset.eq.sq"],
-  ["star", "star"],
   ["subset", "subset"],
   ["subseteq", "subset.eq"],
   ["subsetneq", "subset.neq"],
@@ -269,9 +251,6 @@ var symbolMap = new Map([
   ["to", "arrow.r"],
   ["top", "top"],
   ["triangle", "triangle.t"],
-  ["triangledown", "triangle.b.small"],
-  ["triangleleft", "triangle.l.small"],
-  ["triangleright", "triangle.r.small"],
   ["twoheadrightarrow", "arrow.r.twohead"],
   ["uparrow", "arrow.t"],
   ["updownarrow", "arrow.t.b"],
@@ -297,6 +276,763 @@ var symbolMap = new Map([
   ["LaTeX", "#LaTeX"],
   ["TeX", "#TeX"]
 ]);
+var map_from_official_docs = new Map([
+  ["lparen", "paren.l"],
+  ["lParen", "paren.l.double"],
+  ["rparen", "paren.r"],
+  ["rParen", "paren.r.double"],
+  ["overparen", "paren.t"],
+  ["underparen", "paren.b"],
+  ["lbrace", "brace.l"],
+  ["lBrace", "brace.l.double"],
+  ["rbrace", "brace.r"],
+  ["rBrace", "brace.r.double"],
+  ["underbrace", "brace.b"],
+  ["lbrack", "bracket.l"],
+  ["lBrack", "bracket.l.double"],
+  ["rbrack", "bracket.r"],
+  ["rBrack", "bracket.r.double"],
+  ["overbracket", "bracket.t"],
+  ["underbracket", "bracket.b"],
+  ["lbrbrak", "shell.l"],
+  ["Lbrbrak", "shell.l.double"],
+  ["rbrbrak", "shell.r"],
+  ["Rbrbrak", "shell.r.double"],
+  ["obrbrak", "shell.t"],
+  ["ubrbrak", "shell.b"],
+  ["vert", "bar.v"],
+  ["Vert", "bar.v.double"],
+  ["Vvert", "bar.v.triple"],
+  ["circledvert", "bar.v.circle"],
+  ["horizbar", "bar.h"],
+  ["lvzigzag", "fence.l"],
+  ["Lvzigzag", "fence.l.double"],
+  ["rvzigzag", "fence.r"],
+  ["Rvzigzag", "fence.r.double"],
+  ["fourvdots", "fence.dotted"],
+  ["angle", "angle"],
+  ["langle", "angle.l"],
+  ["lcurvyangle", "angle.l.curly"],
+  ["langledot", "angle.l.dot"],
+  ["rangle", "angle.r"],
+  ["rcurvyangle", "angle.r.curly"],
+  ["rangledot", "angle.r.dot"],
+  ["angdnr", "angle.acute"],
+  ["measuredangle", "angle.arc"],
+  ["measuredangleleft", "angle.arc.rev"],
+  ["wideangledown", "angle.oblique"],
+  ["revangle", "angle.rev"],
+  ["rightangle", "angle.right"],
+  ["measuredrightangle", "angle.right.arc"],
+  ["rightanglemdot", "angle.right.dot"],
+  ["rightanglesqr", "angle.right.sq"],
+  ["angles", "angle.s"],
+  ["threedangle", "angle.spatial"],
+  ["sphericalangle", "angle.spheric"],
+  ["gtlpar", "angle.spheric.rev"],
+  ["sphericalangleup", "angle.spheric.top"],
+  ["lceil", "ceil.l"],
+  ["rceil", "ceil.r"],
+  ["lfloor", "floor.l"],
+  ["rfloor", "floor.r"],
+  ["mathampersand", "amp"],
+  ["upand", "amp.inv"],
+  ["ast", "ast.op"],
+  ["circledast", "ast.circle"],
+  ["boxast", "ast.square"],
+  ["mathatsign", "at"],
+  ["backslash", "backslash"],
+  ["obslash", "backslash.circle"],
+  ["rsolbar", "backslash.not"],
+  ["mathcolon", "colon"],
+  ["Colon", "colon.double"],
+  ["coloneq", "colon.eq"],
+  ["Coloneq", "colon.double.eq"],
+  ["mathcomma", "comma"],
+  ["dagger", "dagger"],
+  ["ddagger", "dagger.double"],
+  ["dashcolon", "dash.colon"],
+  ["circleddash", "dash.circle"],
+  ["hzigzag", "dash.wave.double"],
+  ["cdot", "dot.op"],
+  ["mathperiod", "dot.basic"],
+  ["cdotp", "dot.c"],
+  ["odot", "dot.circle"],
+  ["bigodot", "dot.circle.big"],
+  ["boxdot", "dot.square"],
+  ["dddot", "dot.triple"],
+  ["ddddot", "dot.quad"],
+  ["mathexclam", "excl"],
+  ["Exclam", "excl.double"],
+  ["mathquestion", "quest"],
+  ["Question", "quest.double"],
+  ["mathoctothorpe", "hash"],
+  ["mathhyphen", "hyph"],
+  ["mathpercent", "percent"],
+  ["mathparagraph", "pilcrow"],
+  ["mathsection", "section"],
+  ["mathsemicolon", "semi"],
+  ["mathslash", "slash"],
+  ["sslash", "slash.double"],
+  ["trslash", "slash.triple"],
+  ["xsol", "slash.big"],
+  ["unicodecdots", "dots.h.c"],
+  ["unicodeellipsis", "dots.h"],
+  ["vdots", "dots.v"],
+  ["ddots", "dots.down"],
+  ["adots", "dots.up"],
+  ["sim", "tilde.op"],
+  ["dotsim", "tilde.dot"],
+  ["sime", "tilde.eq"],
+  ["nsimeq", "tilde.eq.not"],
+  ["backsimeq", "tilde.eq.rev"],
+  ["cong", "tilde.equiv"],
+  ["ncong", "tilde.equiv.not"],
+  ["simneqq", "tilde.nequiv"],
+  ["nsim", "tilde.not"],
+  ["backsim", "tilde.rev"],
+  ["backcong", "tilde.rev.equiv"],
+  ["approxident", "tilde.triple"],
+  ["caretinsert", "caret"],
+  ["prime", "prime"],
+  ["backprime", "prime.rev"],
+  ["dprime", "prime.double"],
+  ["backdprime", "prime.double.rev"],
+  ["trprime", "prime.triple"],
+  ["backtrprime", "prime.triple.rev"],
+  ["qprime", "prime.quad"],
+  ["mathplus", "plus"],
+  ["oplus", "plus.circle"],
+  ["rightarrowonoplus", "plus.circle.arrow"],
+  ["bigoplus", "plus.circle.big"],
+  ["dotplus", "plus.dot"],
+  ["doubleplus", "plus.double"],
+  ["pm", "plus.minus"],
+  ["boxplus", "plus.square"],
+  ["triangleplus", "plus.triangle"],
+  ["tripleplus", "plus.triple"],
+  ["minus", "minus"],
+  ["ominus", "minus.circle"],
+  ["dotminus", "minus.dot"],
+  ["mp", "minus.plus"],
+  ["boxminus", "minus.square"],
+  ["eqsim", "minus.tilde"],
+  ["triangleminus", "minus.triangle"],
+  ["div", "div"],
+  ["odiv", "div.circle"],
+  ["times", "times"],
+  ["bigtimes", "times.big"],
+  ["otimes", "times.circle"],
+  ["bigotimes", "times.circle.big"],
+  ["divideontimes", "times.div"],
+  ["leftthreetimes", "times.three.l"],
+  ["rightthreetimes", "times.three.r"],
+  ["ltimes", "times.l"],
+  ["rtimes", "times.r"],
+  ["boxtimes", "times.square"],
+  ["triangletimes", "times.triangle"],
+  ["mathratio", "ratio"],
+  ["equal", "eq"],
+  ["stareq", "eq.star"],
+  ["circledequal", "eq.circle"],
+  ["eqcolon", "eq.colon"],
+  ["eqdef", "eq.def"],
+  ["triangleq", "eq.delta"],
+  ["veeeq", "eq.equi"],
+  ["wedgeq", "eq.est"],
+  ["eqgtr", "eq.gt"],
+  ["eqless", "eq.lt"],
+  ["measeq", "eq.m"],
+  ["ne", "eq.not"],
+  ["curlyeqprec", "eq.prec"],
+  ["questeq", "eq.quest"],
+  ["curlyeqsucc", "eq.succ"],
+  ["equiv", "eq.triple"],
+  ["Equiv", "eq.quad"],
+  ["greater", "gt"],
+  ["ogreaterthan", "gt.circle"],
+  ["gtrdot", "gt.dot"],
+  ["gtrapprox", "gt.approx"],
+  ["gg", "gt.double"],
+  ["geq", "gt.eq"],
+  ["geqslant", "gt.eq.slant"],
+  ["gtreqless", "gt.eq.lt"],
+  ["ngeq", "gt.eq.not"],
+  ["geqq", "gt.equiv"],
+  ["gtrless", "gt.lt"],
+  ["ngtrless", "gt.lt.not"],
+  ["gneq", "gt.neq"],
+  ["gnapprox", "gt.napprox"],
+  ["gneqq", "gt.nequiv"],
+  ["ngtr", "gt.not"],
+  ["gnsim", "gt.ntilde"],
+  ["gtrsim", "gt.tilde"],
+  ["ngtrsim", "gt.tilde.not"],
+  ["vartriangleright", "gt.tri"],
+  ["trianglerighteq", "gt.tri.eq"],
+  ["ntrianglerighteq", "gt.tri.eq.not"],
+  ["nvartriangleright", "gt.tri.not"],
+  ["ggg", "gt.triple"],
+  ["gggnest", "gt.triple.nested"],
+  ["less", "lt"],
+  ["olessthan", "lt.circle"],
+  ["lessdot", "lt.dot"],
+  ["lessapprox", "lt.approx"],
+  ["ll", "lt.double"],
+  ["leq", "lt.eq"],
+  ["leqslant", "lt.eq.slant"],
+  ["lesseqgtr", "lt.eq.gt"],
+  ["nleq", "lt.eq.not"],
+  ["leqq", "lt.equiv"],
+  ["lessgtr", "lt.gt"],
+  ["nlessgtr", "lt.gt.not"],
+  ["lneq", "lt.neq"],
+  ["lnapprox", "lt.napprox"],
+  ["lneqq", "lt.nequiv"],
+  ["nless", "lt.not"],
+  ["lnsim", "lt.ntilde"],
+  ["lesssim", "lt.tilde"],
+  ["nlesssim", "lt.tilde.not"],
+  ["vartriangleleft", "lt.tri"],
+  ["trianglelefteq", "lt.tri.eq"],
+  ["ntrianglelefteq", "lt.tri.eq.not"],
+  ["nvartriangleleft", "lt.tri.not"],
+  ["lll", "lt.triple"],
+  ["lllnest", "lt.triple.nested"],
+  ["approx", "approx"],
+  ["approxeq", "approx.eq"],
+  ["napprox", "approx.not"],
+  ["prec", "prec"],
+  ["precapprox", "prec.approx"],
+  ["preccurlyeq", "prec.curly.eq"],
+  ["npreccurlyeq", "prec.curly.eq.not"],
+  ["Prec", "prec.double"],
+  ["preceq", "prec.eq"],
+  ["preceqq", "prec.equiv"],
+  ["precnapprox", "prec.napprox"],
+  ["precneq", "prec.neq"],
+  ["precneqq", "prec.nequiv"],
+  ["nprec", "prec.not"],
+  ["precnsim", "prec.ntilde"],
+  ["precsim", "prec.tilde"],
+  ["succ", "succ"],
+  ["succapprox", "succ.approx"],
+  ["succcurlyeq", "succ.curly.eq"],
+  ["nsucccurlyeq", "succ.curly.eq.not"],
+  ["Succ", "succ.double"],
+  ["succeq", "succ.eq"],
+  ["succeqq", "succ.equiv"],
+  ["succnapprox", "succ.napprox"],
+  ["succneq", "succ.neq"],
+  ["succneqq", "succ.nequiv"],
+  ["nsucc", "succ.not"],
+  ["succnsim", "succ.ntilde"],
+  ["succsim", "succ.tilde"],
+  ["nequiv", "equiv.not"],
+  ["propto", "prop"],
+  ["origof", "original"],
+  ["imageof", "image"],
+  ["varnothing", "emptyset"],
+  ["emptysetoarr", "emptyset.arrow.r"],
+  ["emptysetoarrl", "emptyset.arrow.l"],
+  ["emptysetobar", "emptyset.bar"],
+  ["emptysetocirc", "emptyset.circle"],
+  ["revemptyset", "emptyset.rev"],
+  ["setminus", "without"],
+  ["complement", "complement"],
+  ["in", "in"],
+  ["notin", "in.not"],
+  ["ni", "in.rev"],
+  ["nni", "in.rev.not"],
+  ["smallni", "in.rev.small"],
+  ["smallin", "in.small"],
+  ["subset", "subset"],
+  ["subsetdot", "subset.dot"],
+  ["Subset", "subset.double"],
+  ["subseteq", "subset.eq"],
+  ["nsubseteq", "subset.eq.not"],
+  ["sqsubseteq", "subset.eq.sq"],
+  ["nsqsubseteq", "subset.eq.sq.not"],
+  ["subsetneq", "subset.neq"],
+  ["nsubset", "subset.not"],
+  ["sqsubset", "subset.sq"],
+  ["sqsubsetneq", "subset.sq.neq"],
+  ["supset", "supset"],
+  ["supsetdot", "supset.dot"],
+  ["Supset", "supset.double"],
+  ["supseteq", "supset.eq"],
+  ["nsupseteq", "supset.eq.not"],
+  ["sqsupseteq", "supset.eq.sq"],
+  ["nsqsupseteq", "supset.eq.sq.not"],
+  ["supsetneq", "supset.neq"],
+  ["nsupset", "supset.not"],
+  ["sqsupset", "supset.sq"],
+  ["sqsupsetneq", "supset.sq.neq"],
+  ["cup", "union"],
+  ["cupleftarrow", "union.arrow"],
+  ["bigcup", "union.big"],
+  ["cupdot", "union.dot"],
+  ["bigcupdot", "union.dot.big"],
+  ["Cup", "union.double"],
+  ["uminus", "union.minus"],
+  ["cupvee", "union.or"],
+  ["uplus", "union.plus"],
+  ["biguplus", "union.plus.big"],
+  ["sqcup", "union.sq"],
+  ["bigsqcup", "union.sq.big"],
+  ["Sqcup", "union.sq.double"],
+  ["cap", "sect"],
+  ["capwedge", "sect.and"],
+  ["bigcap", "sect.big"],
+  ["capdot", "sect.dot"],
+  ["Cap", "sect.double"],
+  ["sqcap", "sect.sq"],
+  ["bigsqcap", "sect.sq.big"],
+  ["Sqcap", "sect.sq.double"],
+  ["infty", "infinity"],
+  ["nvinfty", "infinity.bar"],
+  ["iinfin", "infinity.incomplete"],
+  ["tieinfty", "infinity.tie"],
+  ["partial", "diff"],
+  ["nabla", "gradient"],
+  ["sum", "sum"],
+  ["sumint", "sum.integral"],
+  ["prod", "product"],
+  ["coprod", "product.co"],
+  ["int", "integral"],
+  ["intlarhk", "integral.arrow.hook"],
+  ["awint", "integral.ccw"],
+  ["oint", "integral.cont"],
+  ["ointctrclockwise", "integral.cont.ccw"],
+  ["varointclockwise", "integral.cont.cw"],
+  ["intclockwise", "integral.cw"],
+  ["intbar", "integral.dash"],
+  ["intBar", "integral.dash.double"],
+  ["iint", "integral.double"],
+  ["iiiint", "integral.quad"],
+  ["intcap", "integral.sect"],
+  ["fint", "integral.slash"],
+  ["sqint", "integral.square"],
+  ["oiint", "integral.surf"],
+  ["intx", "integral.times"],
+  ["iiint", "integral.triple"],
+  ["intcup", "integral.union"],
+  ["oiiint", "integral.vol"],
+  ["increment", "laplace"],
+  ["forall", "forall"],
+  ["exists", "exists"],
+  ["nexists", "exists.not"],
+  ["top", "top"],
+  ["bot", "bot"],
+  ["neg", "not"],
+  ["wedge", "and"],
+  ["bigwedge", "and.big"],
+  ["curlywedge", "and.curly"],
+  ["wedgedot", "and.dot"],
+  ["Wedge", "and.double"],
+  ["vee", "or"],
+  ["bigvee", "or.big"],
+  ["curlyvee", "or.curly"],
+  ["veedot", "or.dot"],
+  ["Vee", "or.double"],
+  ["models", "models"],
+  ["Vdash", "forces"],
+  ["nVdash", "forces.not"],
+  ["therefore", "therefore"],
+  ["because", "because"],
+  ["QED", "qed"],
+  ["vysmwhtcircle", "compose"],
+  ["multimap", "multimap"],
+  ["dualmap", "multimap.double"],
+  ["tplus", "tiny"],
+  ["tminus", "miny"],
+  ["mid", "divides"],
+  ["nmid", "divides.not"],
+  ["wr", "wreath"],
+  ["parallel", "parallel"],
+  ["nhpar", "parallel.struck"],
+  ["circledparallel", "parallel.circle"],
+  ["equalparallel", "parallel.eq"],
+  ["equivVert", "parallel.equiv"],
+  ["nparallel", "parallel.not"],
+  ["eparsl", "parallel.slanted.eq"],
+  ["smeparsl", "parallel.slanted.eq.tilde"],
+  ["eqvparsl", "parallel.slanted.equiv"],
+  ["parsim", "parallel.tilde"],
+  ["perp", "perp"],
+  ["operp", "perp.circle"],
+  ["diameter", "diameter"],
+  ["Join", "join"],
+  ["rightouterjoin", "join.r"],
+  ["leftouterjoin", "join.l"],
+  ["fullouterjoin", "join.l.r"],
+  ["smashtimes", "smash"],
+  ["mathdollar", "dollar"],
+  ["euro", "euro"],
+  ["mathsterling", "pound"],
+  ["mathyen", "yen"],
+  ["checkmark", "checkmark"],
+  ["maltese", "maltese"],
+  ["clubsuit", "suit.club.filled"],
+  ["varclubsuit", "suit.club.stroked"],
+  ["vardiamondsuit", "suit.diamond.filled"],
+  ["diamondsuit", "suit.diamond.stroked"],
+  ["varheartsuit", "suit.heart.filled"],
+  ["heartsuit", "suit.heart.stroked"],
+  ["spadesuit", "suit.spade.filled"],
+  ["varspadesuit", "suit.spade.stroked"],
+  ["quarternote", "note.quarter.alt"],
+  ["eighthnote", "note.eighth.alt"],
+  ["twonotes", "note.eighth.beamed"],
+  ["natural", "natural"],
+  ["flat", "flat"],
+  ["sharp", "sharp"],
+  ["smblkcircle", "bullet"],
+  ["mdlgwhtcircle", "circle.stroked"],
+  ["mdsmwhtcircle", "circle.stroked.small"],
+  ["lgwhtcircle", "circle.stroked.big"],
+  ["mdlgblkcircle", "circle.filled"],
+  ["mdsmblkcircle", "circle.filled.tiny"],
+  ["vysmblkcircle", "circle.filled.small"],
+  ["lgblkcircle", "circle.filled.big"],
+  ["dottedcircle", "circle.dotted"],
+  ["circledcirc", "circle.nested"],
+  ["whthorzoval", "ellipse.stroked.h"],
+  ["whtvertoval", "ellipse.stroked.v"],
+  ["blkhorzoval", "ellipse.filled.h"],
+  ["blkvertoval", "ellipse.filled.v"],
+  ["bigtriangleup", "triangle.stroked.t"],
+  ["bigtriangledown", "triangle.stroked.b"],
+  ["triangleright", "triangle.stroked.r"],
+  ["triangleleft", "triangle.stroked.l"],
+  ["lltriangle", "triangle.stroked.bl"],
+  ["lrtriangle", "triangle.stroked.br"],
+  ["ultriangle", "triangle.stroked.tl"],
+  ["urtriangle", "triangle.stroked.tr"],
+  ["vartriangle", "triangle.stroked.small.t"],
+  ["triangledown", "triangle.stroked.small.b"],
+  ["smalltriangleright", "triangle.stroked.small.r"],
+  ["smalltriangleleft", "triangle.stroked.small.l"],
+  ["whiteinwhitetriangle", "triangle.stroked.nested"],
+  ["trianglecdot", "triangle.stroked.dot"],
+  ["bigblacktriangleup", "triangle.filled.t"],
+  ["bigblacktriangledown", "triangle.filled.b"],
+  ["blacktriangleright", "triangle.filled.r"],
+  ["blacktriangleleft", "triangle.filled.l"],
+  ["llblacktriangle", "triangle.filled.bl"],
+  ["lrblacktriangle", "triangle.filled.br"],
+  ["ulblacktriangle", "triangle.filled.tl"],
+  ["urblacktriangle", "triangle.filled.tr"],
+  ["blacktriangle", "triangle.filled.small.t"],
+  ["blacktriangledown", "triangle.filled.small.b"],
+  ["smallblacktriangleright", "triangle.filled.small.r"],
+  ["smallblacktriangleleft", "triangle.filled.small.l"],
+  ["mdlgwhtsquare", "square.stroked"],
+  ["smwhtsquare", "square.stroked.tiny"],
+  ["mdsmwhtsquare", "square.stroked.small"],
+  ["mdwhtsquare", "square.stroked.medium"],
+  ["lgwhtsquare", "square.stroked.big"],
+  ["dottedsquare", "square.stroked.dotted"],
+  ["squoval", "square.stroked.rounded"],
+  ["mdlgblksquare", "square.filled"],
+  ["smblksquare", "square.filled.tiny"],
+  ["mdsmblksquare", "square.filled.small"],
+  ["mdblksquare", "square.filled.medium"],
+  ["lgblksquare", "square.filled.big"],
+  ["hrectangle", "rect.stroked.h"],
+  ["vrectangle", "rect.stroked.v"],
+  ["hrectangleblack", "rect.filled.h"],
+  ["vrectangleblack", "rect.filled.v"],
+  ["pentagon", "penta.stroked"],
+  ["pentagonblack", "penta.filled"],
+  ["varhexagon", "hexa.stroked"],
+  ["varhexagonblack", "hexa.filled"],
+  ["mdlgwhtdiamond", "diamond.stroked"],
+  ["smwhtdiamond", "diamond.stroked.small"],
+  ["mdwhtdiamond", "diamond.stroked.medium"],
+  ["diamondcdot", "diamond.stroked.dot"],
+  ["mdlgblkdiamond", "diamond.filled"],
+  ["mdblkdiamond", "diamond.filled.medium"],
+  ["smblkdiamond", "diamond.filled.small"],
+  ["mdlgwhtlozenge", "lozenge.stroked"],
+  ["smwhtlozenge", "lozenge.stroked.small"],
+  ["mdwhtlozenge", "lozenge.stroked.medium"],
+  ["mdlgblklozenge", "lozenge.filled"],
+  ["smblklozenge", "lozenge.filled.small"],
+  ["mdblklozenge", "lozenge.filled.medium"],
+  ["parallelogram", "parallelogram.stroked"],
+  ["parallelogramblack", "parallelogram.filled"],
+  ["star", "star.op"],
+  ["bigwhitestar", "star.stroked"],
+  ["bigstar", "star.filled"],
+  ["rightarrow", "arrow.r"],
+  ["longmapsto", "arrow.r.long.bar"],
+  ["mapsto", "arrow.r.bar"],
+  ["rightdowncurvedarrow", "arrow.r.curve"],
+  ["rightdasharrow", "arrow.r.dashed"],
+  ["rightdotarrow", "arrow.r.dotted"],
+  ["Rightarrow", "arrow.r.double"],
+  ["Mapsto", "arrow.r.double.bar"],
+  ["Longrightarrow", "arrow.r.double.long"],
+  ["Longmapsto", "arrow.r.double.long.bar"],
+  ["nRightarrow", "arrow.r.double.not"],
+  ["hookrightarrow", "arrow.r.hook"],
+  ["longrightarrow", "arrow.r.long"],
+  ["longrightsquigarrow", "arrow.r.long.squiggly"],
+  ["looparrowright", "arrow.r.loop"],
+  ["nrightarrow", "arrow.r.not"],
+  ["RRightarrow", "arrow.r.quad"],
+  ["rightsquigarrow", "arrow.r.squiggly"],
+  ["rightarrowbar", "arrow.r.stop"],
+  ["rightwhitearrow", "arrow.r.stroked"],
+  ["rightarrowtail", "arrow.r.tail"],
+  ["similarrightarrow", "arrow.r.tilde"],
+  ["Rrightarrow", "arrow.r.triple"],
+  ["twoheadmapsto", "arrow.r.twohead.bar"],
+  ["twoheadrightarrow", "arrow.r.twohead"],
+  ["rightwavearrow", "arrow.r.wave"],
+  ["leftarrow", "arrow.l"],
+  ["mapsfrom", "arrow.l.bar"],
+  ["leftdowncurvedarrow", "arrow.l.curve"],
+  ["leftdasharrow", "arrow.l.dashed"],
+  ["leftdotarrow", "arrow.l.dotted"],
+  ["Leftarrow", "arrow.l.double"],
+  ["Mapsfrom", "arrow.l.double.bar"],
+  ["Longleftarrow", "arrow.l.double.long"],
+  ["Longmapsfrom", "arrow.l.double.long.bar"],
+  ["nLeftarrow", "arrow.l.double.not"],
+  ["hookleftarrow", "arrow.l.hook"],
+  ["longleftarrow", "arrow.l.long"],
+  ["longmapsfrom", "arrow.l.long.bar"],
+  ["longleftsquigarrow", "arrow.l.long.squiggly"],
+  ["looparrowleft", "arrow.l.loop"],
+  ["nleftarrow", "arrow.l.not"],
+  ["LLeftarrow", "arrow.l.quad"],
+  ["leftsquigarrow", "arrow.l.squiggly"],
+  ["barleftarrow", "arrow.l.stop"],
+  ["leftwhitearrow", "arrow.l.stroked"],
+  ["leftarrowtail", "arrow.l.tail"],
+  ["similarleftarrow", "arrow.l.tilde"],
+  ["Lleftarrow", "arrow.l.triple"],
+  ["twoheadmapsfrom", "arrow.l.twohead.bar"],
+  ["twoheadleftarrow", "arrow.l.twohead"],
+  ["leftwavearrow", "arrow.l.wave"],
+  ["uparrow", "arrow.t"],
+  ["mapsup", "arrow.t.bar"],
+  ["uprightcurvearrow", "arrow.t.curve"],
+  ["updasharrow", "arrow.t.dashed"],
+  ["Uparrow", "arrow.t.double"],
+  ["UUparrow", "arrow.t.quad"],
+  ["baruparrow", "arrow.t.stop"],
+  ["upwhitearrow", "arrow.t.stroked"],
+  ["Uuparrow", "arrow.t.triple"],
+  ["twoheaduparrow", "arrow.t.twohead"],
+  ["downarrow", "arrow.b"],
+  ["mapsdown", "arrow.b.bar"],
+  ["downrightcurvedarrow", "arrow.b.curve"],
+  ["downdasharrow", "arrow.b.dashed"],
+  ["Downarrow", "arrow.b.double"],
+  ["DDownarrow", "arrow.b.quad"],
+  ["downarrowbar", "arrow.b.stop"],
+  ["downwhitearrow", "arrow.b.stroked"],
+  ["Ddownarrow", "arrow.b.triple"],
+  ["twoheaddownarrow", "arrow.b.twohead"],
+  ["leftrightarrow", "arrow.l.r"],
+  ["Leftrightarrow", "arrow.l.r.double"],
+  ["Longleftrightarrow", "arrow.l.r.double.long"],
+  ["nLeftrightarrow", "arrow.l.r.double.not"],
+  ["longleftrightarrow", "arrow.l.r.long"],
+  ["nleftrightarrow", "arrow.l.r.not"],
+  ["leftrightsquigarrow", "arrow.l.r.wave"],
+  ["updownarrow", "arrow.t.b"],
+  ["Updownarrow", "arrow.t.b.double"],
+  ["nearrow", "arrow.tr"],
+  ["Nearrow", "arrow.tr.double"],
+  ["hknearrow", "arrow.tr.hook"],
+  ["searrow", "arrow.br"],
+  ["Searrow", "arrow.br.double"],
+  ["hksearrow", "arrow.br.hook"],
+  ["nwarrow", "arrow.tl"],
+  ["Nwarrow", "arrow.tl.double"],
+  ["hknwarrow", "arrow.tl.hook"],
+  ["swarrow", "arrow.bl"],
+  ["Swarrow", "arrow.bl.double"],
+  ["hkswarrow", "arrow.bl.hook"],
+  ["nwsearrow", "arrow.tl.br"],
+  ["neswarrow", "arrow.tr.bl"],
+  ["acwopencirclearrow", "arrow.ccw"],
+  ["curvearrowleft", "arrow.ccw.half"],
+  ["cwopencirclearrow", "arrow.cw"],
+  ["curvearrowright", "arrow.cw.half"],
+  ["downzigzagarrow", "arrow.zigzag"],
+  ["rightrightarrows", "arrows.rr"],
+  ["leftleftarrows", "arrows.ll"],
+  ["upuparrows", "arrows.tt"],
+  ["downdownarrows", "arrows.bb"],
+  ["leftrightarrows", "arrows.lr"],
+  ["barleftarrowrightarrowbar", "arrows.lr.stop"],
+  ["rightleftarrows", "arrows.rl"],
+  ["updownarrows", "arrows.tb"],
+  ["downuparrows", "arrows.bt"],
+  ["rightthreearrows", "arrows.rrr"],
+  ["leftthreearrows", "arrows.lll"],
+  ["rightharpoonup", "harpoon.rt"],
+  ["barrightharpoonup", "harpoon.rt.bar"],
+  ["rightharpoonupbar", "harpoon.rt.stop"],
+  ["rightharpoondown", "harpoon.rb"],
+  ["barrightharpoondown", "harpoon.rb.bar"],
+  ["rightharpoondownbar", "harpoon.rb.stop"],
+  ["leftharpoonup", "harpoon.lt"],
+  ["leftharpoonupbar", "harpoon.lt.bar"],
+  ["barleftharpoonup", "harpoon.lt.stop"],
+  ["leftharpoondown", "harpoon.lb"],
+  ["leftharpoondownbar", "harpoon.lb.bar"],
+  ["barleftharpoondown", "harpoon.lb.stop"],
+  ["upharpoonleft", "harpoon.tl"],
+  ["upharpoonleftbar", "harpoon.tl.bar"],
+  ["barupharpoonleft", "harpoon.tl.stop"],
+  ["upharpoonright", "harpoon.tr"],
+  ["upharpoonrightbar", "harpoon.tr.bar"],
+  ["barupharpoonright", "harpoon.tr.stop"],
+  ["downharpoonleft", "harpoon.bl"],
+  ["bardownharpoonleft", "harpoon.bl.bar"],
+  ["downharpoonleftbar", "harpoon.bl.stop"],
+  ["downharpoonright", "harpoon.br"],
+  ["bardownharpoonright", "harpoon.br.bar"],
+  ["downharpoonrightbar", "harpoon.br.stop"],
+  ["leftrightharpoonupup", "harpoon.lt.rt"],
+  ["leftrightharpoondowndown", "harpoon.lb.rb"],
+  ["leftrightharpoondownup", "harpoon.lb.rt"],
+  ["leftrightharpoonupdown", "harpoon.lt.rb"],
+  ["updownharpoonleftleft", "harpoon.tl.bl"],
+  ["updownharpoonrightright", "harpoon.tr.br"],
+  ["updownharpoonleftright", "harpoon.tl.br"],
+  ["updownharpoonrightleft", "harpoon.tr.bl"],
+  ["rightharpoonsupdown", "harpoons.rtrb"],
+  ["downharpoonsleftright", "harpoons.blbr"],
+  ["downupharpoonsleftright", "harpoons.bltr"],
+  ["leftrightharpoonsdown", "harpoons.lbrb"],
+  ["leftharpoonsupdown", "harpoons.ltlb"],
+  ["leftrightharpoons", "harpoons.ltrb"],
+  ["leftrightharpoonsup", "harpoons.ltrt"],
+  ["rightleftharpoonsdown", "harpoons.rblb"],
+  ["rightleftharpoons", "harpoons.rtlb"],
+  ["rightleftharpoonsup", "harpoons.rtlt"],
+  ["updownharpoonsleftright", "harpoons.tlbr"],
+  ["upharpoonsleftright", "harpoons.tltr"],
+  ["vdash", "tack.r"],
+  ["nvdash", "tack.r.not"],
+  ["vlongdash", "tack.r.long"],
+  ["assert", "tack.r.short"],
+  ["vDash", "tack.r.double"],
+  ["nvDash", "tack.r.double.not"],
+  ["dashv", "tack.l"],
+  ["longdashv", "tack.l.long"],
+  ["shortlefttack", "tack.l.short"],
+  ["Dashv", "tack.l.double"],
+  ["bigbot", "tack.t.big"],
+  ["Vbar", "tack.t.double"],
+  ["shortuptack", "tack.t.short"],
+  ["bigtop", "tack.b.big"],
+  ["barV", "tack.b.double"],
+  ["shortdowntack", "tack.b.short"],
+  ["dashVdash", "tack.l.r"],
+  ["mupalpha", "alpha"],
+  ["mupbeta", "beta"],
+  ["mupchi", "chi"],
+  ["mupdelta", "delta"],
+  ["mupvarepsilon", "epsilon"],
+  ["mupepsilon", "epsilon.alt"],
+  ["mupeta", "eta"],
+  ["mupgamma", "gamma"],
+  ["mupiota", "iota"],
+  ["mupkappa", "kappa"],
+  ["mupvarkappa", "kappa.alt"],
+  ["muplambda", "lambda"],
+  ["mupmu", "mu"],
+  ["mupnu", "nu"],
+  ["mho", "ohm.inv"],
+  ["mupomega", "omega"],
+  ["mupomicron", "omicron"],
+  ["mupvarphi", "phi"],
+  ["mupphi", "phi.alt"],
+  ["muppi", "pi"],
+  ["mupvarpi", "pi.alt"],
+  ["muppsi", "psi"],
+  ["muprho", "rho"],
+  ["mupvarrho", "rho.alt"],
+  ["mupsigma", "sigma"],
+  ["mupvarsigma", "sigma.alt"],
+  ["muptau", "tau"],
+  ["muptheta", "theta"],
+  ["mupvartheta", "theta.alt"],
+  ["mupupsilon", "upsilon"],
+  ["mupxi", "xi"],
+  ["mupzeta", "zeta"],
+  ["mupAlpha", "Alpha"],
+  ["mupBeta", "Beta"],
+  ["mupChi", "Chi"],
+  ["mupDelta", "Delta"],
+  ["mupEpsilon", "Epsilon"],
+  ["mupEta", "Eta"],
+  ["mupGamma", "Gamma"],
+  ["mupIota", "Iota"],
+  ["mupKappa", "Kappa"],
+  ["mupLambda", "Lambda"],
+  ["mupMu", "Mu"],
+  ["mupNu", "Nu"],
+  ["mupOmega", "Omega"],
+  ["mupOmicron", "Omicron"],
+  ["mupPhi", "Phi"],
+  ["mupPi", "Pi"],
+  ["mupPsi", "Psi"],
+  ["mupRho", "Rho"],
+  ["mupSigma", "Sigma"],
+  ["mupTau", "Tau"],
+  ["mupTheta", "Theta"],
+  ["mupUpsilon", "Upsilon"],
+  ["mupXi", "Xi"],
+  ["mupZeta", "Zeta"],
+  ["BbbA", "AA"],
+  ["BbbB", "BB"],
+  ["BbbC", "CC"],
+  ["BbbD", "DD"],
+  ["BbbE", "EE"],
+  ["BbbF", "FF"],
+  ["BbbG", "GG"],
+  ["BbbH", "HH"],
+  ["BbbI", "II"],
+  ["BbbJ", "JJ"],
+  ["BbbK", "KK"],
+  ["BbbL", "LL"],
+  ["BbbM", "MM"],
+  ["BbbN", "NN"],
+  ["BbbO", "OO"],
+  ["BbbP", "PP"],
+  ["BbbQ", "QQ"],
+  ["BbbR", "RR"],
+  ["BbbS", "SS"],
+  ["BbbT", "TT"],
+  ["BbbU", "UU"],
+  ["BbbV", "VV"],
+  ["BbbW", "WW"],
+  ["BbbX", "XX"],
+  ["BbbY", "YY"],
+  ["BbbZ", "ZZ"],
+  ["ell", "ell"],
+  ["Planckconst", "planck"],
+  ["hslash", "planck.reduce"],
+  ["Angstrom", "angstrom"],
+  ["Re", "Re"],
+  ["Im", "Im"],
+  ["imath", "dotless.i"],
+  ["jmath", "dotless.j"]
+]);
+for (const [key, value] of map_from_official_docs) {
+  if (!symbolMap.has(key)) {
+    symbolMap.set(key, value);
+  }
+}
 
 // src/parser.ts
 function assert(condition, message = "") {
@@ -314,16 +1050,16 @@ function get_command_param_num(command) {
   }
 }
 function find_closing_curly_bracket(tokens, start) {
-  assert(token_eq(tokens[start], LEFT_CURLY_BRACKET));
+  assert(tokens[start].eq(LEFT_CURLY_BRACKET));
   let count = 1;
   let pos = start + 1;
   while (count > 0) {
     if (pos >= tokens.length) {
       throw new LatexParserError("Unmatched curly brackets");
     }
-    if (token_eq(tokens[pos], LEFT_CURLY_BRACKET)) {
+    if (tokens[pos].eq(LEFT_CURLY_BRACKET)) {
       count += 1;
-    } else if (token_eq(tokens[pos], RIGHT_CURLY_BRACKET)) {
+    } else if (tokens[pos].eq(RIGHT_CURLY_BRACKET)) {
       count -= 1;
     }
     pos += 1;
@@ -331,16 +1067,16 @@ function find_closing_curly_bracket(tokens, start) {
   return pos - 1;
 }
 function find_closing_square_bracket(tokens, start) {
-  assert(token_eq(tokens[start], LEFT_SQUARE_BRACKET));
+  assert(tokens[start].eq(LEFT_SQUARE_BRACKET));
   let count = 1;
   let pos = start + 1;
   while (count > 0) {
     if (pos >= tokens.length) {
       throw new LatexParserError("Unmatched square brackets");
     }
-    if (token_eq(tokens[pos], LEFT_SQUARE_BRACKET)) {
+    if (tokens[pos].eq(LEFT_SQUARE_BRACKET)) {
       count += 1;
-    } else if (token_eq(tokens[pos], RIGHT_SQUARE_BRACKET)) {
+    } else if (tokens[pos].eq(RIGHT_SQUARE_BRACKET)) {
       count -= 1;
     }
     pos += 1;
@@ -372,7 +1108,7 @@ function eat_parenthesis(tokens, start) {
 }
 function eat_primes(tokens, start) {
   let pos = start;
-  while (pos < tokens.length && token_eq(tokens[pos], { type: 0 /* ELEMENT */, value: "'" })) {
+  while (pos < tokens.length && tokens[pos].eq(new Token(0 /* ELEMENT */, "'"))) {
     pos += 1;
   }
   return pos - start;
@@ -391,9 +1127,9 @@ function find_closing_right_command(tokens, start) {
     if (pos >= tokens.length) {
       return -1;
     }
-    if (token_eq(tokens[pos], LEFT_COMMAND)) {
+    if (tokens[pos].eq(LEFT_COMMAND)) {
       count += 1;
-    } else if (token_eq(tokens[pos], RIGHT_COMMAND)) {
+    } else if (tokens[pos].eq(RIGHT_COMMAND)) {
       count -= 1;
     }
     pos += 1;
@@ -407,9 +1143,9 @@ function find_closing_end_command(tokens, start) {
     if (pos >= tokens.length) {
       return -1;
     }
-    if (token_eq(tokens[pos], BEGIN_COMMAND)) {
+    if (tokens[pos].eq(BEGIN_COMMAND)) {
       count += 1;
-    } else if (token_eq(tokens[pos], END_COMMAND)) {
+    } else if (tokens[pos].eq(END_COMMAND)) {
       count -= 1;
     }
     pos += 1;
@@ -449,7 +1185,7 @@ function tokenize(latex) {
         while (newPos < latex.length && latex[newPos] !== "\n") {
           newPos += 1;
         }
-        token = { type: 3 /* COMMENT */, value: latex.slice(pos + 1, newPos) };
+        token = new Token(3 /* COMMENT */, latex.slice(pos + 1, newPos));
         pos = newPos;
         break;
       }
@@ -458,19 +1194,19 @@ function tokenize(latex) {
       case "_":
       case "^":
       case "&":
-        token = { type: 6 /* CONTROL */, value: firstChar };
+        token = new Token(6 /* CONTROL */, firstChar);
         pos++;
         break;
       case "\n":
-        token = { type: 5 /* NEWLINE */, value: firstChar };
+        token = new Token(5 /* NEWLINE */, firstChar);
         pos++;
         break;
       case "\r": {
         if (pos + 1 < latex.length && latex[pos + 1] === "\n") {
-          token = { type: 5 /* NEWLINE */, value: "\n" };
+          token = new Token(5 /* NEWLINE */, "\n");
           pos += 2;
         } else {
-          token = { type: 5 /* NEWLINE */, value: "\n" };
+          token = new Token(5 /* NEWLINE */, "\n");
           pos++;
         }
         break;
@@ -480,7 +1216,7 @@ function tokenize(latex) {
         while (newPos < latex.length && latex[newPos] === " ") {
           newPos += 1;
         }
-        token = { type: 4 /* WHITESPACE */, value: latex.slice(pos, newPos) };
+        token = new Token(4 /* WHITESPACE */, latex.slice(pos, newPos));
         pos = newPos;
         break;
       }
@@ -490,12 +1226,12 @@ function tokenize(latex) {
         }
         const firstTwoChars = latex.slice(pos, pos + 2);
         if (["\\\\", "\\,"].includes(firstTwoChars)) {
-          token = { type: 6 /* CONTROL */, value: firstTwoChars };
+          token = new Token(6 /* CONTROL */, firstTwoChars);
         } else if (["\\{", "\\}", "\\%", "\\$", "\\&", "\\#", "\\_"].includes(firstTwoChars)) {
-          token = { type: 0 /* ELEMENT */, value: firstTwoChars };
+          token = new Token(0 /* ELEMENT */, firstTwoChars);
         } else {
           const command = eat_command_name(latex, pos + 1);
-          token = { type: 1 /* COMMAND */, value: "\\" + command };
+          token = new Token(1 /* COMMAND */, "\\" + command);
         }
         pos += token.value.length;
         break;
@@ -506,13 +1242,13 @@ function tokenize(latex) {
           while (newPos < latex.length && isdigit(latex[newPos])) {
             newPos += 1;
           }
-          token = { type: 0 /* ELEMENT */, value: latex.slice(pos, newPos) };
+          token = new Token(0 /* ELEMENT */, latex.slice(pos, newPos));
         } else if (isalpha(firstChar)) {
-          token = { type: 0 /* ELEMENT */, value: firstChar };
+          token = new Token(0 /* ELEMENT */, firstChar);
         } else if ("+-*/=\'<>!.,;?()[]|".includes(firstChar)) {
-          token = { type: 0 /* ELEMENT */, value: firstChar };
+          token = new Token(0 /* ELEMENT */, firstChar);
         } else {
-          token = { type: 7 /* UNKNOWN */, value: firstChar };
+          token = new Token(7 /* UNKNOWN */, firstChar);
         }
         pos += token.value.length;
       }
@@ -522,7 +1258,7 @@ function tokenize(latex) {
       if (pos >= latex.length || latex[pos] !== "{") {
         throw new LatexParserError(`No content for ${token.value} command`);
       }
-      tokens.push({ type: 6 /* CONTROL */, value: "{" });
+      tokens.push(new Token(6 /* CONTROL */, "{"));
       const posClosingBracket = find_closing_curly_bracket_char(latex, pos);
       pos++;
       let textInside = latex.slice(pos, posClosingBracket);
@@ -530,18 +1266,15 @@ function tokenize(latex) {
       for (const char of chars) {
         textInside = textInside.replaceAll("\\" + char, char);
       }
-      tokens.push({ type: 2 /* TEXT */, value: textInside });
-      tokens.push({ type: 6 /* CONTROL */, value: "}" });
+      tokens.push(new Token(2 /* TEXT */, textInside));
+      tokens.push(new Token(6 /* CONTROL */, "}"));
       pos = posClosingBracket + 1;
     }
   }
   return tokens;
 }
-function token_eq(token1, token2) {
-  return token1.type == token2.type && token1.value == token2.value;
-}
 function passIgnoreWhitespaceBeforeScriptMark(tokens) {
-  const is_script_mark = (token) => token_eq(token, SUB_SYMBOL) || token_eq(token, SUP_SYMBOL);
+  const is_script_mark = (token) => token.eq(SUB_SYMBOL) || token.eq(SUP_SYMBOL);
   let out_tokens = [];
   for (let i = 0;i < tokens.length; i++) {
     if (tokens[i].type === 4 /* WHITESPACE */ && i + 1 < tokens.length && is_script_mark(tokens[i + 1])) {
@@ -611,15 +1344,27 @@ var BINARY_COMMANDS = [
   "dfrac",
   "tbinom"
 ];
+
+class Token {
+  type;
+  value;
+  constructor(type, value) {
+    this.type = type;
+    this.value = value;
+  }
+  eq(token) {
+    return this.type === token.type && this.value === token.value;
+  }
+}
 var EMPTY_NODE = { type: "empty", content: "" };
-var LEFT_CURLY_BRACKET = { type: 6 /* CONTROL */, value: "{" };
-var RIGHT_CURLY_BRACKET = { type: 6 /* CONTROL */, value: "}" };
-var LEFT_SQUARE_BRACKET = { type: 0 /* ELEMENT */, value: "[" };
-var RIGHT_SQUARE_BRACKET = { type: 0 /* ELEMENT */, value: "]" };
-var LEFT_COMMAND = { type: 1 /* COMMAND */, value: "\\left" };
-var RIGHT_COMMAND = { type: 1 /* COMMAND */, value: "\\right" };
-var BEGIN_COMMAND = { type: 1 /* COMMAND */, value: "\\begin" };
-var END_COMMAND = { type: 1 /* COMMAND */, value: "\\end" };
+var LEFT_CURLY_BRACKET = new Token(6 /* CONTROL */, "{");
+var RIGHT_CURLY_BRACKET = new Token(6 /* CONTROL */, "}");
+var LEFT_SQUARE_BRACKET = new Token(0 /* ELEMENT */, "[");
+var RIGHT_SQUARE_BRACKET = new Token(0 /* ELEMENT */, "]");
+var LEFT_COMMAND = new Token(1 /* COMMAND */, "\\left");
+var RIGHT_COMMAND = new Token(1 /* COMMAND */, "\\right");
+var BEGIN_COMMAND = new Token(1 /* COMMAND */, "\\begin");
+var END_COMMAND = new Token(1 /* COMMAND */, "\\end");
 
 class LatexParserError extends Error {
   constructor(message) {
@@ -627,8 +1372,8 @@ class LatexParserError extends Error {
     this.name = "LatexParserError";
   }
 }
-var SUB_SYMBOL = { type: 6 /* CONTROL */, value: "_" };
-var SUP_SYMBOL = { type: 6 /* CONTROL */, value: "^" };
+var SUB_SYMBOL = new Token(6 /* CONTROL */, "_");
+var SUP_SYMBOL = new Token(6 /* CONTROL */, "^");
 
 class LatexParser {
   space_sensitive;
@@ -680,22 +1425,22 @@ class LatexParser {
     let num_prime = 0;
     num_prime += eat_primes(tokens, pos);
     pos += num_prime;
-    if (pos < tokens.length && token_eq(tokens[pos], SUB_SYMBOL)) {
+    if (pos < tokens.length && tokens[pos].eq(SUB_SYMBOL)) {
       [sub, pos] = this.parseNextExprWithoutSupSub(tokens, pos + 1);
       num_prime += eat_primes(tokens, pos);
       pos += num_prime;
-      if (pos < tokens.length && token_eq(tokens[pos], SUP_SYMBOL)) {
+      if (pos < tokens.length && tokens[pos].eq(SUP_SYMBOL)) {
         [sup, pos] = this.parseNextExprWithoutSupSub(tokens, pos + 1);
         if (eat_primes(tokens, pos) > 0) {
           throw new LatexParserError("Double superscript");
         }
       }
-    } else if (pos < tokens.length && token_eq(tokens[pos], SUP_SYMBOL)) {
+    } else if (pos < tokens.length && tokens[pos].eq(SUP_SYMBOL)) {
       [sup, pos] = this.parseNextExprWithoutSupSub(tokens, pos + 1);
       if (eat_primes(tokens, pos) > 0) {
         throw new LatexParserError("Double superscript");
       }
-      if (pos < tokens.length && token_eq(tokens[pos], SUB_SYMBOL)) {
+      if (pos < tokens.length && tokens[pos].eq(SUB_SYMBOL)) {
         [sub, pos] = this.parseNextExprWithoutSupSub(tokens, pos + 1);
         if (eat_primes(tokens, pos) > 0) {
           throw new LatexParserError("Double superscript");
@@ -741,9 +1486,9 @@ class LatexParser {
       case 5 /* NEWLINE */:
         return [{ type: "newline", content: firstToken.value }, start + 1];
       case 1 /* COMMAND */:
-        if (token_eq(firstToken, BEGIN_COMMAND)) {
+        if (firstToken.eq(BEGIN_COMMAND)) {
           return this.parseBeginEndExpr(tokens, start);
-        } else if (token_eq(firstToken, LEFT_COMMAND)) {
+        } else if (firstToken.eq(LEFT_COMMAND)) {
           return this.parseLeftRightExpr(tokens, start);
         } else {
           return this.parseCommandExpr(tokens, start);
@@ -791,7 +1536,7 @@ class LatexParser {
         }
         return [{ type: "symbol", content: command }, pos];
       case 1: {
-        if (command === "\\sqrt" && pos < tokens.length && token_eq(tokens[pos], LEFT_SQUARE_BRACKET)) {
+        if (command === "\\sqrt" && pos < tokens.length && tokens[pos].eq(LEFT_SQUARE_BRACKET)) {
           const posLeftSquareBracket = pos;
           const posRightSquareBracket = find_closing_square_bracket(tokens, pos);
           const exprInside = tokens.slice(posLeftSquareBracket + 1, posRightSquareBracket);
@@ -802,9 +1547,9 @@ class LatexParser {
           if (pos + 2 >= tokens.length) {
             throw new LatexParserError("Expecting content for \\text command");
           }
-          assert(token_eq(tokens[pos], LEFT_CURLY_BRACKET));
+          assert(tokens[pos].eq(LEFT_CURLY_BRACKET));
           assert(tokens[pos + 1].type === 2 /* TEXT */);
-          assert(token_eq(tokens[pos + 2], RIGHT_CURLY_BRACKET));
+          assert(tokens[pos + 2].eq(RIGHT_CURLY_BRACKET));
           const text = tokens[pos + 1].value;
           return [{ type: "text", content: text }, pos + 3];
         }
@@ -821,7 +1566,7 @@ class LatexParser {
     }
   }
   parseLeftRightExpr(tokens, start) {
-    assert(token_eq(tokens[start], LEFT_COMMAND));
+    assert(tokens[start].eq(LEFT_COMMAND));
     let pos = start + 1;
     pos += eat_whitespaces(tokens, pos).length;
     if (pos >= tokens.length) {
@@ -859,11 +1604,11 @@ class LatexParser {
     return [res, pos];
   }
   parseBeginEndExpr(tokens, start) {
-    assert(token_eq(tokens[start], BEGIN_COMMAND));
+    assert(tokens[start].eq(BEGIN_COMMAND));
     let pos = start + 1;
-    assert(token_eq(tokens[pos], LEFT_CURLY_BRACKET));
+    assert(tokens[pos].eq(LEFT_CURLY_BRACKET));
     assert(tokens[pos + 1].type === 2 /* TEXT */);
-    assert(token_eq(tokens[pos + 2], RIGHT_CURLY_BRACKET));
+    assert(tokens[pos + 2].eq(RIGHT_CURLY_BRACKET));
     const envName = tokens[pos + 1].value;
     pos += 3;
     pos += eat_whitespaces(tokens, pos).length;
@@ -874,9 +1619,9 @@ class LatexParser {
     }
     const exprInsideEnd = endIdx;
     pos = endIdx + 1;
-    assert(token_eq(tokens[pos], LEFT_CURLY_BRACKET));
+    assert(tokens[pos].eq(LEFT_CURLY_BRACKET));
     assert(tokens[pos + 1].type === 2 /* TEXT */);
-    assert(token_eq(tokens[pos + 2], RIGHT_CURLY_BRACKET));
+    assert(tokens[pos + 2].eq(RIGHT_CURLY_BRACKET));
     if (tokens[pos + 1].value !== envName) {
       throw new LatexParserError("Mismatched \\begin and \\end environments");
     }
@@ -982,7 +1727,14 @@ function convertTree(node) {
         content: "",
         args: node.args.map(convertTree)
       };
-      if (["[]", "()", "\\{\\}", "\\lfloor\\rfloor", "\\lceil\\rceil"].includes(left.content + right.content)) {
+      if ([
+        "[]",
+        "()",
+        "\\{\\}",
+        "\\lfloor\\rfloor",
+        "\\lceil\\rceil",
+        "\\lfloor\\rceil"
+      ].includes(left.content + right.content)) {
         return group;
       }
       return {
@@ -1324,17 +2076,24 @@ class TypstWriter {
   finalize() {
     this.flushQueue();
     const smartFloorPass = function(input) {
-      let res = input.replace(/⌊\s*(.*?)\s*⌋/g, "floor($1)");
+      let res = input.replace(/floor\.l\s*(.*?)\s*floor\.r/g, "floor($1)");
       res = res.replace(/floor\(\)/g, 'floor("")');
       return res;
     };
     const smartCeilPass = function(input) {
-      let res = input.replace(/⌈\s*(.*?)\s*⌉/g, "ceil($1)");
+      let res = input.replace(/ceil\.l\s*(.*?)\s*ceil\.r/g, "ceil($1)");
       res = res.replace(/ceil\(\)/g, 'ceil("")');
       return res;
     };
-    this.buffer = smartFloorPass(this.buffer);
-    this.buffer = smartCeilPass(this.buffer);
+    const smartRoundPass = function(input) {
+      let res = input.replace(/floor\.l\s*(.*?)\s*ceil\.r/g, "round($1)");
+      res = res.replace(/round\(\)/g, 'round("")');
+      return res;
+    };
+    const all_passes = [smartFloorPass, smartCeilPass, smartRoundPass];
+    for (const pass of all_passes) {
+      this.buffer = pass(this.buffer);
+    }
     return this.buffer;
   }
 }