tex2typst 0.3.23 → 0.3.24

package/dist/index.js

@@ -1,1124 +1,15 @@
-// src/map.ts
-var symbolMap = /* @__PURE__ */ new Map([
-  ["displaystyle", "display"],
-  ["hspace", "#h"],
-  ["|", "bar.v.double"],
-  [",", "thin"],
-  [":", "med"],
-  [";", "thick"],
-  /* textual operators */
-  ["ln", "ln"],
-  ["log", "log"],
-  ["cos", "cos"],
-  ["sin", "sin"],
-  ["tan", "tan"],
-  ["cot", "cot"],
-  ["sec", "sec"],
-  ["csc", "csc"],
-  ["mod", "mod"],
-  ["omicron", "omicron"],
-  ["Xi", "Xi"],
-  ["Upsilon", "Upsilon"],
-  ["lim", "lim"],
-  ["nonumber", ""],
-  ["vec", "arrow"],
-  ["neq", "eq.not"],
-  ["dot", "dot"],
-  ["ddot", "dot.double"],
-  ["doteq", "dot(eq)"],
-  ["dots", "dots.h"],
-  ["vdots", "dots.v"],
-  ["ddots", "dots.down"],
-  ["widehat", "hat"],
-  // Ideally, the result of \widehat should be longer than \hat. But it is not implemented now.
-  ["widetilde", "tilde"],
-  // Ideally, the result of \widetilde should be longer than \tilde. But it is not implemented now.
-  ["quad", "quad"],
-  ["qquad", "wide"],
-  ["overbrace", "overbrace"],
-  // same
-  ["underbrace", "underbrace"],
-  // same
-  ["overline", "overline"],
-  // same
-  ["underline", "underline"],
-  // same
-  ["bar", "macron"],
-  ["dbinom", "binom"],
-  ["tbinom", "binom"],
-  ["dfrac", "frac"],
-  ["tfrac", "frac"],
-  ["operatorname", "op"],
-  ["boldsymbol", "bold"],
-  ["mathbb", "bb"],
-  ["mathbf", "bold"],
-  ["mathcal", "cal"],
-  ["mathit", "italic"],
-  ["mathfrak", "frak"],
-  ["mathrm", "upright"],
-  ["mathsf", "sans"],
-  ["mathtt", "mono"],
-  ["rm", "upright"],
-  // TODO: \pmb need special logic to handle but it is not implemented now. See the commented test case.
-  ["pmb", "bold"],
-  ["leadsto", "arrow.r.squiggly"],
-  ["P", "pilcrow"],
-  ["S", "section"],
-  ["aleph", "alef"],
-  ["infin", "infinity"],
-  ["Delta", "Delta"],
-  ["Gamma", "Gamma"],
-  ["Lambda", "Lambda"],
-  ["Omega", "Omega"],
-  ["Phi", "Phi"],
-  ["Pi", "Pi"],
-  ["Psi", "Psi"],
-  ["Sigma", "Sigma"],
-  ["Theta", "Theta"],
-  ["alpha", "alpha"],
-  // ['amalg', 'product.co'], 
-  ["beta", "beta"],
-  ["bigcirc", "circle.big"],
-  // ['bowtie', 'join'], 
-  ["bullet", "bullet"],
-  ["cdot", "dot.op"],
-  // 'dot.op' or 'dot.c'
-  ["cdots", "dots.c"],
-  ["checkmark", "checkmark"],
-  ["chi", "chi"],
-  ["circ", "circle.small"],
-  // 'circle.small' or 'compose'
-  ["colon", "colon"],
-  ["cong", "tilde.equiv"],
-  ["coprod", "product.co"],
-  ["copyright", "copyright"],
-  ["cup", "union"],
-  ["curlyvee", "or.curly"],
-  ["curlywedge", "and.curly"],
-  ["dagger", "dagger"],
-  ["dashv", "tack.l"],
-  ["ddagger", "dagger.double"],
-  ["delta", "delta"],
-  ["ddots", "dots.down"],
-  ["diamond", "diamond"],
-  ["div", "div"],
-  ["divideontimes", "times.div"],
-  ["dotplus", "plus.dot"],
-  ["ell", "ell"],
-  ["emptyset", "nothing"],
-  ["epsilon", "epsilon.alt"],
-  ["equiv", "equiv"],
-  ["eta", "eta"],
-  ["exists", "exists"],
-  ["forall", "forall"],
-  // ['frown', 'paren.t'], 
-  ["gamma", "gamma"],
-  ["ge", "gt.eq"],
-  ["geq", "gt.eq"],
-  ["geqslant", "gt.eq.slant"],
-  ["gg", "gt.double"],
-  ["hbar", "planck.reduce"],
-  ["imath", "dotless.i"],
-  ["iiiint", "integral.quad"],
-  ["iiint", "integral.triple"],
-  ["iint", "integral.double"],
-  ["in", "in"],
-  ["infty", "infinity"],
-  ["int", "integral"],
-  ["intercal", "top"],
-  // 'top' or 'tack.b'
-  ["iota", "iota"],
-  ["jmath", "dotless.j"],
-  ["kappa", "kappa"],
-  ["lambda", "lambda"],
-  ["land", "and"],
-  ["langle", "angle.l"],
-  ["lbrace", "brace.l"],
-  ["lbrack", "bracket.l"],
-  ["ldots", "dots.h"],
-  ["le", "lt.eq"],
-  ["leftthreetimes", "times.three.l"],
-  ["leftrightarrow", "arrow.l.r"],
-  ["leq", "lt.eq"],
-  ["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.equiv.not"],
-  ["ne", "eq.not"],
-  ["neg", "not"],
-  ["neq", "eq.not"],
-  ["nexists", "exists.not"],
-  ["ni", "in.rev"],
-  ["nleftarrow", "arrow.l.not"],
-  ["nleq", "lt.eq.not"],
-  ["nparallel", "parallel.not"],
-  ["ngeq", "gt.eq.not"],
-  ["nmid", "divides.not"],
-  ["notin", "in.not"],
-  // ['nrightarrow', 'arrow.not'], 
-  ["nsim", "tilde.not"],
-  ["nsubseteq", "subset.eq.not"],
-  ["nu", "nu"],
-  ["ntriangleleft", "lt.tri.not"],
-  ["ntriangleright", "gt.tri.not"],
-  ["odot", "dot.circle"],
-  ["oint", "integral.cont"],
-  ["oiint", "integral.surf"],
-  ["oiiint", "integral.vol"],
-  ["omega", "omega"],
-  ["ominus", "minus.circle"],
-  // ['oplus', 'xor'], // or 'plus.circle'
-  ["otimes", "times.circle"],
-  ["parallel", "parallel"],
-  ["partial", "diff"],
-  ["perp", "perp"],
-  ["phi", "phi.alt"],
-  ["pi", "pi"],
-  ["pm", "plus.minus"],
-  ["pounds", "pound"],
-  ["prec", "prec"],
-  ["preceq", "prec.eq"],
-  ["prime", "prime"],
-  ["prod", "product"],
-  ["propto", "prop"],
-  ["psi", "psi"],
-  ["rangle", "angle.r"],
-  ["rbrace", "brace.r"],
-  ["rbrack", "bracket.r"],
-  ["rhd", "triangle"],
-  ["rho", "rho"],
-  ["rightarrow", "arrow.r"],
-  ["rightthreetimes", "times.three.r"],
-  ["rtimes", "times.r"],
-  ["setminus", "without"],
-  ["sigma", "sigma"],
-  ["sim", "tilde.op"],
-  ["simeq", "tilde.eq"],
-  ["slash", "slash"],
-  ["smallsetminus", "without"],
-  // ['smile', 'paren.b'], 
-  ["spadesuit", "suit.spade"],
-  ["sqsubseteq", "subset.eq.sq"],
-  ["sqsupseteq", "supset.eq.sq"],
-  // ['star', 'star'], 
-  ["subset", "subset"],
-  ["subseteq", "subset.eq"],
-  ["subsetneq", "subset.neq"],
-  ["succ", "succ"],
-  ["succeq", "succ.eq"],
-  ["sum", "sum"],
-  ["supset", "supset"],
-  ["supseteq", "supset.eq"],
-  ["supsetneq", "supset.neq"],
-  ["tau", "tau"],
-  ["theta", "theta"],
-  ["times", "times"],
-  ["to", "arrow.r"],
-  ["top", "top"],
-  ["triangle", "triangle.t"],
-  // ['triangledown', 'triangle.b.small'], 
-  // ['triangleleft', 'triangle.l.small'], 
-  // ['triangleright', 'triangle.r.small'], 
-  ["twoheadrightarrow", "arrow.r.twohead"],
-  ["upharpoonright", "harpoon.tr"],
-  ["uplus", "union.plus"],
-  ["upsilon", "upsilon"],
-  ["varepsilon", "epsilon"],
-  ["varnothing", "diameter"],
-  // empty set
-  ["varphi", "phi"],
-  ["varpi", "pi.alt"],
-  ["varrho", "rho.alt"],
-  ["varsigma", "sigma.alt"],
-  ["vartheta", "theta.alt"],
-  ["vdash", "tack.r"],
-  ["vdots", "dots.v"],
-  ["vee", "or"],
-  ["wedge", "and"],
-  ["wr", "wreath"],
-  ["xi", "xi"],
-  ["yen", "yen"],
-  ["zeta", "zeta"],
-  // extended
-  ["mathscr", "scr"],
-  ["LaTeX", "#LaTeX"],
-  ["TeX", "#TeX"]
-]);
-var map_from_official_docs = /* @__PURE__ */ new Map([
-  ["acwopencirclearrow", "arrow.ccw"],
-  ["adots", "dots.up"],
-  ["angdnr", "angle.acute"],
-  ["angle", "angle"],
-  ["angles", "angle.s"],
-  ["approx", "approx"],
-  ["approxeq", "approx.eq"],
-  ["approxident", "tilde.triple"],
-  ["assert", "tack.r.short"],
-  ["ast", "ast.op"],
-  ["asymp", "asymp"],
-  ["awint", "integral.ccw"],
-  ["backcong", "tilde.rev.equiv"],
-  ["backdprime", "prime.double.rev"],
-  ["backprime", "prime.rev"],
-  ["backsim", "tilde.rev"],
-  ["backsimeq", "tilde.eq.rev"],
-  ["backslash", "backslash"],
-  ["backtrprime", "prime.triple.rev"],
-  ["bardownharpoonleft", "harpoon.bl.bar"],
-  ["bardownharpoonright", "harpoon.br.bar"],
-  ["barleftarrow", "arrow.l.stop"],
-  ["barleftarrowrightarrowbar", "arrows.lr.stop"],
-  ["barleftharpoondown", "harpoon.lb.stop"],
-  ["barleftharpoonup", "harpoon.lt.stop"],
-  ["barrightharpoondown", "harpoon.rb.bar"],
-  ["barrightharpoonup", "harpoon.rt.bar"],
-  ["baruparrow", "arrow.t.stop"],
-  ["barupharpoonleft", "harpoon.tl.stop"],
-  ["barupharpoonright", "harpoon.tr.stop"],
-  ["barV", "tack.b.double"],
-  ["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"],
-  ["because", "because"],
-  ["bigblacktriangledown", "triangle.filled.b"],
-  ["bigblacktriangleup", "triangle.filled.t"],
-  ["bigbot", "tack.t.big"],
-  ["bigcap", "inter.big"],
-  ["bigcup", "union.big"],
-  ["bigcupdot", "union.dot.big"],
-  ["biginterleave", "interleave.big"],
-  ["bigodot", "dot.circle.big"],
-  ["bigoplus", "plus.circle.big"],
-  // or 'xor.big'
-  ["bigotimes", "times.circle.big"],
-  ["bigsqcap", "inter.sq.big"],
-  ["bigsqcup", "union.sq.big"],
-  ["bigstar", "star.filled"],
-  ["bigtimes", "times.big"],
-  ["bigtop", "tack.b.big"],
-  ["bigtriangledown", "triangle.stroked.b"],
-  // or 'triangle.b'
-  ["bigtriangleup", "triangle.stroked.t"],
-  // or 'triangle.t'
-  ["biguplus", "union.plus.big"],
-  ["bigvee", "or.big"],
-  ["bigwedge", "and.big"],
-  ["bigwhitestar", "star.stroked"],
-  ["blackhourglass", "hourglass.filled"],
-  ["blacktriangle", "triangle.filled.small.t"],
-  ["blacktriangledown", "triangle.filled.small.b"],
-  ["blacktriangleleft", "triangle.filled.l"],
-  ["blacktriangleright", "triangle.filled.r"],
-  ["blkhorzoval", "ellipse.filled.h"],
-  ["blkvertoval", "ellipse.filled.v"],
-  ["bot", "bot"],
-  ["boxast", "ast.square"],
-  ["boxdot", "dot.square"],
-  ["boxminus", "minus.square"],
-  ["boxplus", "plus.square"],
-  ["boxtimes", "times.square"],
-  ["cap", "inter"],
-  ["Cap", "inter.double"],
-  ["capdot", "inter.dot"],
-  ["capwedge", "inter.and"],
-  ["caretinsert", "caret"],
-  ["cdot", "dot.op"],
-  ["cdotp", "dot.c"],
-  ["checkmark", "checkmark"],
-  ["circledast", "ast.circle"],
-  ["circledcirc", "circle.nested"],
-  ["circleddash", "dash.circle"],
-  ["circledequal", "eq.circle"],
-  ["circledparallel", "parallel.circle"],
-  ["circledvert", "bar.v.circle"],
-  ["clubsuit", "suit.club.filled"],
-  ["Colon", "colon.double"],
-  ["coloneq", "colon.eq"],
-  ["Coloneq", "colon.double.eq"],
-  ["complement", "complement"],
-  ["cong", "tilde.equiv"],
-  ["coprod", "product.co"],
-  ["cup", "union"],
-  ["Cup", "union.double"],
-  ["cupdot", "union.dot"],
-  ["cupleftarrow", "union.arrow"],
-  ["cupvee", "union.or"],
-  ["curlyeqprec", "eq.prec"],
-  ["curlyeqsucc", "eq.succ"],
-  ["curlyvee", "or.curly"],
-  ["curlywedge", "and.curly"],
-  ["curvearrowleft", "arrow.ccw.half"],
-  ["curvearrowright", "arrow.cw.half"],
-  ["cwopencirclearrow", "arrow.cw"],
-  ["dagger", "dagger"],
-  ["dashcolon", "dash.colon"],
-  ["dashv", "tack.l"],
-  ["Dashv", "tack.l.double"],
-  ["dashVdash", "tack.l.r"],
-  ["ddagger", "dagger.double"],
-  ["ddddot", "dot.quad"],
-  ["dddot", "dot.triple"],
-  ["ddots", "dots.down"],
-  ["DDownarrow", "arrow.b.quad"],
-  ["Ddownarrow", "arrow.b.triple"],
-  ["diameter", "diameter"],
-  ["diamondcdot", "diamond.stroked.dot"],
-  ["diamondsuit", "suit.diamond.stroked"],
-  ["dicei", "die.one"],
-  ["diceii", "die.two"],
-  ["diceiii", "die.three"],
-  ["diceiv", "die.four"],
-  ["dicev", "die.five"],
-  ["dicevi", "die.six"],
-  ["div", "div"],
-  ["divideontimes", "times.div"],
-  ["Doteq", "eq.dots"],
-  ["dotminus", "minus.dot"],
-  ["dotplus", "plus.dot"],
-  ["dotsim", "tilde.dot"],
-  ["dottedcircle", "circle.dotted"],
-  ["dottedsquare", "square.stroked.dotted"],
-  ["doubleplus", "plus.double"],
-  ["downarrow", "arrow.b"],
-  ["Downarrow", "arrow.b.double"],
-  ["downarrowbar", "arrow.b.stop"],
-  ["downdasharrow", "arrow.b.dashed"],
-  ["downdownarrows", "arrows.bb"],
-  ["downharpoonleft", "harpoon.bl"],
-  ["downharpoonleftbar", "harpoon.bl.stop"],
-  ["downharpoonright", "harpoon.br"],
-  ["downharpoonrightbar", "harpoon.br.stop"],
-  ["downharpoonsleftright", "harpoons.blbr"],
-  ["downrightcurvedarrow", "arrow.b.curve"],
-  ["downuparrows", "arrows.bt"],
-  ["downupharpoonsleftright", "harpoons.bltr"],
-  ["downwhitearrow", "arrow.b.stroked"],
-  ["downzigzagarrow", "arrow.zigzag"],
-  ["dprime", "prime.double"],
-  ["dualmap", "multimap.double"],
-  ["eighthnote", "note.eighth.alt"],
-  ["ell", "ell"],
-  ["emptysetoarr", "emptyset.arrow.r"],
-  ["emptysetoarrl", "emptyset.arrow.l"],
-  ["emptysetobar", "emptyset.bar"],
-  ["emptysetocirc", "emptyset.circle"],
-  ["eparsl", "parallel.slanted.eq"],
-  ["eqcolon", "eq.colon"],
-  ["eqdef", "eq.def"],
-  // \usepackage{mathtools} defines \eqdef
-  ["eqgtr", "eq.gt"],
-  ["eqless", "eq.lt"],
-  ["eqsim", "minus.tilde"],
-  ["equal", "eq"],
-  ["equalparallel", "parallel.eq"],
-  ["equiv", "eq.triple"],
-  ["Equiv", "eq.quad"],
-  ["equivVert", "parallel.equiv"],
-  ["eqvparsl", "parallel.slanted.equiv"],
-  ["errbarblackcircle", "errorbar.circle.filled"],
-  ["errbarblackdiamond", "errorbar.diamond.filled"],
-  ["errbarblacksquare", "errorbar.square.filled"],
-  ["errbarcircle", "errorbar.circle.stroked"],
-  ["errbardiamond", "errorbar.diamond.stroked"],
-  ["errbarsquare", "errorbar.square.stroked"],
-  ["euro", "euro"],
-  ["Exclam", "excl.double"],
-  ["exists", "exists"],
-  ["fallingdotseq", "eq.dots.down"],
-  ["fint", "integral.slash"],
-  ["flat", "flat"],
-  ["forall", "forall"],
-  ["fourvdots", "fence.dotted"],
-  ["fullouterjoin", "join.l.r"],
-  ["geq", "gt.eq"],
-  ["geqq", "gt.equiv"],
-  ["geqslant", "gt.eq.slant"],
-  ["gg", "gt.double"],
-  ["ggg", "gt.triple"],
-  ["gggnest", "gt.triple.nested"],
-  ["gnapprox", "gt.napprox"],
-  ["gneq", "gt.neq"],
-  ["gneqq", "gt.nequiv"],
-  ["gnsim", "gt.ntilde"],
-  ["greater", "gt"],
-  ["gtlpar", "angle.spheric.rev"],
-  ["gtrapprox", "gt.approx"],
-  ["gtrdot", "gt.dot"],
-  ["gtreqless", "gt.eq.lt"],
-  ["gtrless", "gt.lt"],
-  ["gtrsim", "gt.tilde"],
-  ["heartsuit", "suit.heart.stroked"],
-  ["hknearrow", "arrow.tr.hook"],
-  ["hknwarrow", "arrow.tl.hook"],
-  ["hksearrow", "arrow.br.hook"],
-  ["hkswarrow", "arrow.bl.hook"],
-  ["hookleftarrow", "arrow.l.hook"],
-  ["hookrightarrow", "arrow.r.hook"],
-  ["horizbar", "bar.h"],
-  ["hourglass", "hourglass.stroked"],
-  ["hrectangle", "rect.stroked.h"],
-  ["hrectangleblack", "rect.filled.h"],
-  ["hslash", "planck.reduce"],
-  ["hzigzag", "dash.wave.double"],
-  ["iiiint", "integral.quad"],
-  ["iiint", "integral.triple"],
-  ["iinfin", "infinity.incomplete"],
-  ["iint", "integral.double"],
-  ["Im", "Im"],
-  ["imageof", "image"],
-  ["in", "in"],
-  ["increment", "laplace"],
-  ["infty", "infinity"],
-  ["int", "integral"],
-  ["intbar", "integral.dash"],
-  ["intBar", "integral.dash.double"],
-  ["intcap", "integral.inter"],
-  ["intclockwise", "integral.cw"],
-  ["intcup", "integral.union"],
-  ["interleave", "interleave"],
-  ["intlarhk", "integral.arrow.hook"],
-  ["intx", "integral.times"],
-  ["Join", "join"],
-  ["langle", "angle.l"],
-  ["lAngle", "angle.l.double"],
-  ["langledot", "angle.l.dot"],
-  ["lat", "lat"],
-  ["late", "lat.eq"],
-  ["lbrace", "brace.l"],
-  ["lBrace", "brace.l.double"],
-  ["lbrack", "bracket.l"],
-  ["lBrack", "bracket.l.double"],
-  ["lbrbrak", "shell.l"],
-  ["Lbrbrak", "shell.l.double"],
-  ["lceil", "ceil.l"],
-  ["lcurvyangle", "angle.l.curly"],
-  ["leftarrow", "arrow.l"],
-  ["Leftarrow", "arrow.l.double"],
-  ["leftarrowtail", "arrow.l.tail"],
-  ["leftdasharrow", "arrow.l.dashed"],
-  ["leftdotarrow", "arrow.l.dotted"],
-  ["leftdowncurvedarrow", "arrow.l.curve"],
-  ["leftharpoondown", "harpoon.lb"],
-  ["leftharpoondownbar", "harpoon.lb.bar"],
-  ["leftharpoonsupdown", "harpoons.ltlb"],
-  ["leftharpoonup", "harpoon.lt"],
-  ["leftharpoonupbar", "harpoon.lt.bar"],
-  ["leftleftarrows", "arrows.ll"],
-  ["leftouterjoin", "join.l"],
-  ["leftrightarrow", "arrow.l.r"],
-  ["Leftrightarrow", "arrow.l.r.double"],
-  ["leftrightarrows", "arrows.lr"],
-  ["leftrightharpoondowndown", "harpoon.lb.rb"],
-  ["leftrightharpoondownup", "harpoon.lb.rt"],
-  ["leftrightharpoons", "harpoons.ltrb"],
-  ["leftrightharpoonsdown", "harpoons.lbrb"],
-  ["leftrightharpoonsup", "harpoons.ltrt"],
-  ["leftrightharpoonupdown", "harpoon.lt.rb"],
-  ["leftrightharpoonupup", "harpoon.lt.rt"],
-  ["leftrightsquigarrow", "arrow.l.r.wave"],
-  ["leftsquigarrow", "arrow.l.squiggly"],
-  ["leftthreearrows", "arrows.lll"],
-  ["leftthreetimes", "times.three.l"],
-  ["leftwavearrow", "arrow.l.wave"],
-  ["leftwhitearrow", "arrow.l.stroked"],
-  ["leq", "lt.eq"],
-  ["leqq", "lt.equiv"],
-  ["leqslant", "lt.eq.slant"],
-  ["less", "lt"],
-  ["lessapprox", "lt.approx"],
-  ["lessdot", "lt.dot"],
-  ["lesseqgtr", "lt.eq.gt"],
-  ["lessgtr", "lt.gt"],
-  ["lesssim", "lt.tilde"],
-  ["lfloor", "floor.l"],
-  ["lgblkcircle", "circle.filled.big"],
-  ["lgblksquare", "square.filled.big"],
-  ["lgwhtcircle", "circle.stroked.big"],
-  ["lgwhtsquare", "square.stroked.big"],
-  ["ll", "lt.double"],
-  ["llblacktriangle", "triangle.filled.bl"],
-  ["LLeftarrow", "arrow.l.quad"],
-  ["Lleftarrow", "arrow.l.triple"],
-  ["lll", "lt.triple"],
-  ["lllnest", "lt.triple.nested"],
-  ["lltriangle", "triangle.stroked.bl"],
-  ["lnapprox", "lt.napprox"],
-  ["lneq", "lt.neq"],
-  ["lneqq", "lt.nequiv"],
-  ["lnsim", "lt.ntilde"],
-  ["longdashv", "tack.l.long"],
-  ["Longleftarrow", "arrow.l.double.long"],
-  ["longleftarrow", "arrow.l.long"],
-  ["Longleftrightarrow", "arrow.l.r.double.long"],
-  ["longleftrightarrow", "arrow.l.r.long"],
-  ["longleftsquigarrow", "arrow.l.long.squiggly"],
-  ["Longmapsfrom", "arrow.l.double.long.bar"],
-  ["longmapsfrom", "arrow.l.long.bar"],
-  ["longmapsto", "arrow.r.long.bar"],
-  ["Longmapsto", "arrow.r.double.long.bar"],
-  ["Longrightarrow", "arrow.r.double.long"],
-  ["longrightarrow", "arrow.r.long"],
-  ["longrightsquigarrow", "arrow.r.long.squiggly"],
-  ["looparrowleft", "arrow.l.loop"],
-  ["looparrowright", "arrow.r.loop"],
-  ["lparen", "paren.l"],
-  ["lParen", "paren.l.double"],
-  ["lrblacktriangle", "triangle.filled.br"],
-  ["lrtriangle", "triangle.stroked.br"],
-  ["ltimes", "times.l"],
-  ["lvzigzag", "fence.l"],
-  ["Lvzigzag", "fence.l.double"],
-  ["maltese", "maltese"],
-  ["mapsdown", "arrow.b.bar"],
-  ["mapsfrom", "arrow.l.bar"],
-  ["Mapsfrom", "arrow.l.double.bar"],
-  ["mapsto", "arrow.r.bar"],
-  ["Mapsto", "arrow.r.double.bar"],
-  ["mapsup", "arrow.t.bar"],
-  ["mathampersand", "amp"],
-  ["mathatsign", "at"],
-  ["mathcolon", "colon"],
-  ["mathcomma", "comma"],
-  ["mathdollar", "dollar"],
-  ["mathexclam", "excl"],
-  // ['mathhyphen', 'hyph'], // \mathhyphen is not defined in standard amsmath package
-  ["mathoctothorpe", "hash"],
-  ["mathparagraph", "pilcrow"],
-  ["mathpercent", "percent"],
-  ["mathperiod", "dot.basic"],
-  ["mathplus", "plus"],
-  ["mathquestion", "quest"],
-  ["mathratio", "ratio"],
-  ["mathsection", "section"],
-  ["mathsemicolon", "semi"],
-  ["mathslash", "slash"],
-  ["mathsterling", "pound"],
-  ["mathyen", "yen"],
-  ["mdblkdiamond", "diamond.filled.medium"],
-  ["mdblklozenge", "lozenge.filled.medium"],
-  ["mdblksquare", "square.filled.medium"],
-  ["mdlgblkcircle", "circle.filled"],
-  ["mdlgblkdiamond", "diamond.filled"],
-  ["mdlgblklozenge", "lozenge.filled"],
-  ["mdlgblksquare", "square.filled"],
-  ["mdlgwhtcircle", "circle.stroked"],
-  ["mdlgwhtdiamond", "diamond.stroked"],
-  ["mdlgwhtlozenge", "lozenge.stroked"],
-  ["mdlgwhtsquare", "square.stroked"],
-  ["mdsmblkcircle", "circle.filled.tiny"],
-  ["mdsmblksquare", "square.filled.small"],
-  ["mdsmwhtcircle", "circle.stroked.small"],
-  ["mdsmwhtsquare", "square.stroked.small"],
-  ["mdwhtdiamond", "diamond.stroked.medium"],
-  ["mdwhtlozenge", "lozenge.stroked.medium"],
-  ["mdwhtsquare", "square.stroked.medium"],
-  ["measeq", "eq.m"],
-  ["measuredangle", "angle.arc"],
-  ["measuredangleleft", "angle.arc.rev"],
-  ["measuredrightangle", "angle.right.arc"],
-  ["mho", "Omega.inv"],
-  ["mid", "divides"],
-  ["minus", "minus"],
-  ["models", "models"],
-  ["mp", "minus.plus"],
-  ["multimap", "multimap"],
-  /* ['mupAlpha', 'Alpha'],
-  ['mupalpha', 'alpha'],
-  ['mupBeta', 'Beta'],
-  ['mupbeta', 'beta'],
-  ['mupChi', 'Chi'],
-  ['mupchi', 'chi'],
-  ['mupDelta', 'Delta'],
-  ['mupdelta', 'delta'],
-  ['mupEpsilon', 'Epsilon'],
-  ['mupepsilon', 'epsilon.alt'],
-  ['mupEta', 'Eta'],
-  ['mupeta', 'eta'],
-  ['mupGamma', 'Gamma'],
-  ['mupgamma', 'gamma'],
-  ['mupIota', 'Iota'],
-  ['mupiota', 'iota'],
-  ['mupKappa', 'Kappa'],
-  ['mupkappa', 'kappa'],
-  ['mupLambda', 'Lambda'],
-  ['muplambda', 'lambda'],
-  ['mupMu', 'Mu'],
-  ['mupmu', 'mu'],
-  ['mupNu', 'Nu'],
-  ['mupnu', 'nu'],
-  ['mupOmega', 'Omega'],
-  ['mupomega', 'omega'],
-  ['mupOmicron', 'Omicron'],
-  ['mupomicron', 'omicron'],
-  ['mupPhi', 'Phi'],
-  ['mupphi', 'phi.alt'],
-  ['mupPi', 'Pi'],
-  ['muppi', 'pi'],
-  ['mupPsi', 'Psi'],
-  ['muppsi', 'psi'],
-  ['mupRho', 'Rho'],
-  ['muprho', 'rho'],
-  ['mupSigma', 'Sigma'],
-  ['mupsigma', 'sigma'],
-  ['mupTau', 'Tau'],
-  ['muptau', 'tau'],
-  ['mupTheta', 'Theta'],
-  ['muptheta', 'theta'],
-  ['mupUpsilon', 'Upsilon'],
-  ['mupupsilon', 'upsilon'],
-  ['mupvarepsilon', 'epsilon'],
-  ['mupvarkappa', 'kappa.alt'],
-  ['mupvarphi', 'phi'],
-  ['mupvarpi', 'pi.alt'],
-  ['mupvarrho', 'rho.alt'],
-  ['mupvarsigma', 'sigma.alt'],
-  ['mupvartheta', 'theta.alt'],
-  ['mupXi', 'Xi'],
-  ['mupxi', 'xi'],
-  ['mupZeta', 'Zeta'],
-  ['mupzeta', 'zeta'], */
-  ["nabla", "gradient"],
-  ["napprox", "approx.not"],
-  ["nasymp", "asymp.not"],
-  ["natural", "natural"],
-  ["ncong", "tilde.equiv.not"],
-  ["ne", "eq.not"],
-  ["nearrow", "arrow.tr"],
-  ["Nearrow", "arrow.tr.double"],
-  ["neg", "not"],
-  ["nequiv", "equiv.not"],
-  // or eq.triple.not
-  ["neswarrow", "arrow.tr.bl"],
-  ["nexists", "exists.not"],
-  ["ngeq", "gt.eq.not"],
-  ["ngtr", "gt.not"],
-  ["ngtrless", "gt.lt.not"],
-  ["ngtrsim", "gt.tilde.not"],
-  ["nhpar", "parallel.struck"],
-  ["nhVvert", "interleave.struck"],
-  ["ni", "in.rev"],
-  ["nLeftarrow", "arrow.l.double.not"],
-  ["nleftarrow", "arrow.l.not"],
-  ["nLeftrightarrow", "arrow.l.r.double.not"],
-  ["nleftrightarrow", "arrow.l.r.not"],
-  ["nleq", "lt.eq.not"],
-  ["nless", "lt.not"],
-  ["nlessgtr", "lt.gt.not"],
-  ["nlesssim", "lt.tilde.not"],
-  ["nmid", "divides.not"],
-  ["nni", "in.rev.not"],
-  ["notin", "in.not"],
-  ["nparallel", "parallel.not"],
-  ["nprec", "prec.not"],
-  ["npreccurlyeq", "prec.curly.eq.not"],
-  ["nRightarrow", "arrow.r.double.not"],
-  ["nrightarrow", "arrow.r.not"],
-  ["nsim", "tilde.not"],
-  ["nsimeq", "tilde.eq.not"],
-  ["nsqsubseteq", "subset.eq.sq.not"],
-  ["nsqsupseteq", "supset.eq.sq.not"],
-  ["nsubset", "subset.not"],
-  ["nsubseteq", "subset.eq.not"],
-  ["nsucc", "succ.not"],
-  ["nsucccurlyeq", "succ.curly.eq.not"],
-  ["nsupset", "supset.not"],
-  ["nsupseteq", "supset.eq.not"],
-  ["ntrianglelefteq", "lt.tri.eq.not"],
-  ["ntrianglerighteq", "gt.tri.eq.not"],
-  ["nvartriangleleft", "lt.tri.not"],
-  ["nvartriangleright", "gt.tri.not"],
-  ["nVdash", "forces.not"],
-  ["nvdash", "tack.r.not"],
-  ["nvDash", "tack.r.double.not"],
-  ["nvinfty", "infinity.bar"],
-  ["nwarrow", "arrow.tl"],
-  ["Nwarrow", "arrow.tl.double"],
-  ["nwsearrow", "arrow.tl.br"],
-  ["obrbrak", "shell.t"],
-  ["obslash", "backslash.circle"],
-  ["odiv", "div.circle"],
-  ["odot", "dot.circle"],
-  ["ogreaterthan", "gt.circle"],
-  ["oiiint", "integral.vol"],
-  ["oiint", "integral.surf"],
-  ["oint", "integral.cont"],
-  ["ointctrclockwise", "integral.cont.ccw"],
-  ["olessthan", "lt.circle"],
-  ["ominus", "minus.circle"],
-  ["operp", "perp.circle"],
-  ["oplus", "plus.circle"],
-  ["origof", "original"],
-  ["otimes", "times.circle"],
-  // ['overbrace', 'brace.t'],
-  ["overbracket", "bracket.t"],
-  ["overparen", "paren.t"],
-  ["parallel", "parallel"],
-  ["parallelogram", "parallelogram.stroked"],
-  ["parallelogramblack", "parallelogram.filled"],
-  ["parsim", "parallel.tilde"],
-  ["partial", "diff"],
-  ["pentagon", "penta.stroked"],
-  ["pentagonblack", "penta.filled"],
-  ["perp", "perp"],
-  ["Planckconst", "planck"],
-  ["pm", "plus.minus"],
-  ["prec", "prec"],
-  ["Prec", "prec.double"],
-  ["precapprox", "prec.approx"],
-  ["preccurlyeq", "prec.curly.eq"],
-  ["preceq", "prec.eq"],
-  ["preceqq", "prec.equiv"],
-  ["precnapprox", "prec.napprox"],
-  ["precneq", "prec.neq"],
-  ["precneqq", "prec.nequiv"],
-  ["precnsim", "prec.ntilde"],
-  ["precsim", "prec.tilde"],
-  ["prime", "prime"],
-  ["prod", "product"],
-  ["propto", "prop"],
-  ["QED", "qed"],
-  ["qprime", "prime.quad"],
-  ["quarternote", "note.quarter.alt"],
-  ["questeq", "eq.quest"],
-  ["Question", "quest.double"],
-  ["rangle", "angle.r"],
-  ["rAngle", "angle.r.double"],
-  ["rangledot", "angle.r.dot"],
-  ["rbrace", "brace.r"],
-  ["rBrace", "brace.r.double"],
-  ["rbrack", "bracket.r"],
-  ["rBrack", "bracket.r.double"],
-  ["rbrbrak", "shell.r"],
-  ["Rbrbrak", "shell.r.double"],
-  ["rceil", "ceil.r"],
-  ["rcurvyangle", "angle.r.curly"],
-  ["Re", "Re"],
-  ["revangle", "angle.rev"],
-  ["revemptyset", "emptyset.rev"],
-  ["revnmid", "divides.not.rev"],
-  ["rfloor", "floor.r"],
-  ["rightangle", "angle.right"],
-  ["rightanglemdot", "angle.right.dot"],
-  ["rightanglesqr", "angle.right.sq"],
-  ["rightarrow", "arrow.r"],
-  ["Rightarrow", "arrow.r.double"],
-  ["rightarrowbar", "arrow.r.stop"],
-  ["rightarrowonoplus", "plus.circle.arrow"],
-  ["rightarrowtail", "arrow.r.tail"],
-  ["rightdasharrow", "arrow.r.dashed"],
-  ["rightdotarrow", "arrow.r.dotted"],
-  ["rightdowncurvedarrow", "arrow.r.curve"],
-  ["rightharpoondown", "harpoon.rb"],
-  ["rightharpoondownbar", "harpoon.rb.stop"],
-  ["rightharpoonsupdown", "harpoons.rtrb"],
-  ["rightharpoonup", "harpoon.rt"],
-  ["rightharpoonupbar", "harpoon.rt.stop"],
-  ["rightleftarrows", "arrows.rl"],
-  ["rightleftharpoons", "harpoons.rtlb"],
-  ["rightleftharpoonsdown", "harpoons.rblb"],
-  ["rightleftharpoonsup", "harpoons.rtlt"],
-  ["rightouterjoin", "join.r"],
-  ["rightrightarrows", "arrows.rr"],
-  ["rightsquigarrow", "arrow.r.squiggly"],
-  ["rightthreearrows", "arrows.rrr"],
-  ["rightthreetimes", "times.three.r"],
-  ["rightwavearrow", "arrow.r.wave"],
-  ["rightwhitearrow", "arrow.r.stroked"],
-  ["risingdotseq", "eq.dots.up"],
-  ["rparen", "paren.r"],
-  ["rParen", "paren.r.double"],
-  ["RRightarrow", "arrow.r.quad"],
-  ["Rrightarrow", "arrow.r.triple"],
-  ["rsolbar", "backslash.not"],
-  ["rtimes", "times.r"],
-  ["rvzigzag", "fence.r"],
-  ["Rvzigzag", "fence.r.double"],
-  ["searrow", "arrow.br"],
-  ["Searrow", "arrow.br.double"],
-  ["setminus", "without"],
-  ["sharp", "sharp"],
-  ["shortdowntack", "tack.b.short"],
-  ["shortlefttack", "tack.l.short"],
-  ["shortuptack", "tack.t.short"],
-  ["sim", "tilde.op"],
-  ["sime", "tilde.eq"],
-  ["similarleftarrow", "arrow.l.tilde"],
-  ["similarrightarrow", "arrow.r.tilde"],
-  ["simneqq", "tilde.nequiv"],
-  ["smallblacktriangleleft", "triangle.filled.small.l"],
-  ["smallblacktriangleright", "triangle.filled.small.r"],
-  ["smallin", "in.small"],
-  ["smallni", "in.rev.small"],
-  ["smalltriangleleft", "triangle.stroked.small.l"],
-  ["smalltriangleright", "triangle.stroked.small.r"],
-  ["smashtimes", "smash"],
-  ["smblkcircle", "bullet"],
-  ["smblkdiamond", "diamond.filled.small"],
-  ["smblklozenge", "lozenge.filled.small"],
-  ["smblksquare", "square.filled.tiny"],
-  ["smeparsl", "parallel.slanted.eq.tilde"],
-  ["smt", "smt"],
-  ["smte", "smt.eq"],
-  ["smwhtdiamond", "diamond.stroked.small"],
-  ["smwhtlozenge", "lozenge.stroked.small"],
-  ["smwhtsquare", "square.stroked.tiny"],
-  ["spadesuit", "suit.spade.filled"],
-  ["sphericalangle", "angle.spheric"],
-  ["sphericalangleup", "angle.spheric.top"],
-  ["sqcap", "inter.sq"],
-  ["Sqcap", "inter.sq.double"],
-  ["sqcup", "union.sq"],
-  ["Sqcup", "union.sq.double"],
-  ["sqint", "integral.square"],
-  ["sqsubset", "subset.sq"],
-  ["sqsubseteq", "subset.eq.sq"],
-  ["sqsubsetneq", "subset.sq.neq"],
-  ["sqsupset", "supset.sq"],
-  ["sqsupseteq", "supset.eq.sq"],
-  ["sqsupsetneq", "supset.sq.neq"],
-  ["squoval", "square.stroked.rounded"],
-  ["sslash", "slash.double"],
-  ["star", "star.op"],
-  ["stareq", "eq.star"],
-  ["subset", "subset"],
-  ["Subset", "subset.double"],
-  ["subsetdot", "subset.dot"],
-  ["subseteq", "subset.eq"],
-  ["subsetneq", "subset.neq"],
-  ["succ", "succ"],
-  ["Succ", "succ.double"],
-  ["succapprox", "succ.approx"],
-  ["succcurlyeq", "succ.curly.eq"],
-  ["succeq", "succ.eq"],
-  ["succeqq", "succ.equiv"],
-  ["succnapprox", "succ.napprox"],
-  ["succneq", "succ.neq"],
-  ["succneqq", "succ.nequiv"],
-  ["succnsim", "succ.ntilde"],
-  ["succsim", "succ.tilde"],
-  ["sum", "sum"],
-  ["sumint", "sum.integral"],
-  ["supset", "supset"],
-  ["Supset", "supset.double"],
-  ["supsetdot", "supset.dot"],
-  ["supseteq", "supset.eq"],
-  ["supsetneq", "supset.neq"],
-  ["swarrow", "arrow.bl"],
-  ["Swarrow", "arrow.bl.double"],
-  ["therefore", "therefore"],
-  ["threedangle", "angle.spatial"],
-  ["threedotcolon", "colon.tri.op"],
-  ["tieinfty", "infinity.tie"],
-  ["times", "times"],
-  ["tminus", "miny"],
-  ["top", "tack.b"],
-  ["tplus", "tiny"],
-  ["trianglecdot", "triangle.stroked.dot"],
-  ["triangledown", "triangle.stroked.small.b"],
-  ["triangleleft", "triangle.stroked.l"],
-  ["trianglelefteq", "lt.tri.eq"],
-  ["triangleminus", "minus.triangle"],
-  ["triangleplus", "plus.triangle"],
-  ["triangleq", "eq.delta"],
-  ["triangleright", "triangle.stroked.r"],
-  ["trianglerighteq", "gt.tri.eq"],
-  ["triangletimes", "times.triangle"],
-  ["tripleplus", "plus.triple"],
-  ["trprime", "prime.triple"],
-  ["trslash", "slash.triple"],
-  ["twoheaddownarrow", "arrow.b.twohead"],
-  ["twoheadleftarrow", "arrow.l.twohead"],
-  ["twoheadmapsfrom", "arrow.l.twohead.bar"],
-  ["twoheadmapsto", "arrow.r.twohead.bar"],
-  ["twoheadrightarrow", "arrow.r.twohead"],
-  ["twoheaduparrow", "arrow.t.twohead"],
-  ["twonotes", "note.eighth.beamed"],
-  ["ubrbrak", "shell.b"],
-  ["ulblacktriangle", "triangle.filled.tl"],
-  ["ultriangle", "triangle.stroked.tl"],
-  ["uminus", "union.minus"],
-  ["underbrace", "brace.b"],
-  ["underbracket", "bracket.b"],
-  ["underparen", "paren.b"],
-  ["unicodecdots", "dots.h.c"],
-  ["unicodeellipsis", "dots.h"],
-  ["upand", "amp.inv"],
-  ["uparrow", "arrow.t"],
-  ["Uparrow", "arrow.t.double"],
-  ["updasharrow", "arrow.t.dashed"],
-  ["updownarrow", "arrow.t.b"],
-  ["Updownarrow", "arrow.t.b.double"],
-  ["updownarrows", "arrows.tb"],
-  ["updownharpoonleftleft", "harpoon.tl.bl"],
-  ["updownharpoonleftright", "harpoon.tl.br"],
-  ["updownharpoonrightleft", "harpoon.tr.bl"],
-  ["updownharpoonrightright", "harpoon.tr.br"],
-  ["updownharpoonsleftright", "harpoons.tlbr"],
-  ["upharpoonleft", "harpoon.tl"],
-  ["upharpoonleftbar", "harpoon.tl.bar"],
-  ["upharpoonright", "harpoon.tr"],
-  ["upharpoonrightbar", "harpoon.tr.bar"],
-  ["upharpoonsleftright", "harpoons.tltr"],
-  ["uplus", "union.plus"],
-  ["uprightcurvearrow", "arrow.t.curve"],
-  ["upuparrows", "arrows.tt"],
-  ["upwhitearrow", "arrow.t.stroked"],
-  ["urblacktriangle", "triangle.filled.tr"],
-  ["urtriangle", "triangle.stroked.tr"],
-  ["UUparrow", "arrow.t.quad"],
-  ["Uuparrow", "arrow.t.triple"],
-  ["varclubsuit", "suit.club.stroked"],
-  ["vardiamondsuit", "suit.diamond.filled"],
-  ["varheartsuit", "suit.heart.filled"],
-  ["varhexagon", "hexa.stroked"],
-  ["varhexagonblack", "hexa.filled"],
-  ["varnothing", "emptyset"],
-  ["varointclockwise", "integral.cont.cw"],
-  ["varspadesuit", "suit.spade.stroked"],
-  ["vartriangle", "triangle.stroked.small.t"],
-  ["vartriangleleft", "lt.tri"],
-  ["vartriangleright", "gt.tri"],
-  ["Vbar", "tack.t.double"],
-  ["Vdash", "forces"],
-  ["vdash", "tack.r"],
-  ["vDash", "tack.r.double"],
-  ["vdots", "dots.v"],
-  ["vee", "or"],
-  ["Vee", "or.double"],
-  ["veedot", "or.dot"],
-  ["veeeq", "eq.equi"],
-  ["vert", "bar.v"],
-  ["Vert", "bar.v.double"],
-  ["vlongdash", "tack.r.long"],
-  ["vrectangle", "rect.stroked.v"],
-  ["vrectangleblack", "rect.filled.v"],
-  ["Vvert", "bar.v.triple"],
-  ["vysmblkcircle", "circle.filled.small"],
-  ["vysmwhtcircle", "circle.stroked.tiny"],
-  // or compose
-  ["wedge", "and"],
-  ["Wedge", "and.double"],
-  ["wedgedot", "and.dot"],
-  ["wedgeq", "eq.est"],
-  ["whiteinwhitetriangle", "triangle.stroked.nested"],
-  ["whthorzoval", "ellipse.stroked.h"],
-  ["whtvertoval", "ellipse.stroked.v"],
-  ["wideangledown", "angle.oblique"],
-  ["wr", "wreath"],
-  ["xsol", "slash.big"]
-]);
-var texAliasMap = /* @__PURE__ */ new Map([
-  ["gets", "leftarrow"],
-  ["iff", "Longleftrightarrow"],
-  ["implies", "Longrightarrow"]
-]);
-for (const [key, value] of map_from_official_docs) {
-  if (!symbolMap.has(key)) {
-    symbolMap.set(key, value);
-  }
-}
-var reverseSymbolMap = /* @__PURE__ */ new Map();
-for (const [key, value] of Array.from(symbolMap.entries()).reverse()) {
-  reverseSymbolMap.set(value, key);
-}
-reverseSymbolMap.set("oo", "infty");
-var typst_to_tex_map = /* @__PURE__ */ new Map([
-  ["top", "top"],
-  ["frac", "frac"],
-  ["tilde", "tilde"],
-  ["hat", "hat"],
-  ["upright", "mathrm"],
-  ["bold", "boldsymbol"],
-  ["infinity", "infty"]
-]);
-for (const [key, value] of typst_to_tex_map) {
-  reverseSymbolMap.set(key, value);
-}
-for (const [key, value] of texAliasMap) {
-  if (!symbolMap.has(key)) {
-    symbolMap.set(key, symbolMap.get(value));
-  }
-}
-
-// src/generic.ts
-function array_find(array, item, start = 0) {
-  for (let i = start; i < array.length; i++) {
-    if (array[i].eq(item)) {
-      return i;
-    }
-  }
-  return -1;
-}
-function array_includes(array, item) {
-  for (const i of array) {
-    if (i.eq(item)) {
-      return true;
-    }
-  }
-  return false;
-}
-function array_split(array, sep) {
-  const res = [];
-  let current_slice = [];
-  for (const i of array) {
-    if (i.eq(sep)) {
-      res.push(current_slice);
-      current_slice = [];
-    } else {
-      current_slice.push(i);
-    }
-  }
-  res.push(current_slice);
-  return res;
+// src/util.ts
+function isalpha(char) {
+  return "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ".includes(char);
 }
-function array_intersperse(array, sep) {
-  const res = [];
-  for (let i = 0; i < array.length; i++) {
-    res.push(array[i]);
-    if (i != array.length - 1) {
-      res.push(sep);
-    }
+function assert(condition, message = "Assertion failed.") {
+  if (!condition) {
+    throw new Error(message);
   }
-  return res;
 }
 
-// src/types.ts
-var TexToken = class {
+// src/tex-types.ts
+var TexToken = class _TexToken {
   constructor(type, value) {
     this.type = type;
     this.value = value;
@@ -1128,283 +19,248 @@ var TexToken = class {
   }
   toString() {
     switch (this.type) {
-      case 3 /* COMMENT */:
+      case 4 /* COMMENT */:
         return "%" + this.value;
       default:
         return this.value;
     }
   }
-};
-function apply_escape_if_needed(c) {
-  if (["{", "}", "%"].includes(c)) {
-    return "\\" + c;
+  toNode() {
+    return new TexTerminal(this);
   }
-  return c;
-}
+  static {
+    this.EMPTY = new _TexToken(0 /* EMPTY */, "");
+  }
+};
 var TexNode = class {
-  constructor(type, content, args, data) {
+  constructor(type, head, args) {
     this.type = type;
-    this.content = content;
+    this.head = head ? head : TexToken.EMPTY;
     this.args = args;
-    this.data = data;
   }
   // Note that this is only shallow equality.
   eq(other) {
-    return this.type === other.type && this.content === other.content;
+    return this.type === other.type && this.head.eq(other.head);
+  }
+  // Note: toString() is expensive. Do not use it on performance-critical code path.
+  toString() {
+    return this.serialize().reduce(writeTexTokenBuffer, "");
+  }
+};
+var TexTerminal = class extends TexNode {
+  constructor(head) {
+    super("terminal", head);
   }
   serialize() {
-    switch (this.type) {
-      case "empty":
+    switch (this.head.type) {
+      case 0 /* EMPTY */:
         return [];
-      case "element": {
-        let c = this.content;
-        c = apply_escape_if_needed(c);
-        return [new TexToken(0 /* ELEMENT */, c)];
-      }
-      case "symbol":
-        return [new TexToken(1 /* COMMAND */, this.content)];
-      case "literal":
-        return [new TexToken(2 /* LITERAL */, this.content)];
-      case "text":
-        return [
-          new TexToken(1 /* COMMAND */, "\\text"),
-          new TexToken(0 /* ELEMENT */, "{"),
-          new TexToken(2 /* LITERAL */, this.content),
-          new TexToken(0 /* ELEMENT */, "}")
-        ];
-      case "comment":
-        return [new TexToken(3 /* COMMENT */, this.content)];
-      case "whitespace": {
+      case 1 /* ELEMENT */:
+      case 2 /* COMMAND */:
+      case 3 /* LITERAL */:
+      case 4 /* COMMENT */:
+      case 7 /* CONTROL */: {
+        return [this.head];
+      }
+      case 5 /* SPACE */:
+      case 6 /* NEWLINE */: {
         const tokens = [];
-        for (const c of this.content) {
-          const token_type = c === " " ? 4 /* SPACE */ : 5 /* NEWLINE */;
+        for (const c of this.head.value) {
+          const token_type = c === " " ? 5 /* SPACE */ : 6 /* NEWLINE */;
           tokens.push(new TexToken(token_type, c));
         }
         return tokens;
       }
-      case "ordgroup": {
-        return this.args.map((n) => n.serialize()).flat();
-      }
-      case "leftright": {
-        let tokens = this.args.map((n) => n.serialize()).flat();
-        tokens.splice(0, 0, new TexToken(1 /* COMMAND */, "\\left"));
-        tokens.splice(tokens.length - 1, 0, new TexToken(1 /* COMMAND */, "\\right"));
-        return tokens;
-      }
-      case "unaryFunc": {
-        let tokens = [];
-        tokens.push(new TexToken(1 /* COMMAND */, this.content));
-        if (this.content === "\\sqrt" && this.data) {
-          tokens.push(new TexToken(0 /* ELEMENT */, "["));
-          tokens = tokens.concat(this.data.serialize());
-          tokens.push(new TexToken(0 /* ELEMENT */, "]"));
-        }
-        if (this.content === "\\operatorname" && this.args.length === 1 && this.args[0].type === "text") {
-          const text = this.args[0].content;
-          tokens.push(new TexToken(0 /* ELEMENT */, "{"));
-          tokens.push(new TexToken(1 /* COMMAND */, text));
-          tokens.push(new TexToken(0 /* ELEMENT */, "}"));
-          return tokens;
-        }
-        tokens.push(new TexToken(0 /* ELEMENT */, "{"));
-        tokens = tokens.concat(this.args[0].serialize());
-        tokens.push(new TexToken(0 /* ELEMENT */, "}"));
-        return tokens;
-      }
-      case "binaryFunc": {
-        let tokens = [];
-        tokens.push(new TexToken(1 /* COMMAND */, this.content));
-        tokens.push(new TexToken(0 /* ELEMENT */, "{"));
-        tokens = tokens.concat(this.args[0].serialize());
-        tokens.push(new TexToken(0 /* ELEMENT */, "}"));
-        tokens.push(new TexToken(0 /* ELEMENT */, "{"));
-        tokens = tokens.concat(this.args[1].serialize());
-        tokens.push(new TexToken(0 /* ELEMENT */, "}"));
-        return tokens;
-      }
-      case "supsub": {
-        let should_wrap_in_braces2 = function(node) {
-          if (node.type === "ordgroup" || node.type === "supsub" || node.type === "empty") {
-            return true;
-          } else if (node.type === "element" && /\d+(\.\d+)?/.test(node.content) && node.content.length > 1) {
-            return true;
-          } else {
-            return false;
-          }
-        };
-        var should_wrap_in_braces = should_wrap_in_braces2;
-        let tokens = [];
-        const { base, sup, sub } = this.data;
-        tokens = tokens.concat(base.serialize());
-        if (sub) {
-          tokens.push(new TexToken(6 /* CONTROL */, "_"));
-          if (should_wrap_in_braces2(sub)) {
-            tokens.push(new TexToken(0 /* ELEMENT */, "{"));
-            tokens = tokens.concat(sub.serialize());
-            tokens.push(new TexToken(0 /* ELEMENT */, "}"));
-          } else {
-            tokens = tokens.concat(sub.serialize());
-          }
-        }
-        if (sup) {
-          tokens.push(new TexToken(6 /* CONTROL */, "^"));
-          if (should_wrap_in_braces2(sup)) {
-            tokens.push(new TexToken(0 /* ELEMENT */, "{"));
-            tokens = tokens.concat(sup.serialize());
-            tokens.push(new TexToken(0 /* ELEMENT */, "}"));
-          } else {
-            tokens = tokens.concat(sup.serialize());
-          }
-        }
-        return tokens;
-      }
-      case "control": {
-        return [new TexToken(6 /* CONTROL */, this.content)];
-      }
-      case "beginend": {
-        let tokens = [];
-        const matrix = this.data;
-        tokens.push(new TexToken(1 /* COMMAND */, `\\begin{${this.content}}`));
-        tokens.push(new TexToken(5 /* NEWLINE */, "\n"));
-        for (let i = 0; i < matrix.length; i++) {
-          const row = matrix[i];
-          for (let j = 0; j < row.length; j++) {
-            const cell = row[j];
-            tokens = tokens.concat(cell.serialize());
-            if (j !== row.length - 1) {
-              tokens.push(new TexToken(6 /* CONTROL */, "&"));
-            }
-          }
-          if (i !== matrix.length - 1) {
-            tokens.push(new TexToken(6 /* CONTROL */, "\\\\"));
-          }
-        }
-        tokens.push(new TexToken(5 /* NEWLINE */, "\n"));
-        tokens.push(new TexToken(1 /* COMMAND */, `\\end{${this.content}}`));
-        return tokens;
-      }
       default:
-        throw new Error("[TexNode.serialize] Unimplemented type: " + this.type);
+        throw new Error(`Unknown terminal token type: ${this.head.type}`);
     }
   }
 };
-var TypstToken = class {
-  constructor(type, content) {
-    this.type = type;
-    this.value = content;
+var TexText = class extends TexNode {
+  constructor(head) {
+    assert(head.type === 3 /* LITERAL */);
+    super("text", head);
   }
-  eq(other) {
-    return this.type === other.type && this.value === other.value;
+  serialize() {
+    return [
+      new TexToken(2 /* COMMAND */, "\\text"),
+      new TexToken(1 /* ELEMENT */, "{"),
+      this.head,
+      new TexToken(1 /* ELEMENT */, "}")
+    ];
   }
-  isOneOf(tokens) {
-    return array_includes(tokens, this);
+};
+var TexGroup = class extends TexNode {
+  constructor(args) {
+    super("ordgroup", TexToken.EMPTY, args);
   }
-  toNode() {
-    switch (this.type) {
-      case 0 /* NONE */:
-        return new TypstNode("none", "#none");
-      case 3 /* LITERAL */:
-        return new TypstNode("literal", this.value);
-      case 4 /* TEXT */:
-        return new TypstNode("text", this.value);
-      case 5 /* COMMENT */:
-        return new TypstNode("comment", this.value);
-      case 6 /* SPACE */:
-      case 8 /* NEWLINE */:
-        return new TypstNode("whitespace", this.value);
-      case 2 /* ELEMENT */:
-        return new TypstNode("atom", this.value);
-      case 1 /* SYMBOL */:
-        return new TypstNode("symbol", this.value);
-      case 7 /* CONTROL */: {
-        const controlChar = this.value;
-        switch (controlChar) {
-          case "":
-          case "_":
-          case "^":
-            throw new Error(`Should not convert ${controlChar} to a node`);
-          case "&":
-            return new TypstNode("control", "&");
-          case "\\":
-            return new TypstNode("control", "\\");
-          default:
-            throw new Error(`Unexpected control character ${controlChar}`);
-        }
+  serialize() {
+    return this.args.map((n) => n.serialize()).flat();
+  }
+};
+var TexSupSub = class extends TexNode {
+  constructor(data) {
+    super("supsub", TexToken.EMPTY, []);
+    this.base = data.base;
+    this.sup = data.sup;
+    this.sub = data.sub;
+  }
+  serialize() {
+    let tokens = [];
+    const { base, sup, sub } = this;
+    tokens = tokens.concat(base.serialize());
+    function should_wrap_in_braces(node) {
+      if (node.type === "ordgroup" || node.type === "supsub" || node.head.type === 0 /* EMPTY */) {
+        return true;
+      } else if (node.head.type === 1 /* ELEMENT */ && /\d+(\.\d+)?/.test(node.head.value) && node.head.value.length > 1) {
+        return true;
+      } else {
+        return false;
       }
-      default:
-        throw new Error(`Unexpected token type ${this.type}`);
     }
-  }
-  toString() {
-    switch (this.type) {
-      case 4 /* TEXT */:
-        return `"${this.value}"`;
-      case 5 /* COMMENT */:
-        return `//${this.value}`;
-      default:
-        return this.value;
+    if (sub) {
+      tokens.push(new TexToken(7 /* CONTROL */, "_"));
+      if (should_wrap_in_braces(sub)) {
+        tokens.push(new TexToken(1 /* ELEMENT */, "{"));
+        tokens = tokens.concat(sub.serialize());
+        tokens.push(new TexToken(1 /* ELEMENT */, "}"));
+      } else {
+        tokens = tokens.concat(sub.serialize());
+      }
+    }
+    if (sup) {
+      tokens.push(new TexToken(7 /* CONTROL */, "^"));
+      if (should_wrap_in_braces(sup)) {
+        tokens.push(new TexToken(1 /* ELEMENT */, "{"));
+        tokens = tokens.concat(sup.serialize());
+        tokens.push(new TexToken(1 /* ELEMENT */, "}"));
+      } else {
+        tokens = tokens.concat(sup.serialize());
+      }
     }
+    return tokens;
   }
 };
-var TypstNode = class {
-  constructor(type, content, args, data) {
-    this.type = type;
-    this.content = content;
-    this.args = args;
+var TexFuncCall = class extends TexNode {
+  constructor(head, args, data = null) {
+    super("funcCall", head, args);
     this.data = data;
   }
-  setOptions(options) {
-    this.options = options;
+  serialize() {
+    let tokens = [];
+    tokens.push(this.head);
+    if (this.head.value === "\\sqrt" && this.data) {
+      tokens.push(new TexToken(1 /* ELEMENT */, "["));
+      tokens = tokens.concat(this.data.serialize());
+      tokens.push(new TexToken(1 /* ELEMENT */, "]"));
+    }
+    for (const arg of this.args) {
+      tokens.push(new TexToken(1 /* ELEMENT */, "{"));
+      tokens = tokens.concat(arg.serialize());
+      tokens.push(new TexToken(1 /* ELEMENT */, "}"));
+    }
+    return tokens;
   }
-  // Note that this is only shallow equality.
-  eq(other) {
-    return this.type === other.type && this.content === other.content;
+};
+var TexLeftRight = class extends TexNode {
+  constructor(args, data) {
+    super("leftright", TexToken.EMPTY, args);
+    this.left = data.left;
+    this.right = data.right;
   }
-  // whether the node is over high so that if it's wrapped in braces, \left and \right should be used in its TeX form
-  // e.g. 1/2 is over high, "2" is not.
-  isOverHigh() {
-    switch (this.type) {
-      case "fraction":
-        return true;
-      case "funcCall": {
-        if (this.content === "frac") {
-          return true;
-        }
-        return this.args.some((n) => n.isOverHigh());
-      }
-      case "group":
-        return this.args.some((n) => n.isOverHigh());
-      case "supsub":
-        return this.data.base.isOverHigh();
-      case "align":
-      case "cases":
-      case "matrix":
-        return true;
-      default:
-        return false;
-    }
+  serialize() {
+    let tokens = [];
+    tokens.push(new TexToken(2 /* COMMAND */, "\\left"));
+    tokens.push(new TexToken(1 /* ELEMENT */, this.left ? this.left.value : "."));
+    tokens = tokens.concat(this.args.map((n) => n.serialize()).flat());
+    tokens.push(new TexToken(2 /* COMMAND */, "\\right"));
+    tokens.push(new TexToken(1 /* ELEMENT */, this.right ? this.right.value : "."));
+    return tokens;
   }
-  toString() {
-    switch (this.type) {
-      case "text":
-        return `"${this.content}"`;
-      case "comment":
-        return `//${this.content}`;
-      default:
-        return this.content;
-    }
+};
+var TexBeginEnd = class extends TexNode {
+  constructor(head, args, data) {
+    assert(head.type === 3 /* LITERAL */);
+    super("beginend", head, args);
+    this.matrix = data;
+  }
+  serialize() {
+    let tokens = [];
+    const matrix = this.matrix;
+    tokens.push(new TexToken(2 /* COMMAND */, "\\begin"));
+    tokens.push(new TexToken(1 /* ELEMENT */, "{"));
+    tokens = tokens.concat(this.head);
+    tokens.push(new TexToken(1 /* ELEMENT */, "}"));
+    tokens.push(new TexToken(6 /* NEWLINE */, "\n"));
+    for (let i = 0; i < matrix.length; i++) {
+      const row = matrix[i];
+      for (let j = 0; j < row.length; j++) {
+        const cell = row[j];
+        tokens = tokens.concat(cell.serialize());
+        if (j !== row.length - 1) {
+          tokens.push(new TexToken(7 /* CONTROL */, "&"));
+        }
+      }
+      if (i !== matrix.length - 1) {
+        tokens.push(new TexToken(7 /* CONTROL */, "\\\\"));
+      }
+    }
+    tokens.push(new TexToken(6 /* NEWLINE */, "\n"));
+    tokens.push(new TexToken(2 /* COMMAND */, "\\end"));
+    tokens.push(new TexToken(1 /* ELEMENT */, "{"));
+    tokens = tokens.concat(this.head);
+    tokens.push(new TexToken(1 /* ELEMENT */, "}"));
+    return tokens;
   }
 };
-var TYPST_NONE = new TypstNode("none", "#none");
+function writeTexTokenBuffer(buffer, token) {
+  const str = token.toString();
+  let no_need_space = false;
+  if (token.type === 5 /* SPACE */) {
+    no_need_space = true;
+  } else {
+    no_need_space ||= /[{\(\[\|]$/.test(buffer);
+    no_need_space ||= /\\\w+$/.test(buffer) && str === "[";
+    no_need_space ||= /^[\.,;:!\?\(\)\]{}_^]$/.test(str);
+    no_need_space ||= ["\\{", "\\}"].includes(str);
+    no_need_space ||= str === "'";
+    no_need_space ||= buffer.endsWith("_") || buffer.endsWith("^");
+    no_need_space ||= /\s$/.test(buffer);
+    no_need_space ||= /^\s/.test(str);
+    no_need_space ||= buffer === "";
+    no_need_space ||= /[\(\[{]\s*(-|\+)$/.test(buffer) || buffer === "-" || buffer === "+";
+    no_need_space ||= buffer.endsWith("&") && str === "=";
+  }
+  if (!no_need_space) {
+    buffer += " ";
+  }
+  return buffer + str;
+}
 
-// src/util.ts
-function isalpha(char) {
-  return "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ".includes(char);
+// src/generic.ts
+function array_find(array, item, start = 0) {
+  const index = array.slice(start).findIndex((x) => x.eq(item));
+  return index === -1 ? -1 : index + start;
 }
-function assert(condition, message = "") {
-  if (!condition) {
-    throw new Error(message);
+function array_includes(array, item) {
+  return array.some((x) => x.eq(item));
+}
+function array_split(array, sep) {
+  const res = [];
+  let current_slice = [];
+  for (const i of array) {
+    if (i.eq(sep)) {
+      res.push(current_slice);
+      current_slice = [];
+    } else {
+      current_slice.push(i);
+    }
   }
+  res.push(current_slice);
+  return res;
+}
+function array_intersperse(array, sep) {
+  return array.flatMap((x, i) => i !== array.length - 1 ? [x, sep] : [x]);
 }
 
 // src/jslex.ts
@@ -1709,13 +565,13 @@ var rules_map = /* @__PURE__ */ new Map([
     (s) => {
       const match = s.reMatchArray();
       return [
-        new TexToken(1 /* COMMAND */, "\\begin"),
-        new TexToken(6 /* CONTROL */, "{"),
-        new TexToken(2 /* LITERAL */, match[1]),
-        new TexToken(6 /* CONTROL */, "}"),
-        new TexToken(6 /* CONTROL */, "{"),
-        new TexToken(2 /* LITERAL */, match[2]),
-        new TexToken(6 /* CONTROL */, "}")
+        new TexToken(2 /* COMMAND */, "\\begin"),
+        new TexToken(7 /* CONTROL */, "{"),
+        new TexToken(3 /* LITERAL */, match[1]),
+        new TexToken(7 /* CONTROL */, "}"),
+        new TexToken(7 /* CONTROL */, "{"),
+        new TexToken(3 /* LITERAL */, match[2]),
+        new TexToken(7 /* CONTROL */, "}")
       ];
     }
   ],
@@ -1724,19 +580,19 @@ var rules_map = /* @__PURE__ */ new Map([
     (s) => {
       const match = s.reMatchArray();
       return [
-        new TexToken(1 /* COMMAND */, "\\" + match[1]),
-        new TexToken(6 /* CONTROL */, "{"),
-        new TexToken(2 /* LITERAL */, unescape(match[2])),
-        new TexToken(6 /* CONTROL */, "}")
+        new TexToken(2 /* COMMAND */, "\\" + match[1]),
+        new TexToken(7 /* CONTROL */, "{"),
+        new TexToken(3 /* LITERAL */, unescape(match[2])),
+        new TexToken(7 /* CONTROL */, "}")
       ];
     }
   ],
-  [String.raw`%[^\n]*`, (s) => new TexToken(3 /* COMMENT */, s.text().substring(1))],
-  [String.raw`[{}_^&]`, (s) => new TexToken(6 /* CONTROL */, s.text())],
-  [String.raw`\\[\\,:;! ]`, (s) => new TexToken(6 /* CONTROL */, s.text())],
-  [String.raw`\r?\n`, (_s) => new TexToken(5 /* NEWLINE */, "\n")],
-  [String.raw`\s+`, (s) => new TexToken(4 /* SPACE */, s.text())],
-  [String.raw`\\[{}%$&#_|]`, (s) => new TexToken(0 /* ELEMENT */, s.text())],
+  [String.raw`%[^\n]*`, (s) => new TexToken(4 /* COMMENT */, s.text().substring(1))],
+  [String.raw`[{}_^&]`, (s) => new TexToken(7 /* CONTROL */, s.text())],
+  [String.raw`\\[\\,:;! ]`, (s) => new TexToken(7 /* CONTROL */, s.text())],
+  [String.raw`\r?\n`, (_s) => new TexToken(6 /* NEWLINE */, "\n")],
+  [String.raw`\s+`, (s) => new TexToken(5 /* SPACE */, s.text())],
+  [String.raw`\\[{}%$&#_|]`, (s) => new TexToken(1 /* ELEMENT */, s.text())],
   // e.g. match `\frac13`, `\frac1 b`, `\frac a b`
   [String.raw`(\\[a-zA-Z]+)(\s*\d|\s+[a-zA-Z])\s*([0-9a-zA-Z])`, (s) => {
     const match = s.reMatchArray();
@@ -1745,9 +601,9 @@ var rules_map = /* @__PURE__ */ new Map([
       const arg1 = match[2].trimStart();
       const arg2 = match[3];
       return [
-        new TexToken(1 /* COMMAND */, command),
-        new TexToken(0 /* ELEMENT */, arg1),
-        new TexToken(0 /* ELEMENT */, arg2)
+        new TexToken(2 /* COMMAND */, command),
+        new TexToken(1 /* ELEMENT */, arg1),
+        new TexToken(1 /* ELEMENT */, arg2)
       ];
     } else {
       s.reject();
@@ -1761,22 +617,22 @@ var rules_map = /* @__PURE__ */ new Map([
     if (TEX_UNARY_COMMANDS.includes(command.substring(1))) {
       const arg1 = match[2].trimStart();
       return [
-        new TexToken(1 /* COMMAND */, command),
-        new TexToken(0 /* ELEMENT */, arg1)
+        new TexToken(2 /* COMMAND */, command),
+        new TexToken(1 /* ELEMENT */, arg1)
       ];
     } else {
       s.reject();
       return [];
     }
   }],
-  [String.raw`\\[a-zA-Z]+`, (s) => new TexToken(1 /* COMMAND */, s.text())],
+  [String.raw`\\[a-zA-Z]+`, (s) => new TexToken(2 /* COMMAND */, s.text())],
   // Numbers like "123", "3.14"
-  [String.raw`[0-9]+(\.[0-9]+)?`, (s) => new TexToken(0 /* ELEMENT */, s.text())],
-  [String.raw`[a-zA-Z]`, (s) => new TexToken(0 /* ELEMENT */, s.text())],
-  [String.raw`[+\-*/='<>!.,;:?()\[\]|]`, (s) => new TexToken(0 /* ELEMENT */, s.text())],
+  [String.raw`[0-9]+(\.[0-9]+)?`, (s) => new TexToken(1 /* ELEMENT */, s.text())],
+  [String.raw`[a-zA-Z]`, (s) => new TexToken(1 /* ELEMENT */, s.text())],
+  [String.raw`[+\-*/='<>!.,;:?()\[\]|]`, (s) => new TexToken(1 /* ELEMENT */, s.text())],
   // non-ASCII characters
-  [String.raw`[^\x00-\x7F]`, (s) => new TexToken(0 /* ELEMENT */, s.text())],
-  [String.raw`.`, (s) => new TexToken(7 /* UNKNOWN */, s.text())]
+  [String.raw`[^\x00-\x7F]`, (s) => new TexToken(1 /* ELEMENT */, s.text())],
+  [String.raw`.`, (s) => new TexToken(8 /* UNKNOWN */, s.text())]
 ]);
 var spec = {
   "start": rules_map
@@ -1797,7 +653,7 @@ var IGNORED_COMMANDS = [
   "Biggl",
   "Biggr"
 ];
-var EMPTY_NODE = new TexNode("empty", "");
+var EMPTY_NODE = TexToken.EMPTY.toNode();
 function get_command_param_num(command) {
   if (TEX_UNARY_COMMANDS.includes(command)) {
     return 1;
@@ -1807,22 +663,22 @@ function get_command_param_num(command) {
     return 0;
   }
 }
-var LEFT_CURLY_BRACKET = new TexToken(6 /* CONTROL */, "{");
-var RIGHT_CURLY_BRACKET = new TexToken(6 /* CONTROL */, "}");
-var LEFT_SQUARE_BRACKET = new TexToken(0 /* ELEMENT */, "[");
-var RIGHT_SQUARE_BRACKET = new TexToken(0 /* ELEMENT */, "]");
+var LEFT_CURLY_BRACKET = new TexToken(7 /* CONTROL */, "{");
+var RIGHT_CURLY_BRACKET = new TexToken(7 /* CONTROL */, "}");
+var LEFT_SQUARE_BRACKET = new TexToken(1 /* ELEMENT */, "[");
+var RIGHT_SQUARE_BRACKET = new TexToken(1 /* ELEMENT */, "]");
 function eat_whitespaces(tokens, start) {
   let pos = start;
-  while (pos < tokens.length && [4 /* SPACE */, 5 /* NEWLINE */].includes(tokens[pos].type)) {
+  while (pos < tokens.length && [5 /* SPACE */, 6 /* NEWLINE */].includes(tokens[pos].type)) {
     pos++;
   }
   return tokens.slice(start, pos);
 }
 function eat_parenthesis(tokens, start) {
   const firstToken = tokens[start];
-  if (firstToken.type === 0 /* ELEMENT */ && ["(", ")", "[", "]", "|", "\\{", "\\}", ".", "\\|"].includes(firstToken.value)) {
+  if (firstToken.type === 1 /* ELEMENT */ && ["(", ")", "[", "]", "|", "\\{", "\\}", ".", "\\|"].includes(firstToken.value)) {
     return firstToken;
-  } else if (firstToken.type === 1 /* COMMAND */ && ["lfloor", "rfloor", "lceil", "rceil", "langle", "rangle"].includes(firstToken.value.slice(1))) {
+  } else if (firstToken.type === 2 /* COMMAND */ && ["lfloor", "rfloor", "lceil", "rceil", "langle", "rangle"].includes(firstToken.value.slice(1))) {
     return firstToken;
   } else {
     return null;
@@ -1830,7 +686,7 @@ function eat_parenthesis(tokens, start) {
 }
 function eat_primes(tokens, start) {
   let pos = start;
-  while (pos < tokens.length && tokens[pos].eq(new TexToken(0 /* ELEMENT */, "'"))) {
+  while (pos < tokens.length && tokens[pos].eq(new TexToken(1 /* ELEMENT */, "'"))) {
     pos += 1;
   }
   return pos - start;
@@ -1852,13 +708,13 @@ function find_closing_match(tokens, start, leftToken, rightToken) {
   }
   return pos - 1;
 }
-var LEFT_COMMAND = new TexToken(1 /* COMMAND */, "\\left");
-var RIGHT_COMMAND = new TexToken(1 /* COMMAND */, "\\right");
+var LEFT_COMMAND = new TexToken(2 /* COMMAND */, "\\left");
+var RIGHT_COMMAND = new TexToken(2 /* COMMAND */, "\\right");
 function find_closing_right_command(tokens, start) {
   return find_closing_match(tokens, start, LEFT_COMMAND, RIGHT_COMMAND);
 }
-var BEGIN_COMMAND = new TexToken(1 /* COMMAND */, "\\begin");
-var END_COMMAND = new TexToken(1 /* COMMAND */, "\\end");
+var BEGIN_COMMAND = new TexToken(2 /* COMMAND */, "\\begin");
+var END_COMMAND = new TexToken(2 /* COMMAND */, "\\end");
 function find_closing_end_command(tokens, start) {
   return find_closing_match(tokens, start, BEGIN_COMMAND, END_COMMAND);
 }
@@ -1868,26 +724,27 @@ var LatexParserError = class extends Error {
     this.name = "LatexParserError";
   }
 };
-var SUB_SYMBOL = new TexToken(6 /* CONTROL */, "_");
-var SUP_SYMBOL = new TexToken(6 /* CONTROL */, "^");
+var SUB_SYMBOL = new TexToken(7 /* CONTROL */, "_");
+var SUP_SYMBOL = new TexToken(7 /* CONTROL */, "^");
 var LatexParser = class {
   constructor(space_sensitive = false, newline_sensitive = true) {
     this.space_sensitive = space_sensitive;
     this.newline_sensitive = newline_sensitive;
   }
   parse(tokens) {
-    const idx = array_find(tokens, new TexToken(1 /* COMMAND */, "\\displaystyle"));
+    const token_displaystyle = new TexToken(2 /* COMMAND */, "\\displaystyle");
+    const idx = array_find(tokens, token_displaystyle);
     if (idx === -1) {
       const [tree, _] = this.parseGroup(tokens, 0, tokens.length);
       return tree;
     } else if (idx === 0) {
       const [tree, _] = this.parseGroup(tokens, 1, tokens.length);
-      return new TexNode("unaryFunc", "\\displaystyle", [tree]);
+      return new TexFuncCall(token_displaystyle, [tree]);
     } else {
       const [tree1, _1] = this.parseGroup(tokens, 0, idx);
       const [tree2, _2] = this.parseGroup(tokens, idx + 1, tokens.length);
-      const display = new TexNode("unaryFunc", "\\displaystyle", [tree2]);
-      return new TexNode("ordgroup", "", [tree1, display]);
+      const display = new TexFuncCall(token_displaystyle, [tree2]);
+      return new TexGroup([tree1, display]);
     }
   }
   parseGroup(tokens, start, end) {
@@ -1896,15 +753,15 @@ var LatexParser = class {
     while (pos < end) {
       const [res, newPos] = this.parseNextExpr(tokens, pos);
       pos = newPos;
-      if (res.type === "whitespace") {
-        if (!this.space_sensitive && res.content.replace(/ /g, "").length === 0) {
+      if (res.head.type === 5 /* SPACE */ || res.head.type === 6 /* NEWLINE */) {
+        if (!this.space_sensitive && res.head.value.replace(/ /g, "").length === 0) {
           continue;
         }
-        if (!this.newline_sensitive && res.content === "\n") {
+        if (!this.newline_sensitive && res.head.value === "\n") {
           continue;
         }
       }
-      if (res.type === "control" && res.content === "&") {
+      if (res.head.eq(new TexToken(7 /* CONTROL */, "&"))) {
         throw new LatexParserError("Unexpected & outside of an alignment");
       }
       results.push(res);
@@ -1913,7 +770,7 @@ var LatexParser = class {
     if (results.length === 1) {
       node = results[0];
     } else {
-      node = new TexNode("ordgroup", "", results);
+      node = new TexGroup(results);
     }
     return [node, end + 1];
   }
@@ -1947,14 +804,14 @@ var LatexParser = class {
       }
     }
     if (sub !== null || sup !== null || num_prime > 0) {
-      const res = { base };
+      const res = { base, sup: null, sub: null };
       if (sub) {
         res.sub = sub;
       }
       if (num_prime > 0) {
-        res.sup = new TexNode("ordgroup", "", []);
+        res.sup = new TexGroup([]);
         for (let i = 0; i < num_prime; i++) {
-          res.sup.args.push(new TexNode("element", "'"));
+          res.sup.args.push(new TexToken(1 /* ELEMENT */, "'").toNode());
         }
         if (sup) {
           res.sup.args.push(sup);
@@ -1965,7 +822,7 @@ var LatexParser = class {
       } else if (sup) {
         res.sup = sup;
       }
-      return [new TexNode("supsub", "", [], res), pos];
+      return [new TexSupSub(res), pos];
     } else {
       return [base, pos];
     }
@@ -1976,16 +833,13 @@ var LatexParser = class {
     }
     const firstToken = tokens[start];
     switch (firstToken.type) {
-      case 0 /* ELEMENT */:
-        return [new TexNode("element", firstToken.value), start + 1];
-      case 2 /* LITERAL */:
-        return [new TexNode("literal", firstToken.value), start + 1];
-      case 3 /* COMMENT */:
-        return [new TexNode("comment", firstToken.value), start + 1];
-      case 4 /* SPACE */:
-      case 5 /* NEWLINE */:
-        return [new TexNode("whitespace", firstToken.value), start + 1];
-      case 1 /* COMMAND */:
+      case 1 /* ELEMENT */:
+      case 3 /* LITERAL */:
+      case 4 /* COMMENT */:
+      case 5 /* SPACE */:
+      case 6 /* NEWLINE */:
+        return [firstToken.toNode(), start + 1];
+      case 2 /* COMMAND */:
         const commandName = firstToken.value.slice(1);
         if (IGNORED_COMMANDS.includes(commandName)) {
           return this.parseNextExprWithoutSupSub(tokens, start + 1);
@@ -1997,7 +851,7 @@ var LatexParser = class {
         } else {
           return this.parseCommandExpr(tokens, start);
         }
-      case 6 /* CONTROL */:
+      case 7 /* CONTROL */:
         const controlChar = firstToken.value;
         switch (controlChar) {
           case "{":
@@ -2013,14 +867,14 @@ var LatexParser = class {
           case "\\,":
           case "\\:":
           case "\\;":
-            return [new TexNode("control", controlChar), start + 1];
+            return [firstToken.toNode(), start + 1];
           case "\\ ":
-            return [new TexNode("control", "\\:"), start + 1];
+            return [firstToken.toNode(), start + 1];
           case "_":
           case "^":
             return [EMPTY_NODE, start];
           case "&":
-            return [new TexNode("control", "&"), start + 1];
+            return [firstToken.toNode(), start + 1];
           default:
             throw new LatexParserError("Unknown control sequence");
         }
@@ -2029,8 +883,9 @@ var LatexParser = class {
     }
   }
   parseCommandExpr(tokens, start) {
-    assert(tokens[start].type === 1 /* COMMAND */);
-    const command = tokens[start].value;
+    assert(tokens[start].type === 2 /* COMMAND */);
+    const command_token = tokens[start];
+    const command = command_token.value;
     let pos = start + 1;
     if (["left", "right", "begin", "end"].includes(command.slice(1))) {
       throw new LatexParserError("Unexpected command: " + command);
@@ -2038,10 +893,7 @@ var LatexParser = class {
     const paramNum = get_command_param_num(command.slice(1));
     switch (paramNum) {
       case 0:
-        if (!symbolMap.has(command.slice(1))) {
-          return [new TexNode("unknownMacro", command), pos];
-        }
-        return [new TexNode("symbol", command), pos];
+        return [command_token.toNode(), pos];
       case 1: {
         if (pos >= tokens.length) {
           throw new LatexParserError("Expecting argument for " + command);
@@ -2054,24 +906,24 @@ var LatexParser = class {
           }
           const [exponent, _] = this.parseGroup(tokens, posLeftSquareBracket + 1, posRightSquareBracket);
           const [arg12, newPos2] = this.parseNextArg(tokens, posRightSquareBracket + 1);
-          return [new TexNode("unaryFunc", command, [arg12], exponent), newPos2];
+          return [new TexFuncCall(command_token, [arg12], exponent), newPos2];
         } else if (command === "\\text") {
           if (pos + 2 >= tokens.length) {
             throw new LatexParserError("Expecting content for \\text command");
           }
           assert(tokens[pos].eq(LEFT_CURLY_BRACKET));
-          assert(tokens[pos + 1].type === 2 /* LITERAL */);
+          assert(tokens[pos + 1].type === 3 /* LITERAL */);
           assert(tokens[pos + 2].eq(RIGHT_CURLY_BRACKET));
-          const text = tokens[pos + 1].value;
-          return [new TexNode("text", text), pos + 3];
+          const literal = tokens[pos + 1];
+          return [new TexText(literal), pos + 3];
         }
         let [arg1, newPos] = this.parseNextArg(tokens, pos);
-        return [new TexNode("unaryFunc", command, [arg1]), newPos];
+        return [new TexFuncCall(command_token, [arg1]), newPos];
       }
       case 2: {
         const [arg1, pos1] = this.parseNextArg(tokens, pos);
         const [arg2, pos2] = this.parseNextArg(tokens, pos1);
-        return [new TexNode("binaryFunc", command, [arg1, arg2]), pos2];
+        return [new TexFuncCall(command_token, [arg1, arg2]), pos2];
       }
       default:
         throw new Error("Invalid number of parameters");
@@ -2080,9 +932,9 @@ var LatexParser = class {
   /*
   Extract a non-space argument from the token stream.
   So that `\frac{12} 3` is parsed as
-      TexCommand{ content: '\frac', args: ['12', '3'] }
+      TypstFuncCall{ head: '\frac', args: [ELEMENT_12, ELEMENT_3] }
       rather than
-      TexCommand{ content: '\frac', args: ['12', ' '] }, TexElement{ content: '3' }
+      TypstFuncCall{ head: '\frac', args: [ELEMENT_12, SPACE] }, ELEMENT_3
   */
   parseNextArg(tokens, start) {
     let pos = start;
@@ -2090,7 +942,7 @@ var LatexParser = class {
     while (pos < tokens.length) {
       let node;
       [node, pos] = this.parseNextExprWithoutSupSub(tokens, pos);
-      if (node.type !== "whitespace") {
+      if (!(node.head.type === 5 /* SPACE */ || node.head.type === 6 /* NEWLINE */)) {
         arg = node;
         break;
       }
@@ -2129,27 +981,23 @@ var LatexParser = class {
     }
     pos++;
     const [body, _] = this.parseGroup(tokens, exprInsideStart, exprInsideEnd);
-    const args = [
-      new TexNode("element", leftDelimiter.value),
-      body,
-      new TexNode("element", rightDelimiter.value)
-    ];
-    const res = new TexNode("leftright", "", args);
+    const args = [body];
+    const left = leftDelimiter.value === "." ? null : leftDelimiter;
+    const right = rightDelimiter.value === "." ? null : rightDelimiter;
+    const res = new TexLeftRight(args, { left, right });
     return [res, pos];
   }
   parseBeginEndExpr(tokens, start) {
     assert(tokens[start].eq(BEGIN_COMMAND));
     let pos = start + 1;
     assert(tokens[pos].eq(LEFT_CURLY_BRACKET));
-    assert(tokens[pos + 1].type === 2 /* LITERAL */);
+    assert(tokens[pos + 1].type === 3 /* LITERAL */);
     assert(tokens[pos + 2].eq(RIGHT_CURLY_BRACKET));
     const envName = tokens[pos + 1].value;
     pos += 3;
     const args = [];
     if (["array", "subarray"].includes(envName)) {
-      if (pos >= tokens.length || !tokens[pos].eq(LEFT_CURLY_BRACKET)) {
-        throw new LatexParserError(`Missing arg for \\begin{${envName}}`);
-      }
+      pos += eat_whitespaces(tokens, pos).length;
       const [arg, newPos] = this.parseNextArg(tokens, pos);
       args.push(arg);
       pos = newPos;
@@ -2163,18 +1011,18 @@ var LatexParser = class {
     const exprInsideEnd = endIdx;
     pos = endIdx + 1;
     assert(tokens[pos].eq(LEFT_CURLY_BRACKET));
-    assert(tokens[pos + 1].type === 2 /* LITERAL */);
+    assert(tokens[pos + 1].type === 3 /* LITERAL */);
     assert(tokens[pos + 2].eq(RIGHT_CURLY_BRACKET));
     if (tokens[pos + 1].value !== envName) {
       throw new LatexParserError("Mismatched \\begin and \\end environments");
     }
     pos += 3;
     const exprInside = tokens.slice(exprInsideStart, exprInsideEnd);
-    while (exprInside.length > 0 && [4 /* SPACE */, 5 /* NEWLINE */].includes(exprInside[exprInside.length - 1].type)) {
+    while (exprInside.length > 0 && [5 /* SPACE */, 6 /* NEWLINE */].includes(exprInside[exprInside.length - 1].type)) {
       exprInside.pop();
     }
     const body = this.parseAligned(exprInside);
-    const res = new TexNode("beginend", envName, args, body);
+    const res = new TexBeginEnd(new TexToken(3 /* LITERAL */, envName), args, body);
     return [res, pos];
   }
   parseAligned(tokens) {
@@ -2182,26 +1030,26 @@ var LatexParser = class {
     const allRows = [];
     let row = [];
     allRows.push(row);
-    let group = new TexNode("ordgroup", "", []);
+    let group = new TexGroup([]);
     row.push(group);
     while (pos < tokens.length) {
       const [res, newPos] = this.parseNextExpr(tokens, pos);
       pos = newPos;
-      if (res.type === "whitespace") {
-        if (!this.space_sensitive && res.content.replace(/ /g, "").length === 0) {
+      if (res.head.type === 5 /* SPACE */ || res.head.type === 6 /* NEWLINE */) {
+        if (!this.space_sensitive && res.head.value.replace(/ /g, "").length === 0) {
           continue;
         }
-        if (!this.newline_sensitive && res.content === "\n") {
+        if (!this.newline_sensitive && res.head.value === "\n") {
           continue;
         }
       }
-      if (res.type === "control" && res.content === "\\\\") {
+      if (res.head.eq(new TexToken(7 /* CONTROL */, "\\\\"))) {
         row = [];
-        group = new TexNode("ordgroup", "", []);
+        group = new TexGroup([]);
         row.push(group);
         allRows.push(row);
-      } else if (res.type === "control" && res.content === "&") {
-        group = new TexNode("ordgroup", "", []);
+      } else if (res.head.eq(new TexToken(7 /* CONTROL */, "&"))) {
+        group = new TexGroup([]);
         row.push(group);
       } else {
         group.args.push(res);
@@ -2214,10 +1062,10 @@ function passIgnoreWhitespaceBeforeScriptMark(tokens) {
   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 /* SPACE */ && i + 1 < tokens.length && is_script_mark(tokens[i + 1])) {
+    if (tokens[i].type === 5 /* SPACE */ && i + 1 < tokens.length && is_script_mark(tokens[i + 1])) {
       continue;
     }
-    if (tokens[i].type === 4 /* SPACE */ && i - 1 >= 0 && is_script_mark(tokens[i - 1])) {
+    if (tokens[i].type === 5 /* SPACE */ && i - 1 >= 0 && is_script_mark(tokens[i - 1])) {
       continue;
     }
     out_tokens.push(tokens[i]);
@@ -2227,7 +1075,7 @@ function passIgnoreWhitespaceBeforeScriptMark(tokens) {
 function passExpandCustomTexMacros(tokens, customTexMacros) {
   let out_tokens = [];
   for (const token of tokens) {
-    if (token.type === 1 /* COMMAND */ && customTexMacros[token.value]) {
+    if (token.type === 2 /* COMMAND */ && customTexMacros[token.value]) {
       const expanded_tokens = tokenize_tex(customTexMacros[token.value]);
       out_tokens = out_tokens.concat(expanded_tokens);
     } else {
@@ -2244,6 +1092,139 @@ function parseTex(tex, customTexMacros) {
   return parser.parse(tokens);
 }
 
+// src/typst-types.ts
+var TypstToken = class _TypstToken {
+  constructor(type, content) {
+    this.type = type;
+    this.value = content;
+  }
+  eq(other) {
+    return this.type === other.type && this.value === other.value;
+  }
+  isOneOf(tokens) {
+    return array_includes(tokens, this);
+  }
+  toNode() {
+    return new TypstTerminal(this);
+  }
+  toString() {
+    switch (this.type) {
+      case 4 /* TEXT */:
+        return `"${this.value}"`;
+      case 5 /* COMMENT */:
+        return `//${this.value}`;
+      default:
+        return this.value;
+    }
+  }
+  static {
+    this.NONE = new _TypstToken(0 /* NONE */, "#none");
+  }
+};
+var TypstNode = class {
+  constructor(type, head, args) {
+    this.type = type;
+    this.head = head ? head : TypstToken.NONE;
+    this.args = args;
+  }
+  setOptions(options) {
+    this.options = options;
+  }
+  // Note that this is only shallow equality.
+  eq(other) {
+    return this.type === other.type && this.head.eq(other.head);
+  }
+  toString() {
+    throw new Error(`Unimplemented toString() in base class TypstNode`);
+  }
+};
+var TypstTerminal = class extends TypstNode {
+  constructor(head) {
+    super("terminal", head);
+  }
+  isOverHigh() {
+    return false;
+  }
+  toString() {
+    return this.head.toString();
+  }
+};
+var TypstGroup = class extends TypstNode {
+  constructor(args) {
+    super("group", TypstToken.NONE, args);
+  }
+  isOverHigh() {
+    return this.args.some((n) => n.isOverHigh());
+  }
+};
+var TypstSupsub = class extends TypstNode {
+  constructor(data) {
+    super("supsub", TypstToken.NONE, []);
+    this.base = data.base;
+    this.sup = data.sup;
+    this.sub = data.sub;
+  }
+  isOverHigh() {
+    return this.base.isOverHigh();
+  }
+};
+var TypstFuncCall = class extends TypstNode {
+  constructor(head, args) {
+    super("funcCall", head, args);
+  }
+  isOverHigh() {
+    if (this.head.value === "frac") {
+      return true;
+    }
+    return this.args.some((n) => n.isOverHigh());
+  }
+};
+var TypstFraction = class extends TypstNode {
+  constructor(args) {
+    super("fraction", TypstToken.NONE, args);
+  }
+  isOverHigh() {
+    return true;
+  }
+};
+var TypstLeftright = class extends TypstNode {
+  constructor(head, args, data) {
+    super("leftright", head, args);
+    this.left = data.left;
+    this.right = data.right;
+  }
+  isOverHigh() {
+    return this.args.some((n) => n.isOverHigh());
+  }
+};
+var TypstAlign = class extends TypstNode {
+  constructor(data) {
+    super("align", TypstToken.NONE, []);
+    this.matrix = data;
+  }
+  isOverHigh() {
+    return true;
+  }
+};
+var TypstMatrix = class extends TypstNode {
+  constructor(data) {
+    super("matrix", TypstToken.NONE, []);
+    this.matrix = data;
+  }
+  isOverHigh() {
+    return true;
+  }
+};
+var TypstCases = class extends TypstNode {
+  constructor(data) {
+    super("cases", TypstToken.NONE, []);
+    this.matrix = data;
+  }
+  isOverHigh() {
+    return true;
+  }
+};
+
 // src/typst-shorthands.ts
 var shorthandMap = /* @__PURE__ */ new Map([
   ["arrow.l.r.double.long", "<==>"],
@@ -2294,7 +1275,7 @@ for (const [key, value] of shorthandMap.entries()) {
 
 // src/typst-writer.ts
 function is_delimiter(c) {
-  return c.type === "atom" && ["(", ")", "[", "]", "{", "}", "|", "\u230A", "\u230B", "\u2308", "\u2309"].includes(c.content);
+  return c.head.type === 2 /* ELEMENT */ && ["(", ")", "[", "]", "{", "}", "|", "\u230A", "\u230B", "\u2308", "\u2309"].includes(c.head.value);
 }
 var TYPST_LEFT_PARENTHESIS = new TypstToken(2 /* ELEMENT */, "(");
 var TYPST_RIGHT_PARENTHESIS = new TypstToken(2 /* ELEMENT */, ")");
@@ -2343,64 +1324,82 @@ var TypstWriter = class {
     this.buffer += str;
   }
   // Serialize a tree of TypstNode into a list of TypstToken
-  serialize(node) {
-    switch (node.type) {
-      case "none":
-        this.queue.push(new TypstToken(0 /* NONE */, "#none"));
-        break;
-      case "atom": {
-        if (node.content === "," && this.insideFunctionDepth > 0) {
-          this.queue.push(new TypstToken(1 /* SYMBOL */, "comma"));
+  serialize(abstractNode) {
+    switch (abstractNode.type) {
+      case "terminal": {
+        const node = abstractNode;
+        if (node.head.type === 2 /* ELEMENT */) {
+          if (node.head.value === "," && this.insideFunctionDepth > 0) {
+            this.queue.push(new TypstToken(1 /* SYMBOL */, "comma"));
+          } else {
+            this.queue.push(node.head);
+          }
+          break;
+        } else if (node.head.type === 1 /* SYMBOL */) {
+          let symbol_name = node.head.value;
+          if (this.preferShorthands) {
+            if (shorthandMap.has(symbol_name)) {
+              symbol_name = shorthandMap.get(symbol_name);
+            }
+          }
+          if (this.inftyToOo && symbol_name === "infinity") {
+            symbol_name = "oo";
+          }
+          this.queue.push(new TypstToken(1 /* SYMBOL */, symbol_name));
+          break;
+        } else if (node.head.type === 6 /* SPACE */ || node.head.type === 8 /* NEWLINE */) {
+          for (const c of node.head.value) {
+            if (c === " ") {
+              if (this.keepSpaces) {
+                this.queue.push(new TypstToken(6 /* SPACE */, c));
+              }
+            } else if (c === "\n") {
+              this.queue.push(new TypstToken(1 /* SYMBOL */, c));
+            } else {
+              throw new TypstWriterError(`Unexpected whitespace character: ${c}`, node);
+            }
+          }
+          break;
         } else {
-          this.queue.push(new TypstToken(2 /* ELEMENT */, node.content));
+          this.queue.push(node.head);
+          break;
         }
-        break;
       }
-      case "symbol": {
-        let content = node.content;
-        if (this.preferShorthands) {
-          if (shorthandMap.has(content)) {
-            content = shorthandMap.get(content);
-          }
-        }
-        if (this.inftyToOo && content === "infinity") {
-          content = "oo";
+      case "group": {
+        const node = abstractNode;
+        for (const item of node.args) {
+          this.serialize(item);
         }
-        this.queue.push(new TypstToken(1 /* SYMBOL */, content));
         break;
       }
-      case "literal":
-        this.queue.push(new TypstToken(3 /* LITERAL */, node.content));
-        break;
-      case "text":
-        this.queue.push(new TypstToken(4 /* TEXT */, node.content));
-        break;
-      case "comment":
-        this.queue.push(new TypstToken(5 /* COMMENT */, node.content));
-        break;
-      case "whitespace":
-        for (const c of node.content) {
-          if (c === " ") {
-            if (this.keepSpaces) {
-              this.queue.push(new TypstToken(6 /* SPACE */, c));
-            }
-          } else if (c === "\n") {
-            this.queue.push(new TypstToken(1 /* SYMBOL */, c));
-          } else {
-            throw new TypstWriterError(`Unexpected whitespace character: ${c}`, node);
-          }
+      case "leftright": {
+        const node = abstractNode;
+        const LR = new TypstToken(1 /* SYMBOL */, "lr");
+        const { left, right } = node;
+        if (node.head.eq(LR)) {
+          this.queue.push(LR);
+          this.queue.push(TYPST_LEFT_PARENTHESIS);
+        }
+        if (left) {
+          this.queue.push(left);
         }
-        break;
-      case "group":
         for (const item of node.args) {
           this.serialize(item);
         }
+        if (right) {
+          this.queue.push(right);
+        }
+        if (node.head.eq(LR)) {
+          this.queue.push(TYPST_RIGHT_PARENTHESIS);
+        }
         break;
+      }
       case "supsub": {
-        let { base, sup, sub } = node.data;
+        const node = abstractNode;
+        let { base, sup, sub } = node;
         this.appendWithBracketsIfNeeded(base);
         let trailing_space_needed = false;
-        const has_prime = sup && sup.type === "atom" && sup.content === "'";
+        const has_prime = sup && sup.head.eq(new TypstToken(2 /* ELEMENT */, "'"));
         if (has_prime) {
           this.queue.push(new TypstToken(2 /* ELEMENT */, "'"));
           trailing_space_needed = false;
@@ -2419,11 +1418,10 @@ var TypstWriter = class {
         break;
       }
       case "funcCall": {
-        const func_symbol = new TypstToken(1 /* SYMBOL */, node.content);
+        const node = abstractNode;
+        const func_symbol = node.head;
         this.queue.push(func_symbol);
-        if (node.content !== "lr") {
-          this.insideFunctionDepth++;
-        }
+        this.insideFunctionDepth++;
         this.queue.push(TYPST_LEFT_PARENTHESIS);
         for (let i = 0; i < node.args.length; i++) {
           this.serialize(node.args[i]);
@@ -2437,12 +1435,11 @@ var TypstWriter = class {
           }
         }
         this.queue.push(TYPST_RIGHT_PARENTHESIS);
-        if (node.content !== "lr") {
-          this.insideFunctionDepth--;
-        }
+        this.insideFunctionDepth--;
         break;
       }
       case "fraction": {
+        const node = abstractNode;
         const [numerator, denominator] = node.args;
         const pos = this.queue.length;
         const no_wrap = this.appendWithBracketsIfNeeded(numerator);
@@ -2455,7 +1452,8 @@ var TypstWriter = class {
         break;
       }
       case "align": {
-        const matrix = node.data;
+        const node = abstractNode;
+        const matrix = node.matrix;
         matrix.forEach((row, i) => {
           row.forEach((cell, j) => {
             if (j > 0) {
@@ -2470,7 +1468,8 @@ var TypstWriter = class {
         break;
       }
       case "matrix": {
-        const matrix = node.data;
+        const node = abstractNode;
+        const matrix = node.matrix;
         this.queue.push(new TypstToken(1 /* SYMBOL */, "mat"));
         this.insideFunctionDepth++;
         this.queue.push(TYPST_LEFT_PARENTHESIS);
@@ -2496,7 +1495,8 @@ var TypstWriter = class {
         break;
       }
       case "cases": {
-        const cases = node.data;
+        const node = abstractNode;
+        const cases = node.matrix;
         this.queue.push(new TypstToken(1 /* SYMBOL */, "cases"));
         this.insideFunctionDepth++;
         this.queue.push(TYPST_LEFT_PARENTHESIS);
@@ -2521,16 +1521,8 @@ var TypstWriter = class {
         this.insideFunctionDepth--;
         break;
       }
-      case "unknown": {
-        if (this.nonStrict) {
-          this.queue.push(new TypstToken(1 /* SYMBOL */, node.content));
-        } else {
-          throw new TypstWriterError(`Unknown macro: ${node.content}`, node);
-        }
-        break;
-      }
       default:
-        throw new TypstWriterError(`Unimplemented node type to append: ${node.type}`, node);
+        throw new TypstWriterError(`Unimplemented node type to append: ${abstractNode.type}`, abstractNode);
     }
   }
   appendWithBracketsIfNeeded(node) {
@@ -2572,34 +1564,1124 @@ var TypstWriter = class {
     });
     this.queue = [];
   }
-  finalize() {
-    this.flushQueue();
-    const smartFloorPass = function(input) {
-      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(/ceil\.l\s*(.*?)\s*ceil\.r/g, "ceil($1)");
-      res = res.replace(/ceil\(\)/g, 'ceil("")');
-      return res;
-    };
-    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;
-    };
-    if (this.optimize) {
-      const all_passes = [smartFloorPass, smartCeilPass, smartRoundPass];
-      for (const pass of all_passes) {
-        this.buffer = pass(this.buffer);
-      }
-    }
-    return this.buffer;
+  finalize() {
+    this.flushQueue();
+    const smartFloorPass = function(input) {
+      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(/ceil\.l\s*(.*?)\s*ceil\.r/g, "ceil($1)");
+      res = res.replace(/ceil\(\)/g, 'ceil("")');
+      return res;
+    };
+    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;
+    };
+    if (this.optimize) {
+      const all_passes = [smartFloorPass, smartCeilPass, smartRoundPass];
+      for (const pass of all_passes) {
+        this.buffer = pass(this.buffer);
+      }
+    }
+    return this.buffer;
+  }
+};
+
+// src/map.ts
+var symbolMap = /* @__PURE__ */ new Map([
+  ["displaystyle", "display"],
+  ["hspace", "#h"],
+  ["|", "bar.v.double"],
+  [",", "thin"],
+  [":", "med"],
+  [" ", "med"],
+  [";", "thick"],
+  /* textual operators */
+  ["ln", "ln"],
+  ["log", "log"],
+  ["cos", "cos"],
+  ["sin", "sin"],
+  ["tan", "tan"],
+  ["cot", "cot"],
+  ["sec", "sec"],
+  ["csc", "csc"],
+  ["mod", "mod"],
+  ["omicron", "omicron"],
+  ["Xi", "Xi"],
+  ["Upsilon", "Upsilon"],
+  ["lim", "lim"],
+  ["binom", "binom"],
+  ["tilde", "tilde"],
+  ["hat", "hat"],
+  ["sqrt", "sqrt"],
+  ["nonumber", ""],
+  ["vec", "arrow"],
+  ["neq", "eq.not"],
+  ["dot", "dot"],
+  ["ddot", "dot.double"],
+  ["doteq", "dot(eq)"],
+  ["dots", "dots.h"],
+  ["vdots", "dots.v"],
+  ["ddots", "dots.down"],
+  ["widehat", "hat"],
+  // Ideally, the result of \widehat should be longer than \hat. But it is not implemented now.
+  ["widetilde", "tilde"],
+  // Ideally, the result of \widetilde should be longer than \tilde. But it is not implemented now.
+  ["quad", "quad"],
+  ["qquad", "wide"],
+  ["overbrace", "overbrace"],
+  // same
+  ["underbrace", "underbrace"],
+  // same
+  ["overline", "overline"],
+  // same
+  ["underline", "underline"],
+  // same
+  ["bar", "macron"],
+  ["dbinom", "binom"],
+  ["tbinom", "binom"],
+  ["dfrac", "frac"],
+  ["tfrac", "frac"],
+  ["operatorname", "op"],
+  ["boldsymbol", "bold"],
+  ["mathbb", "bb"],
+  ["mathbf", "bold"],
+  ["mathcal", "cal"],
+  ["mathit", "italic"],
+  ["mathfrak", "frak"],
+  ["mathrm", "upright"],
+  ["mathsf", "sans"],
+  ["mathtt", "mono"],
+  ["rm", "upright"],
+  // TODO: \pmb need special logic to handle but it is not implemented now. See the commented test case.
+  ["pmb", "bold"],
+  ["leadsto", "arrow.r.squiggly"],
+  ["P", "pilcrow"],
+  ["S", "section"],
+  ["aleph", "alef"],
+  ["infin", "infinity"],
+  ["Delta", "Delta"],
+  ["Gamma", "Gamma"],
+  ["Lambda", "Lambda"],
+  ["Omega", "Omega"],
+  ["Phi", "Phi"],
+  ["Pi", "Pi"],
+  ["Psi", "Psi"],
+  ["Sigma", "Sigma"],
+  ["Theta", "Theta"],
+  ["alpha", "alpha"],
+  // ['amalg', 'product.co'], 
+  ["beta", "beta"],
+  ["bigcirc", "circle.big"],
+  // ['bowtie', 'join'], 
+  ["bullet", "bullet"],
+  ["cdot", "dot.op"],
+  // 'dot.op' or 'dot.c'
+  ["cdots", "dots.c"],
+  ["checkmark", "checkmark"],
+  ["chi", "chi"],
+  ["circ", "circle.small"],
+  // 'circle.small' or 'compose'
+  ["colon", "colon"],
+  ["cong", "tilde.equiv"],
+  ["coprod", "product.co"],
+  ["copyright", "copyright"],
+  ["cup", "union"],
+  ["curlyvee", "or.curly"],
+  ["curlywedge", "and.curly"],
+  ["dagger", "dagger"],
+  ["dashv", "tack.l"],
+  ["ddagger", "dagger.double"],
+  ["delta", "delta"],
+  ["ddots", "dots.down"],
+  ["diamond", "diamond"],
+  ["div", "div"],
+  ["divideontimes", "times.div"],
+  ["dotplus", "plus.dot"],
+  ["ell", "ell"],
+  ["emptyset", "nothing"],
+  ["epsilon", "epsilon.alt"],
+  ["equiv", "equiv"],
+  ["eta", "eta"],
+  ["exists", "exists"],
+  ["forall", "forall"],
+  // ['frown', 'paren.t'], 
+  ["gamma", "gamma"],
+  ["ge", "gt.eq"],
+  ["geq", "gt.eq"],
+  ["geqslant", "gt.eq.slant"],
+  ["gg", "gt.double"],
+  ["hbar", "planck.reduce"],
+  ["imath", "dotless.i"],
+  ["iiiint", "integral.quad"],
+  ["iiint", "integral.triple"],
+  ["iint", "integral.double"],
+  ["in", "in"],
+  ["infty", "infinity"],
+  ["int", "integral"],
+  ["intercal", "top"],
+  // 'top' or 'tack.b'
+  ["iota", "iota"],
+  ["jmath", "dotless.j"],
+  ["kappa", "kappa"],
+  ["lambda", "lambda"],
+  ["land", "and"],
+  ["langle", "angle.l"],
+  ["lbrace", "brace.l"],
+  ["lbrack", "bracket.l"],
+  ["ldots", "dots.h"],
+  ["le", "lt.eq"],
+  ["leftthreetimes", "times.three.l"],
+  ["leftrightarrow", "arrow.l.r"],
+  ["leq", "lt.eq"],
+  ["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.equiv.not"],
+  ["ne", "eq.not"],
+  ["neg", "not"],
+  ["neq", "eq.not"],
+  ["nexists", "exists.not"],
+  ["ni", "in.rev"],
+  ["nleftarrow", "arrow.l.not"],
+  ["nleq", "lt.eq.not"],
+  ["nparallel", "parallel.not"],
+  ["ngeq", "gt.eq.not"],
+  ["nmid", "divides.not"],
+  ["notin", "in.not"],
+  // ['nrightarrow', 'arrow.not'], 
+  ["nsim", "tilde.not"],
+  ["nsubseteq", "subset.eq.not"],
+  ["nu", "nu"],
+  ["ntriangleleft", "lt.tri.not"],
+  ["ntriangleright", "gt.tri.not"],
+  ["odot", "dot.circle"],
+  ["oint", "integral.cont"],
+  ["oiint", "integral.surf"],
+  ["oiiint", "integral.vol"],
+  ["omega", "omega"],
+  ["ominus", "minus.circle"],
+  // ['oplus', 'xor'], // or 'plus.circle'
+  ["otimes", "times.circle"],
+  ["parallel", "parallel"],
+  ["partial", "diff"],
+  ["perp", "perp"],
+  ["phi", "phi.alt"],
+  ["pi", "pi"],
+  ["pm", "plus.minus"],
+  ["pounds", "pound"],
+  ["prec", "prec"],
+  ["preceq", "prec.eq"],
+  ["prime", "prime"],
+  ["prod", "product"],
+  ["propto", "prop"],
+  ["psi", "psi"],
+  ["rangle", "angle.r"],
+  ["rbrace", "brace.r"],
+  ["rbrack", "bracket.r"],
+  ["rhd", "triangle"],
+  ["rho", "rho"],
+  ["rightarrow", "arrow.r"],
+  ["rightthreetimes", "times.three.r"],
+  ["rtimes", "times.r"],
+  ["setminus", "without"],
+  ["sigma", "sigma"],
+  ["sim", "tilde.op"],
+  ["simeq", "tilde.eq"],
+  ["slash", "slash"],
+  ["smallsetminus", "without"],
+  // ['smile', 'paren.b'], 
+  ["spadesuit", "suit.spade"],
+  ["sqsubseteq", "subset.eq.sq"],
+  ["sqsupseteq", "supset.eq.sq"],
+  // ['star', 'star'], 
+  ["subset", "subset"],
+  ["subseteq", "subset.eq"],
+  ["subsetneq", "subset.neq"],
+  ["succ", "succ"],
+  ["succeq", "succ.eq"],
+  ["sum", "sum"],
+  ["supset", "supset"],
+  ["supseteq", "supset.eq"],
+  ["supsetneq", "supset.neq"],
+  ["tau", "tau"],
+  ["theta", "theta"],
+  ["times", "times"],
+  ["to", "arrow.r"],
+  ["top", "top"],
+  ["triangle", "triangle.t"],
+  // ['triangledown', 'triangle.b.small'], 
+  // ['triangleleft', 'triangle.l.small'], 
+  // ['triangleright', 'triangle.r.small'], 
+  ["twoheadrightarrow", "arrow.r.twohead"],
+  ["upharpoonright", "harpoon.tr"],
+  ["uplus", "union.plus"],
+  ["upsilon", "upsilon"],
+  ["varepsilon", "epsilon"],
+  ["varnothing", "diameter"],
+  // empty set
+  ["varphi", "phi"],
+  ["varpi", "pi.alt"],
+  ["varrho", "rho.alt"],
+  ["varsigma", "sigma.alt"],
+  ["vartheta", "theta.alt"],
+  ["vdash", "tack.r"],
+  ["vdots", "dots.v"],
+  ["vee", "or"],
+  ["wedge", "and"],
+  ["wr", "wreath"],
+  ["xi", "xi"],
+  ["yen", "yen"],
+  ["zeta", "zeta"],
+  // extended
+  ["mathscr", "scr"],
+  ["LaTeX", "#LaTeX"],
+  ["TeX", "#TeX"]
+]);
+var map_from_official_docs = /* @__PURE__ */ new Map([
+  ["acwopencirclearrow", "arrow.ccw"],
+  ["adots", "dots.up"],
+  ["angdnr", "angle.acute"],
+  ["angle", "angle"],
+  ["angles", "angle.s"],
+  ["approx", "approx"],
+  ["approxeq", "approx.eq"],
+  ["approxident", "tilde.triple"],
+  ["assert", "tack.r.short"],
+  ["ast", "ast.op"],
+  ["asymp", "asymp"],
+  ["awint", "integral.ccw"],
+  ["backcong", "tilde.rev.equiv"],
+  ["backdprime", "prime.double.rev"],
+  ["backprime", "prime.rev"],
+  ["backsim", "tilde.rev"],
+  ["backsimeq", "tilde.eq.rev"],
+  ["backslash", "backslash"],
+  ["backtrprime", "prime.triple.rev"],
+  ["bardownharpoonleft", "harpoon.bl.bar"],
+  ["bardownharpoonright", "harpoon.br.bar"],
+  ["barleftarrow", "arrow.l.stop"],
+  ["barleftarrowrightarrowbar", "arrows.lr.stop"],
+  ["barleftharpoondown", "harpoon.lb.stop"],
+  ["barleftharpoonup", "harpoon.lt.stop"],
+  ["barrightharpoondown", "harpoon.rb.bar"],
+  ["barrightharpoonup", "harpoon.rt.bar"],
+  ["baruparrow", "arrow.t.stop"],
+  ["barupharpoonleft", "harpoon.tl.stop"],
+  ["barupharpoonright", "harpoon.tr.stop"],
+  ["barV", "tack.b.double"],
+  ["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"],
+  ["because", "because"],
+  ["bigblacktriangledown", "triangle.filled.b"],
+  ["bigblacktriangleup", "triangle.filled.t"],
+  ["bigbot", "tack.t.big"],
+  ["bigcap", "inter.big"],
+  ["bigcup", "union.big"],
+  ["bigcupdot", "union.dot.big"],
+  ["biginterleave", "interleave.big"],
+  ["bigodot", "dot.circle.big"],
+  ["bigoplus", "plus.circle.big"],
+  // or 'xor.big'
+  ["bigotimes", "times.circle.big"],
+  ["bigsqcap", "inter.sq.big"],
+  ["bigsqcup", "union.sq.big"],
+  ["bigstar", "star.filled"],
+  ["bigtimes", "times.big"],
+  ["bigtop", "tack.b.big"],
+  ["bigtriangledown", "triangle.stroked.b"],
+  // or 'triangle.b'
+  ["bigtriangleup", "triangle.stroked.t"],
+  // or 'triangle.t'
+  ["biguplus", "union.plus.big"],
+  ["bigvee", "or.big"],
+  ["bigwedge", "and.big"],
+  ["bigwhitestar", "star.stroked"],
+  ["blackhourglass", "hourglass.filled"],
+  ["blacktriangle", "triangle.filled.small.t"],
+  ["blacktriangledown", "triangle.filled.small.b"],
+  ["blacktriangleleft", "triangle.filled.l"],
+  ["blacktriangleright", "triangle.filled.r"],
+  ["blkhorzoval", "ellipse.filled.h"],
+  ["blkvertoval", "ellipse.filled.v"],
+  ["bot", "bot"],
+  ["boxast", "ast.square"],
+  ["boxdot", "dot.square"],
+  ["boxminus", "minus.square"],
+  ["boxplus", "plus.square"],
+  ["boxtimes", "times.square"],
+  ["cap", "inter"],
+  ["Cap", "inter.double"],
+  ["capdot", "inter.dot"],
+  ["capwedge", "inter.and"],
+  ["caretinsert", "caret"],
+  ["cdot", "dot.op"],
+  ["cdotp", "dot.c"],
+  ["checkmark", "checkmark"],
+  ["circledast", "ast.circle"],
+  ["circledcirc", "circle.nested"],
+  ["circleddash", "dash.circle"],
+  ["circledequal", "eq.circle"],
+  ["circledparallel", "parallel.circle"],
+  ["circledvert", "bar.v.circle"],
+  ["clubsuit", "suit.club.filled"],
+  ["Colon", "colon.double"],
+  ["coloneq", "colon.eq"],
+  ["Coloneq", "colon.double.eq"],
+  ["complement", "complement"],
+  ["cong", "tilde.equiv"],
+  ["coprod", "product.co"],
+  ["cup", "union"],
+  ["Cup", "union.double"],
+  ["cupdot", "union.dot"],
+  ["cupleftarrow", "union.arrow"],
+  ["cupvee", "union.or"],
+  ["curlyeqprec", "eq.prec"],
+  ["curlyeqsucc", "eq.succ"],
+  ["curlyvee", "or.curly"],
+  ["curlywedge", "and.curly"],
+  ["curvearrowleft", "arrow.ccw.half"],
+  ["curvearrowright", "arrow.cw.half"],
+  ["cwopencirclearrow", "arrow.cw"],
+  ["dagger", "dagger"],
+  ["dashcolon", "dash.colon"],
+  ["dashv", "tack.l"],
+  ["Dashv", "tack.l.double"],
+  ["dashVdash", "tack.l.r"],
+  ["ddagger", "dagger.double"],
+  ["ddddot", "dot.quad"],
+  ["dddot", "dot.triple"],
+  ["ddots", "dots.down"],
+  ["DDownarrow", "arrow.b.quad"],
+  ["Ddownarrow", "arrow.b.triple"],
+  ["diameter", "diameter"],
+  ["diamondcdot", "diamond.stroked.dot"],
+  ["diamondsuit", "suit.diamond.stroked"],
+  ["dicei", "die.one"],
+  ["diceii", "die.two"],
+  ["diceiii", "die.three"],
+  ["diceiv", "die.four"],
+  ["dicev", "die.five"],
+  ["dicevi", "die.six"],
+  ["div", "div"],
+  ["divideontimes", "times.div"],
+  ["Doteq", "eq.dots"],
+  ["dotminus", "minus.dot"],
+  ["dotplus", "plus.dot"],
+  ["dotsim", "tilde.dot"],
+  ["dottedcircle", "circle.dotted"],
+  ["dottedsquare", "square.stroked.dotted"],
+  ["doubleplus", "plus.double"],
+  ["downarrow", "arrow.b"],
+  ["Downarrow", "arrow.b.double"],
+  ["downarrowbar", "arrow.b.stop"],
+  ["downdasharrow", "arrow.b.dashed"],
+  ["downdownarrows", "arrows.bb"],
+  ["downharpoonleft", "harpoon.bl"],
+  ["downharpoonleftbar", "harpoon.bl.stop"],
+  ["downharpoonright", "harpoon.br"],
+  ["downharpoonrightbar", "harpoon.br.stop"],
+  ["downharpoonsleftright", "harpoons.blbr"],
+  ["downrightcurvedarrow", "arrow.b.curve"],
+  ["downuparrows", "arrows.bt"],
+  ["downupharpoonsleftright", "harpoons.bltr"],
+  ["downwhitearrow", "arrow.b.stroked"],
+  ["downzigzagarrow", "arrow.zigzag"],
+  ["dprime", "prime.double"],
+  ["dualmap", "multimap.double"],
+  ["eighthnote", "note.eighth.alt"],
+  ["ell", "ell"],
+  ["emptysetoarr", "emptyset.arrow.r"],
+  ["emptysetoarrl", "emptyset.arrow.l"],
+  ["emptysetobar", "emptyset.bar"],
+  ["emptysetocirc", "emptyset.circle"],
+  ["eparsl", "parallel.slanted.eq"],
+  ["eqcolon", "eq.colon"],
+  ["eqdef", "eq.def"],
+  // \usepackage{mathtools} defines \eqdef
+  ["eqgtr", "eq.gt"],
+  ["eqless", "eq.lt"],
+  ["eqsim", "minus.tilde"],
+  ["equal", "eq"],
+  ["equalparallel", "parallel.eq"],
+  ["equiv", "eq.triple"],
+  ["Equiv", "eq.quad"],
+  ["equivVert", "parallel.equiv"],
+  ["eqvparsl", "parallel.slanted.equiv"],
+  ["errbarblackcircle", "errorbar.circle.filled"],
+  ["errbarblackdiamond", "errorbar.diamond.filled"],
+  ["errbarblacksquare", "errorbar.square.filled"],
+  ["errbarcircle", "errorbar.circle.stroked"],
+  ["errbardiamond", "errorbar.diamond.stroked"],
+  ["errbarsquare", "errorbar.square.stroked"],
+  ["euro", "euro"],
+  ["Exclam", "excl.double"],
+  ["exists", "exists"],
+  ["fallingdotseq", "eq.dots.down"],
+  ["fint", "integral.slash"],
+  ["flat", "flat"],
+  ["forall", "forall"],
+  ["fourvdots", "fence.dotted"],
+  ["fullouterjoin", "join.l.r"],
+  ["geq", "gt.eq"],
+  ["geqq", "gt.equiv"],
+  ["geqslant", "gt.eq.slant"],
+  ["gg", "gt.double"],
+  ["ggg", "gt.triple"],
+  ["gggnest", "gt.triple.nested"],
+  ["gnapprox", "gt.napprox"],
+  ["gneq", "gt.neq"],
+  ["gneqq", "gt.nequiv"],
+  ["gnsim", "gt.ntilde"],
+  ["greater", "gt"],
+  ["gtlpar", "angle.spheric.rev"],
+  ["gtrapprox", "gt.approx"],
+  ["gtrdot", "gt.dot"],
+  ["gtreqless", "gt.eq.lt"],
+  ["gtrless", "gt.lt"],
+  ["gtrsim", "gt.tilde"],
+  ["heartsuit", "suit.heart.stroked"],
+  ["hknearrow", "arrow.tr.hook"],
+  ["hknwarrow", "arrow.tl.hook"],
+  ["hksearrow", "arrow.br.hook"],
+  ["hkswarrow", "arrow.bl.hook"],
+  ["hookleftarrow", "arrow.l.hook"],
+  ["hookrightarrow", "arrow.r.hook"],
+  ["horizbar", "bar.h"],
+  ["hourglass", "hourglass.stroked"],
+  ["hrectangle", "rect.stroked.h"],
+  ["hrectangleblack", "rect.filled.h"],
+  ["hslash", "planck.reduce"],
+  ["hzigzag", "dash.wave.double"],
+  ["iiiint", "integral.quad"],
+  ["iiint", "integral.triple"],
+  ["iinfin", "infinity.incomplete"],
+  ["iint", "integral.double"],
+  ["Im", "Im"],
+  ["imageof", "image"],
+  ["in", "in"],
+  ["increment", "laplace"],
+  ["infty", "infinity"],
+  ["int", "integral"],
+  ["intbar", "integral.dash"],
+  ["intBar", "integral.dash.double"],
+  ["intcap", "integral.inter"],
+  ["intclockwise", "integral.cw"],
+  ["intcup", "integral.union"],
+  ["interleave", "interleave"],
+  ["intlarhk", "integral.arrow.hook"],
+  ["intx", "integral.times"],
+  ["Join", "join"],
+  ["langle", "angle.l"],
+  ["lAngle", "angle.l.double"],
+  ["langledot", "angle.l.dot"],
+  ["lat", "lat"],
+  ["late", "lat.eq"],
+  ["lbrace", "brace.l"],
+  ["lBrace", "brace.l.double"],
+  ["lbrack", "bracket.l"],
+  ["lBrack", "bracket.l.double"],
+  ["lbrbrak", "shell.l"],
+  ["Lbrbrak", "shell.l.double"],
+  ["lceil", "ceil.l"],
+  ["lcurvyangle", "angle.l.curly"],
+  ["leftarrow", "arrow.l"],
+  ["Leftarrow", "arrow.l.double"],
+  ["leftarrowtail", "arrow.l.tail"],
+  ["leftdasharrow", "arrow.l.dashed"],
+  ["leftdotarrow", "arrow.l.dotted"],
+  ["leftdowncurvedarrow", "arrow.l.curve"],
+  ["leftharpoondown", "harpoon.lb"],
+  ["leftharpoondownbar", "harpoon.lb.bar"],
+  ["leftharpoonsupdown", "harpoons.ltlb"],
+  ["leftharpoonup", "harpoon.lt"],
+  ["leftharpoonupbar", "harpoon.lt.bar"],
+  ["leftleftarrows", "arrows.ll"],
+  ["leftouterjoin", "join.l"],
+  ["leftrightarrow", "arrow.l.r"],
+  ["Leftrightarrow", "arrow.l.r.double"],
+  ["leftrightarrows", "arrows.lr"],
+  ["leftrightharpoondowndown", "harpoon.lb.rb"],
+  ["leftrightharpoondownup", "harpoon.lb.rt"],
+  ["leftrightharpoons", "harpoons.ltrb"],
+  ["leftrightharpoonsdown", "harpoons.lbrb"],
+  ["leftrightharpoonsup", "harpoons.ltrt"],
+  ["leftrightharpoonupdown", "harpoon.lt.rb"],
+  ["leftrightharpoonupup", "harpoon.lt.rt"],
+  ["leftrightsquigarrow", "arrow.l.r.wave"],
+  ["leftsquigarrow", "arrow.l.squiggly"],
+  ["leftthreearrows", "arrows.lll"],
+  ["leftthreetimes", "times.three.l"],
+  ["leftwavearrow", "arrow.l.wave"],
+  ["leftwhitearrow", "arrow.l.stroked"],
+  ["leq", "lt.eq"],
+  ["leqq", "lt.equiv"],
+  ["leqslant", "lt.eq.slant"],
+  ["less", "lt"],
+  ["lessapprox", "lt.approx"],
+  ["lessdot", "lt.dot"],
+  ["lesseqgtr", "lt.eq.gt"],
+  ["lessgtr", "lt.gt"],
+  ["lesssim", "lt.tilde"],
+  ["lfloor", "floor.l"],
+  ["lgblkcircle", "circle.filled.big"],
+  ["lgblksquare", "square.filled.big"],
+  ["lgwhtcircle", "circle.stroked.big"],
+  ["lgwhtsquare", "square.stroked.big"],
+  ["ll", "lt.double"],
+  ["llblacktriangle", "triangle.filled.bl"],
+  ["LLeftarrow", "arrow.l.quad"],
+  ["Lleftarrow", "arrow.l.triple"],
+  ["lll", "lt.triple"],
+  ["lllnest", "lt.triple.nested"],
+  ["lltriangle", "triangle.stroked.bl"],
+  ["lnapprox", "lt.napprox"],
+  ["lneq", "lt.neq"],
+  ["lneqq", "lt.nequiv"],
+  ["lnsim", "lt.ntilde"],
+  ["longdashv", "tack.l.long"],
+  ["Longleftarrow", "arrow.l.double.long"],
+  ["longleftarrow", "arrow.l.long"],
+  ["Longleftrightarrow", "arrow.l.r.double.long"],
+  ["longleftrightarrow", "arrow.l.r.long"],
+  ["longleftsquigarrow", "arrow.l.long.squiggly"],
+  ["Longmapsfrom", "arrow.l.double.long.bar"],
+  ["longmapsfrom", "arrow.l.long.bar"],
+  ["longmapsto", "arrow.r.long.bar"],
+  ["Longmapsto", "arrow.r.double.long.bar"],
+  ["Longrightarrow", "arrow.r.double.long"],
+  ["longrightarrow", "arrow.r.long"],
+  ["longrightsquigarrow", "arrow.r.long.squiggly"],
+  ["looparrowleft", "arrow.l.loop"],
+  ["looparrowright", "arrow.r.loop"],
+  ["lparen", "paren.l"],
+  ["lParen", "paren.l.double"],
+  ["lrblacktriangle", "triangle.filled.br"],
+  ["lrtriangle", "triangle.stroked.br"],
+  ["ltimes", "times.l"],
+  ["lvzigzag", "fence.l"],
+  ["Lvzigzag", "fence.l.double"],
+  ["maltese", "maltese"],
+  ["mapsdown", "arrow.b.bar"],
+  ["mapsfrom", "arrow.l.bar"],
+  ["Mapsfrom", "arrow.l.double.bar"],
+  ["mapsto", "arrow.r.bar"],
+  ["Mapsto", "arrow.r.double.bar"],
+  ["mapsup", "arrow.t.bar"],
+  ["mathampersand", "amp"],
+  ["mathatsign", "at"],
+  ["mathcolon", "colon"],
+  ["mathcomma", "comma"],
+  ["mathdollar", "dollar"],
+  ["mathexclam", "excl"],
+  // ['mathhyphen', 'hyph'], // \mathhyphen is not defined in standard amsmath package
+  ["mathoctothorpe", "hash"],
+  ["mathparagraph", "pilcrow"],
+  ["mathpercent", "percent"],
+  ["mathperiod", "dot.basic"],
+  ["mathplus", "plus"],
+  ["mathquestion", "quest"],
+  ["mathratio", "ratio"],
+  ["mathsection", "section"],
+  ["mathsemicolon", "semi"],
+  ["mathslash", "slash"],
+  ["mathsterling", "pound"],
+  ["mathyen", "yen"],
+  ["mdblkdiamond", "diamond.filled.medium"],
+  ["mdblklozenge", "lozenge.filled.medium"],
+  ["mdblksquare", "square.filled.medium"],
+  ["mdlgblkcircle", "circle.filled"],
+  ["mdlgblkdiamond", "diamond.filled"],
+  ["mdlgblklozenge", "lozenge.filled"],
+  ["mdlgblksquare", "square.filled"],
+  ["mdlgwhtcircle", "circle.stroked"],
+  ["mdlgwhtdiamond", "diamond.stroked"],
+  ["mdlgwhtlozenge", "lozenge.stroked"],
+  ["mdlgwhtsquare", "square.stroked"],
+  ["mdsmblkcircle", "circle.filled.tiny"],
+  ["mdsmblksquare", "square.filled.small"],
+  ["mdsmwhtcircle", "circle.stroked.small"],
+  ["mdsmwhtsquare", "square.stroked.small"],
+  ["mdwhtdiamond", "diamond.stroked.medium"],
+  ["mdwhtlozenge", "lozenge.stroked.medium"],
+  ["mdwhtsquare", "square.stroked.medium"],
+  ["measeq", "eq.m"],
+  ["measuredangle", "angle.arc"],
+  ["measuredangleleft", "angle.arc.rev"],
+  ["measuredrightangle", "angle.right.arc"],
+  ["mho", "Omega.inv"],
+  ["mid", "divides"],
+  ["minus", "minus"],
+  ["models", "models"],
+  ["mp", "minus.plus"],
+  ["multimap", "multimap"],
+  /* ['mupAlpha', 'Alpha'],
+  ['mupalpha', 'alpha'],
+  ['mupBeta', 'Beta'],
+  ['mupbeta', 'beta'],
+  ['mupChi', 'Chi'],
+  ['mupchi', 'chi'],
+  ['mupDelta', 'Delta'],
+  ['mupdelta', 'delta'],
+  ['mupEpsilon', 'Epsilon'],
+  ['mupepsilon', 'epsilon.alt'],
+  ['mupEta', 'Eta'],
+  ['mupeta', 'eta'],
+  ['mupGamma', 'Gamma'],
+  ['mupgamma', 'gamma'],
+  ['mupIota', 'Iota'],
+  ['mupiota', 'iota'],
+  ['mupKappa', 'Kappa'],
+  ['mupkappa', 'kappa'],
+  ['mupLambda', 'Lambda'],
+  ['muplambda', 'lambda'],
+  ['mupMu', 'Mu'],
+  ['mupmu', 'mu'],
+  ['mupNu', 'Nu'],
+  ['mupnu', 'nu'],
+  ['mupOmega', 'Omega'],
+  ['mupomega', 'omega'],
+  ['mupOmicron', 'Omicron'],
+  ['mupomicron', 'omicron'],
+  ['mupPhi', 'Phi'],
+  ['mupphi', 'phi.alt'],
+  ['mupPi', 'Pi'],
+  ['muppi', 'pi'],
+  ['mupPsi', 'Psi'],
+  ['muppsi', 'psi'],
+  ['mupRho', 'Rho'],
+  ['muprho', 'rho'],
+  ['mupSigma', 'Sigma'],
+  ['mupsigma', 'sigma'],
+  ['mupTau', 'Tau'],
+  ['muptau', 'tau'],
+  ['mupTheta', 'Theta'],
+  ['muptheta', 'theta'],
+  ['mupUpsilon', 'Upsilon'],
+  ['mupupsilon', 'upsilon'],
+  ['mupvarepsilon', 'epsilon'],
+  ['mupvarkappa', 'kappa.alt'],
+  ['mupvarphi', 'phi'],
+  ['mupvarpi', 'pi.alt'],
+  ['mupvarrho', 'rho.alt'],
+  ['mupvarsigma', 'sigma.alt'],
+  ['mupvartheta', 'theta.alt'],
+  ['mupXi', 'Xi'],
+  ['mupxi', 'xi'],
+  ['mupZeta', 'Zeta'],
+  ['mupzeta', 'zeta'], */
+  ["nabla", "gradient"],
+  ["napprox", "approx.not"],
+  ["nasymp", "asymp.not"],
+  ["natural", "natural"],
+  ["ncong", "tilde.equiv.not"],
+  ["ne", "eq.not"],
+  ["nearrow", "arrow.tr"],
+  ["Nearrow", "arrow.tr.double"],
+  ["neg", "not"],
+  ["nequiv", "equiv.not"],
+  // or eq.triple.not
+  ["neswarrow", "arrow.tr.bl"],
+  ["nexists", "exists.not"],
+  ["ngeq", "gt.eq.not"],
+  ["ngtr", "gt.not"],
+  ["ngtrless", "gt.lt.not"],
+  ["ngtrsim", "gt.tilde.not"],
+  ["nhpar", "parallel.struck"],
+  ["nhVvert", "interleave.struck"],
+  ["ni", "in.rev"],
+  ["nLeftarrow", "arrow.l.double.not"],
+  ["nleftarrow", "arrow.l.not"],
+  ["nLeftrightarrow", "arrow.l.r.double.not"],
+  ["nleftrightarrow", "arrow.l.r.not"],
+  ["nleq", "lt.eq.not"],
+  ["nless", "lt.not"],
+  ["nlessgtr", "lt.gt.not"],
+  ["nlesssim", "lt.tilde.not"],
+  ["nmid", "divides.not"],
+  ["nni", "in.rev.not"],
+  ["notin", "in.not"],
+  ["nparallel", "parallel.not"],
+  ["nprec", "prec.not"],
+  ["npreccurlyeq", "prec.curly.eq.not"],
+  ["nRightarrow", "arrow.r.double.not"],
+  ["nrightarrow", "arrow.r.not"],
+  ["nsim", "tilde.not"],
+  ["nsimeq", "tilde.eq.not"],
+  ["nsqsubseteq", "subset.eq.sq.not"],
+  ["nsqsupseteq", "supset.eq.sq.not"],
+  ["nsubset", "subset.not"],
+  ["nsubseteq", "subset.eq.not"],
+  ["nsucc", "succ.not"],
+  ["nsucccurlyeq", "succ.curly.eq.not"],
+  ["nsupset", "supset.not"],
+  ["nsupseteq", "supset.eq.not"],
+  ["ntrianglelefteq", "lt.tri.eq.not"],
+  ["ntrianglerighteq", "gt.tri.eq.not"],
+  ["nvartriangleleft", "lt.tri.not"],
+  ["nvartriangleright", "gt.tri.not"],
+  ["nVdash", "forces.not"],
+  ["nvdash", "tack.r.not"],
+  ["nvDash", "tack.r.double.not"],
+  ["nvinfty", "infinity.bar"],
+  ["nwarrow", "arrow.tl"],
+  ["Nwarrow", "arrow.tl.double"],
+  ["nwsearrow", "arrow.tl.br"],
+  ["obrbrak", "shell.t"],
+  ["obslash", "backslash.circle"],
+  ["odiv", "div.circle"],
+  ["odot", "dot.circle"],
+  ["ogreaterthan", "gt.circle"],
+  ["oiiint", "integral.vol"],
+  ["oiint", "integral.surf"],
+  ["oint", "integral.cont"],
+  ["ointctrclockwise", "integral.cont.ccw"],
+  ["olessthan", "lt.circle"],
+  ["ominus", "minus.circle"],
+  ["operp", "perp.circle"],
+  ["oplus", "plus.circle"],
+  ["origof", "original"],
+  ["otimes", "times.circle"],
+  // ['overbrace', 'brace.t'],
+  ["overbracket", "bracket.t"],
+  ["overparen", "paren.t"],
+  ["parallel", "parallel"],
+  ["parallelogram", "parallelogram.stroked"],
+  ["parallelogramblack", "parallelogram.filled"],
+  ["parsim", "parallel.tilde"],
+  ["partial", "diff"],
+  ["pentagon", "penta.stroked"],
+  ["pentagonblack", "penta.filled"],
+  ["perp", "perp"],
+  ["Planckconst", "planck"],
+  ["pm", "plus.minus"],
+  ["prec", "prec"],
+  ["Prec", "prec.double"],
+  ["precapprox", "prec.approx"],
+  ["preccurlyeq", "prec.curly.eq"],
+  ["preceq", "prec.eq"],
+  ["preceqq", "prec.equiv"],
+  ["precnapprox", "prec.napprox"],
+  ["precneq", "prec.neq"],
+  ["precneqq", "prec.nequiv"],
+  ["precnsim", "prec.ntilde"],
+  ["precsim", "prec.tilde"],
+  ["prime", "prime"],
+  ["prod", "product"],
+  ["propto", "prop"],
+  ["QED", "qed"],
+  ["qprime", "prime.quad"],
+  ["quarternote", "note.quarter.alt"],
+  ["questeq", "eq.quest"],
+  ["Question", "quest.double"],
+  ["rangle", "angle.r"],
+  ["rAngle", "angle.r.double"],
+  ["rangledot", "angle.r.dot"],
+  ["rbrace", "brace.r"],
+  ["rBrace", "brace.r.double"],
+  ["rbrack", "bracket.r"],
+  ["rBrack", "bracket.r.double"],
+  ["rbrbrak", "shell.r"],
+  ["Rbrbrak", "shell.r.double"],
+  ["rceil", "ceil.r"],
+  ["rcurvyangle", "angle.r.curly"],
+  ["Re", "Re"],
+  ["revangle", "angle.rev"],
+  ["revemptyset", "emptyset.rev"],
+  ["revnmid", "divides.not.rev"],
+  ["rfloor", "floor.r"],
+  ["rightangle", "angle.right"],
+  ["rightanglemdot", "angle.right.dot"],
+  ["rightanglesqr", "angle.right.sq"],
+  ["rightarrow", "arrow.r"],
+  ["Rightarrow", "arrow.r.double"],
+  ["rightarrowbar", "arrow.r.stop"],
+  ["rightarrowonoplus", "plus.circle.arrow"],
+  ["rightarrowtail", "arrow.r.tail"],
+  ["rightdasharrow", "arrow.r.dashed"],
+  ["rightdotarrow", "arrow.r.dotted"],
+  ["rightdowncurvedarrow", "arrow.r.curve"],
+  ["rightharpoondown", "harpoon.rb"],
+  ["rightharpoondownbar", "harpoon.rb.stop"],
+  ["rightharpoonsupdown", "harpoons.rtrb"],
+  ["rightharpoonup", "harpoon.rt"],
+  ["rightharpoonupbar", "harpoon.rt.stop"],
+  ["rightleftarrows", "arrows.rl"],
+  ["rightleftharpoons", "harpoons.rtlb"],
+  ["rightleftharpoonsdown", "harpoons.rblb"],
+  ["rightleftharpoonsup", "harpoons.rtlt"],
+  ["rightouterjoin", "join.r"],
+  ["rightrightarrows", "arrows.rr"],
+  ["rightsquigarrow", "arrow.r.squiggly"],
+  ["rightthreearrows", "arrows.rrr"],
+  ["rightthreetimes", "times.three.r"],
+  ["rightwavearrow", "arrow.r.wave"],
+  ["rightwhitearrow", "arrow.r.stroked"],
+  ["risingdotseq", "eq.dots.up"],
+  ["rparen", "paren.r"],
+  ["rParen", "paren.r.double"],
+  ["RRightarrow", "arrow.r.quad"],
+  ["Rrightarrow", "arrow.r.triple"],
+  ["rsolbar", "backslash.not"],
+  ["rtimes", "times.r"],
+  ["rvzigzag", "fence.r"],
+  ["Rvzigzag", "fence.r.double"],
+  ["searrow", "arrow.br"],
+  ["Searrow", "arrow.br.double"],
+  ["setminus", "without"],
+  ["sharp", "sharp"],
+  ["shortdowntack", "tack.b.short"],
+  ["shortlefttack", "tack.l.short"],
+  ["shortuptack", "tack.t.short"],
+  ["sim", "tilde.op"],
+  ["sime", "tilde.eq"],
+  ["similarleftarrow", "arrow.l.tilde"],
+  ["similarrightarrow", "arrow.r.tilde"],
+  ["simneqq", "tilde.nequiv"],
+  ["smallblacktriangleleft", "triangle.filled.small.l"],
+  ["smallblacktriangleright", "triangle.filled.small.r"],
+  ["smallin", "in.small"],
+  ["smallni", "in.rev.small"],
+  ["smalltriangleleft", "triangle.stroked.small.l"],
+  ["smalltriangleright", "triangle.stroked.small.r"],
+  ["smashtimes", "smash"],
+  ["smblkcircle", "bullet"],
+  ["smblkdiamond", "diamond.filled.small"],
+  ["smblklozenge", "lozenge.filled.small"],
+  ["smblksquare", "square.filled.tiny"],
+  ["smeparsl", "parallel.slanted.eq.tilde"],
+  ["smt", "smt"],
+  ["smte", "smt.eq"],
+  ["smwhtdiamond", "diamond.stroked.small"],
+  ["smwhtlozenge", "lozenge.stroked.small"],
+  ["smwhtsquare", "square.stroked.tiny"],
+  ["spadesuit", "suit.spade.filled"],
+  ["sphericalangle", "angle.spheric"],
+  ["sphericalangleup", "angle.spheric.top"],
+  ["sqcap", "inter.sq"],
+  ["Sqcap", "inter.sq.double"],
+  ["sqcup", "union.sq"],
+  ["Sqcup", "union.sq.double"],
+  ["sqint", "integral.square"],
+  ["sqsubset", "subset.sq"],
+  ["sqsubseteq", "subset.eq.sq"],
+  ["sqsubsetneq", "subset.sq.neq"],
+  ["sqsupset", "supset.sq"],
+  ["sqsupseteq", "supset.eq.sq"],
+  ["sqsupsetneq", "supset.sq.neq"],
+  ["squoval", "square.stroked.rounded"],
+  ["sslash", "slash.double"],
+  ["star", "star.op"],
+  ["stareq", "eq.star"],
+  ["subset", "subset"],
+  ["Subset", "subset.double"],
+  ["subsetdot", "subset.dot"],
+  ["subseteq", "subset.eq"],
+  ["subsetneq", "subset.neq"],
+  ["succ", "succ"],
+  ["Succ", "succ.double"],
+  ["succapprox", "succ.approx"],
+  ["succcurlyeq", "succ.curly.eq"],
+  ["succeq", "succ.eq"],
+  ["succeqq", "succ.equiv"],
+  ["succnapprox", "succ.napprox"],
+  ["succneq", "succ.neq"],
+  ["succneqq", "succ.nequiv"],
+  ["succnsim", "succ.ntilde"],
+  ["succsim", "succ.tilde"],
+  ["sum", "sum"],
+  ["sumint", "sum.integral"],
+  ["supset", "supset"],
+  ["Supset", "supset.double"],
+  ["supsetdot", "supset.dot"],
+  ["supseteq", "supset.eq"],
+  ["supsetneq", "supset.neq"],
+  ["swarrow", "arrow.bl"],
+  ["Swarrow", "arrow.bl.double"],
+  ["therefore", "therefore"],
+  ["threedangle", "angle.spatial"],
+  ["threedotcolon", "colon.tri.op"],
+  ["tieinfty", "infinity.tie"],
+  ["times", "times"],
+  ["tminus", "miny"],
+  ["top", "tack.b"],
+  ["tplus", "tiny"],
+  ["trianglecdot", "triangle.stroked.dot"],
+  ["triangledown", "triangle.stroked.small.b"],
+  ["triangleleft", "triangle.stroked.l"],
+  ["trianglelefteq", "lt.tri.eq"],
+  ["triangleminus", "minus.triangle"],
+  ["triangleplus", "plus.triangle"],
+  ["triangleq", "eq.delta"],
+  ["triangleright", "triangle.stroked.r"],
+  ["trianglerighteq", "gt.tri.eq"],
+  ["triangletimes", "times.triangle"],
+  ["tripleplus", "plus.triple"],
+  ["trprime", "prime.triple"],
+  ["trslash", "slash.triple"],
+  ["twoheaddownarrow", "arrow.b.twohead"],
+  ["twoheadleftarrow", "arrow.l.twohead"],
+  ["twoheadmapsfrom", "arrow.l.twohead.bar"],
+  ["twoheadmapsto", "arrow.r.twohead.bar"],
+  ["twoheadrightarrow", "arrow.r.twohead"],
+  ["twoheaduparrow", "arrow.t.twohead"],
+  ["twonotes", "note.eighth.beamed"],
+  ["ubrbrak", "shell.b"],
+  ["ulblacktriangle", "triangle.filled.tl"],
+  ["ultriangle", "triangle.stroked.tl"],
+  ["uminus", "union.minus"],
+  ["underbrace", "brace.b"],
+  ["underbracket", "bracket.b"],
+  ["underparen", "paren.b"],
+  ["unicodecdots", "dots.h.c"],
+  ["unicodeellipsis", "dots.h"],
+  ["upand", "amp.inv"],
+  ["uparrow", "arrow.t"],
+  ["Uparrow", "arrow.t.double"],
+  ["updasharrow", "arrow.t.dashed"],
+  ["updownarrow", "arrow.t.b"],
+  ["Updownarrow", "arrow.t.b.double"],
+  ["updownarrows", "arrows.tb"],
+  ["updownharpoonleftleft", "harpoon.tl.bl"],
+  ["updownharpoonleftright", "harpoon.tl.br"],
+  ["updownharpoonrightleft", "harpoon.tr.bl"],
+  ["updownharpoonrightright", "harpoon.tr.br"],
+  ["updownharpoonsleftright", "harpoons.tlbr"],
+  ["upharpoonleft", "harpoon.tl"],
+  ["upharpoonleftbar", "harpoon.tl.bar"],
+  ["upharpoonright", "harpoon.tr"],
+  ["upharpoonrightbar", "harpoon.tr.bar"],
+  ["upharpoonsleftright", "harpoons.tltr"],
+  ["uplus", "union.plus"],
+  ["uprightcurvearrow", "arrow.t.curve"],
+  ["upuparrows", "arrows.tt"],
+  ["upwhitearrow", "arrow.t.stroked"],
+  ["urblacktriangle", "triangle.filled.tr"],
+  ["urtriangle", "triangle.stroked.tr"],
+  ["UUparrow", "arrow.t.quad"],
+  ["Uuparrow", "arrow.t.triple"],
+  ["varclubsuit", "suit.club.stroked"],
+  ["vardiamondsuit", "suit.diamond.filled"],
+  ["varheartsuit", "suit.heart.filled"],
+  ["varhexagon", "hexa.stroked"],
+  ["varhexagonblack", "hexa.filled"],
+  ["varnothing", "emptyset"],
+  ["varointclockwise", "integral.cont.cw"],
+  ["varspadesuit", "suit.spade.stroked"],
+  ["vartriangle", "triangle.stroked.small.t"],
+  ["vartriangleleft", "lt.tri"],
+  ["vartriangleright", "gt.tri"],
+  ["Vbar", "tack.t.double"],
+  ["Vdash", "forces"],
+  ["vdash", "tack.r"],
+  ["vDash", "tack.r.double"],
+  ["vdots", "dots.v"],
+  ["vee", "or"],
+  ["Vee", "or.double"],
+  ["veedot", "or.dot"],
+  ["veeeq", "eq.equi"],
+  ["vert", "bar.v"],
+  ["Vert", "bar.v.double"],
+  ["vlongdash", "tack.r.long"],
+  ["vrectangle", "rect.stroked.v"],
+  ["vrectangleblack", "rect.filled.v"],
+  ["Vvert", "bar.v.triple"],
+  ["vysmblkcircle", "circle.filled.small"],
+  ["vysmwhtcircle", "circle.stroked.tiny"],
+  // or compose
+  ["wedge", "and"],
+  ["Wedge", "and.double"],
+  ["wedgedot", "and.dot"],
+  ["wedgeq", "eq.est"],
+  ["whiteinwhitetriangle", "triangle.stroked.nested"],
+  ["whthorzoval", "ellipse.stroked.h"],
+  ["whtvertoval", "ellipse.stroked.v"],
+  ["wideangledown", "angle.oblique"],
+  ["wr", "wreath"],
+  ["xsol", "slash.big"]
+]);
+var texAliasMap = /* @__PURE__ */ new Map([
+  ["gets", "leftarrow"],
+  ["iff", "Longleftrightarrow"],
+  ["implies", "Longrightarrow"]
+]);
+for (const [key, value] of map_from_official_docs) {
+  if (!symbolMap.has(key)) {
+    symbolMap.set(key, value);
+  }
+}
+var reverseSymbolMap = /* @__PURE__ */ new Map();
+for (const [key, value] of Array.from(symbolMap.entries()).reverse()) {
+  reverseSymbolMap.set(value, key);
+}
+reverseSymbolMap.set("oo", "infty");
+var typst_to_tex_map = /* @__PURE__ */ new Map([
+  ["top", "top"],
+  ["frac", "frac"],
+  ["tilde", "tilde"],
+  ["hat", "hat"],
+  ["upright", "mathrm"],
+  ["bold", "boldsymbol"],
+  ["infinity", "infty"]
+]);
+for (const [key, value] of typst_to_tex_map) {
+  reverseSymbolMap.set(key, value);
+}
+for (const [key, value] of texAliasMap) {
+  if (!symbolMap.has(key)) {
+    symbolMap.set(key, symbolMap.get(value));
   }
-};
+}
 
 // src/convert.ts
+var ConverterError = class extends Error {
+  constructor(message, node = null) {
+    super(message);
+    this.name = "ConverterError";
+    this.node = node;
+  }
+};
+var TYPST_NONE = TypstToken.NONE.toNode();
 var TYPST_INTRINSIC_OP = [
   "dim",
   "id",
@@ -2610,13 +2692,13 @@ var TYPST_INTRINSIC_OP = [
   "csch"
   // 'sgn
 ];
-function tex_token_to_typst(token) {
+function _tex_token_str_to_typst(token) {
   if (/^[a-zA-Z0-9]$/.test(token)) {
     return token;
   } else if (token === "/") {
     return "\\/";
-  } else if (token === "\\\\") {
-    return "\\";
+  } else if (["\\\\", "\\{", "\\}", "\\%"].includes(token)) {
+    return token.substring(1);
   } else if (["\\$", "\\#", "\\&", "\\_"].includes(token)) {
     return token;
   } else if (token.startsWith("\\")) {
@@ -2624,54 +2706,86 @@ function tex_token_to_typst(token) {
     if (symbolMap.has(symbol)) {
       return symbolMap.get(symbol);
     } else {
-      return symbol;
+      return null;
     }
   }
   return token;
 }
+function tex_token_to_typst(token, options) {
+  let token_type;
+  switch (token.type) {
+    case 0 /* EMPTY */:
+      return TypstToken.NONE;
+    case 2 /* COMMAND */:
+      token_type = 1 /* SYMBOL */;
+      break;
+    case 1 /* ELEMENT */:
+      token_type = 2 /* ELEMENT */;
+      break;
+    case 3 /* LITERAL */:
+      token_type = 3 /* LITERAL */;
+      break;
+    case 4 /* COMMENT */:
+      token_type = 5 /* COMMENT */;
+      break;
+    case 5 /* SPACE */:
+      token_type = 6 /* SPACE */;
+      break;
+    case 6 /* NEWLINE */:
+      token_type = 8 /* NEWLINE */;
+      break;
+    case 7 /* CONTROL */: {
+      if (token.value === "\\\\") {
+        return new TypstToken(7 /* CONTROL */, "\\");
+      } else if (token.value === "\\!") {
+        return new TypstToken(1 /* SYMBOL */, "#h(-math.thin.amount)");
+      } else if (symbolMap.has(token.value.substring(1))) {
+        const typst_symbol = symbolMap.get(token.value.substring(1));
+        return new TypstToken(1 /* SYMBOL */, typst_symbol);
+      } else {
+        throw new Error(`Unknown control sequence: ${token.value}`);
+      }
+    }
+    default:
+      throw Error(`Unknown token type: ${token.type}`);
+  }
+  const typst_str = _tex_token_str_to_typst(token.value);
+  if (typst_str === null) {
+    if (options.nonStrict) {
+      return new TypstToken(token_type, token.value.substring(1));
+    } else {
+      throw new ConverterError(`Unknown token: ${token.value}`, token);
+    }
+  }
+  return new TypstToken(token_type, typst_str);
+}
 function convert_overset(node, options) {
   const [sup, base] = node.args;
   if (options.optimize) {
-    const is_def = (n) => {
-      if (n.eq(new TexNode("text", "def"))) {
-        return true;
-      }
-      if (n.type === "ordgroup" && n.args.length === 3) {
-        const [a1, a2, a3] = n.args;
-        const d = new TexNode("element", "d");
-        const e = new TexNode("element", "e");
-        const f = new TexNode("element", "f");
-        if (a1.eq(d) && a2.eq(e) && a3.eq(f)) {
-          return true;
-        }
-      }
-      return false;
-    };
-    const is_eq = (n) => n.eq(new TexNode("element", "="));
-    if (is_def(sup) && is_eq(base)) {
-      return new TypstNode("symbol", "eq.def");
+    if (["\\overset{\\text{def}}{=}", "\\overset{d e f}{=}"].includes(node.toString())) {
+      return new TypstToken(1 /* SYMBOL */, "eq.def").toNode();
     }
   }
-  const limits_call = new TypstNode(
-    "funcCall",
-    "limits",
+  const limits_call = new TypstFuncCall(
+    new TypstToken(1 /* SYMBOL */, "limits"),
     [convert_tex_node_to_typst(base, options)]
   );
-  return new TypstNode("supsub", "", [], {
+  return new TypstSupsub({
     base: limits_call,
-    sup: convert_tex_node_to_typst(sup, options)
+    sup: convert_tex_node_to_typst(sup, options),
+    sub: null
   });
 }
 function convert_underset(node, options) {
   const [sub, base] = node.args;
-  const limits_call = new TypstNode(
-    "funcCall",
-    "limits",
+  const limits_call = new TypstFuncCall(
+    new TypstToken(1 /* SYMBOL */, "limits"),
     [convert_tex_node_to_typst(base, options)]
   );
-  return new TypstNode("supsub", "", [], {
+  return new TypstSupsub({
     base: limits_call,
-    sub: convert_tex_node_to_typst(sub, options)
+    sub: convert_tex_node_to_typst(sub, options),
+    sup: null
   });
 }
 function convert_tex_array_align_literal(alignLiteral) {
@@ -2694,430 +2808,450 @@ function convert_tex_array_align_literal(alignLiteral) {
     } else {
       augment_str = `#(vline: (${vlinePositions.join(", ")}))`;
     }
-    np["augment"] = new TypstNode("literal", augment_str);
+    np["augment"] = new TypstToken(3 /* LITERAL */, augment_str).toNode();
   }
-  const alignments = chars.map((c) => alignMap[c]).filter((x) => x !== void 0).map((s) => new TypstNode("literal", s));
+  const alignments = chars.map((c) => alignMap[c]).filter((x) => x !== void 0).map((s) => new TypstToken(3 /* LITERAL */, s).toNode());
   if (alignments.length > 0) {
     const all_same = alignments.every((item) => item.eq(alignments[0]));
-    np["align"] = all_same ? alignments[0] : new TypstNode("literal", "#center");
+    np["align"] = all_same ? alignments[0] : new TypstToken(3 /* LITERAL */, "#center").toNode();
   }
   return np;
 }
-function convert_tex_node_to_typst(node, options = {}) {
-  switch (node.type) {
-    case "empty":
-      return TYPST_NONE;
-    case "whitespace":
-      return new TypstNode("whitespace", node.content);
-    case "ordgroup":
-      return new TypstNode(
-        "group",
-        "",
-        node.args.map((n) => convert_tex_node_to_typst(n, options))
-      );
-    case "element":
-      return new TypstNode("atom", tex_token_to_typst(node.content));
-    case "symbol":
-      return new TypstNode("symbol", tex_token_to_typst(node.content));
+function convert_tex_node_to_typst(abstractNode, options = {}) {
+  switch (abstractNode.type) {
+    case "terminal": {
+      const node2 = abstractNode;
+      return tex_token_to_typst(node2.head, options).toNode();
+    }
     case "text": {
-      if (/[^\x00-\x7F]+/.test(node.content) && options.nonAsciiWrapper !== "") {
-        return new TypstNode(
-          "funcCall",
-          options.nonAsciiWrapper,
-          [new TypstNode("text", node.content)]
+      const node2 = abstractNode;
+      if (/[^\x00-\x7F]+/.test(node2.head.value) && options.nonAsciiWrapper !== "") {
+        return new TypstFuncCall(
+          new TypstToken(1 /* SYMBOL */, options.nonAsciiWrapper),
+          [new TypstToken(4 /* TEXT */, node2.head.value).toNode()]
         );
       }
-      return new TypstNode("text", node.content);
+      return new TypstToken(4 /* TEXT */, node2.head.value).toNode();
     }
-    case "literal":
-      return new TypstNode("literal", node.content);
-    case "comment":
-      return new TypstNode("comment", node.content);
+    case "ordgroup":
+      const node = abstractNode;
+      return new TypstGroup(
+        node.args.map((n) => convert_tex_node_to_typst(n, options))
+      );
     case "supsub": {
-      let { base, sup, sub } = node.data;
-      if (base && base.type === "unaryFunc" && base.content === "\\overbrace" && sup) {
-        return new TypstNode(
-          "funcCall",
-          "overbrace",
+      const node2 = abstractNode;
+      let { base, sup, sub } = node2;
+      if (base && base.type === "funcCall" && base.head.value === "\\overbrace" && sup) {
+        return new TypstFuncCall(
+          new TypstToken(1 /* SYMBOL */, "overbrace"),
           [convert_tex_node_to_typst(base.args[0], options), convert_tex_node_to_typst(sup, options)]
         );
-      } else if (base && base.type === "unaryFunc" && base.content === "\\underbrace" && sub) {
-        return new TypstNode(
-          "funcCall",
-          "underbrace",
+      } else if (base && base.type === "funcCall" && base.head.value === "\\underbrace" && sub) {
+        return new TypstFuncCall(
+          new TypstToken(1 /* SYMBOL */, "underbrace"),
           [convert_tex_node_to_typst(base.args[0], options), convert_tex_node_to_typst(sub, options)]
         );
       }
       const data = {
-        base: convert_tex_node_to_typst(base, options)
+        base: convert_tex_node_to_typst(base, options),
+        sup: sup ? convert_tex_node_to_typst(sup, options) : null,
+        sub: sub ? convert_tex_node_to_typst(sub, options) : null
       };
-      if (data.base.type === "none") {
-        data.base = new TypstNode("none", "");
-      }
-      if (sup) {
-        data.sup = convert_tex_node_to_typst(sup, options);
-      }
-      if (sub) {
-        data.sub = convert_tex_node_to_typst(sub, options);
-      }
-      return new TypstNode("supsub", "", [], data);
+      return new TypstSupsub(data);
     }
     case "leftright": {
-      const [left, _body, right] = node.args;
-      const [typ_left, typ_body, typ_right] = node.args.map((n) => convert_tex_node_to_typst(n, options));
+      const node2 = abstractNode;
+      const { left, right } = node2;
+      const [_body] = node2.args;
+      const typ_body = convert_tex_node_to_typst(_body, options);
       if (options.optimize) {
-        if (left.content === "\\|" && right.content === "\\|") {
-          return new TypstNode("funcCall", "norm", [typ_body]);
-        }
-        if ([
-          "[]",
-          "()",
-          "\\{\\}",
-          "\\lfloor\\rfloor",
-          "\\lceil\\rceil",
-          "\\lfloor\\rceil"
-        ].includes(left.content + right.content)) {
-          return new TypstNode("group", "", [typ_left, typ_body, typ_right]);
-        }
-      }
-      const group = new TypstNode(
-        "group",
-        "",
-        [typ_left, typ_body, typ_right]
-      );
+        if (left !== null && right !== null) {
+          const typ_left2 = tex_token_to_typst(left, options);
+          const typ_right2 = tex_token_to_typst(right, options);
+          if (left.value === "\\|" && right.value === "\\|") {
+            return new TypstFuncCall(new TypstToken(1 /* SYMBOL */, "norm"), [typ_body]);
+          }
+          if ([
+            "[]",
+            "()",
+            "\\{\\}",
+            "\\lfloor\\rfloor",
+            "\\lceil\\rceil",
+            "\\lfloor\\rceil"
+          ].includes(left.value + right.value)) {
+            return new TypstGroup([typ_left2.toNode(), typ_body, typ_right2.toNode()]);
+          }
+        }
+      }
       const escape_curly_or_paren = function(s) {
-        if (["(", ")", "{", "["].includes(s)) {
-          return "\\" + s;
+        if (["(", ")", "{", "["].includes(s.value)) {
+          return new TypstToken(2 /* ELEMENT */, "\\" + s.value);
         } else {
           return s;
         }
       };
-      if (right.content === ".") {
-        typ_left.content = escape_curly_or_paren(typ_left.content);
-        group.args = [typ_left, typ_body];
-      } else if (left.content === ".") {
-        typ_right.content = escape_curly_or_paren(typ_right.content);
-        group.args = [typ_body, typ_right];
-      }
-      return new TypstNode("funcCall", "lr", [group]);
-    }
-    case "binaryFunc": {
-      if (node.content === "\\overset") {
-        return convert_overset(node, options);
-      }
-      if (node.content === "\\underset") {
-        return convert_underset(node, options);
-      }
-      if (node.content === "\\frac") {
-        if (options.fracToSlash) {
-          return new TypstNode(
-            "fraction",
-            "",
-            node.args.map((n) => convert_tex_node_to_typst(n, options))
-          );
-        }
-      }
-      return new TypstNode(
-        "funcCall",
-        tex_token_to_typst(node.content),
-        node.args.map((n) => convert_tex_node_to_typst(n, options))
+      let typ_left = left ? tex_token_to_typst(left, options) : null;
+      let typ_right = right ? tex_token_to_typst(right, options) : null;
+      if (typ_left === null && typ_right !== null) {
+        typ_right = escape_curly_or_paren(typ_right);
+      }
+      if (typ_right === null && typ_left !== null) {
+        typ_left = escape_curly_or_paren(typ_left);
+      }
+      return new TypstLeftright(
+        new TypstToken(1 /* SYMBOL */, "lr"),
+        [typ_body],
+        { left: typ_left, right: typ_right }
       );
     }
-    case "unaryFunc": {
-      const arg0 = convert_tex_node_to_typst(node.args[0], options);
-      if (node.content === "\\sqrt" && node.data) {
-        const data = convert_tex_node_to_typst(node.data, options);
-        return new TypstNode(
-          "funcCall",
-          "root",
+    case "funcCall": {
+      const node2 = abstractNode;
+      const arg0 = convert_tex_node_to_typst(node2.args[0], options);
+      if (node2.head.value === "\\sqrt" && node2.data) {
+        const data = convert_tex_node_to_typst(node2.data, options);
+        return new TypstFuncCall(
+          new TypstToken(1 /* SYMBOL */, "root"),
           [data, arg0]
         );
       }
-      if (node.content === "\\mathbf") {
-        const inner = new TypstNode(
-          "funcCall",
-          "bold",
+      if (node2.head.value === "\\mathbf") {
+        const inner = new TypstFuncCall(
+          new TypstToken(1 /* SYMBOL */, "bold"),
           [arg0]
         );
-        return new TypstNode(
-          "funcCall",
-          "upright",
+        return new TypstFuncCall(
+          new TypstToken(1 /* SYMBOL */, "upright"),
           [inner]
         );
       }
-      if (node.content === "\\overrightarrow") {
-        return new TypstNode(
-          "funcCall",
-          "arrow",
+      if (node2.head.value === "\\overrightarrow") {
+        return new TypstFuncCall(
+          new TypstToken(1 /* SYMBOL */, "arrow"),
           [arg0]
         );
       }
-      if (node.content === "\\overleftarrow") {
-        return new TypstNode(
-          "funcCall",
-          "accent",
-          [arg0, new TypstNode("symbol", "arrow.l")]
+      if (node2.head.value === "\\overleftarrow") {
+        return new TypstFuncCall(
+          new TypstToken(1 /* SYMBOL */, "accent"),
+          [arg0, new TypstToken(1 /* SYMBOL */, "arrow.l").toNode()]
         );
       }
-      if (node.content === "\\operatorname") {
+      if (node2.head.value === "\\operatorname") {
         if (options.optimize) {
-          if (TYPST_INTRINSIC_OP.includes(arg0.content)) {
-            return new TypstNode("symbol", arg0.content);
+          if (TYPST_INTRINSIC_OP.includes(arg0.head.value)) {
+            return new TypstToken(1 /* SYMBOL */, arg0.head.value).toNode();
           }
         }
-        return new TypstNode("funcCall", "op", [new TypstNode("text", arg0.content)]);
+        return new TypstFuncCall(new TypstToken(1 /* SYMBOL */, "op"), [new TypstToken(4 /* TEXT */, arg0.head.value).toNode()]);
       }
-      if (node.content === "\\substack") {
+      if (node2.head.value === "\\substack") {
         return arg0;
       }
+      if (node2.head.value === "\\overset") {
+        return convert_overset(node2, options);
+      }
+      if (node2.head.value === "\\underset") {
+        return convert_underset(node2, options);
+      }
+      if (node2.head.value === "\\frac") {
+        if (options.fracToSlash) {
+          return new TypstFraction(node2.args.map((n) => convert_tex_node_to_typst(n, options)));
+        }
+      }
       if (options.optimize) {
-        if (node.content === "\\mathbb" && arg0.type === "atom" && /^[A-Z]$/.test(arg0.content)) {
-          return new TypstNode("symbol", arg0.content + arg0.content);
+        if (node2.head.value === "\\mathbb" && /^\\mathbb{[A-Z]}$/.test(node2.toString())) {
+          return new TypstToken(1 /* SYMBOL */, arg0.head.value.repeat(2)).toNode();
         }
-        if (node.content === "\\mathrm" && arg0.eq(new TypstNode("atom", "d"))) {
-          return new TypstNode("symbol", "dif");
+        if (node2.head.value === "\\mathrm" && node2.toString() === "\\mathrm{d}") {
+          return new TypstToken(1 /* SYMBOL */, "dif").toNode();
         }
       }
-      return new TypstNode(
-        "funcCall",
-        tex_token_to_typst(node.content),
-        node.args.map((n) => convert_tex_node_to_typst(n, options))
+      return new TypstFuncCall(
+        tex_token_to_typst(node2.head, options),
+        node2.args.map((n) => convert_tex_node_to_typst(n, options))
       );
     }
     case "beginend": {
-      const matrix = node.data;
-      const data = matrix.map((row) => row.map((n) => convert_tex_node_to_typst(n, options)));
-      if (node.content.startsWith("align")) {
-        return new TypstNode("align", "", [], data);
+      const node2 = abstractNode;
+      const data = node2.matrix.map((row) => row.map((n) => convert_tex_node_to_typst(n, options)));
+      if (node2.head.value.startsWith("align")) {
+        return new TypstAlign(data);
       }
-      if (node.content === "cases") {
-        return new TypstNode("cases", "", [], data);
+      if (node2.head.value === "cases") {
+        return new TypstCases(data);
       }
-      if (node.content === "subarray") {
-        const align_node = node.args[0];
-        switch (align_node.content) {
+      if (node2.head.value === "subarray") {
+        const align_node = node2.args[0];
+        switch (align_node.head.value) {
           case "r":
-            data.forEach((row) => row[0].args.push(new TypstNode("symbol", "&")));
+            data.forEach((row) => row[0].args.push(new TypstToken(7 /* CONTROL */, "&").toNode()));
             break;
           case "l":
-            data.forEach((row) => row[0].args.unshift(new TypstNode("symbol", "&")));
+            data.forEach((row) => row[0].args.unshift(new TypstToken(7 /* CONTROL */, "&").toNode()));
             break;
           default:
             break;
         }
-        return new TypstNode("align", "", [], data);
+        return new TypstAlign(data);
       }
-      if (node.content === "array") {
+      if (node2.head.value === "array") {
         const np = { "delim": TYPST_NONE };
-        assert(node.args.length > 0 && node.args[0].type === "literal");
-        const np_new = convert_tex_array_align_literal(node.args[0].content);
+        assert(node2.args.length > 0 && node2.args[0].head.type === 3 /* LITERAL */);
+        const np_new = convert_tex_array_align_literal(node2.args[0].head.value);
         Object.assign(np, np_new);
-        const res = new TypstNode("matrix", "", [], data);
+        const res = new TypstMatrix(data);
         res.setOptions(np);
         return res;
       }
-      if (node.content.endsWith("matrix")) {
-        const res = new TypstNode("matrix", "", [], data);
+      if (node2.head.value.endsWith("matrix")) {
+        const res = new TypstMatrix(data);
         let delim;
-        switch (node.content) {
+        switch (node2.head.value) {
           case "matrix":
-            delim = TYPST_NONE;
+            delim = TypstToken.NONE;
             break;
           case "pmatrix":
             return res;
           // typst mat use delim:"(" by default
           case "bmatrix":
-            delim = new TypstNode("text", "[");
+            delim = new TypstToken(4 /* TEXT */, "[");
             break;
           case "Bmatrix":
-            delim = new TypstNode("text", "{");
+            delim = new TypstToken(4 /* TEXT */, "{");
             break;
           case "vmatrix":
-            delim = new TypstNode("text", "|");
+            delim = new TypstToken(4 /* TEXT */, "|");
             break;
           case "Vmatrix": {
-            delim = new TypstNode("symbol", "bar.v.double");
+            delim = new TypstToken(1 /* SYMBOL */, "bar.v.double");
             break;
           }
           default:
-            throw new TypstWriterError(`Unimplemented beginend: ${node.content}`, node);
+            throw new ConverterError(`Unimplemented beginend: ${node2.head}`, node2);
         }
-        res.setOptions({ "delim": delim });
+        res.setOptions({ "delim": delim.toNode() });
         return res;
       }
-      throw new TypstWriterError(`Unimplemented beginend: ${node.content}`, node);
-    }
-    case "unknownMacro":
-      return new TypstNode("unknown", tex_token_to_typst(node.content));
-    case "control":
-      if (node.content === "\\\\") {
-        return new TypstNode("symbol", "\\");
-      } else if (node.content === "\\!") {
-        return new TypstNode("funcCall", "#h", [
-          new TypstNode("literal", "-math.thin.amount")
-        ]);
-      } else if (symbolMap.has(node.content.substring(1))) {
-        const typst_symbol = symbolMap.get(node.content.substring(1));
-        return new TypstNode("symbol", typst_symbol);
-      } else {
-        throw new TypstWriterError(`Unknown control sequence: ${node.content}`, node);
-      }
+      throw new ConverterError(`Unimplemented beginend: ${node2.head}`, node2);
+    }
     default:
-      throw new TypstWriterError(`Unimplemented node type: ${node.type}`, node);
-  }
-}
-function apply_escape_if_needed2(c) {
-  if (["{", "}", "%"].includes(c)) {
-    return "\\" + c;
+      throw new ConverterError(`Unimplemented node type: ${abstractNode.type}`, abstractNode);
   }
-  return c;
 }
 function typst_token_to_tex(token) {
-  if (/^[a-zA-Z0-9]$/.test(token)) {
-    return token;
-  } else if (reverseSymbolMap.has(token)) {
-    return "\\" + reverseSymbolMap.get(token);
+  switch (token.type) {
+    case 0 /* NONE */:
+      return TexToken.EMPTY;
+    case 1 /* SYMBOL */: {
+      const _typst_symbol_to_tex = function(symbol) {
+        if (reverseSymbolMap.has(symbol)) {
+          return "\\" + reverseSymbolMap.get(symbol);
+        } else {
+          return "\\" + symbol;
+        }
+      };
+      return new TexToken(2 /* COMMAND */, _typst_symbol_to_tex(token.value));
+    }
+    case 2 /* ELEMENT */: {
+      let value;
+      if (["{", "}", "%"].includes(token.value)) {
+        value = "\\" + token.value;
+      } else {
+        value = token.value;
+      }
+      return new TexToken(1 /* ELEMENT */, value);
+    }
+    case 3 /* LITERAL */:
+      return new TexToken(3 /* LITERAL */, token.value);
+    case 4 /* TEXT */:
+      return new TexToken(3 /* LITERAL */, token.value);
+    case 5 /* COMMENT */:
+      return new TexToken(4 /* COMMENT */, token.value);
+    case 6 /* SPACE */:
+      return new TexToken(5 /* SPACE */, token.value);
+    case 7 /* CONTROL */: {
+      let value;
+      switch (token.value) {
+        case "\\":
+          value = "\\\\";
+          break;
+        case "&":
+          value = "&";
+          break;
+        default:
+          throw new Error(`[typst_token_to_tex]Unimplemented control sequence: ${token.value}`);
+      }
+      return new TexToken(7 /* CONTROL */, value);
+    }
+    case 8 /* NEWLINE */:
+      return new TexToken(6 /* NEWLINE */, token.value);
+    default:
+      throw new Error(`Unimplemented token type: ${token.type}`);
   }
-  return "\\" + token;
 }
-var TEX_NODE_COMMA = new TexNode("element", ",");
-function convert_typst_node_to_tex(node) {
-  if (node.eq(new TypstNode("symbol", "eq.def"))) {
-    return new TexNode("binaryFunc", "\\overset", [
-      new TexNode("text", "def"),
-      new TexNode("element", "=")
-    ]);
-  }
-  switch (node.type) {
-    case "none":
-      return new TexNode("empty", "");
-    case "whitespace":
-      return new TexNode("whitespace", node.content);
-    case "atom":
-      return new TexNode("element", node.content);
-    case "symbol": {
-      if (node.content === "comma") {
-        return new TexNode("element", ",");
-      }
-      if (node.content === "dif") {
-        return new TexNode("unaryFunc", "\\mathrm", [new TexNode("element", "d")]);
-      }
-      if (node.content === "hyph" || node.content === "hyph.minus") {
-        return new TexNode("text", "-");
-      }
-      if (/^([A-Z])\1$/.test(node.content)) {
-        return new TexNode("unaryFunc", "\\mathbb", [
-          new TexNode("element", node.content[0])
-        ]);
-      }
-      return new TexNode("symbol", typst_token_to_tex(node.content));
-    }
-    case "literal":
-      return new TexNode("literal", node.content);
-    case "text":
-      return new TexNode("text", node.content);
-    case "comment":
-      return new TexNode("comment", node.content);
+var TEX_NODE_COMMA = new TexToken(1 /* ELEMENT */, ",").toNode();
+function convert_typst_node_to_tex(abstractNode) {
+  switch (abstractNode.type) {
+    case "terminal": {
+      const node = abstractNode;
+      if (node.head.type === 1 /* SYMBOL */) {
+        if (node.head.value === "eq.def") {
+          return new TexFuncCall(new TexToken(2 /* COMMAND */, "\\overset"), [
+            new TexText(new TexToken(3 /* LITERAL */, "def")),
+            new TexToken(1 /* ELEMENT */, "=").toNode()
+          ]);
+        }
+        if (node.head.value === "comma") {
+          return new TexToken(1 /* ELEMENT */, ",").toNode();
+        }
+        if (node.head.value === "dif") {
+          return new TexFuncCall(new TexToken(2 /* COMMAND */, "\\mathrm"), [new TexToken(1 /* ELEMENT */, "d").toNode()]);
+        }
+        if (node.head.value === "hyph" || node.head.value === "hyph.minus") {
+          return new TexText(new TexToken(3 /* LITERAL */, "-"));
+        }
+        if (/^([A-Z])\1$/.test(node.head.value)) {
+          return new TexFuncCall(new TexToken(2 /* COMMAND */, "\\mathbb"), [
+            new TexToken(1 /* ELEMENT */, node.head.value[0]).toNode()
+          ]);
+        }
+      }
+      if (node.head.type === 4 /* TEXT */) {
+        return new TexText(new TexToken(3 /* LITERAL */, node.head.value));
+      }
+      return typst_token_to_tex(node.head).toNode();
+    }
     case "group": {
+      const node = abstractNode;
+      const args = node.args.map(convert_typst_node_to_tex);
+      const alignment_char = new TexToken(7 /* CONTROL */, "&").toNode();
+      const newline_char = new TexToken(7 /* CONTROL */, "\\\\").toNode();
+      if (array_includes(args, alignment_char)) {
+        const rows = array_split(args, newline_char);
+        const data = [];
+        for (const row of rows) {
+          const cells = array_split(row, alignment_char);
+          data.push(cells.map((cell) => new TexGroup(cell)));
+        }
+        return new TexBeginEnd(new TexToken(3 /* LITERAL */, "aligned"), [], data);
+      }
+      return new TexGroup(args);
+    }
+    case "leftright": {
+      const node = abstractNode;
       const args = node.args.map(convert_typst_node_to_tex);
-      if (node.content === "parenthesis") {
-        const is_over_high = node.isOverHigh();
-        const left_delim = is_over_high ? "\\left(" : "(";
-        const right_delim = is_over_high ? "\\right)" : ")";
-        args.unshift(new TexNode("element", left_delim));
-        args.push(new TexNode("element", right_delim));
+      let left = node.left ? typst_token_to_tex(node.left) : new TexToken(1 /* ELEMENT */, ".");
+      let right = node.right ? typst_token_to_tex(node.right) : new TexToken(1 /* ELEMENT */, ".");
+      if (node.isOverHigh()) {
+        left.value = "\\left" + left.value;
+        right.value = "\\right" + right.value;
       }
-      return new TexNode("ordgroup", node.content, args);
+      args.unshift(left.toNode());
+      args.push(right.toNode());
+      return new TexGroup(args);
     }
     case "funcCall": {
-      if (node.content === "lr") {
-        const data = node.data;
-        if (data.leftDelim !== null) {
-          let left_delim = apply_escape_if_needed2(data.leftDelim);
-          assert(data.rightDelim !== null, "leftDelim has value but rightDelim not");
-          let right_delim = apply_escape_if_needed2(data.rightDelim);
-          return new TexNode("ordgroup", "", [
-            new TexNode("element", "\\left" + left_delim),
-            ...node.args.map(convert_typst_node_to_tex),
-            new TexNode("element", "\\right" + right_delim)
-          ]);
-        } else {
-          return new TexNode("ordgroup", "", node.args.map(convert_typst_node_to_tex));
-        }
-      }
-      if (node.content === "norm") {
-        const arg0 = node.args[0];
-        const tex_node_type = node.isOverHigh() ? "leftright" : "ordgroup";
-        return new TexNode(tex_node_type, "", [
-          new TexNode("symbol", "\\|"),
-          convert_typst_node_to_tex(arg0),
-          new TexNode("symbol", "\\|")
-        ]);
-      }
-      if (node.content === "floor" || node.content === "ceil") {
-        const left = "\\l" + node.content;
-        const right = "\\r" + node.content;
-        const arg0 = node.args[0];
-        const tex_node_type = node.isOverHigh() ? "leftright" : "ordgroup";
-        return new TexNode(tex_node_type, "", [
-          new TexNode("symbol", left),
-          convert_typst_node_to_tex(arg0),
-          new TexNode("symbol", right)
-        ]);
-      }
-      if (node.content === "root") {
-        const [degree, radicand] = node.args;
-        const data = convert_typst_node_to_tex(degree);
-        return new TexNode("unaryFunc", "\\sqrt", [convert_typst_node_to_tex(radicand)], data);
-      }
-      if (node.content === "overbrace" || node.content === "underbrace") {
-        const [body, label] = node.args;
-        const base = new TexNode("unaryFunc", "\\" + node.content, [convert_typst_node_to_tex(body)]);
-        const script = convert_typst_node_to_tex(label);
-        const data = node.content === "overbrace" ? { base, sup: script } : { base, sub: script };
-        return new TexNode("supsub", "", [], data);
-      }
-      if (node.content === "vec") {
-        const tex_data = node.args.map(convert_typst_node_to_tex).map((n) => [n]);
-        return new TexNode("beginend", "pmatrix", [], tex_data);
-      }
-      const func_name_tex = typst_token_to_tex(node.content);
-      if (func_name_tex.length > 0 && TEX_UNARY_COMMANDS.includes(func_name_tex.substring(1))) {
-        return new TexNode("unaryFunc", func_name_tex, node.args.map(convert_typst_node_to_tex));
-      } else if (func_name_tex.length > 0 && TEX_BINARY_COMMANDS.includes(func_name_tex.substring(1))) {
-        return new TexNode("binaryFunc", func_name_tex, node.args.map(convert_typst_node_to_tex));
-      } else {
-        return new TexNode("ordgroup", "", [
-          new TexNode("symbol", typst_token_to_tex(node.content)),
-          new TexNode("element", "("),
-          ...array_intersperse(node.args.map(convert_typst_node_to_tex), TEX_NODE_COMMA),
-          new TexNode("element", ")")
-        ]);
+      const node = abstractNode;
+      switch (node.head.value) {
+        // special hook for norm
+        // `\| a  \|` <- `norm(a)`
+        // `\left\| a + \frac{1}{3} \right\|` <- `norm(a + 1/3)`
+        case "norm": {
+          const arg0 = node.args[0];
+          const args = [convert_typst_node_to_tex(arg0)];
+          if (node.isOverHigh()) {
+            return new TexLeftRight(args, {
+              left: new TexToken(2 /* COMMAND */, "\\|"),
+              right: new TexToken(2 /* COMMAND */, "\\|")
+            });
+          } else {
+            return new TexGroup(args);
+          }
+        }
+        // special hook for floor, ceil
+        // `\lfloor a \rfloor` <- `floor(a)`
+        // `\lceil a \rceil` <- `ceil(a)`
+        // `\left\lfloor a \right\rfloor` <- `floor(a)`
+        // `\left\lceil a \right\rceil` <- `ceil(a)`
+        case "floor":
+        case "ceil": {
+          const left = "\\l" + node.head.value;
+          const right = "\\r" + node.head.value;
+          const arg0 = node.args[0];
+          const typ_arg0 = convert_typst_node_to_tex(arg0);
+          const left_node = new TexToken(2 /* COMMAND */, left);
+          const right_node = new TexToken(2 /* COMMAND */, right);
+          if (node.isOverHigh()) {
+            return new TexLeftRight([typ_arg0], {
+              left: left_node,
+              right: right_node
+            });
+          } else {
+            return new TexGroup([left_node.toNode(), typ_arg0, right_node.toNode()]);
+          }
+        }
+        // special hook for root
+        case "root": {
+          const [degree, radicand] = node.args;
+          const data = convert_typst_node_to_tex(degree);
+          return new TexFuncCall(new TexToken(2 /* COMMAND */, "\\sqrt"), [convert_typst_node_to_tex(radicand)], data);
+        }
+        // special hook for overbrace and underbrace
+        case "overbrace":
+        case "underbrace": {
+          const [body, label] = node.args;
+          const base = new TexFuncCall(typst_token_to_tex(node.head), [convert_typst_node_to_tex(body)]);
+          const script = convert_typst_node_to_tex(label);
+          const data = node.head.value === "overbrace" ? { base, sup: script, sub: null } : { base, sub: script, sup: null };
+          return new TexSupSub(data);
+        }
+        // special hook for vec
+        // "vec(a, b, c)" -> "\begin{pmatrix}a\\ b\\ c\end{pmatrix}"
+        case "vec": {
+          const tex_data = node.args.map(convert_typst_node_to_tex).map((n) => [n]);
+          return new TexBeginEnd(new TexToken(3 /* LITERAL */, "pmatrix"), [], tex_data);
+        }
+        // special hook for op
+        case "op": {
+          const arg0 = node.args[0];
+          assert(arg0.head.type === 4 /* TEXT */);
+          return new TexFuncCall(typst_token_to_tex(node.head), [new TexToken(3 /* LITERAL */, arg0.head.value).toNode()]);
+        }
+        // general case
+        default: {
+          const func_name_tex = typst_token_to_tex(node.head);
+          const is_known_func = TEX_UNARY_COMMANDS.includes(func_name_tex.value.substring(1)) || TEX_BINARY_COMMANDS.includes(func_name_tex.value.substring(1));
+          if (func_name_tex.value.length > 0 && is_known_func) {
+            return new TexFuncCall(func_name_tex, node.args.map(convert_typst_node_to_tex));
+          } else {
+            return new TexGroup([
+              typst_token_to_tex(node.head).toNode(),
+              new TexToken(1 /* ELEMENT */, "(").toNode(),
+              ...array_intersperse(node.args.map(convert_typst_node_to_tex), TEX_NODE_COMMA),
+              new TexToken(1 /* ELEMENT */, ")").toNode()
+            ]);
+          }
+        }
       }
     }
     case "supsub": {
-      const { base, sup, sub } = node.data;
-      let sup_tex;
-      let sub_tex;
-      if (sup) {
-        sup_tex = convert_typst_node_to_tex(sup);
-      }
-      if (sub) {
-        sub_tex = convert_typst_node_to_tex(sub);
-      }
-      if (base.eq(new TypstNode("funcCall", "limits"))) {
+      const node = abstractNode;
+      const { base, sup, sub } = node;
+      const sup_tex = sup ? convert_typst_node_to_tex(sup) : null;
+      const sub_tex = sub ? convert_typst_node_to_tex(sub) : null;
+      if (base.head.eq(new TypstToken(1 /* SYMBOL */, "limits"))) {
         const body_in_limits = convert_typst_node_to_tex(base.args[0]);
-        if (sup_tex !== void 0 && sub_tex === void 0) {
-          return new TexNode("binaryFunc", "\\overset", [sup_tex, body_in_limits]);
-        } else if (sup_tex === void 0 && sub_tex !== void 0) {
-          return new TexNode("binaryFunc", "\\underset", [sub_tex, body_in_limits]);
+        if (sup_tex !== null && sub_tex === null) {
+          return new TexFuncCall(new TexToken(2 /* COMMAND */, "\\overset"), [sup_tex, body_in_limits]);
+        } else if (sup_tex === null && sub_tex !== null) {
+          return new TexFuncCall(new TexToken(2 /* COMMAND */, "\\underset"), [sub_tex, body_in_limits]);
         } else {
-          const underset_call = new TexNode("binaryFunc", "\\underset", [sub_tex, body_in_limits]);
-          return new TexNode("binaryFunc", "\\overset", [sup_tex, underset_call]);
+          const underset_call = new TexFuncCall(new TexToken(2 /* COMMAND */, "\\underset"), [sub_tex, body_in_limits]);
+          return new TexFuncCall(new TexToken(2 /* COMMAND */, "\\overset"), [sup_tex, underset_call]);
         }
       }
       const base_tex = convert_typst_node_to_tex(base);
-      const res = new TexNode("supsub", "", [], {
+      const res = new TexSupSub({
         base: base_tex,
         sup: sup_tex,
         sub: sub_tex
@@ -3125,13 +3259,13 @@ function convert_typst_node_to_tex(node) {
       return res;
     }
     case "matrix": {
-      const typst_data = node.data;
-      const tex_data = typst_data.map((row) => row.map(convert_typst_node_to_tex));
+      const node = abstractNode;
+      const tex_data = node.matrix.map((row) => row.map(convert_typst_node_to_tex));
       let env_type = "pmatrix";
       if (node.options) {
         if ("delim" in node.options) {
           const delim = node.options.delim;
-          switch (delim.content) {
+          switch (delim.head.value) {
             case "#none":
               env_type = "matrix";
               break;
@@ -3158,35 +3292,26 @@ function convert_typst_node_to_tex(node) {
               env_type = "Vmatrix";
               break;
             default:
-              throw new Error(`Unexpected delimiter ${delim.content}`);
+              throw new Error(`Unexpected delimiter ${delim.head}`);
           }
         }
       }
-      return new TexNode("beginend", env_type, [], tex_data);
+      return new TexBeginEnd(new TexToken(3 /* LITERAL */, env_type), [], tex_data);
     }
     case "cases": {
-      const typst_data = node.data;
-      const tex_data = typst_data.map((row) => row.map(convert_typst_node_to_tex));
-      return new TexNode("beginend", "cases", [], tex_data);
-    }
-    case "control": {
-      switch (node.content) {
-        case "\\":
-          return new TexNode("control", "\\\\");
-        case "&":
-          return new TexNode("control", "&");
-        default:
-          throw new Error("[convert_typst_node_to_tex] Unimplemented control: " + node.content);
-      }
+      const node = abstractNode;
+      const tex_data = node.matrix.map((row) => row.map(convert_typst_node_to_tex));
+      return new TexBeginEnd(new TexToken(3 /* LITERAL */, "cases"), [], tex_data);
     }
     case "fraction": {
+      const node = abstractNode;
       const [numerator, denominator] = node.args;
       const num_tex = convert_typst_node_to_tex(numerator);
       const den_tex = convert_typst_node_to_tex(denominator);
-      return new TexNode("binaryFunc", "\\frac", [num_tex, den_tex]);
+      return new TexFuncCall(new TexToken(2 /* COMMAND */, "\\frac"), [num_tex, den_tex]);
     }
     default:
-      throw new Error("[convert_typst_node_to_tex] Unimplemented type: " + node.type);
+      throw new Error("[convert_typst_node_to_tex] Unimplemented type: " + abstractNode.type);
   }
 }
 
@@ -3279,7 +3404,7 @@ function _find_closing_match(tokens, start, leftBrackets, rightBrackets) {
   let pos = start + 1;
   while (count > 0) {
     if (pos >= tokens.length) {
-      throw new Error("Unmatched brackets");
+      throw new Error("Unmatched brackets or parentheses");
     }
     if (tokens[pos].isOneOf(rightBrackets)) {
       count -= 1;
@@ -3307,14 +3432,14 @@ function find_closing_delim(tokens, start) {
   );
 }
 function find_closing_parenthesis(nodes, start) {
-  const left_parenthesis = new TypstNode("atom", "(");
-  const right_parenthesis = new TypstNode("atom", ")");
+  const left_parenthesis = new TypstToken(2 /* ELEMENT */, "(").toNode();
+  const right_parenthesis = new TypstToken(2 /* ELEMENT */, ")").toNode();
   assert(nodes[start].eq(left_parenthesis));
   let count = 1;
   let pos = start + 1;
   while (count > 0) {
     if (pos >= nodes.length) {
-      throw new Error("Unmatched brackets");
+      throw new Error("Unmatched '('");
     }
     if (nodes[pos].eq(left_parenthesis)) {
       count += 1;
@@ -3328,14 +3453,14 @@ function find_closing_parenthesis(nodes, start) {
 function primes(num) {
   const res = [];
   for (let i = 0; i < num; i++) {
-    res.push(new TypstNode("atom", "'"));
+    res.push(new TypstToken(2 /* ELEMENT */, "'").toNode());
   }
   return res;
 }
-var DIV = new TypstNode("atom", "/");
+var DIV = new TypstToken(2 /* ELEMENT */, "/").toNode();
 function next_non_whitespace(nodes, start) {
   let pos = start;
-  while (pos < nodes.length && nodes[pos].type === "whitespace") {
+  while (pos < nodes.length && (nodes[pos].head.type === 6 /* SPACE */ || nodes[pos].head.type === 8 /* NEWLINE */)) {
     pos++;
   }
   return pos === nodes.length ? null : nodes[pos];
@@ -3345,7 +3470,7 @@ function trim_whitespace_around_operators(nodes) {
   const res = [];
   for (let i = 0; i < nodes.length; i++) {
     const current = nodes[i];
-    if (current.type === "whitespace") {
+    if (current.head.type === 6 /* SPACE */ || current.head.type === 8 /* NEWLINE */) {
       if (after_operator) {
         continue;
       }
@@ -3364,8 +3489,8 @@ function trim_whitespace_around_operators(nodes) {
 }
 function process_operators(nodes, parenthesis = false) {
   nodes = trim_whitespace_around_operators(nodes);
-  const opening_bracket = new TypstNode("atom", "(");
-  const closing_bracket = new TypstNode("atom", ")");
+  const opening_bracket = LEFT_PARENTHESES.toNode();
+  const closing_bracket = RIGHT_PARENTHESES.toNode();
   const stack = [];
   const args = [];
   let pos = 0;
@@ -3387,18 +3512,18 @@ function process_operators(nodes, parenthesis = false) {
         pos++;
       }
       if (stack.length > 0 && stack[stack.length - 1].eq(DIV)) {
-        const denominator = current_tree;
+        let denominator = current_tree;
         if (args.length === 0) {
           throw new TypstParserError("Unexpected '/' operator, no numerator before it");
         }
-        const numerator = args.pop();
-        if (denominator.type === "group" && denominator.content === "parenthesis") {
-          denominator.content = "";
+        let numerator = args.pop();
+        if (denominator.type === "leftright") {
+          denominator = new TypstGroup(denominator.args);
         }
-        if (numerator.type === "group" && numerator.content === "parenthesis") {
-          numerator.content = "";
+        if (numerator.type === "leftright") {
+          numerator = new TypstGroup(numerator.args);
         }
-        args.push(new TypstNode("fraction", "", [numerator, denominator]));
+        args.push(new TypstFraction([numerator, denominator]));
         stack.pop();
       } else {
         args.push(current_tree);
@@ -3406,12 +3531,12 @@ function process_operators(nodes, parenthesis = false) {
     }
   }
   if (parenthesis) {
-    return new TypstNode("group", "parenthesis", args);
+    return new TypstLeftright(null, args, { left: LEFT_PARENTHESES, right: RIGHT_PARENTHESES });
   } else {
     if (args.length === 1) {
       return args[0];
     } else {
-      return new TypstNode("group", "", args);
+      return new TypstGroup(args);
     }
   }
 }
@@ -3433,6 +3558,7 @@ var VERTICAL_BAR = new TypstToken(2 /* ELEMENT */, "|");
 var COMMA = new TypstToken(2 /* ELEMENT */, ",");
 var SEMICOLON = new TypstToken(2 /* ELEMENT */, ";");
 var SINGLE_SPACE = new TypstToken(6 /* SPACE */, " ");
+var CONTROL_AND = new TypstToken(7 /* CONTROL */, "&");
 var TypstParser = class {
   constructor(space_sensitive = true, newline_sensitive = true) {
     this.space_sensitive = space_sensitive;
@@ -3448,11 +3574,11 @@ var TypstParser = class {
     while (pos < end) {
       const [res, newPos] = this.parseNextExpr(tokens, pos);
       pos = newPos;
-      if (res.type === "whitespace") {
-        if (!this.space_sensitive && res.content.replace(/ /g, "").length === 0) {
+      if (res.head.type === 6 /* SPACE */ || res.head.type === 8 /* NEWLINE */) {
+        if (!this.space_sensitive && res.head.value.replace(/ /g, "").length === 0) {
           continue;
         }
-        if (!this.newline_sensitive && res.content === "\n") {
+        if (!this.newline_sensitive && res.head.value === "\n") {
           continue;
         }
       }
@@ -3476,7 +3602,7 @@ var TypstParser = class {
     let sup = null;
     const num_base_prime = eat_primes2(tokens, pos);
     if (num_base_prime > 0) {
-      base = new TypstNode("group", "", [base].concat(primes(num_base_prime)));
+      base = new TypstGroup([base].concat(primes(num_base_prime)));
       pos += num_base_prime;
     }
     if (pos < tokens.length && tokens[pos].eq(SUB_SYMBOL2)) {
@@ -3491,14 +3617,8 @@ var TypstParser = class {
       }
     }
     if (sub !== null || sup !== null) {
-      const res = { base };
-      if (sub) {
-        res.sub = sub;
-      }
-      if (sup) {
-        res.sup = sup;
-      }
-      return [new TypstNode("supsub", "", [], res), pos];
+      const res = { base, sup, sub };
+      return [new TypstSupsub(res), pos];
     } else {
       return [base, pos];
     }
@@ -3514,7 +3634,7 @@ var TypstParser = class {
     }
     const num_prime = eat_primes2(tokens, end);
     if (num_prime > 0) {
-      node = new TypstNode("group", "", [node].concat(primes(num_prime)));
+      node = new TypstGroup([node].concat(primes(num_prime)));
       end += num_prime;
     }
     return [node, end];
@@ -3532,24 +3652,22 @@ var TypstParser = class {
     if ([2 /* ELEMENT */, 1 /* SYMBOL */].includes(firstToken.type)) {
       if (start + 1 < tokens.length && tokens[start + 1].eq(LEFT_PARENTHESES)) {
         if (firstToken.value === "mat") {
-          const [matrix, named_params, newPos2] = this.parseGroupsOfArguments(tokens, start + 1);
-          const mat = new TypstNode("matrix", "", [], matrix);
+          const [matrix, named_params, newPos2] = this.parseMatrix(tokens, start + 1, SEMICOLON, COMMA);
+          const mat = new TypstMatrix(matrix);
           mat.setOptions(named_params);
           return [mat, newPos2];
         }
         if (firstToken.value === "cases") {
-          const [cases, named_params, newPos2] = this.parseGroupsOfArguments(tokens, start + 1, COMMA);
-          const casesNode = new TypstNode("cases", "", [], cases);
+          const [cases, named_params, newPos2] = this.parseMatrix(tokens, start + 1, COMMA, CONTROL_AND);
+          const casesNode = new TypstCases(cases);
           casesNode.setOptions(named_params);
           return [casesNode, newPos2];
         }
         if (firstToken.value === "lr") {
-          const [args2, newPos2, lrData] = this.parseLrArguments(tokens, start + 1);
-          const func_call2 = new TypstNode("funcCall", firstToken.value, args2, lrData);
-          return [func_call2, newPos2];
+          return this.parseLrArguments(tokens, start + 1);
         }
         const [args, newPos] = this.parseArguments(tokens, start + 1);
-        const func_call = new TypstNode("funcCall", firstToken.value, args);
+        const func_call = new TypstFuncCall(firstToken, args);
         return [func_call, newPos];
       }
     }
@@ -3558,31 +3676,30 @@ var TypstParser = class {
   // start: the position of the left parentheses
   parseArguments(tokens, start) {
     const end = find_closing_match2(tokens, start);
-    return [this.parseCommaSeparatedArguments(tokens, start + 1, end), end + 1];
+    return [this.parseArgumentsWithSeparator(tokens, start + 1, end, COMMA), end + 1];
   }
   // start: the position of the left parentheses
   parseLrArguments(tokens, start) {
+    const lr_token = tokens[start];
     if (tokens[start + 1].isOneOf([LEFT_PARENTHESES, LEFT_BRACKET, LEFT_CURLY_BRACKET2, VERTICAL_BAR])) {
       const end = find_closing_match2(tokens, start);
       const inner_start = start + 1;
       const inner_end = find_closing_delim(tokens, inner_start);
-      const inner_args = this.parseCommaSeparatedArguments(tokens, inner_start + 1, inner_end);
+      const inner_args = this.parseArgumentsWithSeparator(tokens, inner_start + 1, inner_end, COMMA);
       return [
-        inner_args,
-        end + 1,
-        { leftDelim: tokens[inner_start].value, rightDelim: tokens[inner_end].value }
+        new TypstLeftright(lr_token, inner_args, { left: tokens[inner_start], right: tokens[inner_end] }),
+        end + 1
       ];
     } else {
       const [args, end] = this.parseArguments(tokens, start);
       return [
-        args,
-        end,
-        { leftDelim: null, rightDelim: null }
+        new TypstLeftright(lr_token, args, { left: null, right: null }),
+        end
       ];
     }
   }
   // start: the position of the left parentheses
-  parseGroupsOfArguments(tokens, start, newline_token = SEMICOLON) {
+  parseMatrix(tokens, start, rowSepToken, cellSepToken) {
     const end = find_closing_match2(tokens, start);
     tokens = tokens.slice(0, end);
     const matrix = [];
@@ -3591,7 +3708,7 @@ var TypstParser = class {
     while (pos < end) {
       while (pos < end) {
         let extract_named_params2 = function(arr) {
-          const COLON = new TypstNode("atom", ":");
+          const COLON = new TypstToken(2 /* ELEMENT */, ":").toNode();
           const np2 = {};
           const to_delete = [];
           for (let i = 0; i < arr.length; i++) {
@@ -3605,7 +3722,7 @@ var TypstParser = class {
             }
             to_delete.push(i);
             const param_name = g.args[pos_colon - 1];
-            if (param_name.eq(new TypstNode("symbol", "delim"))) {
+            if (param_name.eq(new TypstToken(1 /* SYMBOL */, "delim").toNode())) {
               if (g.args.length !== 3) {
                 throw new TypstParserError("Invalid number of arguments for delim");
               }
@@ -3620,11 +3737,11 @@ var TypstParser = class {
           return [arr, np2];
         };
         var extract_named_params = extract_named_params2;
-        let next_stop = array_find(tokens, newline_token, pos);
+        let next_stop = array_find(tokens, rowSepToken, pos);
         if (next_stop === -1) {
           next_stop = end;
         }
-        let row = this.parseCommaSeparatedArguments(tokens, pos, next_stop);
+        let row = this.parseArgumentsWithSeparator(tokens, pos, next_stop, cellSepToken);
         let np = {};
         [row, np] = extract_named_params2(row);
         matrix.push(row);
@@ -3635,13 +3752,13 @@ var TypstParser = class {
     return [matrix, named_params, end + 1];
   }
   // start: the position of the first token of arguments
-  parseCommaSeparatedArguments(tokens, start, end) {
+  parseArgumentsWithSeparator(tokens, start, end, sepToken) {
     const args = [];
     let pos = start;
     while (pos < end) {
       let nodes = [];
       while (pos < end) {
-        if (tokens[pos].eq(COMMA)) {
+        if (tokens[pos].eq(sepToken)) {
           pos += 1;
           break;
         } else if (tokens[pos].eq(SINGLE_SPACE)) {
@@ -3675,46 +3792,12 @@ var TexWriter = class {
     this.buffer = "";
     this.queue = [];
   }
-  writeBuffer(token) {
-    const str = token.toString();
-    let no_need_space = false;
-    if (token.type === 4 /* SPACE */) {
-      no_need_space = true;
-    } else {
-      no_need_space ||= /[{\(\[\|]$/.test(this.buffer);
-      no_need_space ||= /\\\w+$/.test(this.buffer) && str === "[";
-      no_need_space ||= /^[\.,;:!\?\(\)\]{}_^]$/.test(str);
-      no_need_space ||= ["\\{", "\\}"].includes(str);
-      no_need_space ||= str === "'";
-      no_need_space ||= this.buffer.endsWith("_") || this.buffer.endsWith("^");
-      no_need_space ||= /\s$/.test(this.buffer);
-      no_need_space ||= /^\s/.test(str);
-      no_need_space ||= this.buffer === "";
-      no_need_space ||= /[\(\[{]\s*(-|\+)$/.test(this.buffer) || this.buffer === "-" || this.buffer === "+";
-      no_need_space ||= this.buffer.endsWith("&") && str === "=";
-    }
-    if (!no_need_space) {
-      this.buffer += " ";
-    }
-    this.buffer += str;
-  }
   append(node) {
-    const alignment_char = new TexNode("control", "&");
-    const newline_char = new TexNode("control", "\\\\");
-    if (node.type === "ordgroup" && array_includes(node.args, alignment_char)) {
-      const rows = array_split(node.args, newline_char);
-      const data = [];
-      for (const row of rows) {
-        const cells = array_split(row, alignment_char);
-        data.push(cells.map((cell) => new TexNode("ordgroup", "", cell)));
-      }
-      node = new TexNode("beginend", "aligned", [], data);
-    }
     this.queue = this.queue.concat(node.serialize());
   }
   flushQueue() {
     for (let i = 0; i < this.queue.length; i++) {
-      this.writeBuffer(this.queue[i]);
+      this.buffer = writeTexTokenBuffer(this.buffer, this.queue[i]);
     }
     this.queue = [];
   }