tex2typst 0.4.1 → 0.5.1

package/src/map.ts

@@ -8,6 +8,23 @@ const symbolMap = new Map<string, string>([
     [':', 'med'],
     [' ', 'med'],
     [';', 'thick'],
+    ['>', 'med'],
+    ['~', 'space.nobreak'],
+
+    ['blacktriangleleft', 'triangle.filled.l'],
+    ['blacktriangleright', 'triangle.filled.r'],
+    ['clubsuit', 'suit.club.filled'],
+    ['hookleftarrow', 'arrow.l.hook'],
+    ['hookrightarrow', 'arrow.r.hook'],
+    ['leftrightarrow', 'arrow.l.r'],
+    ['lgblksquare', 'square.filled.big'],
+    ['lgwhtsquare', 'square.stroked.big'],
+    ['nearrow', 'arrow.tr'],
+    ['nwarrow', 'arrow.tl'],
+    ['searrow', 'arrow.br'],
+    ['swarrow', 'arrow.bl'],
+    ['spadesuit', 'suit.spade.filled'],
+    ['updownarrow', 'arrow.t.b'],
 
     /* textual operators */
     ['ln', 'ln'],
@@ -41,10 +58,10 @@ const symbolMap = new Map<string, string>([
     ['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
+    ['overbrace', 'overbrace'],
+    ['underbrace', 'underbrace'],
+    ['overline', 'overline'],
+    ['underline', 'underline'],
     ['bar', 'macron'],
     ['dbinom', 'binom'],
     ['tbinom', 'binom'],
@@ -127,7 +144,7 @@ const symbolMap = new Map<string, string>([
     ['geq', 'gt.eq'], 
     ['geqslant', 'gt.eq.slant'], 
     ['gg', 'gt.double'], 
-    ['hbar', 'planck.reduce'], 
+    ['hbar', 'planck'], 
     ['imath', 'dotless.i'], 
     ['iiiint', 'integral.quad'], 
     ['iiint', 'integral.triple'], 
@@ -141,7 +158,7 @@ const symbolMap = new Map<string, string>([
     ['kappa', 'kappa'], 
     ['lambda', 'lambda'], 
     ['land', 'and'],
-    ['langle', 'angle.l'], 
+    ['langle', 'chevron.l'], 
     ['lbrace', 'brace.l'], 
     ['lbrack', 'bracket.l'], 
     ['ldots', 'dots.h'], 
@@ -203,7 +220,7 @@ const symbolMap = new Map<string, string>([
     ['prod', 'product'], 
     ['propto', 'prop'], 
     ['psi', 'psi'], 
-    ['rangle', 'angle.r'], 
+    ['rangle', 'chevron.r'], 
     ['rbrace', 'brace.r'], 
     ['rbrack', 'bracket.r'], 
     ['rhd', 'triangle'], 
@@ -278,6 +295,7 @@ const map_from_official_docs: Map<string, string> = new Map([
     ['approxident', 'tilde.triple'],
     ['assert', 'tack.r.short'],
     ['ast', 'ast.op'],
+    ['astrosun', 'sun'],
     ['asymp', 'asymp'],
     ['awint', 'integral.ccw'],
     ['backcong', 'tilde.rev.equiv'],
@@ -333,9 +351,9 @@ const map_from_official_docs: Map<string, string> = new Map([
     ['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'],
+    ['bigodot', 'dot.o.big'],
+    ['bigoplus', 'plus.o.big'],
+    ['bigotimes', 'times.o.big'],
     ['bigsqcap', 'inter.sq.big'],
     ['bigsqcup', 'union.sq.big'],
     ['bigstar', 'star.filled'],
@@ -350,8 +368,6 @@ const map_from_official_docs: Map<string, string> = new Map([
     ['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'],
@@ -368,13 +384,14 @@ const map_from_official_docs: Map<string, string> = new Map([
     ['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'],
+    ['circledast', 'ast.op.o'],
+    ['circledbullet', 'bullet.o'],
+    ['circledcirc', 'compose.o'],
+    ['circleddash', 'dash.o'],
+    ['circledequal', 'cc.nd'],
+    ['circledparallel', 'parallel.o'],
+    ['circledvert', 'bar.v.o'],
+    ['circledwhitebullet', 'bullet.stroked.o'],
     ['Colon', 'colon.double'],
     ['coloneq', 'colon.eq'],
     ['Coloneq', 'colon.double.eq'],
@@ -425,6 +442,7 @@ const map_from_official_docs: Map<string, string> = new Map([
     ['downarrow', 'arrow.b'],
     ['Downarrow', 'arrow.b.double'],
     ['downarrowbar', 'arrow.b.stop'],
+    ['downarrowbarred', 'arrow.b.struck'],
     ['downdasharrow', 'arrow.b.dashed'],
     ['downdownarrows', 'arrows.bb'],
     ['downharpoonleft', 'harpoon.bl'],
@@ -432,7 +450,6 @@ const map_from_official_docs: Map<string, string> = new Map([
     ['downharpoonright', 'harpoon.br'],
     ['downharpoonrightbar', 'harpoon.br.stop'],
     ['downharpoonsleftright', 'harpoons.blbr'],
-    ['downrightcurvedarrow', 'arrow.b.curve'],
     ['downuparrows', 'arrows.bt'],
     ['downupharpoonsleftright', 'harpoons.bltr'],
     ['downwhitearrow', 'arrow.b.stroked'],
@@ -464,13 +481,13 @@ const map_from_official_docs: Map<string, string> = new Map([
     ['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'],
+    ['frown', 'frown'],
     ['fullouterjoin', 'join.l.r'],
     ['geq', 'gt.eq'],
     ['geqq', 'gt.equiv'],
@@ -494,14 +511,11 @@ const map_from_official_docs: Map<string, string> = new Map([
     ['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'],
+    ['hyphenbullet', 'bullet.hyph'],
     ['iiiint', 'integral.quad'],
     ['iiint', 'integral.triple'],
     ['iinfin', 'infinity.incomplete'],
@@ -520,23 +534,29 @@ const map_from_official_docs: Map<string, string> = new Map([
     ['interleave', 'interleave'],
     ['intlarhk', 'integral.arrow.hook'],
     ['intx', 'integral.times'],
+    ['inversebullet', 'bullet.hole'],
     ['Join', 'join'],
-    ['langle', 'angle.l'],
-    ['lAngle', 'angle.l.double'],
-    ['langledot', 'angle.l.dot'],
+    ['langle', 'chevron.l'],
+    ['lAngle', 'chevron.l.double'],
+    ['langledot', 'chevron.l.dot'],
     ['lat', 'lat'],
     ['late', 'lat.eq'],
+    ['lbag', 'bag.l'],
+    ['lblkbrbrak', 'shell.l.filled'],
     ['lbrace', 'brace.l'],
-    ['lBrace', 'brace.l.double'],
+    ['lBrace', 'brace.l.stroked'],
     ['lbrack', 'bracket.l'],
-    ['lBrack', 'bracket.l.double'],
+    ['lBrack', 'bracket.l.stroked'],
+    ['lbracklltick', 'bracket.l.tick.b'],
+    ['lbrackultick', 'bracket.l.tick.t'],
     ['lbrbrak', 'shell.l'],
-    ['Lbrbrak', 'shell.l.double'],
+    ['Lbrbrak', 'shell.l.stroked'],
     ['lceil', 'ceil.l'],
-    ['lcurvyangle', 'angle.l.curly'],
+    ['lcurvyangle', 'chevron.l.curly'],
     ['leftarrow', 'arrow.l'],
     ['Leftarrow', 'arrow.l.double'],
     ['leftarrowtail', 'arrow.l.tail'],
+    ['leftarrowtriangle', 'arrow.l.open'],
     ['leftdasharrow', 'arrow.l.dashed'],
     ['leftdotarrow', 'arrow.l.dotted'],
     ['leftdowncurvedarrow', 'arrow.l.curve'],
@@ -547,9 +567,9 @@ const map_from_official_docs: Map<string, string> = new Map([
     ['leftharpoonupbar', 'harpoon.lt.bar'],
     ['leftleftarrows', 'arrows.ll'],
     ['leftouterjoin', 'join.l'],
-    ['leftrightarrow', 'arrow.l.r'],
     ['Leftrightarrow', 'arrow.l.r.double'],
     ['leftrightarrows', 'arrows.lr'],
+    ['leftrightarrowtriangle', 'arrow.l.r.open'],
     ['leftrightharpoondowndown', 'harpoon.lb.rb'],
     ['leftrightharpoondownup', 'harpoon.lb.rt'],
     ['leftrightharpoons', 'harpoons.ltrb'],
@@ -574,16 +594,19 @@ const map_from_official_docs: Map<string, string> = new Map([
     ['lesssim', 'lt.tilde'],
     ['lfloor', 'floor.l'],
     ['lgblkcircle', 'circle.filled.big'],
-    ['lgblksquare', 'square.filled.big'],
+    ['lgroup', 'paren.l.flat'],
     ['lgwhtcircle', 'circle.stroked.big'],
-    ['lgwhtsquare', 'square.stroked.big'],
     ['ll', 'lt.double'],
+    ['llangle', 'chevron.l.closed'],
     ['llblacktriangle', 'triangle.filled.bl'],
+    ['llcorner', 'corner.l.b'],
     ['LLeftarrow', 'arrow.l.quad'],
     ['Lleftarrow', 'arrow.l.triple'],
     ['lll', 'lt.triple'],
     ['lllnest', 'lt.triple.nested'],
+    ['llparenthesis', 'paren.l.closed'],
     ['lltriangle', 'triangle.stroked.bl'],
+    ['lmoustache', 'mustache.l'],
     ['lnapprox', 'lt.napprox'],
     ['lneq', 'lt.neq'],
     ['lneqq', 'lt.nequiv'],
@@ -604,8 +627,9 @@ const map_from_official_docs: Map<string, string> = new Map([
     ['looparrowleft', 'arrow.l.loop'],
     ['looparrowright', 'arrow.r.loop'],
     ['lparen', 'paren.l'],
-    ['lParen', 'paren.l.double'],
+    ['lParen', 'paren.l.stroked'],
     ['lrblacktriangle', 'triangle.filled.br'],
+    ['lrcorner', 'corner.r.b'],
     ['lrtriangle', 'triangle.stroked.br'],
     ['ltimes', 'times.l'],
     ['lvzigzag', 'fence.l'],
@@ -623,8 +647,7 @@ const map_from_official_docs: Map<string, string> = new Map([
     ['mathcomma', 'comma'],
     ['mathdollar', 'dollar'],
     ['mathexclam', 'excl'],
-    // ['mathhyphen', 'hyph'], // \mathhyphen is not defined in standard amsmath package
-    ['mathoctothorpe', 'hash'],
+    ['mathhyphen', 'hyph'], // \mathhyphen is not defined in standard amsmath package
     ['mathparagraph', 'pilcrow'],
     ['mathpercent', 'percent'],
     ['mathperiod', 'dot.basic'],
@@ -638,7 +661,6 @@ const map_from_official_docs: Map<string, string> = new Map([
     ['mathyen', 'yen'],
     ['mdblkdiamond', 'diamond.filled.medium'],
     ['mdblklozenge', 'lozenge.filled.medium'],
-    ['mdblksquare', 'square.filled.medium'],
     ['mdlgblkcircle', 'circle.filled'],
     ['mdlgblkdiamond', 'diamond.filled'],
     ['mdlgblklozenge', 'lozenge.filled'],
@@ -648,12 +670,9 @@ const map_from_official_docs: Map<string, string> = new Map([
     ['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'],
@@ -714,6 +733,7 @@ const map_from_official_docs: Map<string, string> = new Map([
     ['mupvarpi', 'pi.alt'],
     ['mupvarrho', 'rho.alt'],
     ['mupvarsigma', 'sigma.alt'],
+    ['mupvarTheta', 'Theta.alt'],
     ['mupvartheta', 'theta.alt'],
     ['mupXi', 'Xi'],
     ['mupxi', 'xi'],
@@ -725,7 +745,6 @@ const map_from_official_docs: Map<string, string> = new Map([
     ['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
@@ -735,7 +754,9 @@ const map_from_official_docs: Map<string, string> = new Map([
     ['ngtr', 'gt.not'],
     ['ngtrless', 'gt.lt.not'],
     ['ngtrsim', 'gt.tilde.not'],
+    ['nHdownarrow', 'arrow.b.dstruck'],
     ['nhpar', 'parallel.struck'],
+    ['nHuparrow', 'arrow.t.dstruck'],
     ['nhVvert', 'interleave.struck'],
     ['ni', 'in.rev'],
     ['nLeftarrow', 'arrow.l.double.not'],
@@ -772,36 +793,62 @@ const map_from_official_docs: Map<string, string> = new Map([
     ['nvdash', 'tack.r.not'],
     ['nvDash', 'tack.r.double.not'],
     ['nvinfty', 'infinity.bar'],
-    ['nwarrow', 'arrow.tl'],
+    ['nvLeftarrow', 'arrow.l.double.struck'],
+    ['nvleftarrow', 'arrow.l.struck'],
+    ['nVleftarrow', 'arrow.l.dstruck'],
+    ['nvleftarrowtail', 'arrow.l.tail.struck'],
+    ['nVleftarrowtail', 'arrow.l.tail.dstruck'],
+    ['nvLeftrightarrow', 'arrow.l.r.double.struck'],
+    ['nvleftrightarrow', 'arrow.l.r.struck'],
+    ['nVleftrightarrow', 'arrow.l.r.dstruck'],
+    ['nvRightarrow', 'arrow.r.double.struck'],
+    ['nvrightarrow', 'arrow.r.struck'],
+    ['nVrightarrow', 'arrow.r.dstruck'],
+    ['nvrightarrowtail', 'arrow.r.tail.struck'],
+    ['nVrightarrowtail', 'arrow.r.tail.dstruck'],
+    ['nvtwoheadleftarrow', 'arrow.l.twohead.struck'],
+    ['nVtwoheadleftarrow', 'arrow.l.twohead.dstruck'],
+    ['nvtwoheadleftarrowtail', 'arrow.l.twohead.tail.struck'],
+    ['nVtwoheadleftarrowtail', 'arrow.l.twohead.tail.dstruck'],
+    ['nvtwoheadrightarrow', 'arrow.r.twohead.struck'],
+    ['nVtwoheadrightarrow', 'arrow.r.twohead.dstruck'],
+    ['nvtwoheadrightarrowtail', 'arrow.r.twohead.tail.struck'],
+    ['nVtwoheadrightarrowtail', 'arrow.r.twohead.tail.dstruck'],
     ['Nwarrow', 'arrow.tl.double'],
     ['nwsearrow', 'arrow.tl.br'],
     ['obrbrak', 'shell.t'],
-    ['obslash', 'backslash.circle'],
-    ['odiv', 'div.circle'],
-    ['odot', 'dot.circle'],
-    ['ogreaterthan', 'gt.circle'],
+    ['obslash', 'backslash.o'],
+    ['odiv', 'div.o'],
+    ['odot', 'dot.o'],
+    ['odotslashdot', 'div.slanted.o'],
+    ['ogreaterthan', 'gt.o'],
     ['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'],
+    ['olessthan', 'lt.o'],
+    ['ominus', 'minus.o'],
+    ['operp', 'perp.o'],
+    ['oplus', 'plus.o'],
+    ['opluslhrim', 'plus.o.l'],
+    ['oplusrhrim', 'plus.o.r'],
     ['origof', 'original'],
-    ['otimes', 'times.circle'],
+    ['oslash', 'slash.o'],
+    ['otimes', 'times.o'],
+    ['otimeshat', 'times.o.hat'],
+    ['otimeslhrim', 'times.o.l'],
+    ['otimesrhrim', 'times.o.r'],
     // ['overbrace', 'brace.t'],
-    ['overbracket', 'bracket.t'],
-    ['overparen', 'paren.t'],
+    // ['overbracket', 'bracket.t'],
+    // ['overparen', 'paren.t'],
     ['parallel', 'parallel'],
     ['parallelogram', 'parallelogram.stroked'],
     ['parallelogramblack', 'parallelogram.filled'],
     ['parsim', 'parallel.tilde'],
-    ['partial', 'diff'],
+    ['partial', 'partial'],
     ['pentagon', 'penta.stroked'],
     ['pentagonblack', 'penta.filled'],
     ['perp', 'perp'],
-    ['Planckconst', 'planck'],
     ['pm', 'plus.minus'],
     ['prec', 'prec'],
     ['Prec', 'prec.double'],
@@ -822,30 +869,37 @@ const map_from_official_docs: Map<string, string> = new Map([
     ['quarternote', 'note.quarter.alt'],
     ['questeq', 'eq.quest'],
     ['Question', 'quest.double'],
-    ['rangle', 'angle.r'],
-    ['rAngle', 'angle.r.double'],
-    ['rangledot', 'angle.r.dot'],
+    ['rangle', 'chevron.r'],
+    ['rAngle', 'chevron.r.double'],
+    ['rangledot', 'chevron.r.dot'],
+    ['rangledownzigzagarrow', 'angle.azimuth'],
+    ['rbag', 'bag.r'],
+    ['rblkbrbrak', 'shell.r.filled'],
     ['rbrace', 'brace.r'],
-    ['rBrace', 'brace.r.double'],
+    ['rBrace', 'brace.r.stroked'],
     ['rbrack', 'bracket.r'],
-    ['rBrack', 'bracket.r.double'],
+    ['rBrack', 'bracket.r.stroked'],
+    ['rbracklrtick', 'bracket.r.tick.b'],
+    ['rbrackurtick', 'bracket.r.tick.t'],
     ['rbrbrak', 'shell.r'],
-    ['Rbrbrak', 'shell.r.double'],
+    ['Rbrbrak', 'shell.r.stroked'],
     ['rceil', 'ceil.r'],
-    ['rcurvyangle', 'angle.r.curly'],
+    ['rcurvyangle', 'chevron.r.curly'],
     ['Re', 'Re'],
     ['revangle', 'angle.rev'],
     ['revemptyset', 'emptyset.rev'],
     ['revnmid', 'divides.not.rev'],
     ['rfloor', 'floor.r'],
+    ['rgroup', 'paren.r.flat'],
     ['rightangle', 'angle.right'],
     ['rightanglemdot', 'angle.right.dot'],
-    ['rightanglesqr', 'angle.right.sq'],
+    ['rightanglesqr', 'angle.right.square'],
     ['rightarrow', 'arrow.r'],
     ['Rightarrow', 'arrow.r.double'],
     ['rightarrowbar', 'arrow.r.stop'],
-    ['rightarrowonoplus', 'plus.circle.arrow'],
+    ['rightarrowonoplus', 'plus.o.arrow'],
     ['rightarrowtail', 'arrow.r.tail'],
+    ['rightarrowtriangle', 'arrow.r.open'],
     ['rightdasharrow', 'arrow.r.dashed'],
     ['rightdotarrow', 'arrow.r.dotted'],
     ['rightdowncurvedarrow', 'arrow.r.curve'],
@@ -866,15 +920,17 @@ const map_from_official_docs: Map<string, string> = new Map([
     ['rightwavearrow', 'arrow.r.wave'],
     ['rightwhitearrow', 'arrow.r.stroked'],
     ['risingdotseq', 'eq.dots.up'],
+    ['rmoustache', 'mustache.r'],
     ['rparen', 'paren.r'],
-    ['rParen', 'paren.r.double'],
+    ['rParen', 'paren.r.stroked'],
+    ['rrangle', 'chevron.r.closed'],
     ['RRightarrow', 'arrow.r.quad'],
     ['Rrightarrow', 'arrow.r.triple'],
+    ['rrparenthesis', 'paren.r.closed'],
     ['rsolbar', 'backslash.not'],
     ['rtimes', 'times.r'],
     ['rvzigzag', 'fence.r'],
     ['Rvzigzag', 'fence.r.double'],
-    ['searrow', 'arrow.br'],
     ['Searrow', 'arrow.br.double'],
     ['setminus', 'without'],
     ['sharp', 'sharp'],
@@ -896,16 +952,15 @@ const map_from_official_docs: Map<string, string> = new Map([
     ['smblkcircle', 'bullet'],
     ['smblkdiamond', 'diamond.filled.small'],
     ['smblklozenge', 'lozenge.filled.small'],
-    ['smblksquare', 'square.filled.tiny'],
     ['smeparsl', 'parallel.slanted.eq.tilde'],
+    ['smile', 'smile'],
     ['smt', 'smt'],
     ['smte', 'smt.eq'],
+    ['smwhtcircle', 'bullet.stroked'],
     ['smwhtdiamond', 'diamond.stroked.small'],
     ['smwhtlozenge', 'lozenge.stroked.small'],
-    ['smwhtsquare', 'square.stroked.tiny'],
-    ['spadesuit', 'suit.spade.filled'],
     ['sphericalangle', 'angle.spheric'],
-    ['sphericalangleup', 'angle.spheric.top'],
+    ['sphericalangleup', 'angle.spheric.t'],
     ['sqcap', 'inter.sq'],
     ['Sqcap', 'inter.sq.double'],
     ['sqcup', 'union.sq'],
@@ -944,7 +999,6 @@ const map_from_official_docs: Map<string, string> = new Map([
     ['supsetdot', 'supset.dot'],
     ['supseteq', 'supset.eq'],
     ['supsetneq', 'supset.neq'],
-    ['swarrow', 'arrow.bl'],
     ['Swarrow', 'arrow.bl.double'],
     ['therefore', 'therefore'],
     ['threedangle', 'angle.spatial'],
@@ -967,15 +1021,19 @@ const map_from_official_docs: Map<string, string> = new Map([
     ['tripleplus', 'plus.triple'],
     ['trprime', 'prime.triple'],
     ['trslash', 'slash.triple'],
+    ['turnediota', 'iota.inv'],
     ['twoheaddownarrow', 'arrow.b.twohead'],
     ['twoheadleftarrow', 'arrow.l.twohead'],
+    ['twoheadleftarrowtail', 'arrow.l.twohead.tail'],
     ['twoheadmapsfrom', 'arrow.l.twohead.bar'],
     ['twoheadmapsto', 'arrow.r.twohead.bar'],
     ['twoheadrightarrow', 'arrow.r.twohead'],
+    ['twoheadrightarrowtail', 'arrow.r.twohead.tail'],
     ['twoheaduparrow', 'arrow.t.twohead'],
     ['twonotes', 'note.eighth.beamed'],
     ['ubrbrak', 'shell.b'],
     ['ulblacktriangle', 'triangle.filled.tl'],
+    ['ulcorner', 'corner.l.t'],
     ['ultriangle', 'triangle.stroked.tl'],
     ['uminus', 'union.minus'],
     ['underbrace', 'brace.b'],
@@ -986,8 +1044,11 @@ const map_from_official_docs: Map<string, string> = new Map([
     ['upand', 'amp.inv'],
     ['uparrow', 'arrow.t'],
     ['Uparrow', 'arrow.t.double'],
+    ['uparrowbarred', 'arrow.t.struck'],
+    ['upbackepsilon', 'epsilon.alt.rev'],
     ['updasharrow', 'arrow.t.dashed'],
-    ['updownarrow', 'arrow.t.b'],
+    ['upDigamma', 'Digamma'],
+    ['updigamma', 'digamma'],
     ['Updownarrow', 'arrow.t.b.double'],
     ['updownarrows', 'arrows.tb'],
     ['updownharpoonleftleft', 'harpoon.tl.bl'],
@@ -1001,16 +1062,14 @@ const map_from_official_docs: Map<string, string> = new Map([
     ['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'],
+    ['urcorner', 'corner.r.t'],
     ['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'],
@@ -1034,7 +1093,7 @@ const map_from_official_docs: Map<string, string> = new Map([
     ['vrectangle', 'rect.stroked.v'],
     ['vrectangleblack', 'rect.filled.v'],
     ['Vvert', 'bar.v.triple'],
-    ['vysmblkcircle', 'circle.filled.small'],
+    ['vysmblkcircle', 'circle.filled.small'], // or bullet.op
     ['vysmwhtcircle', 'circle.stroked.tiny'], // or compose
     ['wedge', 'and'],
     ['Wedge', 'and.double'],
@@ -1043,7 +1102,7 @@ const map_from_official_docs: Map<string, string> = new Map([
     ['whiteinwhitetriangle', 'triangle.stroked.nested'],
     ['whthorzoval', 'ellipse.stroked.h'],
     ['whtvertoval', 'ellipse.stroked.v'],
-    ['wideangledown', 'angle.oblique'],
+    ['wideangledown', 'angle.obtuse'],
     ['wr', 'wreath'],
     ['xsol', 'slash.big'],
 ]);

package/src/tex-parser.ts

@@ -1,6 +1,6 @@
 import { TexBeginEnd, TexFuncCall, TexLeftRight, TexNode, TexGroup, TexSupSub, TexSupsubData, TexText, TexToken, TexTokenType } from "./tex-types";
 import { assert } from "./utils";
-import { array_find, array_join, array_split } from "./generic";
+import { array_join, array_split } from "./generic";
 import { TEX_BINARY_COMMANDS, TEX_UNARY_COMMANDS, tokenize_tex } from "./tex-tokenizer";
 
 const IGNORED_COMMANDS = [
@@ -103,22 +103,7 @@ export class LatexParser {
     }
 
     parse(tokens: TexToken[]): TexNode {
-        const token_displaystyle = new TexToken(TexTokenType.COMMAND, '\\displaystyle');
-        const idx = array_find(tokens, token_displaystyle);
-        if (idx === -1) {
-            // no \displaystyle, normal execution path
-            return this.parseGroup(tokens.slice(0));
-        } else if (idx === 0) {
-            // \displaystyle at the beginning. Wrap the whole thing in \displaystyle
-            const tree = this.parseGroup(tokens.slice(1));
-            return new TexFuncCall(token_displaystyle, [tree]);
-        } else {
-            // \displaystyle somewhere in the middle. Split the expression to two parts
-            const tree1 = this.parseGroup(tokens.slice(0, idx));
-            const tree2 = this.parseGroup(tokens.slice(idx + 1, tokens.length));
-            const display = new TexFuncCall(token_displaystyle, [tree2]);
-            return new TexGroup([tree1, display]);
-        }
+        return this.parseGroup(tokens.slice(0));
     }
 
     parseGroup(tokens: TexToken[]): TexNode {
@@ -152,11 +137,13 @@ export class LatexParser {
             return [EMPTY_NODE, -1];
         }
 
+        const styledResults = this.applyStyleCommands(results);
+
         let node: TexNode;
-        if (results.length === 1) {
-            node = results[0];
+        if (styledResults.length === 1) {
+            node = styledResults[0];
         } else {
-            node = new TexGroup(results);
+            node = new TexGroup(styledResults);
         }
         return [node, pos + 1];
     }
@@ -173,8 +160,9 @@ export class LatexParser {
             const next_token = tokens[pos];
             if (next_token.eq(SUB_SYMBOL)) {
                 [sub, pos] = this.parseNextExprWithoutSupSub(tokens, pos + 1);
-                num_prime += eat_primes(tokens, pos);
-                pos += num_prime;
+                const new_primes = eat_primes(tokens, pos);
+                num_prime += new_primes;
+                pos += new_primes;
                 if (pos < tokens.length && tokens[pos].eq(SUP_SYMBOL)) {
                     [sup, pos] = this.parseNextExprWithoutSupSub(tokens, pos + 1);
                     if (eat_primes(tokens, pos) > 0) {
@@ -262,8 +250,10 @@ export class LatexParser {
                     case '\\,':
                     case '\\:':
                     case '\\;':
+                    case '\\>':
                         return [firstToken.toNode(), start + 1];
                     case '\\ ':
+                    case '~':
                         return [firstToken.toNode(), start + 1];
                     case '_':
                     case '^':
@@ -472,6 +462,36 @@ export class LatexParser {
         this.alignmentDepth--;
         return [allRows, pos];
     }
+
+    private applyStyleCommands(nodes: TexNode[]): TexNode[] {
+        for (let i = 0; i < nodes.length; i++) {
+            const styleToken = this.getStyleToken(nodes[i]);
+            if (styleToken) {
+                const before = this.applyStyleCommands(nodes.slice(0, i));
+                const after = this.applyStyleCommands(nodes.slice(i + 1));
+                let body: TexNode;
+                if (after.length === 0) {
+                    body = EMPTY_NODE;
+                } else if (after.length === 1) {
+                    body = after[0];
+                } else {
+                    body = new TexGroup(after);
+                }
+                const funcCall = new TexFuncCall(styleToken, [body]);
+                return before.concat(funcCall);
+            }
+        }
+        return nodes;
+    }
+
+    private getStyleToken(node: TexNode): TexToken | null {
+        if (node.type === 'terminal') {
+            if (node.head.eq(TexToken.COMMAND_DISPLAYSTYLE) || node.head.eq(TexToken.COMMAND_TEXTSTYLE)) {
+                return node.head;
+            }
+        }
+        return null;
+    }
 }
 
 // Remove all whitespace before or after _ or ^

package/src/tex-tokenizer.ts

@@ -94,7 +94,8 @@ const rules_map = new Map<string, (a: Scanner<TexToken>) => TexToken | TexToken[
     ],
     [String.raw`%[^\n]*`, (s) => new TexToken(TexTokenType.COMMENT, s.text()!.substring(1))],
     [String.raw`[{}_^&]`, (s) => new TexToken(TexTokenType.CONTROL, s.text()!)],
-    [String.raw`\\[\\,:;! ]`, (s) => new TexToken(TexTokenType.CONTROL, s.text()!)],
+    [String.raw`\\[\\,:;!> ]`, (s) => new TexToken(TexTokenType.CONTROL, s.text()!)],
+    [String.raw`~`, (s) => new TexToken(TexTokenType.CONTROL, s.text()!)],
     [String.raw`\r?\n`, (_s) => new TexToken(TexTokenType.NEWLINE, "\n")],
     [String.raw`\s+`, (s) => new TexToken(TexTokenType.SPACE, s.text()!)],
     [String.raw`\\[{}%$&#_|]`, (s) => new TexToken(TexTokenType.ELEMENT, s.text()!)],